@farm.js/core 0.1.61 → 0.1.63

package/dist/chunk-UYRI6U3P.mjs

@@ -0,0 +1,137 @@
+import {
+  _withFarmGuardedResponseCache
+} from "./chunk-E4RDMG3K.mjs";
+import {
+  _markFarmOwnedResponse,
+  _withFarmResponseHeaders
+} from "./chunk-LM55GS4R.mjs";
+
+// src/mobile/shell-response.ts
+var FARM_SHELL_HEADER = "X-Farm-Shell";
+function isFarmMobileShellRequest(request) {
+  const value = request.headers.get(FARM_SHELL_HEADER);
+  return value !== null && /^[a-z][a-z0-9-]{0,31}$/.test(value);
+}
+function isHtml(response) {
+  return response.headers.get("content-type")?.toLowerCase().includes("text/html") === true;
+}
+function appendVary(headers, name) {
+  const current = headers.get("Vary");
+  if (!current) {
+    headers.set("Vary", name);
+    return;
+  }
+  const names = current.split(",").map((value) => value.trim().toLowerCase());
+  if (names.includes("*") || names.includes(name.toLowerCase())) return;
+  headers.set("Vary", `${current}, ${name}`);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var MAX_HELD_TAG = 4096;
+function createFarmMobileShellRewriter(client) {
+  const entry = new RegExp(`(["'])${escapeRegExp(client.webEntry)}\\1`, "g");
+  const webOnly = new Set(client.webOnly);
+  const preload = /<link rel="modulepreload" href="\/([^"]+)"[^>]*>/g;
+  let held = "";
+  return (text, final = false) => {
+    let input = held + text;
+    held = "";
+    if (!final) {
+      const open = input.lastIndexOf("<");
+      if (open !== -1 && input.indexOf(">", open) === -1 && input.length - open <= MAX_HELD_TAG) {
+        held = input.slice(open);
+        input = input.slice(0, open);
+      }
+    }
+    return input.replace(entry, (_match, quote) => `${quote}${client.entry}${quote}`).replace(preload, (tag, file) => webOnly.has(file) ? "" : tag);
+  };
+}
+function _applyFarmMobileShellClient(request, response, client, onPrivate) {
+  if (!client || !isHtml(response)) return response;
+  if (!isFarmMobileShellRequest(request) || !response.body) {
+    return _withFarmResponseHeaders(response, (headers2) => appendVary(headers2, FARM_SHELL_HEADER));
+  }
+  onPrivate?.();
+  const headers = new Headers(_withFarmGuardedResponseCache(response).headers);
+  appendVary(headers, FARM_SHELL_HEADER);
+  headers.delete("content-length");
+  headers.delete("etag");
+  const rewrite = createFarmMobileShellRewriter(client);
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  const body = response.body.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        const output = rewrite(decoder.decode(chunk, { stream: true }));
+        if (output) controller.enqueue(encoder.encode(output));
+      },
+      flush(controller) {
+        const output = rewrite(decoder.decode(), true);
+        if (output) controller.enqueue(encoder.encode(output));
+      }
+    })
+  );
+  return _markFarmOwnedResponse(
+    new Response(body, { status: response.status, statusText: response.statusText, headers })
+  );
+}
+
+// src/mobile/shell-render.ts
+var FARM_SHELL_RENDER_HEADER = "X-Farm-Shell-Render";
+var FARM_SHELL_ROUTE_HEADER = "X-Farm-Shell-Route";
+var FARM_SHELL_PARAM_SEGMENT = "__farm_shell__";
+function constantTimeEqual(left, right) {
+  if (left.length !== right.length) return false;
+  let difference = 0;
+  for (let index = 0; index < left.length; index += 1) {
+    difference |= left.charCodeAt(index) ^ right.charCodeAt(index);
+  }
+  return difference === 0;
+}
+function _isFarmMobileShellRenderRequest(request, token) {
+  const value = request.headers.get(FARM_SHELL_RENDER_HEADER);
+  return token.length > 0 && value !== null && constantTimeEqual(value, token);
+}
+function stripRouteGroups(pattern) {
+  const segments = pattern.split("/").filter((segment) => segment && !(segment.startsWith("(") && segment.endsWith(")")));
+  return segments.length === 0 ? "/" : `/${segments.join("/")}`;
+}
+function isDynamicPattern(pattern) {
+  return pattern.split("/").some((segment) => segment.startsWith("["));
+}
+function _checkFarmMobileShellRoute(check) {
+  const route = stripRouteGroups(check.route);
+  if (check.requested === null || stripRouteGroups(check.requested) !== route) {
+    return `the request matched ${route}, not ${check.requested ?? "a requested route"}`;
+  }
+  if (check.loading === null) return "it has no loading file";
+  if (isDynamicPattern(check.loading)) {
+    return `its loading file is in a dynamic folder (${stripRouteGroups(check.loading)})`;
+  }
+  const layout = check.layouts.find(isDynamicPattern);
+  if (layout !== void 0) {
+    return `a layout is in a dynamic folder (${stripRouteGroups(layout)})`;
+  }
+  return null;
+}
+function createFarmMobileShellRenderPath(route) {
+  const segments = [];
+  for (const segment of route.split("/")) {
+    if (!segment || segment.startsWith("(") && segment.endsWith(")")) continue;
+    if (segment.startsWith("[[...") && segment.endsWith("]]")) continue;
+    segments.push(segment.startsWith("[") ? FARM_SHELL_PARAM_SEGMENT : segment);
+  }
+  return `/${segments.join("/")}`;
+}
+
+export {
+  FARM_SHELL_HEADER,
+  _applyFarmMobileShellClient,
+  FARM_SHELL_RENDER_HEADER,
+  FARM_SHELL_ROUTE_HEADER,
+  FARM_SHELL_PARAM_SEGMENT,
+  _isFarmMobileShellRenderRequest,
+  _checkFarmMobileShellRoute,
+  createFarmMobileShellRenderPath
+};

