@farm.js/core 0.1.47 → 0.1.48

package/dist/chunk-UYQOIPXE.mjs

@@ -0,0 +1,368 @@
+import {
+  ServerFnFailure,
+  getServerActionExecutionContext,
+  getServerActionSignal,
+  isServerFnFailure,
+  runWithServerActionRequest
+} from "./chunk-JOHXK4BB.mjs";
+import {
+  applyFarmCacheInvalidationTargets
+} from "./chunk-RLEALQEN.mjs";
+import {
+  getFarmRedirectError
+} from "./chunk-JNYFXL7X.mjs";
+import {
+  _resolveCurrentRequestForApp,
+  _toAppRequestView
+} from "./chunk-VIXTAVEA.mjs";
+
+// src/server-fn.ts
+var FARM_SERVER_FN_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn");
+var FARM_SERVER_FUNCTION_DESCRIPTOR = /* @__PURE__ */ Symbol.for("farm.server-function.descriptor");
+var ServerFnInputError = class extends Error {
+  constructor(cause) {
+    super("Server function input is invalid");
+    this.cause = cause;
+  }
+};
+function createServerFunctionDescriptor(kind, options, run) {
+  return Object.freeze({
+    kind,
+    input: options.input,
+    output: options.output,
+    mcp: options.mcp === void 0 ? void 0 : Object.freeze({ ...options.mcp }),
+    run
+  });
+}
+function _attachServerFunctionDescriptor(target, descriptor) {
+  Object.defineProperty(target, FARM_SERVER_FUNCTION_DESCRIPTOR, {
+    value: descriptor,
+    enumerable: false
+  });
+}
+function getServerFunctionRunner(value) {
+  if (typeof value !== "function") return void 0;
+  return value[FARM_SERVER_FUNCTION_DESCRIPTOR];
+}
+function _runServerFunctionForCaller(value, input) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) throw new TypeError("Expected a function created with createServerFn");
+  return runner.run(input);
+}
+function _describeServerFunction(value) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) return void 0;
+  const { kind, input, output, mcp } = runner;
+  return Object.freeze({ kind, input, output, mcp });
+}
+async function _invokeServerFunction(value, input, request) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) {
+    throw new TypeError("Expected a function created with createServerFn or createServerQuery");
+  }
+  try {
+    const data = await runWithServerActionRequest(request, () => runner.run(input));
+    return { ok: true, data };
+  } catch (error) {
+    if (error instanceof ServerFnInputError) {
+      return { ok: false, reason: "input", error: error.cause };
+    }
+    if (isServerFnFailure(error)) return { ok: false, reason: "failure", failure: error };
+    const redirect = getFarmRedirectError(error);
+    if (redirect) {
+      return { ok: false, reason: "redirect", url: redirect.url, status: redirect.status };
+    }
+    return { ok: false, reason: "error", error };
+  }
+}
+var UNSAFE_FORM_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function createServerMiddleware(options) {
+  if (!options || typeof options.handler !== "function") {
+    throw new TypeError("createServerMiddleware requires a handler function");
+  }
+  const middleware = Object.freeze([...options.middleware ?? []]);
+  for (const entry of middleware) {
+    assertServerFnMiddleware(entry);
+  }
+  return Object.freeze({
+    __farmServerFnMiddleware: true,
+    middleware,
+    handler: options.handler
+  });
+}
+function createServerFn(options) {
+  if (!options || typeof options.handler !== "function") {
+    throw new TypeError("createServerFn requires a handler function");
+  }
+  const middleware = resolveServerFnMiddleware(options.middleware);
+  const errors = normalizeServerFnErrors(options.errors);
+  const error = createServerFnErrorHandler(errors);
+  const run = async (value, labelInputErrors) => {
+    const formData = isFormData(value) ? value : void 0;
+    const rawInput = formData ? formDataToObject(formData) : value;
+    let input;
+    try {
+      input = await _parseServerFnSchema(options.input, rawInput, "input");
+    } catch (cause) {
+      throw labelInputErrors && isSchemaValidationFailure(cause) ? new ServerFnInputError(cause) : cause;
+    }
+    const executionContext = getServerActionExecutionContext();
+    const request = executionContext ? _toAppRequestView(executionContext.request) : _resolveCurrentRequestForApp();
+    const signal = executionContext?.signal ?? request?.signal ?? getServerActionSignal();
+    const handlerContext = {
+      input,
+      rawInput,
+      formData,
+      request,
+      signal
+    };
+    let resolvedContext = Object.freeze(/* @__PURE__ */ Object.create(null));
+    const result = await runServerFnMiddleware(middleware, handlerContext, async (context) => {
+      resolvedContext = context.context;
+      return options.handler({ ...context, error });
+    });
+    const parsedResult = await _parseServerFnSchema(options.output, result, "output");
+    if (options.invalidates) {
+      const declaration = typeof options.invalidates === "function" ? await options.invalidates({
+        ...handlerContext,
+        context: resolvedContext,
+        result: parsedResult
+      }) : options.invalidates;
+      await applyFarmCacheInvalidationTargets(declaration);
+    }
+    return parsedResult;
+  };
+  const serverFn = (value) => run(value, false);
+  Object.defineProperties(serverFn, {
+    [FARM_SERVER_FN_SYMBOL]: {
+      value: true,
+      enumerable: false
+    },
+    __farmServerFn: {
+      value: true,
+      enumerable: false
+    },
+    __farmServerFnInput: {
+      value: options.input,
+      enumerable: false
+    },
+    __farmServerFnOutput: {
+      value: options.output,
+      enumerable: false
+    },
+    __farmServerFnError: {
+      value: void 0,
+      enumerable: false
+    },
+    __farmServerFnMiddleware: {
+      value: middleware,
+      enumerable: false
+    },
+    __farmServerFnInvalidates: {
+      value: options.invalidates,
+      enumerable: false
+    }
+  });
+  _attachServerFunctionDescriptor(
+    serverFn,
+    createServerFunctionDescriptor("action", options, (value) => run(value, true))
+  );
+  return serverFn;
+}
+async function runServerFnMiddleware(middleware, handlerContext, handler) {
+  const dispatch = async (index, context) => {
+    const current = middleware[index];
+    if (!current) {
+      return handler({ ...handlerContext, context });
+    }
+    let nextCalled = false;
+    const result = await current.handler({
+      ...handlerContext,
+      context,
+      next: async (nextOptions) => {
+        if (nextCalled) {
+          throw new Error("Server function middleware next() can only be called once");
+        }
+        nextCalled = true;
+        return dispatch(index + 1, mergeServerFnContext(context, nextOptions?.context));
+      }
+    });
+    if (!nextCalled) {
+      throw new Error("Server function middleware must call next()");
+    }
+    return result;
+  };
+  return dispatch(0, Object.freeze(/* @__PURE__ */ Object.create(null)));
+}
+function normalizeServerFnErrors(definitions) {
+  if (definitions === void 0) return Object.freeze({});
+  if (!isPlainServerFnObject(definitions)) {
+    throw new TypeError("createServerFn errors must be an object");
+  }
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [code, definition] of Object.entries(definitions)) {
+    if (!code.trim()) {
+      throw new TypeError("Server function error codes cannot be empty");
+    }
+    if (!definition || typeof definition !== "object") {
+      throw new TypeError(`Server function error "${code}" must be an object`);
+    }
+    if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
+      throw new TypeError(
+        `Server function error "${code}" status must be an integer between 400 and 599`
+      );
+    }
+    if (!definition.data || typeof definition.data.parse !== "function" && typeof definition.data.safeParse !== "function") {
+      throw new TypeError(
+        `Server function error "${code}" data must provide synchronous parse() or safeParse()`
+      );
+    }
+    if (definition.message !== void 0 && typeof definition.message !== "string") {
+      throw new TypeError(`Server function error "${code}" message must be a string`);
+    }
+    normalized[code] = Object.freeze({ ...definition });
+  }
+  return Object.freeze(normalized);
+}
+function createServerFnErrorHandler(definitions) {
+  return ((code, data) => {
+    const definition = definitions[code];
+    if (!definition) {
+      throw new TypeError(`Server function error "${code}" is not declared`);
+    }
+    const parsed = parseServerFnFailureData(code, definition.data, data);
+    throw new ServerFnFailure(code, parsed, {
+      status: definition.status,
+      message: definition.message ?? "Server function failed"
+    });
+  });
+}
+function parseServerFnFailureData(code, schema, value) {
+  if (typeof schema.safeParse === "function") {
+    const result2 = schema.safeParse(value);
+    if (isPromiseLike(result2)) {
+      throw new TypeError(`Server function error "${code}" data schema must parse synchronously`);
+    }
+    return unwrapSafeParseResult(result2);
+  }
+  const result = schema.parse(value);
+  if (isPromiseLike(result)) {
+    throw new TypeError(`Server function error "${code}" data schema must parse synchronously`);
+  }
+  return result;
+}
+function isPlainServerFnObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isPromiseLike(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function"
+  );
+}
+function resolveServerFnMiddleware(middleware) {
+  const resolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = (entry) => {
+    assertServerFnMiddleware(entry);
+    if (seen.has(entry)) return;
+    if (visiting.has(entry)) {
+      throw new Error("Server function middleware dependencies cannot contain a cycle");
+    }
+    visiting.add(entry);
+    for (const dependency of entry.middleware) {
+      visit(dependency);
+    }
+    visiting.delete(entry);
+    seen.add(entry);
+    resolved.push(entry);
+  };
+  for (const entry of middleware ?? []) {
+    visit(entry);
+  }
+  return Object.freeze(resolved);
+}
+function assertServerFnMiddleware(value) {
+  if (!value || typeof value !== "object" || value.__farmServerFnMiddleware !== true || typeof value.handler !== "function" || !Array.isArray(value.middleware)) {
+    throw new TypeError("createServerFn middleware must be created with createServerMiddleware");
+  }
+}
+function mergeServerFnContext(current, added) {
+  if (added !== void 0 && (added === null || typeof added !== "object" || Array.isArray(added))) {
+    throw new TypeError("Server function middleware context must be an object");
+  }
+  return Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), current, added));
+}
+async function _parseServerFnSchema(schema, value, contract, owner = "createServerFn") {
+  if (!schema) return value;
+  if (typeof schema.safeParseAsync === "function") {
+    const result = await schema.safeParseAsync(value);
+    return unwrapSafeParseResult(result);
+  }
+  if (typeof schema.safeParse === "function") {
+    const result = schema.safeParse(value);
+    return unwrapSafeParseResult(await result);
+  }
+  if (typeof schema.parseAsync === "function") {
+    return schema.parseAsync(value);
+  }
+  if (typeof schema.parse === "function") {
+    return schema.parse(value);
+  }
+  throw new TypeError(`${owner} ${contract} must provide parse, parseAsync, or safeParse`);
+}
+var schemaValidationFailures = /* @__PURE__ */ new WeakSet();
+function isSchemaValidationFailure(error) {
+  if (!error || typeof error !== "object") return false;
+  return schemaValidationFailures.has(error) || Array.isArray(error.issues);
+}
+function unwrapSafeParseResult(result) {
+  if (result && typeof result === "object" && "success" in result && result.success === false) {
+    const error = result.error;
+    if (error && typeof error === "object") schemaValidationFailures.add(error);
+    throw error;
+  }
+  if (result && typeof result === "object" && "success" in result && result.success === true) {
+    return result.data;
+  }
+  return result;
+}
+function formDataToObject(formData) {
+  const output = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of formData.entries()) {
+    if (!isSafeFormKey(key)) continue;
+    const existing = output[key];
+    if (existing === void 0) {
+      output[key] = value;
+    } else if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      output[key] = [existing, value];
+    }
+  }
+  return output;
+}
+function isSafeFormKey(key) {
+  return !key.startsWith("$ACTION_") && !UNSAFE_FORM_KEYS.has(key);
+}
+function isFormData(value) {
+  if (!value || typeof value !== "object") return false;
+  if (typeof FormData !== "undefined" && value instanceof FormData) {
+    return true;
+  }
+  return Object.prototype.toString.call(value) === "[object FormData]" && typeof value.entries === "function";
+}
+
+export {
+  FARM_SERVER_FN_SYMBOL,
+  createServerFunctionDescriptor,
+  _attachServerFunctionDescriptor,
+  _runServerFunctionForCaller,
+  _describeServerFunction,
+  _invokeServerFunction,
+  createServerMiddleware,
+  createServerFn,
+  _parseServerFnSchema
+};

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-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;