@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-KGZIORNL.cjs

@@ -0,0 +1,43 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/client/document-head.ts
+var FARM_NAVIGATION_HEAD_SELECTOR = [
+  "meta[name]",
+  "meta[property]",
+  "meta[http-equiv]",
+  "meta[charset]",
+  "meta[itemprop]",
+  'link[rel~="author"]',
+  'link[rel~="canonical"]',
+  'link[rel~="alternate"]',
+  'link[rel~="icon"]',
+  'link[rel~="apple-touch-icon"]',
+  'link[rel~="manifest"]',
+  'link[rel~="search"]',
+  'link[rel~="next"]',
+  'link[rel~="prev"]',
+  'link[rel~="publisher"]',
+  'link[rel~="license"]',
+  'link[rel~="help"]',
+  'link[rel~="me"]',
+  'link[rel~="pingback"]',
+  'link[rel~="privacy-policy"]',
+  'link[rel~="terms-of-service"]',
+  // Page and layout `metadata.jsonLd` (FARM_METADATA_ATTRIBUTE). The site-level
+  // agent JSON-LD and app-authored scripts carry no marker and stay in place.
+  'script[type="application/ld+json"][data-farm-metadata]'
+].join(",");
+function reconcileFarmDocumentHead(nextDocument) {
+  const nextTitle = nextDocument.querySelector("title");
+  document.title = _optionalChain([nextTitle, 'optionalAccess', _ => _.textContent]) || "";
+  document.head.querySelectorAll(FARM_NAVIGATION_HEAD_SELECTOR).forEach((node) => node.remove());
+  nextDocument.head.querySelectorAll(FARM_NAVIGATION_HEAD_SELECTOR).forEach((node) => document.head.appendChild(document.importNode(node, true)));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, reconcileFarmDocumentHead, "reconcileFarmDocumentHead");
+
+
+
+
+exports.FARM_NAVIGATION_HEAD_SELECTOR = FARM_NAVIGATION_HEAD_SELECTOR; exports.reconcileFarmDocumentHead = reconcileFarmDocumentHead;

package/dist/chunk-KR6CKSXT.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/config-entry.ts
+function defineConfig(config) {
+  return config;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defineConfig, "defineConfig");
+var defineFarmConfig = defineConfig;
+
+
+
+
+exports.defineConfig = defineConfig; exports.defineFarmConfig = defineFarmConfig;

package/dist/chunk-KROWKCUH.cjs