package/dist/chunk-UYTAP4FQ.cjs

@@ -0,0 +1,60 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunk6XQSPIN6cjs = require('./chunk-6XQSPIN6.cjs');
+
+
+var _chunkHNAISJFDcjs = require('./chunk-HNAISJFD.cjs');
+
+// src/plugins/rewrites.ts
+var FARM_CONFIG_REWRITES_PLUGIN_NAME = "farm:rewrites";
+function createRewritesPlugin(rewrites, {
+  beforeRequest: overrideBeforeRequest,
+  afterResponse: overrideAfterResponse,
+  i18n
+} = {}) {
+  const compiledRewrites = rewrites.map((rewrite) => ({
+    rewrite,
+    pattern: _chunk6XQSPIN6cjs.compileConfigRoutePattern.call(void 0, rewrite.source)
+  }));
+  return {
+    name: FARM_CONFIG_REWRITES_PLUGIN_NAME,
+    enforce: "pre",
+    async beforeRequest(req, res, context) {
+      if (overrideBeforeRequest) {
+        await overrideBeforeRequest(req, res, context);
+      }
+      const url = _chunkHNAISJFDcjs.resolveFarmRequestURL.call(void 0, req);
+      const routePath = _chunk6XQSPIN6cjs.resolveConfigRoutePathname.call(void 0, url.pathname, i18n);
+      const pathname = routePath.pathname;
+      for (const { rewrite, pattern } of compiledRewrites) {
+        const match = pathname.match(pattern.regex);
+        if (match) {
+          const newPath = _chunk6XQSPIN6cjs.localizeConfigRouteDestination.call(void 0, 
+            _chunk6XQSPIN6cjs.interpolateConfigRouteDestination.call(void 0, rewrite.destination, match, pattern.tokens),
+            routePath.locale,
+            i18n
+          );
+          const destinationUrl = new URL(newPath, url);
+          if (!destinationUrl.search && url.search) {
+            destinationUrl.search = url.search;
+          }
+          req.url = destinationUrl.origin === url.origin ? destinationUrl.pathname + destinationUrl.search : destinationUrl.href;
+          break;
+        }
+      }
+    },
+    async afterResponse(req, res, context) {
+      if (overrideAfterResponse) {
+        await overrideAfterResponse(req, res, context);
+      }
+    }
+  };
+}
+
+
+
+
+exports.FARM_CONFIG_REWRITES_PLUGIN_NAME = FARM_CONFIG_REWRITES_PLUGIN_NAME; exports.createRewritesPlugin = createRewritesPlugin;

