fifony 0.1.47 → 0.1.48

package/dist/telemetry-KVUFHDQS.js

@@ -0,0 +1,828 @@
+import "./chunk-Z6ZWNWWR.js";
+
+// node_modules/.pnpm/raffel@1.0.26_ajv@8.18.0_fastest-validator@1.19.1_zod-to-json-schema@3.25.2_zod@4.3.6__zod@4.3.6/node_modules/raffel/dist/metrics/types.js
+var DEFAULT_HISTOGRAM_BUCKETS = [
+  5e-3,
+  0.01,
+  0.025,
+  0.05,
+  0.1,
+  0.25,
+  0.5,
+  1,
+  2.5,
+  5,
+  10
+];
+
+// node_modules/.pnpm/raffel@1.0.26_ajv@8.18.0_fastest-validator@1.19.1_zod-to-json-schema@3.25.2_zod@4.3.6__zod@4.3.6/node_modules/raffel/dist/metrics/exporters.js
+function formatLabels(labels) {
+  const entries = Object.entries(labels);
+  if (entries.length === 0)
+    return "";
+  entries.sort(([a], [b]) => a.localeCompare(b));
+  const formatted = entries.map(([k, v]) => `${k}="${escapePrometheusValue(v)}"`).join(",");
+  return `{${formatted}}`;
+}
+function escapePrometheusValue(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}
+function exportPrometheus(metrics, _defaultLabels) {
+  const lines = [];
+  for (const metric of metrics.values()) {
+    if (metric.description) {
+      lines.push(`# HELP ${metric.name} ${metric.description}`);
+    }
+    lines.push(`# TYPE ${metric.name} ${metric.type}`);
+    if (metric.type === "histogram") {
+      for (const histValue of metric.histogramValues.values()) {
+        const baseLabels = formatLabels(histValue.labels);
+        const baseName = metric.name;
+        for (const bucket of histValue.buckets) {
+          const leLabel = bucket.le === Infinity ? "+Inf" : bucket.le.toString();
+          const bucketLabels = histValue.labels;
+          const labelStr = formatLabels({ ...bucketLabels, le: leLabel });
+          lines.push(`${baseName}_bucket${labelStr} ${bucket.count}`);
+        }
+        const infLabels = formatLabels({ ...histValue.labels, le: "+Inf" });
+        lines.push(`${baseName}_bucket${infLabels} ${histValue.count}`);
+        lines.push(`${baseName}_sum${baseLabels} ${histValue.sum}`);
+        lines.push(`${baseName}_count${baseLabels} ${histValue.count}`);
+      }
+    } else {
+      for (const value of metric.values.values()) {
+        const labelStr = formatLabels(value.labels);
+        lines.push(`${metric.name}${labelStr} ${value.value}`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function exportJson(metrics, defaultLabels) {
+  const output = {
+    defaultLabels,
+    metrics: {}
+  };
+  const metricsObj = output.metrics;
+  for (const metric of metrics.values()) {
+    if (metric.type === "histogram") {
+      const histograms = [];
+      for (const histValue of metric.histogramValues.values()) {
+        histograms.push({
+          labels: histValue.labels,
+          buckets: histValue.buckets,
+          sum: histValue.sum,
+          count: histValue.count
+        });
+      }
+      metricsObj[metric.name] = {
+        type: metric.type,
+        description: metric.description,
+        values: histograms
+      };
+    } else {
+      const values = [];
+      for (const value of metric.values.values()) {
+        values.push({
+          labels: value.labels,
+          value: value.value
+        });
+      }
+      metricsObj[metric.name] = {
+        type: metric.type,
+        description: metric.description,
+        values
+      };
+    }
+  }
+  return JSON.stringify(output, null, 2);
+}
+
+// node_modules/.pnpm/raffel@1.0.26_ajv@8.18.0_fastest-validator@1.19.1_zod-to-json-schema@3.25.2_zod@4.3.6__zod@4.3.6/node_modules/raffel/dist/metrics/registry.js
+function labelsToKey(labels) {
+  const sortedKeys = Object.keys(labels).sort();
+  if (sortedKeys.length === 0)
+    return "";
+  return sortedKeys.map((k) => `${k}="${labels[k]}"`).join(",");
+}
+function mergeLabels(defaults, provided = {}) {
+  return { ...defaults, ...provided };
+}
+function validateLabels(metricName, labelKeys, provided, defaultLabels) {
+  const providedKeys = Object.keys(provided);
+  const defaultKeys = Object.keys(defaultLabels);
+  for (const key of providedKeys) {
+    if (defaultKeys.includes(key))
+      continue;
+    if (!labelKeys.includes(key)) {
+      throw new Error(`Metric '${metricName}' does not have label '${key}'. Registered labels: [${labelKeys.join(", ")}]`);
+    }
+  }
+}
+function createHistogramValue(buckets, labels) {
+  return {
+    labels,
+    buckets: buckets.map((le) => ({ le, count: 0 })),
+    sum: 0,
+    count: 0
+  };
+}
+function createMetricRegistry() {
+  const metrics = /* @__PURE__ */ new Map();
+  let defaultLabels = {};
+  function registerMetric(name, type, opts = {}) {
+    if (metrics.has(name)) {
+      throw new Error(`Metric '${name}' is already registered`);
+    }
+    const definition = {
+      name,
+      type,
+      description: opts.description ?? "",
+      labelKeys: opts.labels ?? [],
+      values: /* @__PURE__ */ new Map()
+    };
+    if (type === "histogram") {
+      definition.buckets = opts.buckets ?? [...DEFAULT_HISTOGRAM_BUCKETS];
+      definition.histogramValues = /* @__PURE__ */ new Map();
+    }
+    metrics.set(name, definition);
+  }
+  function getMetricOrThrow(name, expectedType) {
+    const metric = metrics.get(name);
+    if (!metric) {
+      throw new Error(`Metric '${name}' is not registered`);
+    }
+    if (expectedType && metric.type !== expectedType) {
+      throw new Error(`Metric '${name}' is a ${metric.type}, not a ${expectedType}`);
+    }
+    return metric;
+  }
+  const registry = {
+    counter(name, opts) {
+      registerMetric(name, "counter", opts);
+    },
+    gauge(name, opts) {
+      registerMetric(name, "gauge", opts);
+    },
+    histogram(name, opts) {
+      registerMetric(name, "histogram", opts);
+    },
+    increment(name, labels = {}, delta = 1) {
+      const metric = getMetricOrThrow(name, "counter");
+      const mergedLabels = mergeLabels(defaultLabels, labels);
+      validateLabels(name, metric.labelKeys, mergedLabels, defaultLabels);
+      const key = labelsToKey(mergedLabels);
+      const existing = metric.values.get(key);
+      if (existing) {
+        existing.value += delta;
+      } else {
+        metric.values.set(key, {
+          value: delta,
+          labels: mergedLabels
+        });
+      }
+    },
+    set(name, value, labels = {}) {
+      const metric = getMetricOrThrow(name, "gauge");
+      const mergedLabels = mergeLabels(defaultLabels, labels);
+      validateLabels(name, metric.labelKeys, mergedLabels, defaultLabels);
+      const key = labelsToKey(mergedLabels);
+      metric.values.set(key, {
+        value,
+        labels: mergedLabels
+      });
+    },
+    observe(name, value, labels = {}) {
+      const metric = getMetricOrThrow(name, "histogram");
+      const mergedLabels = mergeLabels(defaultLabels, labels);
+      validateLabels(name, metric.labelKeys, mergedLabels, defaultLabels);
+      const key = labelsToKey(mergedLabels);
+      let histValue = metric.histogramValues.get(key);
+      if (!histValue) {
+        histValue = createHistogramValue(metric.buckets, mergedLabels);
+        metric.histogramValues.set(key, histValue);
+      }
+      histValue.sum += value;
+      histValue.count += 1;
+      for (const bucket of histValue.buckets) {
+        if (value <= bucket.le) {
+          bucket.count += 1;
+        }
+      }
+    },
+    timer(name, labels = {}) {
+      const start = performance.now();
+      return () => {
+        const duration = (performance.now() - start) / 1e3;
+        registry.observe(name, duration, labels);
+        return duration;
+      };
+    },
+    export(format) {
+      if (format === "prometheus") {
+        return exportPrometheus(metrics, defaultLabels);
+      }
+      return exportJson(metrics, defaultLabels);
+    },
+    getMetric(name) {
+      return metrics.get(name);
+    },
+    getMetricNames() {
+      return Array.from(metrics.keys());
+    },
+    reset() {
+      for (const metric of metrics.values()) {
+        metric.values.clear();
+        if (metric.histogramValues) {
+          metric.histogramValues.clear();
+        }
+      }
+    },
+    getDefaultLabels() {
+      return { ...defaultLabels };
+    },
+    setDefaultLabels(labels) {
+      defaultLabels = { ...labels };
+    }
+  };
+  return registry;
+}
+
+// node_modules/.pnpm/raffel@1.0.26_ajv@8.18.0_fastest-validator@1.19.1_zod-to-json-schema@3.25.2_zod@4.3.6__zod@4.3.6/node_modules/raffel/dist/proxy/telemetry.js
+var PROXY_AUTO_METRICS = {
+  FLOWS_TOTAL: "raffel_proxy_edge_flows_total",
+  ACTIVE_FLOWS: "raffel_proxy_edge_active_flows",
+  BYTES_FROM_SOURCE: "raffel_proxy_edge_bytes_from_source_total",
+  BYTES_TO_SOURCE: "raffel_proxy_edge_bytes_to_source_total",
+  REQUESTS_TOTAL: "raffel_proxy_edge_requests_total",
+  REQUEST_DURATION: "raffel_proxy_edge_request_duration_seconds",
+  FLOW_DURATION: "raffel_proxy_edge_flow_duration_seconds",
+  FLOW_DURATION_QUANTILE: "raffel_proxy_edge_flow_duration_quantile_seconds",
+  ERRORS_TOTAL: "raffel_proxy_edge_errors_total",
+  FLOW_RATE: "raffel_proxy_edge_flow_rate_per_second",
+  REQUEST_RATE: "raffel_proxy_edge_request_rate_per_second",
+  ERROR_RATE: "raffel_proxy_edge_error_rate_per_second",
+  BYTES_FROM_SOURCE_RATE: "raffel_proxy_edge_bytes_from_source_rate_per_second",
+  BYTES_TO_SOURCE_RATE: "raffel_proxy_edge_bytes_to_source_rate_per_second",
+  FAILURE_RATIO: "raffel_proxy_edge_failure_ratio"
+};
+var DEFAULT_PROXY_PERCENTILES = [0.5, 0.9, 0.95];
+var DEFAULT_PROXY_DURATION_BUCKETS = [1e-3, 5e-3, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60];
+var DEFAULT_PROXY_RATE_WINDOW_MS = 6e4;
+var RATE_BUCKET_MS = 1e3;
+function isErrorStatus(status) {
+  if (!status)
+    return false;
+  const numeric = Number.parseInt(status, 10);
+  return Number.isFinite(numeric) ? numeric >= 400 : status !== "success";
+}
+function statusClass(status) {
+  if (!status)
+    return "other";
+  const numeric = Number.parseInt(status, 10);
+  if (!Number.isFinite(numeric))
+    return "other";
+  if (numeric >= 500)
+    return "5xx";
+  if (numeric >= 400)
+    return "4xx";
+  if (numeric >= 300)
+    return "3xx";
+  if (numeric >= 200)
+    return "2xx";
+  if (numeric >= 100)
+    return "1xx";
+  return "other";
+}
+function edgeKey(labels) {
+  return `${labels.source}\0${labels.destination}\0${labels.protocol}`;
+}
+function percentileLabel(value) {
+  const percentage = value * 100;
+  if (Number.isInteger(percentage)) {
+    return `p${percentage}`;
+  }
+  return `p${percentage.toFixed(2).replace(/\.?0+$/, "").replace(".", "_")}`;
+}
+function normalizePercentiles(percentiles) {
+  const input = percentiles && percentiles.length > 0 ? percentiles : [...DEFAULT_PROXY_PERCENTILES];
+  const values = Array.from(new Set(input.filter((value) => Number.isFinite(value) && value > 0 && value <= 1).map((value) => Number(value)))).sort((a, b) => a - b);
+  const safeValues = values.length > 0 ? values : [...DEFAULT_PROXY_PERCENTILES];
+  return safeValues.map((value) => ({
+    label: percentileLabel(value),
+    value
+  }));
+}
+function normalizeRateWindowMs(rateWindowMs) {
+  if (!Number.isFinite(rateWindowMs) || rateWindowMs == null || rateWindowMs <= 0) {
+    return DEFAULT_PROXY_RATE_WINDOW_MS;
+  }
+  return Math.max(RATE_BUCKET_MS, Math.round(rateWindowMs));
+}
+function cloneBuckets(buckets) {
+  return buckets.map((le) => ({ le, count: 0 }));
+}
+function observeDuration(state, value) {
+  state.sum += value;
+  state.count += 1;
+  for (const bucket of state.buckets) {
+    if (value <= bucket.le) {
+      bucket.count += 1;
+    }
+  }
+}
+function estimatePercentile(state, percentile) {
+  if (state.count === 0)
+    return null;
+  const target = state.count * percentile;
+  let previousCount = 0;
+  let previousLe = 0;
+  for (const bucket of state.buckets) {
+    if (bucket.count >= target) {
+      const bucketCount = bucket.count - previousCount;
+      if (bucketCount <= 0) {
+        return bucket.le;
+      }
+      const offset = Math.max(0, target - previousCount);
+      const ratio = Math.min(1, offset / bucketCount);
+      return previousLe + (bucket.le - previousLe) * ratio;
+    }
+    previousCount = bucket.count;
+    previousLe = bucket.le;
+  }
+  return state.buckets.at(-1)?.le ?? null;
+}
+function summarizeLatency(state, percentiles) {
+  return {
+    averageSeconds: state.count > 0 ? state.sum / state.count : null,
+    percentiles: Object.fromEntries(percentiles.map((definition) => [
+      definition.label,
+      estimatePercentile(state, definition.value)
+    ]))
+  };
+}
+function pruneRateBuckets(state, nowMs, rateWindowMs) {
+  const cutoff = nowMs - rateWindowMs;
+  for (const [bucketStartMs] of state.buckets) {
+    if (bucketStartMs < cutoff) {
+      state.buckets.delete(bucketStartMs);
+    }
+  }
+}
+function ensureRateBucket(state, nowMs) {
+  const bucketStartMs = Math.floor(nowMs / RATE_BUCKET_MS) * RATE_BUCKET_MS;
+  const existing = state.buckets.get(bucketStartMs);
+  if (existing)
+    return existing;
+  const created = {
+    bucketStartMs,
+    flows: 0,
+    requests: 0,
+    errors: 0,
+    bytesFromSource: 0,
+    bytesToSource: 0
+  };
+  state.buckets.set(bucketStartMs, created);
+  return created;
+}
+function recordRateDelta(state, nowMs, rateWindowMs, delta) {
+  pruneRateBuckets(state, nowMs, rateWindowMs);
+  const bucket = ensureRateBucket(state, nowMs);
+  bucket.flows += delta.flows ?? 0;
+  bucket.requests += delta.requests ?? 0;
+  bucket.errors += delta.errors ?? 0;
+  bucket.bytesFromSource += delta.bytesFromSource ?? 0;
+  bucket.bytesToSource += delta.bytesToSource ?? 0;
+}
+function summarizeRates(state, nowMs, rateWindowMs) {
+  pruneRateBuckets(state, nowMs, rateWindowMs);
+  let flows = 0;
+  let requests = 0;
+  let errors = 0;
+  let bytesFromSource = 0;
+  let bytesToSource = 0;
+  for (const bucket of state.buckets.values()) {
+    flows += bucket.flows;
+    requests += bucket.requests;
+    errors += bucket.errors;
+    bytesFromSource += bucket.bytesFromSource;
+    bytesToSource += bucket.bytesToSource;
+  }
+  const windowSeconds = rateWindowMs / 1e3;
+  const denominator = requests > 0 ? requests : flows > 0 ? flows : 0;
+  return {
+    windowSeconds,
+    flowsPerSecond: flows / windowSeconds,
+    requestsPerSecond: requests / windowSeconds,
+    errorsPerSecond: errors / windowSeconds,
+    bytesFromSourcePerSecond: bytesFromSource / windowSeconds,
+    bytesToSourcePerSecond: bytesToSource / windowSeconds,
+    bytesPerSecond: (bytesFromSource + bytesToSource) / windowSeconds,
+    failureRatio: denominator > 0 ? errors / denominator : null
+  };
+}
+function ensureProxyMetricsRegistered(registry) {
+  if (!registry.getMetric(PROXY_AUTO_METRICS.FLOWS_TOTAL)) {
+    registry.counter(PROXY_AUTO_METRICS.FLOWS_TOTAL, {
+      description: "Completed proxy flows grouped by edge and protocol",
+      labels: ["source", "destination", "protocol", "status"]
+    });
+  }
+  if (!registry.getMetric(PROXY_AUTO_METRICS.ACTIVE_FLOWS)) {
+    registry.gauge(PROXY_AUTO_METRICS.ACTIVE_FLOWS, {
+      description: "Active proxy flows grouped by edge and protocol",
+      labels: ["source", "destination", "protocol"]
+    });
+  }
+  if (!registry.getMetric(PROXY_AUTO_METRICS.BYTES_FROM_SOURCE)) {
+    registry.counter(PROXY_AUTO_METRICS.BYTES_FROM_SOURCE, {
+      description: "Bytes proxied from source to destination grouped by edge and protocol",
+      labels: ["source", "destination", "protocol"]
+    });
+  }
+  if (!registry.getMetric(PROXY_AUTO_METRICS.BYTES_TO_SOURCE)) {
+    registry.counter(PROXY_AUTO_METRICS.BYTES_TO_SOURCE, {
+      description: "Bytes proxied from destination back to source grouped by edge and protocol",
+      labels: ["source", "destination", "protocol"]
+    });
+  }
+  if (!registry.getMetric(PROXY_AUTO_METRICS.REQUESTS_TOTAL)) {
+    registry.counter(PROXY_AUTO_METRICS.REQUESTS_TOTAL, {
+      description: "Proxy requests grouped by edge, protocol, method, and status",
+      labels: ["source", "destination", "protocol", "method", "status"]
+    });
+  }
+  if (!registry.getMetric(PROXY_AUTO_METRICS.REQUEST_DURATION)) {
+    registry.histogram(PROXY_AUTO_METRICS.REQUEST_DURATION, {
+      description: "Proxy request duration in seconds grouped by edge, protocol, and method",
+      labels: ["source", "destination", "protocol", "method"],
+      buckets: [...DEFAULT_PROXY_DURATION_BUCKETS]
+    });
+  }
+  if (!registry.getMetric(PROXY_AUTO_METRICS.FLOW_DURATION)) {
+    registry.histogram(PROXY_AUTO_METRICS.FLOW_DURATION, {
+      description: "Proxy flow duration in seconds grouped by edge and protocol",
+      labels: ["source", "destination", "protocol"],
+      buckets: [...DEFAULT_PROXY_DURATION_BUCKETS]
+    });
+  }
+  if (!registry.getMetric(PROXY_AUTO_METRICS.FLOW_DURATION_QUANTILE)) {
+    registry.gauge(PROXY_AUTO_METRICS.FLOW_DURATION_QUANTILE, {
+      description: "Estimated proxy flow duration quantiles grouped by edge and protocol",
+      labels: ["source", "destination", "protocol", "quantile"]
+    });
+  }
+  if (!registry.getMetric(PROXY_AUTO_METRICS.ERRORS_TOTAL)) {
+    registry.counter(PROXY_AUTO_METRICS.ERRORS_TOTAL, {
+      description: "Proxy edge errors grouped by edge, protocol, and error reason",
+      labels: ["source", "destination", "protocol", "error"]
+    });
+  }
+  if (!registry.getMetric(PROXY_AUTO_METRICS.FLOW_RATE)) {
+    registry.gauge(PROXY_AUTO_METRICS.FLOW_RATE, {
+      description: "Recent proxy flow rate per second grouped by edge and protocol",
+      labels: ["source", "destination", "protocol"]
+    });
+  }
+  if (!registry.getMetric(PROXY_AUTO_METRICS.REQUEST_RATE)) {
+    registry.gauge(PROXY_AUTO_METRICS.REQUEST_RATE, {
+      description: "Recent proxy request rate per second grouped by edge and protocol",
+      labels: ["source", "destination", "protocol"]
+    });
+  }
+  if (!registry.getMetric(PROXY_AUTO_METRICS.ERROR_RATE)) {
+    registry.gauge(PROXY_AUTO_METRICS.ERROR_RATE, {
+      description: "Recent proxy error rate per second grouped by edge and protocol",
+      labels: ["source", "destination", "protocol"]
+    });
+  }
+  if (!registry.getMetric(PROXY_AUTO_METRICS.BYTES_FROM_SOURCE_RATE)) {
+    registry.gauge(PROXY_AUTO_METRICS.BYTES_FROM_SOURCE_RATE, {
+      description: "Recent bytes per second flowing from source to destination grouped by edge and protocol",
+      labels: ["source", "destination", "protocol"]
+    });
+  }
+  if (!registry.getMetric(PROXY_AUTO_METRICS.BYTES_TO_SOURCE_RATE)) {
+    registry.gauge(PROXY_AUTO_METRICS.BYTES_TO_SOURCE_RATE, {
+      description: "Recent bytes per second flowing from destination back to source grouped by edge and protocol",
+      labels: ["source", "destination", "protocol"]
+    });
+  }
+  if (!registry.getMetric(PROXY_AUTO_METRICS.FAILURE_RATIO)) {
+    registry.gauge(PROXY_AUTO_METRICS.FAILURE_RATIO, {
+      description: "Recent proxy failure ratio grouped by edge and protocol",
+      labels: ["source", "destination", "protocol"]
+    });
+  }
+}
+function createProxyTelemetry(config = {}) {
+  const registry = config.registry ?? createMetricRegistry();
+  const currentDefaults = registry.getDefaultLabels();
+  if (config.defaultLabels) {
+    registry.setDefaultLabels({ ...currentDefaults, ...config.defaultLabels });
+  }
+  ensureProxyMetricsRegistered(registry);
+  const percentiles = normalizePercentiles(config.percentiles);
+  const flowDurationBuckets = registry.getMetric(PROXY_AUTO_METRICS.FLOW_DURATION)?.buckets ?? [...DEFAULT_PROXY_DURATION_BUCKETS];
+  const rateWindowMs = normalizeRateWindowMs(config.rateWindowMs);
+  let seq = 0;
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  function emit(event) {
+    for (const listener of listeners) {
+      listener(event);
+    }
+  }
+  function buildEdgeSnapshot(edge, nowMs) {
+    return {
+      id: edge.id,
+      source: edge.source,
+      target: edge.target,
+      protocol: edge.protocol,
+      firstSeenAt: edge.firstSeenAt,
+      lastSeenAt: edge.lastSeenAt,
+      activeFlows: edge.activeFlows,
+      flowsTotal: edge.flowsTotal,
+      requestsTotal: edge.requestsTotal,
+      errorsTotal: edge.errorsTotal,
+      bytesFromSource: edge.bytesFromSource,
+      bytesToSource: edge.bytesToSource,
+      durationCount: edge.duration.count,
+      durationSumSeconds: edge.duration.sum,
+      latency: summarizeLatency(edge.duration, percentiles),
+      rates: summarizeRates(edge.rates, nowMs, rateWindowMs),
+      statusClassCounts: { ...edge.statusClassCounts },
+      methodCounts: { ...edge.methodCounts },
+      topPaths: Array.from(edge.pathCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([path, count]) => ({ path, count }))
+    };
+  }
+  function ensureNode(id, seenAt) {
+    const existing = nodes.get(id);
+    if (existing) {
+      existing.lastSeenAt = seenAt;
+      return existing;
+    }
+    const created = { id, lastSeenAt: seenAt };
+    nodes.set(id, created);
+    emit({ type: "node:new", seq, nodeId: id, firstSeenAt: seenAt });
+    return created;
+  }
+  function ensureEdge(labels, seenAt) {
+    const key = edgeKey(labels);
+    const existing = edges.get(key);
+    if (existing) {
+      existing.lastSeenAt = seenAt;
+      return { edge: existing, isNew: false };
+    }
+    const created = {
+      id: key,
+      source: labels.source,
+      target: labels.destination,
+      protocol: labels.protocol,
+      firstSeenAt: seenAt,
+      activeFlows: 0,
+      flowsTotal: 0,
+      requestsTotal: 0,
+      errorsTotal: 0,
+      bytesFromSource: 0,
+      bytesToSource: 0,
+      duration: {
+        buckets: cloneBuckets(flowDurationBuckets),
+        sum: 0,
+        count: 0
+      },
+      rates: {
+        buckets: /* @__PURE__ */ new Map()
+      },
+      lastSeenAt: seenAt,
+      statusClassCounts: {},
+      methodCounts: {},
+      pathCounts: /* @__PURE__ */ new Map()
+    };
+    edges.set(key, created);
+    return { edge: created, isNew: true };
+  }
+  function updateRateMetrics(labels, edge, nowMs) {
+    const rates = summarizeRates(edge.rates, nowMs, rateWindowMs);
+    registry.set(PROXY_AUTO_METRICS.FLOW_RATE, rates.flowsPerSecond, labels);
+    registry.set(PROXY_AUTO_METRICS.REQUEST_RATE, rates.requestsPerSecond, labels);
+    registry.set(PROXY_AUTO_METRICS.ERROR_RATE, rates.errorsPerSecond, labels);
+    registry.set(PROXY_AUTO_METRICS.BYTES_FROM_SOURCE_RATE, rates.bytesFromSourcePerSecond, labels);
+    registry.set(PROXY_AUTO_METRICS.BYTES_TO_SOURCE_RATE, rates.bytesToSourcePerSecond, labels);
+    registry.set(PROXY_AUTO_METRICS.FAILURE_RATIO, rates.failureRatio ?? 0, labels);
+  }
+  return {
+    registry,
+    percentiles,
+    rateWindowSeconds: rateWindowMs / 1e3,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    reset() {
+      nodes.clear();
+      edges.clear();
+      seq = 0;
+      emit({ type: "reset", seq });
+    },
+    expireEdgesBefore(iso) {
+      let removed = 0;
+      for (const [key, edge] of edges) {
+        if (edge.lastSeenAt < iso) {
+          edges.delete(key);
+          seq++;
+          emit({
+            type: "edge:expire",
+            seq,
+            edgeId: edge.id,
+            source: edge.source,
+            target: edge.target,
+            protocol: edge.protocol
+          });
+          removed++;
+        }
+      }
+      if (removed > 0) {
+        const referencedNodes = /* @__PURE__ */ new Set();
+        for (const edge of edges.values()) {
+          referencedNodes.add(edge.source);
+          referencedNodes.add(edge.target);
+        }
+        for (const nodeId of nodes.keys()) {
+          if (!referencedNodes.has(nodeId)) {
+            nodes.delete(nodeId);
+          }
+        }
+      }
+      return removed;
+    },
+    startFlow(labels) {
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const startedAtMs = Date.now();
+      ensureNode(labels.source, startedAt);
+      ensureNode(labels.destination, startedAt);
+      const { edge, isNew } = ensureEdge(labels, startedAt);
+      edge.activeFlows++;
+      edge.flowsTotal++;
+      seq++;
+      recordRateDelta(edge.rates, startedAtMs, rateWindowMs, { flows: 1 });
+      registry.set(PROXY_AUTO_METRICS.ACTIVE_FLOWS, edge.activeFlows, labels);
+      updateRateMetrics(labels, edge, startedAtMs);
+      emit({
+        type: isNew ? "edge:new" : "edge:update",
+        seq,
+        edge: buildEdgeSnapshot(edge, startedAtMs)
+      });
+      let finished = false;
+      return {
+        addBytesFromSource(delta) {
+          if (finished || delta <= 0)
+            return;
+          const nowMs = Date.now();
+          edge.bytesFromSource += delta;
+          edge.lastSeenAt = new Date(nowMs).toISOString();
+          recordRateDelta(edge.rates, nowMs, rateWindowMs, { bytesFromSource: delta });
+          registry.increment(PROXY_AUTO_METRICS.BYTES_FROM_SOURCE, labels, delta);
+          updateRateMetrics(labels, edge, nowMs);
+        },
+        addBytesToSource(delta) {
+          if (finished || delta <= 0)
+            return;
+          const nowMs = Date.now();
+          edge.bytesToSource += delta;
+          edge.lastSeenAt = new Date(nowMs).toISOString();
+          recordRateDelta(edge.rates, nowMs, rateWindowMs, { bytesToSource: delta });
+          registry.increment(PROXY_AUTO_METRICS.BYTES_TO_SOURCE, labels, delta);
+          updateRateMetrics(labels, edge, nowMs);
+        },
+        finish(input = {}) {
+          if (finished)
+            return;
+          finished = true;
+          const nowMs = Date.now();
+          const seenAt = new Date(nowMs).toISOString();
+          edge.lastSeenAt = seenAt;
+          edge.activeFlows = Math.max(0, edge.activeFlows - 1);
+          const errorLabel = input.error ?? (isErrorStatus(input.status) ? `status_${input.status}` : void 0);
+          const rateDelta = {};
+          if (input.method) {
+            const method = input.method.toUpperCase();
+            edge.requestsTotal++;
+            edge.methodCounts[method] = (edge.methodCounts[method] ?? 0) + 1;
+            rateDelta.requests = 1;
+          }
+          if (input.path) {
+            edge.pathCounts.set(input.path, (edge.pathCounts.get(input.path) ?? 0) + 1);
+          }
+          if (input.status) {
+            const cls = statusClass(input.status);
+            edge.statusClassCounts[cls] = (edge.statusClassCounts[cls] ?? 0) + 1;
+          }
+          if (errorLabel) {
+            edge.errorsTotal++;
+            rateDelta.errors = 1;
+            registry.increment(PROXY_AUTO_METRICS.ERRORS_TOTAL, { ...labels, error: errorLabel });
+          }
+          if (rateDelta.requests || rateDelta.errors) {
+            recordRateDelta(edge.rates, nowMs, rateWindowMs, rateDelta);
+          }
+          if (typeof input.durationSeconds === "number") {
+            observeDuration(edge.duration, input.durationSeconds);
+            registry.observe(PROXY_AUTO_METRICS.FLOW_DURATION, input.durationSeconds, labels);
+            for (const percentile of percentiles) {
+              const estimated = estimatePercentile(edge.duration, percentile.value);
+              if (estimated != null) {
+                registry.set(PROXY_AUTO_METRICS.FLOW_DURATION_QUANTILE, estimated, {
+                  ...labels,
+                  quantile: percentile.label
+                });
+              }
+            }
+          }
+          registry.set(PROXY_AUTO_METRICS.ACTIVE_FLOWS, edge.activeFlows, labels);
+          registry.increment(PROXY_AUTO_METRICS.FLOWS_TOTAL, {
+            ...labels,
+            status: input.status ?? (errorLabel ? "error" : "success")
+          });
+          if (input.method) {
+            registry.increment(PROXY_AUTO_METRICS.REQUESTS_TOTAL, {
+              ...labels,
+              method: input.method,
+              status: input.status ?? (errorLabel ? "error" : "success")
+            });
+            if (typeof input.durationSeconds === "number") {
+              registry.observe(PROXY_AUTO_METRICS.REQUEST_DURATION, input.durationSeconds, {
+                ...labels,
+                method: input.method
+              });
+            }
+          }
+          seq++;
+          updateRateMetrics(labels, edge, nowMs);
+          emit({ type: "edge:update", seq, edge: buildEdgeSnapshot(edge, nowMs) });
+        }
+      };
+    },
+    snapshot() {
+      const inboundCounts = /* @__PURE__ */ new Map();
+      const outboundCounts = /* @__PURE__ */ new Map();
+      const nodeRequestsOut = /* @__PURE__ */ new Map();
+      const nodeRequestsIn = /* @__PURE__ */ new Map();
+      const nodeErrorsOut = /* @__PURE__ */ new Map();
+      const nodeErrorsIn = /* @__PURE__ */ new Map();
+      const nodeBytesOut = /* @__PURE__ */ new Map();
+      const nodeBytesIn = /* @__PURE__ */ new Map();
+      const nodeActiveFlows = /* @__PURE__ */ new Map();
+      const nodeProtocols = /* @__PURE__ */ new Map();
+      const nowMs = Date.now();
+      for (const edge of edges.values()) {
+        outboundCounts.set(edge.source, (outboundCounts.get(edge.source) ?? 0) + 1);
+        inboundCounts.set(edge.target, (inboundCounts.get(edge.target) ?? 0) + 1);
+        nodeRequestsOut.set(edge.source, (nodeRequestsOut.get(edge.source) ?? 0) + edge.requestsTotal);
+        nodeErrorsOut.set(edge.source, (nodeErrorsOut.get(edge.source) ?? 0) + edge.errorsTotal);
+        nodeBytesOut.set(edge.source, (nodeBytesOut.get(edge.source) ?? 0) + edge.bytesFromSource);
+        nodeActiveFlows.set(edge.source, (nodeActiveFlows.get(edge.source) ?? 0) + edge.activeFlows);
+        const srcProtocols = nodeProtocols.get(edge.source) ?? {};
+        srcProtocols[edge.protocol] = (srcProtocols[edge.protocol] ?? 0) + edge.flowsTotal;
+        nodeProtocols.set(edge.source, srcProtocols);
+        nodeRequestsIn.set(edge.target, (nodeRequestsIn.get(edge.target) ?? 0) + edge.requestsTotal);
+        nodeErrorsIn.set(edge.target, (nodeErrorsIn.get(edge.target) ?? 0) + edge.errorsTotal);
+        nodeBytesIn.set(edge.target, (nodeBytesIn.get(edge.target) ?? 0) + edge.bytesFromSource);
+      }
+      return {
+        seq,
+        generatedAt: new Date(nowMs).toISOString(),
+        windowStart: new Date(nowMs - rateWindowMs).toISOString(),
+        windowEnd: new Date(nowMs).toISOString(),
+        percentiles: percentiles.map((percentile) => percentile.label),
+        rateWindowSeconds: rateWindowMs / 1e3,
+        nodes: Array.from(nodes.values()).map((node) => ({
+          id: node.id,
+          label: node.id,
+          inboundEdges: inboundCounts.get(node.id) ?? 0,
+          outboundEdges: outboundCounts.get(node.id) ?? 0,
+          lastSeenAt: node.lastSeenAt,
+          requestsOut: nodeRequestsOut.get(node.id) ?? 0,
+          requestsIn: nodeRequestsIn.get(node.id) ?? 0,
+          errorsOut: nodeErrorsOut.get(node.id) ?? 0,
+          errorsIn: nodeErrorsIn.get(node.id) ?? 0,
+          bytesOut: nodeBytesOut.get(node.id) ?? 0,
+          bytesIn: nodeBytesIn.get(node.id) ?? 0,
+          activeFlows: nodeActiveFlows.get(node.id) ?? 0,
+          protocols: nodeProtocols.get(node.id) ?? {}
+        })).sort((a, b) => a.id.localeCompare(b.id)),
+        edges: Array.from(edges.values()).map((edge) => buildEdgeSnapshot(edge, nowMs)).sort((a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target) || a.protocol.localeCompare(b.protocol))
+      };
+    }
+  };
+}
+export {
+  DEFAULT_PROXY_PERCENTILES,
+  PROXY_AUTO_METRICS,
+  createProxyTelemetry
+};
+//# sourceMappingURL=telemetry-KVUFHDQS.js.map