@farm.js/core 0.1.51-beta.3 → 0.1.61

package/dist/chunk-EVIWKPJV.cjs

@@ -1,560 +0,0 @@
-"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

@@ -1,133 +0,0 @@
-// 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
-};