package/dist/chunk-UZCMMJJT.cjs

@@ -0,0 +1,80 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/cache-invalidation.ts
+var FARM_CACHE_INVALIDATION_HEADER = "x-farm-cache-invalidations";
+var FARM_CACHE_INVALIDATION_STATE = /* @__PURE__ */ Symbol.for("farm.cacheInvalidationState");
+var globalState = globalThis;
+function getFarmCacheInvalidationState() {
+  return _nullishCoalesce(globalState[FARM_CACHE_INVALIDATION_STATE], () => ( (globalState[FARM_CACHE_INVALIDATION_STATE] = {
+    listeners: /* @__PURE__ */ new Set(),
+    taskListeners: /* @__PURE__ */ new Set()
+  })));
+}
+function warnFarmCacheListenerError(scope, error) {
+  const detail = error instanceof Error ? _nullishCoalesce(error.stack, () => ( error.message)) : String(error);
+  console.warn(`[farm:cache] ${scope} listener failed: ${detail}`);
+}
+function notifyFarmCacheInvalidation(key, source = "local") {
+  if (typeof key !== "string" || key.length === 0) return;
+  for (const listener of getFarmCacheInvalidationState().listeners) {
+    try {
+      listener(key, source);
+    } catch (error) {
+      warnFarmCacheListenerError("invalidation", error);
+    }
+  }
+}
+function notifyFarmCacheTask(task) {
+  for (const listener of getFarmCacheInvalidationState().taskListeners) {
+    try {
+      listener(task);
+    } catch (error) {
+      warnFarmCacheListenerError("task", error);
+    }
+  }
+}
+function applyFarmCacheInvalidations(keys, source = "local") {
+  if (!Array.isArray(keys)) return;
+  for (const key of keys) {
+    if (typeof key === "string") {
+      notifyFarmCacheInvalidation(key, source);
+    }
+  }
+}
+function encodeFarmCacheInvalidations(keys) {
+  const normalized = Array.from(
+    new Set(keys.filter((key) => typeof key === "string" && key.length > 0))
+  );
+  if (normalized.length === 0) return null;
+  return encodeURIComponent(JSON.stringify(normalized));
+}
+function decodeFarmCacheInvalidations(value) {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(decodeURIComponent(value));
+    return Array.isArray(parsed) ? Array.from(
+      new Set(parsed.filter((key) => typeof key === "string" && key.length > 0))
+    ) : [];
+  } catch (e) {
+    return [];
+  }
+}
+function subscribeFarmCacheInvalidation(listener) {
+  const state = getFarmCacheInvalidationState();
+  state.listeners.add(listener);
+  return () => state.listeners.delete(listener);
+}
+function subscribeFarmCacheTask(listener) {
+  const state = getFarmCacheInvalidationState();
+  state.taskListeners.add(listener);
+  return () => state.taskListeners.delete(listener);
+}
+
+
+
+
+
+
+
+
+
+
+exports.FARM_CACHE_INVALIDATION_HEADER = FARM_CACHE_INVALIDATION_HEADER; exports.notifyFarmCacheInvalidation = notifyFarmCacheInvalidation; exports.notifyFarmCacheTask = notifyFarmCacheTask; exports.applyFarmCacheInvalidations = applyFarmCacheInvalidations; exports.encodeFarmCacheInvalidations = encodeFarmCacheInvalidations; exports.decodeFarmCacheInvalidations = decodeFarmCacheInvalidations; exports.subscribeFarmCacheInvalidation = subscribeFarmCacheInvalidation; exports.subscribeFarmCacheTask = subscribeFarmCacheTask;

package/dist/chunk-UZZ6IEQP.mjs