@@ -0,0 +1,185 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/client/chunk-recovery.ts
+var DEFAULT_MAX_AGE_MS = 3e4;
+var STORAGE_KEY_PREFIX = "farm:chunk-recovery:";
+var CHUNK_ERROR_PATTERNS = [
+  /ChunkLoadError/i,
+  /Loading chunk [\w-]+ failed/i,
+  /Loading CSS chunk [\w-]+ failed/i,
+  /CSS_CHUNK_LOAD_FAILED/i,
+  /failed to fetch dynamically imported module/i,
+  /error loading dynamically imported module/i,
+  /importing a module script failed/i,
+  /unable to preload CSS/i,
+  /module script failed/i
+];
+function isChunkLoadError(errorLike) {
+  const values = collectErrorText(errorLike);
+  if (values.some((value) => CHUNK_ERROR_PATTERNS.some((pattern) => pattern.test(value)))) {
+    return true;
+  }
+  const targetUrl = getEventTargetAssetUrl(errorLike);
+  return Boolean(
+    targetUrl && /\.(?:m?js|css)(?:[?#].*)?$/i.test(targetUrl) && isSameOriginAssetUrl(targetUrl)
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isChunkLoadError, "isChunkLoadError");
+function isSameOriginAssetUrl(url) {
+  if (typeof window === "undefined" || !window.location) {
+    return false;
+  }
+  try {
+    return new URL(url, window.location.href).origin === window.location.origin;
+  } catch (e) {
+    return false;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isSameOriginAssetUrl, "isSameOriginAssetUrl");
+function installChunkErrorRecovery(options = {}) {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  const recover = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (errorLike) => {
+    if (!isChunkLoadError(errorLike)) {
+      return;
+    }
+    if (!markRecovered(options)) {
+      return;
+    }
+    _optionalChain([options, 'access', _ => _.onRecover, 'optionalCall', _2 => _2(errorLike)]);
+    getReload(options)();
+  }, "recover");
+  const onError = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (event) => {
+    recover(getErrorEventPayload(event));
+  }, "onError");
+  const onUnhandledRejection = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (event) => {
+    recover(event.reason);
+  }, "onUnhandledRejection");
+  window.addEventListener("error", onError, true);
+  window.addEventListener("unhandledrejection", onUnhandledRejection);
+  return () => {
+    window.removeEventListener("error", onError, true);
+    window.removeEventListener("unhandledrejection", onUnhandledRejection);
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, installChunkErrorRecovery, "installChunkErrorRecovery");
+function markRecovered(options) {
+  const now = getNow(options);
+  const maxAgeMs = _nullishCoalesce(options.maxAgeMs, () => ( DEFAULT_MAX_AGE_MS));
+  const storage = getStorage(options);
+  const key = getStorageKey(options);
+  if (!storage) {
+    return false;
+  }
+  try {
+    const previous = Number(storage.getItem(key));
+    if (Number.isFinite(previous) && previous > 0 && now - previous < maxAgeMs) {
+      return false;
+    }
+    storage.setItem(key, String(now));
+    return true;
+  } catch (e2) {
+    return false;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, markRecovered, "markRecovered");
+function getErrorEventPayload(event) {
+  if ("error" in event && event.error) {
+    return event.error;
+  }
+  if ("message" in event && event.message) {
+    return event.message;
+  }
+  return event;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getErrorEventPayload, "getErrorEventPayload");
+function collectErrorText(value, seen = /* @__PURE__ */ new Set()) {
+  if (value == null || seen.has(value)) {
+    return [];
+  }
+  seen.add(value);
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return [String(value)];
+  }
+  if (typeof value !== "object") {
+    return [];
+  }
+  const record = value;
+  const output = [];
+  for (const key of ["name", "message", "code", "type", "request", "src", "href"]) {
+    const candidate = record[key];
+    if (typeof candidate === "string") {
+      output.push(candidate);
+    }
+  }
+  if ("reason" in record) {
+    output.push(...collectErrorText(record.reason, seen));
+  }
+  if ("error" in record) {
+    output.push(...collectErrorText(record.error, seen));
+  }
+  return output;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, collectErrorText, "collectErrorText");
+function getEventTargetAssetUrl(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const target = value.target;
+  if (!target || typeof target !== "object") {
+    return void 0;
+  }
+  const tagName = typeof target.tagName === "string" ? target.tagName.toLowerCase() : "";
+  if (tagName !== "script" && tagName !== "link") {
+    return void 0;
+  }
+  return typeof target.src === "string" && target.src ? target.src : typeof target.href === "string" && target.href ? target.href : void 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getEventTargetAssetUrl, "getEventTargetAssetUrl");
+function getStorage(options) {
+  if ("storage" in options) {
+    return options.storage;
+  }
+  try {
+    return window.sessionStorage;
+  } catch (e3) {
+    return null;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getStorage, "getStorage");
+function getStorageKey(options) {
+  if (options.storageKey) {
+    return options.storageKey;
+  }
+  const location = getLocation(options);
+  return `${STORAGE_KEY_PREFIX}${location.pathname}${location.search}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getStorageKey, "getStorageKey");
+function getLocation(options) {
+  return _nullishCoalesce(options.location, () => ( window.location));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getLocation, "getLocation");
+function getReload(options) {
+  if (options.reload) {
+    return options.reload;
+  }
+  const location = getLocation(options);
+  return () => location.reload();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getReload, "getReload");
+function getNow(options) {
+  return options.now ? options.now() : Date.now();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getNow, "getNow");
+
+
+
+
+exports.isChunkLoadError = isChunkLoadError; exports.installChunkErrorRecovery = installChunkErrorRecovery;

package/dist/chunk-KVFPGF2M.cjs

@@ -0,0 +1,46 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk62YJ2IEBcjs = require('./chunk-62YJ2IEB.cjs');
+
+
+var _chunkWJ3HK3LJcjs = require('./chunk-WJ3HK3LJ.cjs');
+
+
+var _chunkI57LW5VZcjs = require('./chunk-I57LW5VZ.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/navigation.ts
+function useRouter2() {
+  const router = _chunk62YJ2IEBcjs.useRouter.call(void 0, );
+  return {
+    push: router.push,
+    replace: router.replace,
+    back: router.back,
+    forward: router.forward,
+    refresh() {
+      if (typeof window === "undefined") return Promise.resolve();
+      return _chunkWJ3HK3LJcjs.getRouter.call(void 0, ).refresh();
+    },
+    prefetch(href) {
+      if (typeof window === "undefined") return Promise.resolve();
+      return _chunkWJ3HK3LJcjs.getRouter.call(void 0, ).prefetch(_chunkI57LW5VZcjs.applyFarmBasePath.call(void 0, href));
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, useRouter2, "useRouter");
+function usePathname() {
+  return _chunk62YJ2IEBcjs.useRouter.call(void 0, ).pathname;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, usePathname, "usePathname");
+function useSearchParams() {
+  return _chunk62YJ2IEBcjs.useRouter.call(void 0, ).searchParams;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, useSearchParams, "useSearchParams");
+
+
+
+
+
+exports.useRouter = useRouter2; exports.usePathname = usePathname; exports.useSearchParams = useSearchParams;

package/dist/{chunk-TNBAYAWO.mjs → chunk-L4DVIHOC.mjs}

@@ -21,7 +21,7 @@ import {
   readSchemaState,
   readSchemaTables,
   withoutRenameTargets
-} from "./chunk-DHDVMXYK.mjs";
+} from "./chunk-HALDNTIV.mjs";
 import {
   resolveSchemaModels
 } from "./chunk-ZMSZZXOR.mjs";

package/dist/chunk-LCCBO7PJ.cjs

@@ -0,0 +1,46 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkWMOGFOUJcjs = require('./chunk-WMOGFOUJ.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/query/params.ts
+function parseParam(input, key, parser) {
+  const values = input instanceof URLSearchParams ? input.getAll(key) : [_nullishCoalesce(input[key], () => ( ""))];
+  return {
+    raw: values.length > 1 ? values.join(",") : _nullishCoalesce(values[0], () => ( "")),
+    parsed: _chunkWMOGFOUJcjs.parseQueryParameter.call(void 0, parser, values)
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseParam, "parseParam");
+async function loadRouteParams(input, parsers, options = {}) {
+  const resolved = await Promise.resolve(input);
+  const result = {};
+  for (const [key, parser] of Object.entries(parsers)) {
+    const { raw, parsed } = parseParam(resolved, key, parser);
+    if (parsed === null && options.strict) {
+      throw new Error(`Failed to parse route param "${key}" with value "${raw}"`);
+    }
+    result[key] = parsed;
+  }
+  return result;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, loadRouteParams, "loadRouteParams");
+function parseRouteParams(input, parsers, options = {}) {
+  const result = {};
+  for (const [key, parser] of Object.entries(parsers)) {
+    const { raw, parsed } = parseParam(input, key, parser);
+    if (parsed === null && options.strict) {
+      throw new Error(`Failed to parse route param "${key}" with value "${raw}"`);
+    }
+    result[key] = parsed;
+  }
+  return result;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseRouteParams, "parseRouteParams");
+
+
+
+
+exports.loadRouteParams = loadRouteParams; exports.parseRouteParams = parseRouteParams;

package/dist/chunk-LIUGYUX3.cjs

@@ -0,0 +1,22 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/i18n/bridge.ts
+var FARM_I18N_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.i18n.snapshotResolver");
+function _setFarmI18nSnapshotResolver(resolver) {
+  globalThis[FARM_I18N_SNAPSHOT_RESOLVER] = resolver;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _setFarmI18nSnapshotResolver, "_setFarmI18nSnapshotResolver");
+function getActiveFarmI18nSnapshot() {
+  if (typeof window !== "undefined" && window.__FARM_I18N__) {
+    return window.__FARM_I18N__;
+  }
+  return _optionalChain([globalThis, 'access', _ => _[FARM_I18N_SNAPSHOT_RESOLVER], 'optionalCall', _2 => _2()]);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getActiveFarmI18nSnapshot, "getActiveFarmI18nSnapshot");
+
+
+
+
+exports._setFarmI18nSnapshotResolver = _setFarmI18nSnapshotResolver; exports.getActiveFarmI18nSnapshot = getActiveFarmI18nSnapshot;

package/dist/chunk-LTNGXMQ6.cjs

@@ -0,0 +1,55 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/client-observers.ts
+function notifyClientObserver(observer, args, label = "Client lifecycle") {
+  if (!observer) return;
+  const report = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (error) => {
+    const reportError = globalThis.reportError;
+    if (typeof reportError === "function") {
+      try {
+        reportError.call(globalThis, error);
+        return;
+      } catch (e) {
+      }
+    }
+    try {
+      console.error(`[Farm.js] ${label} callback failed:`, error);
+    } catch (e2) {
+    }
+  }, "report");
+  try {
+    const result = observer(...args);
+    if (result && typeof result.then === "function")
+      void Promise.resolve(result).catch(report);
+  } catch (error) {
+    report(error);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, notifyClientObserver, "notifyClientObserver");
+
+// src/client-retry.ts
+var MAX_TIMER_DELAY = 2147483647;
+function resolveClientRetryCount(value) {
+  const count = _nullishCoalesce(value, () => ( 0));
+  if (!Number.isSafeInteger(count) || count < 0) {
+    throw new RangeError("retry.count must be a non-negative safe integer");
+  }
+  return count;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveClientRetryCount, "resolveClientRetryCount");
+function resolveClientRetryDelay(value) {
+  const delay = _nullishCoalesce(value, () => ( 0));
+  if (!Number.isFinite(delay) || delay < 0 || delay > MAX_TIMER_DELAY) {
+    throw new RangeError(`retry.delay must be between 0 and ${MAX_TIMER_DELAY} milliseconds`);
+  }
+  return delay;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveClientRetryDelay, "resolveClientRetryDelay");
+
+
+
+
+
+exports.notifyClientObserver = notifyClientObserver; exports.resolveClientRetryCount = resolveClientRetryCount; exports.resolveClientRetryDelay = resolveClientRetryDelay;

package/dist/chunk-M2L4MYDQ.cjs

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/cli-colors.ts
+var _picocolors = require('picocolors'); var _picocolors2 = _interopRequireDefault(_picocolors);
+function createCliColors(interactive = process.stdout.isTTY === true) {
+  return _picocolors2.default.createColors(interactive);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createCliColors, "createCliColors");
+
+
+
+exports.createCliColors = createCliColors;

package/dist/chunk-MCJLA63J.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/chunk-MKB2EGIR.cjs

@@ -0,0 +1,148 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFarmRouteRuntimeConfig, "normalizeFarmRouteRuntimeConfig");
+function mergeFarmRouteRuntimeConfigs(...configs) {
+  const merged = {};
+  for (const config of configs) {
+    if (!config) continue;
+    if (config.runtime !== void 0) merged.runtime = config.runtime;
+    if (config.regions !== void 0) merged.regions = config.regions;
+    if (config.maxDuration !== void 0) merged.maxDuration = config.maxDuration;
+  }
+  return merged;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, mergeFarmRouteRuntimeConfigs, "mergeFarmRouteRuntimeConfigs");
+function resolveFarmRouteRuntimeConfig(config, source) {
+  const normalized = normalizeFarmRouteRuntimeConfig(config, source);
+  return {
+    runtime: _nullishCoalesce(normalized.runtime, () => ( "auto")),
+    ...normalized.regions && normalized.regions !== "auto" ? { regions: [...normalized.regions] } : {},
+    ...typeof normalized.maxDuration === "number" ? { maxDuration: normalized.maxDuration } : {}
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmRouteRuntimeConfig, "resolveFarmRouteRuntimeConfig");
+function hasFarmRouteRuntimeControls(config) {
+  return Boolean(
+    config && (config.runtime !== void 0 || config.regions !== void 0 || config.maxDuration !== void 0)
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, hasFarmRouteRuntimeControls, "hasFarmRouteRuntimeControls");
+function getFarmRouteRuntimeConfig(value) {
+  if (!value || typeof value !== "object") return {};
+  const route = value;
+  return {
+    ...route.runtime !== void 0 ? { runtime: route.runtime } : {},
+    ...route.regions !== void 0 ? { regions: route.regions } : {},
+    ...route.maxDuration !== void 0 ? { maxDuration: route.maxDuration } : {}
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmRouteRuntimeConfig, "getFarmRouteRuntimeConfig");
+function createFarmRouteRuntimeKey(config) {
+  return JSON.stringify({
+    runtime: config.runtime,
+    regions: config.regions || null,
+    maxDuration: config.maxDuration || null
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmRouteRuntimeKey, "createFarmRouteRuntimeKey");
+function resolveFarmRouteRuleRuntimeConfig(pathname, routeRules) {
+  if (!routeRules) return {};
+  const matches = Object.entries(routeRules).filter(
+    ([pattern, rule]) => hasFarmRouteRuntimeControls(rule) && farmRouteRuleMatches(pattern, pathname)
+  ).sort(([left], [right]) => compareFarmRouteRuleSpecificity(left, right));
+  return mergeFarmRouteRuntimeConfigs(...matches.map(([, rule]) => rule));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveFarmRouteRuleRuntimeConfig, "resolveFarmRouteRuleRuntimeConfig");
+function farmRouteRuleMatches(pattern, pathname) {
+  const normalizedPattern = normalizeRoutePattern(pattern);
+  const normalizedPathname = normalizeRoutePattern(pathname);
+  if (normalizedPattern === normalizedPathname) return true;
+  const expression = normalizedPattern.split("/").filter(Boolean).map((segment) => {
+    if (segment === "**") return ".*";
+    if (segment === "*") return "[^/]+";
+    if (/^\[\[\.\.\..+\]\]$/.test(segment)) return ".*";
+    if (/^\[\.\.\..+\]$/.test(segment)) return ".+";
+    if (/^\[.+\]$/.test(segment) || /^:.+$/.test(segment)) return "[^/]+";
+    return escapeRegExp(segment);
+  }).join("/");
+  return new RegExp(`^/${expression}/?$`).test(normalizedPathname);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, farmRouteRuleMatches, "farmRouteRuleMatches");
+function compareFarmRouteRuleSpecificity(left, right) {
+  const leftScore = getFarmRouteRuleSpecificity(left);
+  const rightScore = getFarmRouteRuleSpecificity(right);
+  return leftScore - rightScore || left.localeCompare(right);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compareFarmRouteRuleSpecificity, "compareFarmRouteRuleSpecificity");
+function getFarmRouteRuleSpecificity(pattern) {
+  return normalizeRoutePattern(pattern).split("/").filter(Boolean).reduce((score, segment) => {
+    if (segment === "**" || segment.startsWith("[[...")) return score + 1;
+    if (segment === "*" || segment.startsWith("[...")) return score + 10;
+    if (/^\[.+\]$/.test(segment) || /^:.+$/.test(segment)) return score + 50;
+    return score + 100;
+  }, 0);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmRouteRuleSpecificity, "getFarmRouteRuleSpecificity");
+function normalizeRoutePattern(value) {
+  const withSlash = value.trim().startsWith("/") ? value.trim() : `/${value.trim()}`;
+  return withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeRoutePattern, "normalizeRoutePattern");
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, escapeRegExp, "escapeRegExp");
+
+
+
+
+
+
+
+
+
+
+exports.normalizeFarmRouteRuntimeConfig = normalizeFarmRouteRuntimeConfig; exports.mergeFarmRouteRuntimeConfigs = mergeFarmRouteRuntimeConfigs; exports.resolveFarmRouteRuntimeConfig = resolveFarmRouteRuntimeConfig; exports.hasFarmRouteRuntimeControls = hasFarmRouteRuntimeControls; exports.getFarmRouteRuntimeConfig = getFarmRouteRuntimeConfig; exports.createFarmRouteRuntimeKey = createFarmRouteRuntimeKey; exports.resolveFarmRouteRuleRuntimeConfig = resolveFarmRouteRuleRuntimeConfig; exports.farmRouteRuleMatches = farmRouteRuleMatches;