@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-Q3UU2KXC.mjs

@@ -0,0 +1,775 @@
+import {
+  getFarmRouteContext
+} from "./chunk-BMQAPZXD.mjs";
+import {
+  PROGRAMMATIC_ROUTE_SOURCE,
+  TRACK_PROGRAMMATIC_ROUTE_SOURCES,
+  extractProgrammaticPageCallPathLiterals,
+  getProgrammaticRouteDefinitionSource,
+  parseProgrammaticRoutePath
+} from "./chunk-6YFC3ZFX.mjs";
+import {
+  normalizeFarmRouteRuntimeConfig
+} from "./chunk-EVMXPJCB.mjs";
+import {
+  createRouteDataCacheTag,
+  getFarmDataCache
+} from "./chunk-RLEALQEN.mjs";
+import {
+  createFarmCacheKey
+} from "./chunk-GLOICKDO.mjs";
+
+// 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(
+      (route) => stampProgrammaticRouteSource(normalizeProgrammaticRoute(route), route, false)
+    )
+  };
+  Object.defineProperty(manifest, FARM_ROUTES_BRAND, {
+    value: true,
+    enumerable: false
+  });
+  return manifest;
+}
+var routesBuilder = {
+  page(path, options) {
+    return createProgrammaticRoute({
+      kind: "page",
+      path,
+      ...options
+    });
+  },
+  layout(path, options) {
+    return createProgrammaticRoute({
+      kind: "layout",
+      path,
+      ...options
+    });
+  },
+  api(path, options) {
+    const { render, runtime, regions, maxDuration, ...methods } = options;
+    return createProgrammaticRoute({
+      kind: "api",
+      path,
+      render,
+      runtime,
+      regions,
+      maxDuration,
+      methods: normalizeApiMethods(methods)
+    });
+  },
+  redirect(source, destination, options = {}) {
+    return createProgrammaticRoute({
+      kind: "redirect",
+      source,
+      destination,
+      ...options
+    });
+  }
+};
+function createProgrammaticRoute(route) {
+  return stampProgrammaticRouteSource(normalizeProgrammaticRoute(route), route, true);
+}
+function stampProgrammaticRouteSource(route, input, created) {
+  if (!globalThis[TRACK_PROGRAMMATIC_ROUTE_SOURCES]) return route;
+  const previous = getProgrammaticRouteDefinitionSource(input);
+  const source = {
+    stacks: [...previous?.stacks ?? [], captureRouteSourceStack()],
+    raw: created ? false : previous?.raw ?? true
+  };
+  Object.defineProperty(route, PROGRAMMATIC_ROUTE_SOURCE, {
+    value: source,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+  return route;
+}
+function captureRouteSourceStack() {
+  const limit = Error.stackTraceLimit;
+  try {
+    Error.stackTraceLimit = 200;
+    return new Error().stack ?? "";
+  } catch {
+    return "";
+  } finally {
+    try {
+      Error.stackTraceLimit = limit;
+    } catch {
+    }
+  }
+}
+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;
+}
+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;
+}
+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 };
+}
+function getProgrammaticRouteSearchOptions(search) {
+  if (!search || isProgrammaticRouteSchema(search)) return void 0;
+  return search;
+}
+function isProgrammaticRouteSchema(value) {
+  return !!value && typeof value === "object" && typeof value.parse === "function";
+}
+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;
+}
+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;
+}
+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;
+  }
+}
+function readSearchValue(value, key) {
+  return value && typeof value === "object" ? value[key] : void 0;
+}
+function searchValuesEqual(left, right) {
+  return JSON.stringify(normalizeComparableValue(left)) === JSON.stringify(normalizeComparableValue(right));
+}
+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;
+}
+function createRoute(path, options) {
+  return routesBuilder.page(path, options);
+}
+function isProgrammaticRoutesFileName(fileName) {
+  const normalized = fileName.replace(/\\/g, "/");
+  const baseName = normalized.split("/").pop() || normalized;
+  return PROGRAMMATIC_ROUTE_FILE_NAMES.includes(baseName);
+}
+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;
+}
+function isProgrammaticRouteManifest(value) {
+  return !!value && typeof value === "object" && value.__farmRoutes === true && Array.isArray(value.routes);
+}
+function isProgrammaticRouteDefinition(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const kind = value.kind;
+  return kind === "page" || kind === "layout" || kind === "api" || kind === "redirect";
+}
+function createProgrammaticRouteModuleId(filePath, kind, routePath) {
+  return `${filePath}?farm-route=${kind}:${encodeURIComponent(normalizeRoutePath(routePath))}&lang.js`;
+}
+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))
+  };
+}
+function parseProgrammaticRoutePath2(routePath, type = "page") {
+  return parseProgrammaticRoutePath(routePath, type);
+}
+function createRouteModuleFromProgrammaticPage(route, rendererRuntime) {
+  const mod = {
+    default: createProgrammaticPageComponent(route, rendererRuntime),
+    ...normalizeFarmRouteRuntimeConfig(route, `Route "${route.path}"`)
+  };
+  if (route.params || route.search || hasProgrammaticServerProps(route)) {
+    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;
+}
+function createLayoutModuleFromProgrammaticLayout(route) {
+  return {
+    default: route.component,
+    ...normalizeFarmRouteRuntimeConfig(route, `Layout "${route.path}"`),
+    metadata: route.metadata,
+    generateMetadata: route.generateMetadata
+  };
+}
+function scanProgrammaticPagePaths(source) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const routePath of extractProgrammaticPageCallPathLiterals(source)) {
+    if (routePath) {
+      paths.add(normalizeRoutePath(routePath));
+    }
+  }
+  return Array.from(paths);
+}
+function createProgrammaticPageComponent(route, rendererRuntime) {
+  if (!route.params && !route.search && !hasProgrammaticServerProps(route) && !route.pending && !route.error && !route.notFound) {
+    return route.component;
+  }
+  const createElement = (...args) => {
+    if (!rendererRuntime) {
+      throw new Error(
+        `Programmatic route "${route.path}" requires a FARMJS renderer runtime before it can render.`
+      );
+    }
+    return rendererRuntime.createElement(...args);
+  };
+  const markFunctionComponent = (component) => rendererRuntime?.markFunctionComponent?.(component) ?? component;
+  const Component = route.component;
+  if (route.pending) {
+    const PendingComponent = route.pending;
+    const routePropsResources = /* @__PURE__ */ new WeakMap();
+    const FarmProgrammaticPageContent2 = 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;
+      }
+    };
+    const PageContent = markFunctionComponent(
+      FarmProgrammaticPageContent2
+    );
+    const FarmProgrammaticPage = function FarmProgrammaticPage2(props) {
+      return createElement(
+        rendererRuntime.Suspense,
+        {
+          fallback: createElement(PendingComponent, createProgrammaticRoutePendingProps(props))
+        },
+        createElement(PageContent, props)
+      );
+    };
+    return markClientStrippedPage(
+      route,
+      markFunctionComponent(FarmProgrammaticPage)
+    );
+  }
+  if (getClientStrippedServerHooks(route)) {
+    const FarmProgrammaticClientPage = function FarmProgrammaticClientPage2(props) {
+      if (!isProgrammaticRoutePropsResolved(props)) {
+        throw createClientStrippedRouteError(route);
+      }
+      return createElement(Component, stripProgrammaticRoutePropsMarker(props));
+    };
+    return markClientStrippedPage(
+      route,
+      markFunctionComponent(FarmProgrammaticClientPage)
+    );
+  }
+  const renderRouteError = (error, props) => {
+    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;
+  };
+  const FarmProgrammaticPageContent = function FarmProgrammaticPageContent2(props) {
+    if (isProgrammaticRoutePropsResolved(props)) {
+      try {
+        return createElement(Component, stripProgrammaticRoutePropsMarker(props));
+      } catch (error) {
+        return renderRouteError(error, props);
+      }
+    }
+    return resolveProgrammaticRouteProps(route, props).then(
+      (resolvedProps) => createElement(Component, stripProgrammaticRoutePropsMarker(resolvedProps))
+    ).catch((error) => renderRouteError(error, props));
+  };
+  return markClientStrippedPage(
+    route,
+    markFunctionComponent(FarmProgrammaticPageContent)
+  );
+}
+function getClientStrippedServerHooks(route) {
+  const hooks = route.__farmServerHooks;
+  return Array.isArray(hooks) && hooks.length > 0 ? hooks : void 0;
+}
+function createClientStrippedRouteError(route) {
+  return new Error(
+    `Route "${route.path}" resolves its ${getClientStrippedServerHooks(route).join(" and ")} on the server; the browser can only render it with server-resolved props.`
+  );
+}
+function hasProgrammaticServerProps(route) {
+  return Boolean(route.guard || route.data || getClientStrippedServerHooks(route));
+}
+function markClientStrippedPage(route, component) {
+  if (getClientStrippedServerHooks(route) && typeof component === "function") {
+    Object.defineProperty(component, "__farmServerProps", { value: true });
+  }
+  return component;
+}
+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;
+}
+function isPromiseLike(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function"
+  );
+}
+function createProgrammaticRoutePendingProps(props) {
+  return {
+    params: props.params,
+    searchParams: props.searchParams,
+    path: props.path
+  };
+}
+function createProgrammaticRouteErrorProps(error, props) {
+  return {
+    error,
+    params: props.params,
+    searchParams: props.searchParams,
+    path: props.path
+  };
+}
+function isProgrammaticRedirectSignal(error) {
+  if (!error || typeof error !== "object") return false;
+  const digest = error.digest;
+  return typeof digest === "string" && digest.startsWith("FARM_REDIRECT;");
+}
+function isProgrammaticNotFoundSignal(error) {
+  if (!error || typeof error !== "object") return false;
+  const digest = error.digest;
+  return digest === "FARM_NOT_FOUND";
+}
+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
+  );
+  if (getClientStrippedServerHooks(route)) {
+    throw createClientStrippedRouteError(route);
+  }
+  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 } : {}
+  });
+}
+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 revalidate = normalizeProgrammaticRouteStaleTime(dataHooks.staleTime, route.path);
+  if (revalidate === 0) {
+    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
+  };
+  return getFarmDataCache().getOrSet(cacheKey, () => dataHooks.main(context), cacheOptions);
+}
+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);
+}
+function normalizeProgrammaticRouteStaleTime(staleTime, routePath) {
+  if (staleTime === void 0) return void 0;
+  if (staleTime === false) return false;
+  let milliseconds;
+  if (typeof staleTime === "number") {
+    milliseconds = staleTime;
+  } else {
+    const match = typeof staleTime === "string" && staleTime.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/);
+    if (!match) {
+      throw new TypeError(
+        `Route "${routePath}" data.staleTime must be milliseconds or a duration like "250ms", "30s", "5m", or "1h".`
+      );
+    }
+    const unit = match[2];
+    milliseconds = Number(match[1]) * (unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : 36e5);
+  }
+  if (!Number.isFinite(milliseconds) || milliseconds < 0) {
+    throw new TypeError(`Route "${routePath}" data.staleTime must be a non-negative duration.`);
+  }
+  return milliseconds === 0 ? 0 : Math.max(1, Math.ceil(milliseconds / 1e3));
+}
+function isProgrammaticRoutePropsResolved(value) {
+  return !!value && typeof value === "object" && value.__farmRoutePropsResolved === true;
+}
+function markProgrammaticRoutePropsResolved(props) {
+  return {
+    ...props,
+    __farmRoutePropsResolved: true
+  };
+}
+function addCanonicalPath(props, canonicalPath) {
+  return canonicalPath ? { ...props, __farmCanonicalPath: canonicalPath } : props;
+}
+function stripProgrammaticRoutePropsMarker(props) {
+  if (!isProgrammaticRoutePropsResolved(props)) {
+    return props;
+  }
+  const {
+    __farmRoutePropsResolved,
+    __farmCanonicalPath,
+    __farmRoutePropsPromise,
+    ...componentProps
+  } = props;
+  return componentProps;
+}
+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}`);
+  }
+}
+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;
+  normalizeProgrammaticRouteStaleTime(route.data?.staleTime, route.path);
+  return {
+    ...route,
+    ...routeActions,
+    ...normalizeFarmRouteRuntimeConfig(
+      route,
+      `${route.kind === "layout" ? "Layout" : "Route"} "${route.path}"`
+    ),
+    path: normalizeRoutePath(route.path)
+  };
+}
+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
+  };
+}
+function normalizeRoutePath(routePath) {
+  const withSlash = routePath.startsWith("/") ? routePath : `/${routePath}`;
+  const withoutTrailing = withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
+  return withoutTrailing || "/";
+}
+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;
+}
+function isProgrammaticRouteMethod(method) {
+  return method === "GET" || method === "HEAD" || method === "QUERY" || method === "POST" || method === "PUT" || method === "DELETE" || method === "PATCH" || method === "OPTIONS";
+}
+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)
+      ])
+    );
+  });
+}
+
+export {
+  PROGRAMMATIC_ROUTE_FILE_NAMES,
+  defineRoutes,
+  routesBuilder,
+  page,
+  layout,
+  api,
+  redirect,
+  getProgrammaticRouteSearchSchema,
+  getProgrammaticRouteSearchClientOptions,
+  createRoute,
+  isProgrammaticRoutesFileName,
+  getProgrammaticRouteManifest,
+  isProgrammaticRouteManifest,
+  isProgrammaticRouteDefinition,
+  createProgrammaticRouteModuleId,
+  parseProgrammaticRouteModuleId,
+  parseProgrammaticRoutePath2 as parseProgrammaticRoutePath,
+  createRouteModuleFromProgrammaticPage,
+  createLayoutModuleFromProgrammaticLayout,
+  scanProgrammaticPagePaths
+};