@@ -0,0 +1,169 @@
+import {
+  collectFarmLlmsTxtPages
+} from "./chunk-KVW2M6PI.mjs";
+import {
+  getFarmMarkdownMirrorPath,
+  isFarmMarkdownMirrorExposed
+} from "./chunk-YSXTNSXS.mjs";
+import {
+  _listFarmMCPCatalogs,
+  _listFarmRegisteredMCPServers
+} from "./chunk-C7GJDVN4.mjs";
+import {
+  applyFarmBasePath,
+  stripFarmBasePath
+} from "./chunk-SF3JB56B.mjs";
+
+// src/agent-mcp.ts
+var FARM_DEFAULT_MCP_PATH = "/mcp";
+var FARM_DEFAULT_MCP_PROTOCOL_VERSIONS = [
+  "2025-11-25",
+  "2025-06-18",
+  "2025-03-26",
+  "2024-11-05"
+];
+var FARM_DEFAULT_MCP_DESCRIPTION = "Read-only access to this site's public pages: list, search, and read them as Markdown.";
+var READ_ONLY = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var PAGE_SCHEMA = {
+  type: "object",
+  properties: {
+    path: { type: "string", description: `The page's path, such as "/about".` },
+    title: { type: "string" },
+    url: { type: "string", description: "The page's absolute URL." },
+    description: { type: "string" }
+  },
+  required: ["path", "title", "url"]
+};
+var PAGES_OUTPUT_SCHEMA = {
+  type: "object",
+  properties: { pages: { type: "array", items: PAGE_SCHEMA } },
+  required: ["pages"]
+};
+var FARM_DEFAULT_MCP_TOOLS = [
+  {
+    name: "list_pages",
+    title: "List pages",
+    description: "List this site's public pages with each page's path, title, URL, and description. Pass a page's path to read_page to read it as Markdown.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    outputSchema: PAGES_OUTPUT_SCHEMA,
+    annotations: READ_ONLY
+  },
+  {
+    name: "search_pages",
+    title: "Search pages",
+    description: "Search this site's public pages by title, description, and path. Every word of the query must match. Returns the matching pages, best match first.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          minLength: 1,
+          maxLength: 200,
+          description: 'Words to look for, such as "pricing" or "getting started".'
+        },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: 50,
+          default: 10,
+          description: "The most pages to return."
+        }
+      },
+      required: ["query"],
+      additionalProperties: false
+    },
+    outputSchema: PAGES_OUTPUT_SCHEMA,
+    annotations: READ_ONLY
+  },
+  {
+    name: "read_page",
+    title: "Read a page",
+    description: `Read one of this site's public pages as Markdown. Takes a path from list_pages or search_pages, such as "/" or "/about".`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          minLength: 1,
+          maxLength: 2048,
+          description: `The page's path, such as "/about", or its full URL on this site.`
+        }
+      },
+      required: ["path"],
+      additionalProperties: false
+    },
+    annotations: READ_ONLY
+  }
+];
+function collectFarmDefaultMCPPages(sources, options) {
+  const readable = [];
+  for (const source of sources) {
+    const module = isRecord(source.module) ? source.module : void 0;
+    if (module?.__farmRouteGuard) continue;
+    if (!isFarmMarkdownMirrorExposed(options.markdown, source.pattern)) continue;
+    readable.push({ pattern: source.pattern, metadata: module?.metadata });
+  }
+  return collectFarmLlmsTxtPages(readable, {
+    origin: options.origin,
+    basePath: options.basePath,
+    markdown: options.markdown
+  }).map((page) => ({
+    path: page.path,
+    title: page.title,
+    url: `${options.origin}${applyFarmBasePath(page.path, options.basePath)}`,
+    ...page.description ? { description: page.description } : {},
+    markdownUrl: `${options.origin}${applyFarmBasePath(
+      getFarmMarkdownMirrorPath(page.path),
+      options.basePath
+    )}`
+  }));
+}
+function createFarmDefaultMCPServer(app, farmVersion) {
+  const name = typeof app?.name === "string" && app.name.trim() ? app.name.trim() : "farm-app";
+  const version = typeof app?.version === "string" && app.version.trim() ? app.version.trim() : farmVersion;
+  return {
+    name,
+    version,
+    description: FARM_DEFAULT_MCP_DESCRIPTION,
+    protocolVersions: [...FARM_DEFAULT_MCP_PROTOCOL_VERSIONS],
+    path: FARM_DEFAULT_MCP_PATH
+  };
+}
+function resolveFarmDefaultMCPServer(server) {
+  if (!server) return void 0;
+  if (_listFarmMCPCatalogs().length > 0 || _listFarmRegisteredMCPServers().length > 0) {
+    return void 0;
+  }
+  return server;
+}
+function isFarmDefaultMCPPathname(pathname, basePath) {
+  const path = stripFarmBasePath(pathname, basePath);
+  return path === FARM_DEFAULT_MCP_PATH || path === `${FARM_DEFAULT_MCP_PATH}/`;
+}
+function farmConfigMountsMCP(config) {
+  const { mcp } = config;
+  if (isRecord(mcp) && mcp.enabled !== false) return true;
+  return Boolean(
+    config.plugins?.some((plugin) => isRecord(plugin) && plugin.name === "farm:api-mcp")
+  );
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+export {
+  FARM_DEFAULT_MCP_PATH,
+  FARM_DEFAULT_MCP_PROTOCOL_VERSIONS,
+  FARM_DEFAULT_MCP_DESCRIPTION,
+  FARM_DEFAULT_MCP_TOOLS,
+  collectFarmDefaultMCPPages,
+  createFarmDefaultMCPServer,
+  resolveFarmDefaultMCPServer,
+  isFarmDefaultMCPPathname,
+  farmConfigMountsMCP
+};

package/dist/chunk-V3UOEWCB.cjs

@@ -0,0 +1,46 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+
+var _chunkKORZ6PREcjs = require('./chunk-KORZ6PRE.cjs');
+
+// src/docs/engine.ts
+var FARMING_LABS_DOCS_INSTALL_HINT = _chunkKORZ6PREcjs.formatOptionalPeerInstallHint.call(void 0, 
+  "@farming-labs/docs",
+  "use the docs engine"
+);
+var engine;
+var loading;
+function loadFarmDocsEngine() {
+  _nullishCoalesce(loading, () => ( (loading = Promise.all([import("@farming-labs/docs"), import("@farming-labs/docs/server")]).then(
+    ([docs, server]) => {
+      engine = {
+        ...docs,
+        resolveApiReferenceOpenApiDiscovery: server.resolveApiReferenceOpenApiDiscovery
+      };
+      return engine;
+    },
+    (error) => {
+      loading = void 0;
+      if (!_chunkKORZ6PREcjs.isMissingPackageError.call(void 0, error, "@farming-labs/docs")) throw error;
+      throw _chunkKORZ6PREcjs.withOptionalPeerCause.call(void 0, 
+        new Error(
+          `docs is enabled, but @farming-labs/docs is not installed. ${FARMING_LABS_DOCS_INSTALL_HINT}`
+        ),
+        error
+      );
+    }
+  ))));
+  return loading;
+}
+function docsEngine() {
+  if (!engine) {
+    throw new Error("Farm docs engine was used before loadFarmDocsEngine() resolved.");
+  }
+  return engine;
+}
+
+
+
+
+exports.loadFarmDocsEngine = loadFarmDocsEngine; exports.docsEngine = docsEngine;

package/dist/chunk-V56632LA.cjs

@@ -0,0 +1,141 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkOYZXVBZPcjs = require('./chunk-OYZXVBZP.cjs');
+
+
+var _chunk6XQSPIN6cjs = require('./chunk-6XQSPIN6.cjs');
+
+
+var _chunk7JUIK547cjs = require('./chunk-7JUIK547.cjs');
+
+// src/route-rules.ts
+function normalizeRouteRules(routeRules) {
+  if (!routeRules) return {};
+  const normalized = {};
+  const normalizedSources = /* @__PURE__ */ new Map();
+  for (const [source, rule] of Object.entries(routeRules)) {
+    if (!rule) continue;
+    const normalizedSource = normalizeRuleSource(source);
+    _chunk6XQSPIN6cjs.validateConfigRouteSource.call(void 0, normalizedSource, `Route rule "${source}" source`);
+    const existingSource = normalizedSources.get(normalizedSource);
+    if (existingSource !== void 0) {
+      throw new Error(
+        `Route rules "${existingSource}" and "${source}" both normalize to "${normalizedSource}".`
+      );
+    }
+    normalizedSources.set(normalizedSource, source);
+    if (typeof rule.redirect === "object" && rule.redirect.statusCode !== void 0 && !_chunk7JUIK547cjs.isFarmRedirectStatus.call(void 0, rule.redirect.statusCode)) {
+      throw new RangeError(
+        `Route rule "${normalizedSource}" redirect.statusCode must be one of 301, 302, 303, 307, or 308.`
+      );
+    }
+    normalized[normalizedSource] = {
+      ...rule,
+      ..._chunkOYZXVBZPcjs.normalizeFarmRouteRuntimeConfig.call(void 0, rule, `Route rule "${normalizedSource}"`)
+    };
+  }
+  return normalized;
+}
+function routeRulesToRedirects(routeRules) {
+  return Object.entries(routeRules).filter(
+    (entry) => Boolean(entry[1].redirect)
+  ).map(([source, rule]) => {
+    const redirect = typeof rule.redirect === "string" ? { to: rule.redirect } : rule.redirect;
+    return {
+      source,
+      destination: redirect.to,
+      permanent: redirect.permanent,
+      statusCode: _nullishCoalesce(redirect.statusCode, () => ( (redirect.permanent === true ? 308 : void 0)))
+    };
+  });
+}
+function routeRulesToHeaders(routeRules) {
+  const configs = [];
+  for (const [source, rule] of Object.entries(routeRules)) {
+    const headers = {
+      ...normalizeCorsHeaders(rule.cors),
+      ...rule.headers
+    };
+    const entries = Object.entries(headers);
+    if (entries.length === 0) continue;
+    configs.push({
+      source,
+      headers: entries.map(([key, value]) => ({ key, value }))
+    });
+  }
+  return configs;
+}
+function routeRulesToNitroRouteRules(routeRules) {
+  const nitroRules = {};
+  for (const [source, rule] of Object.entries(routeRules)) {
+    const nitroRule = { ...rule };
+    if (rule.render === "static") {
+      nitroRule.prerender = true;
+    } else if (rule.render === "dynamic") {
+      nitroRule.prerender = false;
+    }
+    if (rule.redirect) {
+      const redirect = typeof rule.redirect === "string" ? { to: rule.redirect } : rule.redirect;
+      if (hasExplicitQuery(redirect.to)) {
+        delete nitroRule.redirect;
+      } else {
+        nitroRule.redirect = {
+          to: redirect.to,
+          status: _nullishCoalesce(redirect.statusCode, () => ( (redirect.permanent === true ? 308 : 307)))
+        };
+      }
+    }
+    if (rule.cors) {
+      nitroRule.cors = true;
+      nitroRule.headers = {
+        ...normalizeCorsHeaders(rule.cors),
+        ...rule.headers
+      };
+    }
+    delete nitroRule.render;
+    delete nitroRule.runtime;
+    delete nitroRule.regions;
+    delete nitroRule.maxDuration;
+    nitroRules[source] = nitroRule;
+  }
+  return nitroRules;
+}
+function normalizeCorsHeaders(cors) {
+  if (!cors) return {};
+  if (cors === true) {
+    return {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "*",
+      "Access-Control-Allow-Headers": "*"
+    };
+  }
+  return {
+    "Access-Control-Allow-Origin": _nullishCoalesce(cors.origin, () => ( "*")),
+    "Access-Control-Allow-Methods": _nullishCoalesce(normalizeList(cors.methods), () => ( "*")),
+    "Access-Control-Allow-Headers": _nullishCoalesce(normalizeList(cors.headers), () => ( "*"))
+  };
+}
+function normalizeList(value) {
+  if (!value || typeof value === "string") return value;
+  return value.join(", ");
+}
+function normalizeRuleSource(source) {
+  const trimmed = source.trim();
+  if (!trimmed) {
+    throw new TypeError("Route rule source must be a non-empty pathname pattern.");
+  }
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function hasExplicitQuery(destination) {
+  const queryIndex = destination.indexOf("?");
+  if (queryIndex === -1) return false;
+  const hashIndex = destination.indexOf("#");
+  return hashIndex === -1 || queryIndex < hashIndex;
+}
+
+
+
+
+
+
+exports.normalizeRouteRules = normalizeRouteRules; exports.routeRulesToRedirects = routeRulesToRedirects; exports.routeRulesToHeaders = routeRulesToHeaders; exports.routeRulesToNitroRouteRules = routeRulesToNitroRouteRules;