@farm.js/core 0.1.47 → 0.1.48

package/dist/chunk-EVIWKPJV.cjs

@@ -0,0 +1,560 @@
+"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; }// src/tracing.ts
+
+
+
+
+
+
+
+
+var _api = require('@opentelemetry/api');
+var FARM_TRACER_NAME = "@farm.js/core";
+var ALL_SPAN_KINDS = [
+  "request",
+  "render",
+  "middleware",
+  "api",
+  "integration",
+  "storage",
+  "ppr",
+  "build",
+  "plugin"
+];
+var DEFAULT_IGNORED_PATHS = [
+  "/@vite/",
+  "/@fs/",
+  "/@id/",
+  "/@react-refresh",
+  "/node_modules/",
+  "/__vite",
+  "/.well-known/appspecific/"
+];
+var FARM_REQUEST_METHOD_CONTEXT_KEY = _api.createContextKey.call(void 0, "@farm.js/core/request-method");
+var TRACING_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/tracing-runtime/v1");
+var runtime = globalThis;
+var tracingState = _nullishCoalesce(runtime[TRACING_RUNTIME], () => ( (runtime[TRACING_RUNTIME] = normalizeFarmTracingConfig(false))));
+function normalizeFarmTracingConfig(config) {
+  if (!config) {
+    return {
+      enabled: false,
+      spans: new Set(ALL_SPAN_KINDS),
+      recordEvents: true,
+      attributes: {},
+      ignorePaths: DEFAULT_IGNORED_PATHS
+    };
+  }
+  if (config === true) {
+    return {
+      enabled: true,
+      spans: new Set(ALL_SPAN_KINDS),
+      recordEvents: true,
+      attributes: {},
+      ignorePaths: DEFAULT_IGNORED_PATHS
+    };
+  }
+  return {
+    enabled: _nullishCoalesce(config.enabled, () => ( true)),
+    spans: new Set(_nullishCoalesce(config.spans, () => ( ALL_SPAN_KINDS))),
+    recordEvents: _nullishCoalesce(config.recordEvents, () => ( true)),
+    attributes: { ...config.attributes },
+    ignorePaths: [...DEFAULT_IGNORED_PATHS, ..._nullishCoalesce(config.ignorePaths, () => ( []))]
+  };
+}
+function configureFarmTracing(config) {
+  if (isResolvedFarmTracingConfig(config)) {
+    Object.assign(tracingState, {
+      ...config,
+      spans: new Set(config.spans),
+      attributes: { ...config.attributes },
+      ignorePaths: [...config.ignorePaths]
+    });
+    return;
+  }
+  Object.assign(
+    tracingState,
+    normalizeFarmTracingConfig(config)
+  );
+}
+function isResolvedFarmTracingConfig(config) {
+  return !!config && typeof config === "object" && typeof config.enabled === "boolean" && config.spans instanceof Set && typeof config.recordEvents === "boolean" && Array.isArray(config.ignorePaths);
+}
+function resetFarmTracing() {
+  Object.assign(tracingState, normalizeFarmTracingConfig(false));
+}
+function getFarmTraceContext() {
+  return getSpanTraceContext(_api.trace.getSpan(_api.context.active()));
+}
+async function runWithFarmSpan(name, handler, options = {}) {
+  const spanFamily = options.kind;
+  if (!tracingState.enabled || spanFamily !== void 0 && !tracingState.spans.has(spanFamily)) {
+    return await handler();
+  }
+  const tracer = _api.trace.getTracer(FARM_TRACER_NAME);
+  return await tracer.startActiveSpan(
+    name,
+    {
+      kind: _nullishCoalesce(options.spanKind, () => ( _api.SpanKind.INTERNAL)),
+      attributes: {
+        ...tracingState.attributes,
+        ...options.attributes
+      }
+    },
+    async (span) => {
+      try {
+        return await handler();
+      } catch (error) {
+        recordSpanError(span, error);
+        throw error;
+      } finally {
+        span.end();
+      }
+    }
+  );
+}
+async function _runWithFarmRequestSpan(request, handler, options = {}) {
+  const startedAt = Date.now();
+  const url = tracingState.enabled && tracingState.spans.has("request") ? new URL(request.url) : void 0;
+  const shouldTrace = url && !tracingState.ignorePaths.some((prefix) => url.pathname.startsWith(prefix));
+  if (!shouldTrace) {
+    _optionalChain([options, 'access', _ => _.onStart, 'optionalCall', _2 => _2()]);
+    try {
+      const result = await handler();
+      _optionalChain([options, 'access', _3 => _3.onComplete, 'optionalCall', _4 => _4(resolveResultStatus(result, options), Date.now() - startedAt)]);
+      return result;
+    } catch (error) {
+      _optionalChain([options, 'access', _5 => _5.onError, 'optionalCall', _6 => _6(error, Date.now() - startedAt)]);
+      throw error;
+    }
+  }
+  const extractedContext = _api.propagation.extract(_api.context.active(), request.headers, {
+    keys(carrier) {
+      return Array.from(carrier.keys());
+    },
+    get(carrier, key) {
+      return _nullishCoalesce(carrier.get(key), () => ( void 0));
+    }
+  });
+  const requestContext = extractedContext.setValue(FARM_REQUEST_METHOD_CONTEXT_KEY, request.method);
+  const tracer = _api.trace.getTracer(FARM_TRACER_NAME);
+  const attributes = {
+    ...tracingState.attributes,
+    "http.request.method": request.method,
+    "url.path": url.pathname,
+    "url.scheme": url.protocol.replace(/:$/, ""),
+    "server.address": url.hostname
+  };
+  if (url.port) attributes["server.port"] = Number(url.port);
+  return await tracer.startActiveSpan(
+    `${request.method} ${url.pathname}`,
+    { kind: _api.SpanKind.SERVER, attributes },
+    requestContext,
+    async (span) => {
+      _optionalChain([options, 'access', _7 => _7.onStart, 'optionalCall', _8 => _8()]);
+      try {
+        const result = await handler();
+        const status = resolveResultStatus(result, options);
+        setResponseStatus(span, status);
+        _optionalChain([options, 'access', _9 => _9.onComplete, 'optionalCall', _10 => _10(status, Date.now() - startedAt)]);
+        return result;
+      } catch (error) {
+        recordSpanError(span, error);
+        _optionalChain([options, 'access', _11 => _11.onError, 'optionalCall', _12 => _12(error, Date.now() - startedAt)]);
+        throw error;
+      } finally {
+        span.end();
+      }
+    }
+  );
+}
+function recordFarmEventTrace(event) {
+  if (!tracingState.enabled) return void 0;
+  const activeContext = _api.context.active();
+  const activeSpan = _api.trace.getSpan(activeContext);
+  const traceContext = getSpanTraceContext(activeSpan);
+  if (activeSpan && traceContext) {
+    if (event.type === "route.matched") {
+      const method = _nullishCoalesce(activeContext.getValue(FARM_REQUEST_METHOD_CONTEXT_KEY), () => ( "HTTP"));
+      activeSpan.updateName(`${method} ${event.route}`);
+      activeSpan.setAttribute("http.route", event.route);
+      activeSpan.setAttribute("farm.route", event.route);
+    }
+    if (tracingState.recordEvents) {
+      activeSpan.addEvent(event.type, toEventAttributes(event), event.timestamp);
+    }
+    const error = event.type === "request.error" ? void 0 : getEventError(event);
+    if (error !== void 0) {
+      if (event.type === "render.error") {
+        recordSpanException(activeSpan, error);
+      } else {
+        recordSpanError(activeSpan, error);
+      }
+    }
+  }
+  const completedTraceContext = recordCompletedEventSpan(event, activeContext);
+  return _nullishCoalesce(traceContext, () => ( completedTraceContext));
+}
+function recordCompletedEventSpan(event, parentContext) {
+  const descriptor = getCompletedSpanDescriptor(event);
+  if (!descriptor || !tracingState.spans.has(descriptor.kind)) return void 0;
+  const tracer = _api.trace.getTracer(FARM_TRACER_NAME);
+  const span = tracer.startSpan(
+    descriptor.name,
+    {
+      kind: _api.SpanKind.INTERNAL,
+      startTime: event.timestamp - descriptor.durationMs,
+      attributes: {
+        ...tracingState.attributes,
+        ...toEventAttributes(event),
+        "farm.event.type": event.type
+      }
+    },
+    parentContext
+  );
+  const status = "status" in event && typeof event.status === "number" ? event.status : void 0;
+  if (status !== void 0) setResponseStatus(span, status);
+  const error = getEventError(event);
+  if (error !== void 0) recordSpanError(span, error);
+  const traceContext = getSpanTraceContext(span);
+  span.end(event.timestamp);
+  return traceContext;
+}
+function getCompletedSpanDescriptor(event) {
+  if (!("durationMs" in event) || typeof event.durationMs !== "number") return void 0;
+  switch (event.type) {
+    case "render.complete":
+      return { kind: "render", name: `farm.render ${event.route}`, durationMs: event.durationMs };
+    case "render.stream.shellReady":
+      return {
+        kind: "render",
+        name: `farm.render.shell ${event.route}`,
+        durationMs: event.durationMs
+      };
+    case "render.stream.complete":
+      return {
+        kind: "render",
+        name: `farm.render.stream ${event.route}`,
+        durationMs: event.durationMs
+      };
+    case "middleware.complete":
+      return {
+        kind: "middleware",
+        name: `farm.middleware ${_nullishCoalesce(_nullishCoalesce(event.name, () => ( event.route)), () => ( "anonymous"))}`,
+        durationMs: event.durationMs
+      };
+    case "api.request.complete":
+    case "api.error":
+      return {
+        kind: "api",
+        name: `farm.api ${event.method} ${event.route}`,
+        durationMs: event.durationMs
+      };
+    case "integration.api.call.complete":
+      return {
+        kind: "integration",
+        name: `farm.integration ${event.integration}.${event.operation}`,
+        durationMs: event.durationMs
+      };
+    case "storage.query.complete":
+      return {
+        kind: "storage",
+        name: `farm.storage ${event.operation}`,
+        durationMs: event.durationMs
+      };
+    case "ppr.refresh.complete":
+      return {
+        kind: "ppr",
+        name: `farm.ppr.refresh ${event.route}`,
+        durationMs: event.durationMs
+      };
+    case "build.complete":
+      return {
+        kind: "build",
+        name: `farm.build${event.target ? ` ${event.target}` : ""}`,
+        durationMs: event.durationMs
+      };
+    case "plugin.hook.complete":
+      return {
+        kind: "plugin",
+        name: `farm.plugin ${event.plugin}.${event.hook}`,
+        durationMs: event.durationMs
+      };
+    default:
+      return void 0;
+  }
+}
+function hashFarmCacheKey(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function toEventAttributes(event) {
+  const attributes = {};
+  for (const [key, value] of Object.entries(event)) {
+    if (key === "timestamp" || key === "level" || key === "error" || key === "traceId" || key === "spanId" || key === "traceSampled" || value === void 0) {
+      continue;
+    }
+    if (key === "key" && typeof value === "string") {
+      attributes["farm.key_hash"] = hashFarmCacheKey(value);
+      continue;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      attributes[`farm.${key}`] = value;
+    } else if (Array.isArray(value)) {
+      if (value.every((entry) => typeof entry === "string")) {
+        attributes[`farm.${key}`] = value;
+      } else if (value.every((entry) => typeof entry === "number")) {
+        attributes[`farm.${key}`] = value;
+      } else if (value.every((entry) => typeof entry === "boolean")) {
+        attributes[`farm.${key}`] = value;
+      }
+    }
+  }
+  return attributes;
+}
+function getEventError(event) {
+  return "error" in event ? event.error : void 0;
+}
+function recordSpanException(span, error) {
+  const normalized = error instanceof Error ? error : new Error(String(error));
+  span.recordException(normalized);
+  return normalized;
+}
+function recordSpanError(span, error) {
+  const normalized = recordSpanException(span, error);
+  span.setStatus({ code: _api.SpanStatusCode.ERROR, message: normalized.message });
+}
+function setResponseStatus(span, status) {
+  span.setAttribute("http.response.status_code", status);
+  if (status >= 500) {
+    span.setStatus({ code: _api.SpanStatusCode.ERROR });
+  }
+}
+function resolveResultStatus(result, options) {
+  if (result instanceof Response) return result.status;
+  return _nullishCoalesce(_optionalChain([options, 'access', _13 => _13.getStatusCode, 'optionalCall', _14 => _14()]), () => ( 200));
+}
+function getSpanTraceContext(span) {
+  if (!span) return void 0;
+  const spanContext = span.spanContext();
+  if (!_api.isSpanContextValid.call(void 0, spanContext)) return void 0;
+  return {
+    traceId: spanContext.traceId,
+    spanId: spanContext.spanId,
+    traceSampled: (spanContext.traceFlags & 1) === 1
+  };
+}
+
+// src/observability.ts
+var OBSERVABILITY_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/observability-runtime/v1");
+var runtime2 = globalThis;
+var shared = _nullishCoalesce(runtime2[OBSERVABILITY_RUNTIME], () => ( (runtime2[OBSERVABILITY_RUNTIME] = {
+  handlers: /* @__PURE__ */ new Set(),
+  unfilteredHandlers: /* @__PURE__ */ new Set(),
+  config: { logs: false, handlers: [], tracing: normalizeFarmTracingConfig(false) }
+})));
+var runtimeHandlers = shared.handlers;
+var unfilteredRuntimeHandlers = shared.unfilteredHandlers;
+var observabilityState = shared.config;
+function configureFarmObservability(config) {
+  Object.assign(
+    observabilityState,
+    { events: void 0 },
+    normalizeFarmObservabilityConfig(config)
+  );
+  configureFarmTracing(observabilityState.tracing);
+}
+function normalizeFarmObservabilityConfig(config) {
+  if (config === void 0 || config === false) {
+    return { logs: false, handlers: [], tracing: normalizeFarmTracingConfig(false) };
+  }
+  if (config === true) {
+    return { logs: true, handlers: [], tracing: normalizeFarmTracingConfig(false) };
+  }
+  const handlers = config.onEvent ? Array.isArray(config.onEvent) ? [...config.onEvent] : [config.onEvent] : [];
+  return {
+    logs: _nullishCoalesce(config.logs, () => ( false)),
+    handlers,
+    events: config.events ? new Set(config.events) : void 0,
+    tracing: normalizeFarmTracingConfig(config.tracing)
+  };
+}
+function onFarmEvent(handler, options = {}) {
+  const handlers = options.unfiltered ? unfilteredRuntimeHandlers : runtimeHandlers;
+  handlers.add(handler);
+  return () => {
+    handlers.delete(handler);
+  };
+}
+function resetFarmObservability() {
+  runtimeHandlers.clear();
+  unfilteredRuntimeHandlers.clear();
+  Object.assign(observabilityState, {
+    logs: false,
+    handlers: [],
+    events: void 0,
+    tracing: normalizeFarmTracingConfig(false)
+  });
+  resetFarmTracing();
+}
+function emitFarmEvent(input) {
+  const event = {
+    timestamp: Date.now(),
+    level: inferFarmEventLevel(input.type),
+    ...input
+  };
+  if (event.type === "route.redirect") event.to = event.to.replace(/[?#][\s\S]*$/, "");
+  const traceContext = recordFarmEventTrace(event);
+  if (traceContext) {
+    event.traceId = traceContext.traceId;
+    event.spanId = traceContext.spanId;
+    event.traceSampled = traceContext.traceSampled;
+  }
+  notifyFarmEventHandlers(event, unfilteredRuntimeHandlers);
+  if (!shouldEmitFarmEvent(event)) return event;
+  if (observabilityState.logs) {
+    logFarmEvent(event);
+  }
+  notifyFarmEventHandlers(event, [...observabilityState.handlers, ...runtimeHandlers]);
+  return event;
+}
+function notifyFarmEventHandlers(event, handlers) {
+  for (const handler of handlers) {
+    try {
+      Promise.resolve(handler(event)).catch((error) => {
+        console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
+      });
+    } catch (error) {
+      console.warn(`[farm:observability] event handler failed: ${formatError(error)}`);
+    }
+  }
+}
+async function runWithFarmRequestSpan(request, handler, options = {}) {
+  const url = new URL(request.url);
+  const method = request.method || "GET";
+  return await _runWithFarmRequestSpan(request, handler, {
+    ...options,
+    onStart() {
+      emitFarmEvent({ type: "request.start", method, pathname: url.pathname });
+      _optionalChain([options, 'access', _15 => _15.onStart, 'optionalCall', _16 => _16()]);
+    },
+    onComplete(status, durationMs) {
+      emitFarmEvent({
+        type: "request.complete",
+        method,
+        pathname: url.pathname,
+        status,
+        durationMs
+      });
+      _optionalChain([options, 'access', _17 => _17.onComplete, 'optionalCall', _18 => _18(status, durationMs)]);
+    },
+    onError(error, durationMs) {
+      emitFarmEvent({
+        type: "request.error",
+        method,
+        pathname: url.pathname,
+        durationMs,
+        error
+      });
+      _optionalChain([options, 'access', _19 => _19.onError, 'optionalCall', _20 => _20(error, durationMs)]);
+    }
+  });
+}
+function shouldEmitFarmEvent(event) {
+  if (!observabilityState.logs && observabilityState.handlers.length === 0 && runtimeHandlers.size === 0) {
+    return false;
+  }
+  if (observabilityState.events && !observabilityState.events.has(event.type)) {
+    return false;
+  }
+  return true;
+}
+function inferFarmEventLevel(type) {
+  if (type === "error" || type.endsWith(".error") || type.endsWith(".failed")) {
+    return "error";
+  }
+  if (type.endsWith(".bypass") || type.endsWith(".invalidated") || type.endsWith(".stale") || type.endsWith(".notFound")) {
+    return "warn";
+  }
+  if (type.endsWith(".hit") || type.endsWith(".miss") || type.endsWith(".start") || type.endsWith(".shellReady")) {
+    return "debug";
+  }
+  return "info";
+}
+function logFarmEvent(event) {
+  const message = `[farm:${event.level}] ${event.type}${formatFarmEventDetails(event)}`;
+  switch (event.level) {
+    case "error":
+      console.error(message);
+      break;
+    case "warn":
+      console.warn(message);
+      break;
+    default:
+      console.log(message);
+      break;
+  }
+}
+function formatFarmEventDetails(event) {
+  const details = [];
+  const record = event;
+  for (const key of [
+    "route",
+    "pathname",
+    "method",
+    "status",
+    "key",
+    "tag",
+    "path",
+    "reason",
+    "durationMs",
+    "integration",
+    "server",
+    "tool",
+    "outcome",
+    "operation",
+    "plugin",
+    "hook",
+    "target",
+    "count"
+  ]) {
+    const value = record[key];
+    if (key === "key" && typeof value === "string") {
+      details.push(`key_hash=${hashFarmCacheKey(value)}`);
+    } else if (value !== void 0) {
+      details.push(`${key}=${formatDetailValue(value)}`);
+    }
+  }
+  return details.length > 0 ? ` ${details.join(" ")}` : "";
+}
+function formatDetailValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch (e) {
+    return String(value);
+  }
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+exports.normalizeFarmTracingConfig = normalizeFarmTracingConfig; exports.configureFarmTracing = configureFarmTracing; exports.getFarmTraceContext = getFarmTraceContext; exports.runWithFarmSpan = runWithFarmSpan; exports.configureFarmObservability = configureFarmObservability; exports.normalizeFarmObservabilityConfig = normalizeFarmObservabilityConfig; exports.onFarmEvent = onFarmEvent; exports.resetFarmObservability = resetFarmObservability; exports.emitFarmEvent = emitFarmEvent; exports.runWithFarmRequestSpan = runWithFarmRequestSpan;

package/dist/chunk-EVMXPJCB.mjs

@@ -0,0 +1,133 @@
+// src/route-runtime.ts
+function normalizeFarmRouteRuntimeConfig(value, source = "Route configuration") {
+  if (!value) return {};
+  const normalized = {};
+  if (value.runtime !== void 0) {
+    const runtime = value.runtime === "nodejs" ? "node" : value.runtime;
+    if (runtime !== "auto" && runtime !== "node" && runtime !== "edge") {
+      throw new TypeError(`${source} runtime must be "auto", "node", or "edge"`);
+    }
+    normalized.runtime = 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;
+}
+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;
+}
+function resolveFarmRouteRuntimeConfig(config, source) {
+  const normalized = normalizeFarmRouteRuntimeConfig(config, source);
+  return {
+    runtime: normalized.runtime ?? "auto",
+    ...normalized.regions && normalized.regions !== "auto" ? { regions: [...normalized.regions] } : {},
+    ...typeof normalized.maxDuration === "number" ? { maxDuration: normalized.maxDuration } : {}
+  };
+}
+function hasFarmRouteRuntimeControls(config) {
+  return Boolean(
+    config && (config.runtime !== void 0 || config.regions !== void 0 || config.maxDuration !== void 0)
+  );
+}
+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 } : {}
+  };
+}
+function createFarmRouteRuntimeKey(config) {
+  return JSON.stringify({
+    runtime: config.runtime,
+    regions: config.regions || null,
+    maxDuration: config.maxDuration || null
+  });
+}
+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));
+}
+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);
+}
+function compareFarmRouteRuleSpecificity(left, right) {
+  const leftScore = getFarmRouteRuleSpecificity(left);
+  const rightScore = getFarmRouteRuleSpecificity(right);
+  return leftScore - rightScore || left.localeCompare(right);
+}
+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);
+}
+function normalizeRoutePattern(value) {
+  const withSlash = value.trim().startsWith("/") ? value.trim() : `/${value.trim()}`;
+  return withSlash.length > 1 ? withSlash.replace(/\/+$/, "") : withSlash;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export {
+  normalizeFarmRouteRuntimeConfig,
+  mergeFarmRouteRuntimeConfigs,
+  resolveFarmRouteRuntimeConfig,
+  hasFarmRouteRuntimeControls,
+  getFarmRouteRuntimeConfig,
+  createFarmRouteRuntimeKey,
+  resolveFarmRouteRuleRuntimeConfig,
+  farmRouteRuleMatches
+};