@farm.js/core 0.1.61 → 0.1.63

package/dist/chunk-FUZEBRP3.mjs

@@ -1,593 +0,0 @@
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/tracing.ts
-import {
-  context,
-  createContextKey,
-  isSpanContextValid,
-  propagation,
-  SpanKind,
-  SpanStatusCode,
-  trace
-} from "@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 = createContextKey("@farm.js/core/request-method");
-var TRACING_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/tracing-runtime/v1");
-var runtime = globalThis;
-var tracingState = 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: config.enabled ?? true,
-    spans: new Set(config.spans ?? ALL_SPAN_KINDS),
-    recordEvents: config.recordEvents ?? true,
-    attributes: { ...config.attributes },
-    ignorePaths: [...DEFAULT_IGNORED_PATHS, ...config.ignorePaths ?? []]
-  };
-}
-__name(normalizeFarmTracingConfig, "normalizeFarmTracingConfig");
-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)
-  );
-}
-__name(configureFarmTracing, "configureFarmTracing");
-function isResolvedFarmTracingConfig(config) {
-  return !!config && typeof config === "object" && typeof config.enabled === "boolean" && config.spans instanceof Set && typeof config.recordEvents === "boolean" && Array.isArray(config.ignorePaths);
-}
-__name(isResolvedFarmTracingConfig, "isResolvedFarmTracingConfig");
-function resetFarmTracing() {
-  Object.assign(tracingState, normalizeFarmTracingConfig(false));
-}
-__name(resetFarmTracing, "resetFarmTracing");
-function getFarmTraceContext() {
-  return getSpanTraceContext(trace.getSpan(context.active()));
-}
-__name(getFarmTraceContext, "getFarmTraceContext");
-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 = trace.getTracer(FARM_TRACER_NAME);
-  return await tracer.startActiveSpan(
-    name,
-    {
-      kind: options.spanKind ?? SpanKind.INTERNAL,
-      attributes: {
-        ...tracingState.attributes,
-        ...options.attributes
-      }
-    },
-    async (span) => {
-      try {
-        return await handler();
-      } catch (error) {
-        recordSpanError(span, error);
-        throw error;
-      } finally {
-        span.end();
-      }
-    }
-  );
-}
-__name(runWithFarmSpan, "runWithFarmSpan");
-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) {
-    options.onStart?.();
-    try {
-      const result = await handler();
-      options.onComplete?.(resolveResultStatus(result, options), Date.now() - startedAt);
-      return result;
-    } catch (error) {
-      options.onError?.(error, Date.now() - startedAt);
-      throw error;
-    }
-  }
-  const extractedContext = propagation.extract(context.active(), request.headers, {
-    keys(carrier) {
-      return Array.from(carrier.keys());
-    },
-    get(carrier, key) {
-      return carrier.get(key) ?? void 0;
-    }
-  });
-  const requestContext = extractedContext.setValue(FARM_REQUEST_METHOD_CONTEXT_KEY, request.method);
-  const tracer = 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: SpanKind.SERVER, attributes },
-    requestContext,
-    async (span) => {
-      options.onStart?.();
-      try {
-        const result = await handler();
-        const status = resolveResultStatus(result, options);
-        setResponseStatus(span, status);
-        options.onComplete?.(status, Date.now() - startedAt);
-        return result;
-      } catch (error) {
-        recordSpanError(span, error);
-        options.onError?.(error, Date.now() - startedAt);
-        throw error;
-      } finally {
-        span.end();
-      }
-    }
-  );
-}
-__name(_runWithFarmRequestSpan, "_runWithFarmRequestSpan");
-function recordFarmEventTrace(event) {
-  if (!tracingState.enabled) return void 0;
-  const activeContext = context.active();
-  const activeSpan = trace.getSpan(activeContext);
-  const traceContext = getSpanTraceContext(activeSpan);
-  if (activeSpan && traceContext) {
-    if (event.type === "route.matched") {
-      const method = 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 traceContext ?? completedTraceContext;
-}
-__name(recordFarmEventTrace, "recordFarmEventTrace");
-function recordCompletedEventSpan(event, parentContext) {
-  const descriptor = getCompletedSpanDescriptor(event);
-  if (!descriptor || !tracingState.spans.has(descriptor.kind)) return void 0;
-  const tracer = trace.getTracer(FARM_TRACER_NAME);
-  const span = tracer.startSpan(
-    descriptor.name,
-    {
-      kind: 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;
-}
-__name(recordCompletedEventSpan, "recordCompletedEventSpan");
-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 ${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;
-  }
-}
-__name(getCompletedSpanDescriptor, "getCompletedSpanDescriptor");
-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");
-}
-__name(hashFarmCacheKey, "hashFarmCacheKey");
-function toEventAttributes(event) {
-  const attributes = {};
-  const redactKey = typeof event.type === "string" && event.type.startsWith("cache.");
-  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 (redactKey && 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;
-}
-__name(toEventAttributes, "toEventAttributes");
-function getEventError(event) {
-  return "error" in event ? event.error : void 0;
-}
-__name(getEventError, "getEventError");
-function recordSpanException(span, error) {
-  const normalized = error instanceof Error ? error : new Error(String(error));
-  span.recordException(normalized);
-  return normalized;
-}
-__name(recordSpanException, "recordSpanException");
-function recordSpanError(span, error) {
-  const normalized = recordSpanException(span, error);
-  span.setStatus({ code: SpanStatusCode.ERROR, message: normalized.message });
-}
-__name(recordSpanError, "recordSpanError");
-function setResponseStatus(span, status) {
-  span.setAttribute("http.response.status_code", status);
-  if (status >= 500) {
-    span.setStatus({ code: SpanStatusCode.ERROR });
-  }
-}
-__name(setResponseStatus, "setResponseStatus");
-function resolveResultStatus(result, options) {
-  if (result instanceof Response) return result.status;
-  return options.getStatusCode?.() ?? 200;
-}
-__name(resolveResultStatus, "resolveResultStatus");
-function getSpanTraceContext(span) {
-  if (!span) return void 0;
-  const spanContext = span.spanContext();
-  if (!isSpanContextValid(spanContext)) return void 0;
-  return {
-    traceId: spanContext.traceId,
-    spanId: spanContext.spanId,
-    traceSampled: (spanContext.traceFlags & 1) === 1
-  };
-}
-__name(getSpanTraceContext, "getSpanTraceContext");
-
-// src/observability.ts
-var OBSERVABILITY_RUNTIME = /* @__PURE__ */ Symbol.for("@farm.js/core/observability-runtime/v1");
-var runtime2 = globalThis;
-var shared = 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);
-}
-__name(configureFarmObservability, "configureFarmObservability");
-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: config.logs ?? false,
-    handlers,
-    events: config.events ? new Set(config.events) : void 0,
-    tracing: normalizeFarmTracingConfig(config.tracing)
-  };
-}
-__name(normalizeFarmObservabilityConfig, "normalizeFarmObservabilityConfig");
-function onFarmEvent(handler, options = {}) {
-  const handlers = options.unfiltered ? unfilteredRuntimeHandlers : runtimeHandlers;
-  handlers.add(handler);
-  return () => {
-    handlers.delete(handler);
-  };
-}
-__name(onFarmEvent, "onFarmEvent");
-function resetFarmObservability() {
-  runtimeHandlers.clear();
-  unfilteredRuntimeHandlers.clear();
-  Object.assign(observabilityState, {
-    logs: false,
-    handlers: [],
-    events: void 0,
-    tracing: normalizeFarmTracingConfig(false)
-  });
-  resetFarmTracing();
-}
-__name(resetFarmObservability, "resetFarmObservability");
-function emitFarmEvent(input) {
-  const event = {
-    timestamp: Date.now(),
-    level: inferFarmEventLevel(input.type),
-    ...input
-  };
-  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;
-}
-__name(emitFarmEvent, "emitFarmEvent");
-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)}`);
-    }
-  }
-}
-__name(notifyFarmEventHandlers, "notifyFarmEventHandlers");
-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 });
-      options.onStart?.();
-    },
-    onComplete(status, durationMs) {
-      emitFarmEvent({
-        type: "request.complete",
-        method,
-        pathname: url.pathname,
-        status,
-        durationMs
-      });
-      options.onComplete?.(status, durationMs);
-    },
-    onError(error, durationMs) {
-      emitFarmEvent({
-        type: "request.error",
-        method,
-        pathname: url.pathname,
-        durationMs,
-        error
-      });
-      options.onError?.(error, durationMs);
-    }
-  });
-}
-__name(runWithFarmRequestSpan, "runWithFarmRequestSpan");
-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;
-}
-__name(shouldEmitFarmEvent, "shouldEmitFarmEvent");
-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";
-}
-__name(inferFarmEventLevel, "inferFarmEventLevel");
-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;
-  }
-}
-__name(logFarmEvent, "logFarmEvent");
-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 (value !== void 0) {
-      details.push(`${key}=${formatDetailValue(value)}`);
-    }
-  }
-  return details.length > 0 ? ` ${details.join(" ")}` : "";
-}
-__name(formatFarmEventDetails, "formatFarmEventDetails");
-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 {
-    return String(value);
-  }
-}
-__name(formatDetailValue, "formatDetailValue");
-function formatError(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-__name(formatError, "formatError");
-
-export {
-  normalizeFarmTracingConfig,
-  configureFarmTracing,
-  getFarmTraceContext,
-  runWithFarmSpan,
-  configureFarmObservability,
-  normalizeFarmObservabilityConfig,
-  onFarmEvent,
-  resetFarmObservability,
-  emitFarmEvent,
-  runWithFarmRequestSpan
-};

package/dist/chunk-FZ6YYU2W.mjs

@@ -1,65 +0,0 @@
-import {
-  getRequestSourceOrigin,
-  matchesAllowedOrigin,
-  matchesHostHeader,
-  normalizeAllowedOriginPattern
-} from "./chunk-FP2INE7H.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/integration-request-security.ts
-function resolveIntegrationAllowedOrigins(values, label) {
-  return Object.freeze((values ?? []).map((value) => normalizeAllowedOriginPattern(value, label)));
-}
-__name(resolveIntegrationAllowedOrigins, "resolveIntegrationAllowedOrigins");
-function validateIntegrationRequestOrigin(request, policy = {}) {
-  const allowedOrigins = policy.allowedOrigins ?? [];
-  const requireOriginMetadata = policy.requireOriginMetadata ?? true;
-  const fetchSite = request.headers.get("sec-fetch-site")?.trim().toLowerCase();
-  const source = getRequestSourceOrigin(request);
-  if (!source.ok) {
-    return { ok: false, reason: source.reason };
-  }
-  if (source.origin === null) {
-    if (fetchSite === "same-origin") {
-      return { ok: true };
-    }
-    if (requireOriginMetadata) {
-      return { ok: false, reason: fetchSite === "cross-site" ? "cross-site" : "missing-origin" };
-    }
-    return fetchSite === "cross-site" ? { ok: false, reason: "cross-site" } : { ok: true };
-  }
-  const requestUrl = new URL(request.url);
-  const matchesConfiguredOrigin = allowedOrigins.some(
-    (pattern) => matchesAllowedOrigin(source.origin, pattern)
-  );
-  const matchesRequest = source.origin === requestUrl.origin || matchesHostHeader(source.origin, request);
-  if (!matchesRequest && !matchesConfiguredOrigin) {
-    return { ok: false, reason: "cross-site" };
-  }
-  if (fetchSite === "cross-site" && !matchesConfiguredOrigin) {
-    return { ok: false, reason: "cross-site" };
-  }
-  return { ok: true };
-}
-__name(validateIntegrationRequestOrigin, "validateIntegrationRequestOrigin");
-function describeIntegrationOriginRejection(reason) {
-  switch (reason) {
-    case "missing-origin":
-      return "Request is missing same-origin metadata.";
-    case "opaque-origin":
-      return "Opaque origins are not allowed.";
-    case "invalid-origin":
-      return "Invalid request origin.";
-    case "cross-site":
-      return "Cross-site request was rejected.";
-  }
-}
-__name(describeIntegrationOriginRejection, "describeIntegrationOriginRejection");
-
-export {
-  resolveIntegrationAllowedOrigins,
-  validateIntegrationRequestOrigin,
-  describeIntegrationOriginRejection
-};