@autter/runtime-node 1.4.0 → 1.6.0

package/dist/chunk-ARN26OK6.cjs

@@ -0,0 +1,810 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// ../otlp-ingester/src/compat-manifest.json
+var compat_manifest_default = {
+  manifestVersion: 1,
+  docs: "https://github.com/Autter-dev/autter-runtime/blob/main/docs/COMPATIBILITY.md",
+  upgrade: {
+    ingester: "docker pull ghcr.io/autter-dev/otlp-ingester:latest and restart it (ClickHouse migrations run at boot)",
+    sdk: "npm install {package}@latest"
+  },
+  features: [
+    {
+      id: "llm_calls",
+      title: "LLM call tracking",
+      ingester: "1.1.0",
+      migrations: ["0004-llm-calls"],
+      sdks: { "@autter/runtime-node": "1.1.0", "@autter/runtime-next": "1.1.0" }
+    },
+    {
+      id: "endpoint_latency",
+      title: "Endpoint latency regression detection",
+      ingester: "1.3.1",
+      migrations: ["0005-latency-histograms"],
+      sdks: { "@autter/runtime-node": "1.3.0", "@autter/runtime-next": "1.3.0" }
+    },
+    {
+      id: "browser_network_events",
+      title: "Browser network, timing and outcome capture",
+      ingester: "1.3.2",
+      migrations: [],
+      sdks: { "@autter/runtime-browser": "1.3.2", "@autter/runtime-next": "1.3.2" },
+      browserEvents: ["request_failure", "timing", "outcome"]
+    },
+    {
+      id: "profiles",
+      title: "Profile ingestion",
+      ingester: "1.3.2",
+      migrations: ["0006-profile-samples"],
+      route: "/v1/profiles",
+      sdks: {}
+    },
+    {
+      id: "source_maps",
+      title: "Source map upload",
+      ingester: "1.3.2",
+      migrations: ["0007-source-maps"],
+      route: "/v1/sourcemaps",
+      sdks: {}
+    },
+    {
+      id: "memory_metrics",
+      title: "Memory pressure detection",
+      ingester: "1.3.3",
+      migrations: ["0008-memory-signals", "0010-memory-temporality"],
+      sdks: { "@autter/runtime-node": "1.3.3", "@autter/runtime-next": "1.3.3" }
+    },
+    {
+      id: "platform_events",
+      title: "Platform OOM/restart events",
+      ingester: "1.3.3",
+      migrations: ["0008-memory-signals"],
+      route: "/v1/platform-events",
+      sdks: {}
+    },
+    {
+      id: "csp_violations",
+      title: "Browser CSP violation capture",
+      ingester: "1.3.4",
+      migrations: [],
+      sdks: { "@autter/runtime-browser": "1.3.3", "@autter/runtime-next": "1.3.4" },
+      browserEvents: ["csp_violation"]
+    },
+    {
+      id: "operation_logging",
+      title: "Operation logging",
+      ingester: "1.4.0",
+      migrations: ["0011-runtime-logs"],
+      route: "/v1/logs",
+      sdks: { "@autter/runtime-node": "1.4.0", "@autter/runtime-next": "1.4.0" }
+    },
+    {
+      id: "request_summaries",
+      title: "Request summaries and the per-route request rollup",
+      ingester: "1.5.0",
+      migrations: ["0012-runtime-logs-requests", "0014-runtime-request-1m"],
+      route: "/v1/logs",
+      sdks: { "@autter/runtime-node": "1.5.0", "@autter/runtime-next": "1.5.0", "@autter/runtime-edge": "1.0.0" }
+    },
+    {
+      id: "coded_errors",
+      title: "Coded errors and code-based grouping",
+      ingester: "1.5.0",
+      migrations: ["0013-occurrence-codes"],
+      sdks: { "@autter/runtime-node": "1.5.0", "@autter/runtime-next": "1.5.0", "@autter/runtime-browser": "1.4.0", "@autter/runtime-edge": "1.0.0" }
+    },
+    {
+      id: "breadcrumbs",
+      title: "Breadcrumbs: the steps before an error",
+      ingester: "1.6.0",
+      migrations: [],
+      sdks: { "@autter/runtime-browser": "1.6.0", "@autter/runtime-node": "1.6.0", "@autter/runtime-next": "1.6.0" }
+    },
+    {
+      id: "source_map_debug_ids",
+      title: "Source map debug ids",
+      ingester: "1.6.0",
+      migrations: ["0017-source-maps-debug-id"],
+      route: "/v1/sourcemaps/check",
+      sdks: { "@autter/runtime-browser": "1.6.0", "@autter/runtime-next": "1.6.0" }
+    },
+    {
+      id: "fingerprint_override",
+      title: "Fingerprint override",
+      ingester: "1.6.0",
+      migrations: [],
+      sdks: { "@autter/runtime-browser": "1.6.0", "@autter/runtime-node": "1.6.0", "@autter/runtime-next": "1.6.0", "@autter/runtime-edge": "1.1.0" }
+    },
+    {
+      id: "browser_trace_propagation",
+      title: "Browser trace propagation (browser errors linked to server traces)",
+      ingester: "1.6.0",
+      migrations: [],
+      sdks: { "@autter/runtime-browser": "1.6.0", "@autter/runtime-next": "1.6.0", "@autter/runtime-node": "1.6.0" }
+    }
+  ]
+};
+
+// ../otlp-ingester/src/compat.ts
+var COMPAT_MANIFEST = compat_manifest_default;
+var INGESTER_PACKAGE = "@autter/otlp-ingester";
+var INGESTER_VERSION_HEADER = "x-autter-ingester-version";
+function parseVersion(version) {
+  if (typeof version !== "string") return null;
+  const match = /^v?(\d{1,6})\.(\d{1,6})\.(\d{1,6})(-[0-9A-Za-z.-]+)?/.exec(
+    version.trim()
+  );
+  if (!match) return null;
+  return [
+    Number(match[1]),
+    Number(match[2]),
+    Number(match[3]),
+    // A prerelease sorts before its release: 1.4.0-rc.1 < 1.4.0.
+    match[4] ? 0 : 1
+  ];
+}
+function compareVersions(a, b) {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  if (!left || !right) return null;
+  for (let i = 0; i < 4; i++) {
+    if (left[i] !== right[i]) return left[i] < right[i] ? -1 : 1;
+  }
+  return 0;
+}
+function versionAtLeast(version, minimum) {
+  if (!version) return null;
+  const result = compareVersions(version, minimum);
+  return result === null ? null : result >= 0;
+}
+function featureById(id, manifest = COMPAT_MANIFEST) {
+  return manifest.features.find((feature) => feature.id === id);
+}
+function featuresForBrowserEvents(types, manifest = COMPAT_MANIFEST) {
+  const wanted = new Set(types);
+  return manifest.features.filter((feature) => _optionalChain([feature, 'access', _ => _.browserEvents, 'optionalAccess', _2 => _2.some, 'call', _3 => _3((type) => wanted.has(type))])).map((feature) => feature.id);
+}
+function ingesterUpgradeHint(manifest = COMPAT_MANIFEST) {
+  return `Upgrade the ingester: ${manifest.upgrade.ingester}. See ${manifest.docs}`;
+}
+function sdkUpgradeHint(pkg, manifest) {
+  return `Upgrade the SDK: ${manifest.upgrade.sdk.replace("{package}", pkg)}. See ${manifest.docs}`;
+}
+function evaluateCompat(input) {
+  const manifest = _nullishCoalesce(input.manifest, () => ( COMPAT_MANIFEST));
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of input.features) {
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const feature = featureById(id, manifest);
+    if (!feature) continue;
+    const sdkMin = input.sdk ? feature.sdks[input.sdk.name] : void 0;
+    if (input.sdk && sdkMin && versionAtLeast(input.sdk.version, sdkMin) === false) {
+      const fix2 = sdkUpgradeHint(input.sdk.name, manifest);
+      issues.push({
+        feature: id,
+        title: feature.title,
+        kind: "sdk_too_old",
+        component: input.sdk.name,
+        required: sdkMin,
+        actual: input.sdk.version,
+        message: `${feature.title} needs ${input.sdk.name} >= ${sdkMin}; yours is ${input.sdk.version}. ${fix2}`,
+        fix: fix2
+      });
+    }
+    const ingester = input.ingester;
+    if (!ingester) continue;
+    const fix = ingesterUpgradeHint(manifest);
+    const atLeast = versionAtLeast(ingester.version, feature.ingester);
+    if (atLeast === false) {
+      issues.push({
+        feature: id,
+        title: feature.title,
+        kind: "ingester_too_old",
+        component: INGESTER_PACKAGE,
+        required: feature.ingester,
+        actual: ingester.version,
+        message: `${feature.title} needs ingester >= ${feature.ingester}; yours is ${ingester.version}. ${fix}`,
+        fix
+      });
+      continue;
+    }
+    if (ingester.version === null && feature.route && _optionalChain([ingester, 'access', _4 => _4.routes, 'optionalAccess', _5 => _5[feature.route]]) === false) {
+      const actual = "1.4.0 or older (no /v1/compat)";
+      issues.push({
+        feature: id,
+        title: feature.title,
+        kind: "ingester_too_old",
+        component: INGESTER_PACKAGE,
+        required: feature.ingester,
+        actual,
+        message: `${feature.title} needs ingester >= ${feature.ingester}; yours is ${actual} and has no ${feature.route} route, so this data is dropped. ${fix}`,
+        fix
+      });
+      continue;
+    }
+    const schema = ingester.schema;
+    if (atLeast && schema && feature.migrations.length) {
+      const applied = new Set(schema.applied);
+      const missing = feature.migrations.filter((m) => !applied.has(m));
+      if (schema.status === "failed" || schema.status === "ready" && missing.length) {
+        const schemaFix = `Check the ingester's CLICKHOUSE_URL/credentials and its logs, then restart it so the boot migrations run. See ${manifest.docs}`;
+        const what = missing.length ? missing.join(", ") : feature.migrations.join(", ");
+        issues.push({
+          feature: id,
+          title: feature.title,
+          kind: "schema_not_applied",
+          component: INGESTER_PACKAGE,
+          required: feature.migrations.join(", "),
+          actual: schema.status === "failed" ? "migrations failed" : `missing ${what}`,
+          message: `${feature.title} needs ClickHouse migration ${what}, which ingester ${ingester.version} has not applied (schema ${schema.status}). ${schemaFix}`,
+          fix: schemaFix
+        });
+      }
+    }
+  }
+  return issues;
+}
+function ingesterInfoFromReport(body) {
+  if (!body || typeof body !== "object") return null;
+  const report = body;
+  const version = _optionalChain([report, 'access', _6 => _6.ingester, 'optionalAccess', _7 => _7.version]);
+  if (typeof version !== "string" || !parseVersion(version)) return null;
+  const schema = report.schema;
+  const statuses = ["ready", "pending", "failed", "unconfigured"];
+  return {
+    version,
+    ...schema && statuses.includes(schema.status) && Array.isArray(schema.applied) ? {
+      schema: {
+        status: schema.status,
+        applied: schema.applied.filter((id) => typeof id === "string")
+      }
+    } : {}
+  };
+}
+
+// src/lifecycle.ts
+var _core = require('@opentelemetry/core');
+var debugEnabled = process.env.AUTTER_DEBUG === "1" || process.env.AUTTER_DEBUG === "true";
+function setDebugMode(enabled) {
+  debugEnabled = enabled;
+}
+function isDebugEnabled() {
+  return debugEnabled;
+}
+function debugLog(...args) {
+  if (debugEnabled) {
+    console.error("[autter]", ...args);
+  }
+}
+var TelemetryStats = (_class = class {constructor() { _class.prototype.__init.call(this); }
+  /** Captures queued via our APIs and not yet seen leaving an exporter. */
+  __init() {this.pendingCaptures = 0}
+  markCaptured(count = 1) {
+    this.pendingCaptures += count;
+  }
+  /** An exporter batch left the process successfully. */
+  onExported(spanCount) {
+    this.pendingCaptures = Math.max(0, this.pendingCaptures - spanCount);
+    if (debugEnabled && spanCount > 0) {
+      debugLog(`exported ${spanCount} span${spanCount === 1 ? "" : "s"}`);
+    }
+  }
+  markAllFlushed() {
+    this.pendingCaptures = 0;
+  }
+}, _class);
+var telemetryStats = new TelemetryStats();
+var CountingExporter = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  
+  export(spans, resultCallback) {
+    this.inner.export(spans, (result) => {
+      if (result.code === _core.ExportResultCode.SUCCESS) {
+        telemetryStats.onExported(spans.length);
+      }
+      resultCallback(result);
+    });
+  }
+  shutdown() {
+    return this.inner.shutdown();
+  }
+  forceFlush() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _8 => _8.inner, 'access', _9 => _9.forceFlush, 'optionalCall', _10 => _10()]), () => ( Promise.resolve()));
+  }
+};
+var flushTargets = /* @__PURE__ */ new Map();
+function registerFlushTarget(key, target) {
+  flushTargets.set(key, target);
+}
+function unregisterFlushTargets() {
+  flushTargets.clear();
+}
+function activeFlushTargets() {
+  return [...flushTargets.values()];
+}
+var DEFAULT_SIGNALS = ["SIGINT", "SIGTERM"];
+var SIGNAL_EXIT_CODES = {
+  SIGINT: 130,
+  SIGTERM: 143
+};
+function installAutterAutoFlush(options = {}) {
+  const logger = _nullishCoalesce(options.logger, () => ( console));
+  const log = options.log !== false;
+  const warnOnUnflushedExit = options.warnOnUnflushedExit !== false;
+  const timeoutMs = Math.max(100, _nullishCoalesce(options.timeoutMs, () => ( 3e3)));
+  const signals = _nullishCoalesce(options.signals, () => ( DEFAULT_SIGNALS));
+  const flushOnUncaughtException = options.flushOnUncaughtException !== false;
+  let disposed = false;
+  let inFlight = null;
+  const doFlush = async () => {
+    const targets = _nullishCoalesce(options.targets, () => ( activeFlushTargets()));
+    if (targets.length === 0) return true;
+    let timer;
+    const timedOut = new Promise((resolve) => {
+      timer = setTimeout(() => resolve(false), timeoutMs);
+    });
+    const drained = Promise.allSettled(
+      targets.map(
+        (target) => Promise.resolve().then(() => target.forceFlush())
+      )
+    ).then(
+      (results) => results.every((result) => result.status === "fulfilled")
+    );
+    let ok;
+    try {
+      ok = await Promise.race([drained, timedOut]);
+    } finally {
+      clearTimeout(timer);
+    }
+    if (ok) {
+      telemetryStats.markAllFlushed();
+      if (log) {
+        logger.log("[autter] telemetry flushed");
+      }
+    } else {
+      logger.error(
+        `[autter] flush did not finish within ${timeoutMs}ms \u2014 some telemetry may be lost`
+      );
+    }
+    return ok;
+  };
+  const flush = (reason = "exit") => {
+    if (disposed) return Promise.resolve(false);
+    if (!inFlight) {
+      inFlight = doFlush().finally(() => {
+        inFlight = null;
+      });
+    }
+    if (isDebugEnabled()) debugLog(`auto-flush requested on ${reason}`);
+    return inFlight;
+  };
+  const signalCounts = /* @__PURE__ */ new Map();
+  let handlingUncaughtException = false;
+  const onUncaughtException = (error) => {
+    if (process.listenerCount("uncaughtException") > 1) return;
+    if (handlingUncaughtException) return;
+    handlingUncaughtException = true;
+    logger.error(error instanceof Error ? _nullishCoalesce(error.stack, () => ( error.message)) : String(error));
+    const keepAlive = setTimeout(() => {
+    }, timeoutMs + 50);
+    void flush("uncaughtException").finally(() => {
+      clearTimeout(keepAlive);
+      process.exit(1);
+    });
+  };
+  const onSignal = (signal) => {
+    const count = (_nullishCoalesce(signalCounts.get(signal), () => ( 0))) + 1;
+    signalCounts.set(signal, count);
+    const exitCode = _nullishCoalesce(SIGNAL_EXIT_CODES[signal], () => ( 1));
+    if (count > 1) {
+      process.exit(exitCode);
+    }
+    const otherHandlers = process.listenerCount(signal) - 1;
+    if (otherHandlers > 0) {
+      void flush(signal);
+      return;
+    }
+    void flush(signal).finally(() => {
+      process.exit(exitCode);
+    });
+  };
+  const MAX_BEFORE_EXIT_FLUSHES = 10;
+  let beforeExitFlushes = 0;
+  const onBeforeExit = () => {
+    if (disposed) return;
+    const targets = _nullishCoalesce(options.targets, () => ( activeFlushTargets()));
+    const worthIt = beforeExitFlushes === 0 ? targets.length > 0 : telemetryStats.pendingCaptures > 0;
+    if (!worthIt || beforeExitFlushes >= MAX_BEFORE_EXIT_FLUSHES) return;
+    beforeExitFlushes++;
+    const keepAlive = setTimeout(() => {
+    }, timeoutMs);
+    void flush("beforeExit").finally(() => clearTimeout(keepAlive));
+  };
+  const onExit = () => {
+    if (!warnOnUnflushedExit || disposed) return;
+    const pending = telemetryStats.pendingCaptures;
+    if (pending > 0) {
+      logger.error(
+        `[autter] process exiting with ~${pending} captured item(s) never confirmed exported \u2014 await autter.shutdown() on graceful shutdown`
+      );
+    }
+  };
+  const signalHandlers = /* @__PURE__ */ new Map();
+  process.on("beforeExit", onBeforeExit);
+  if (flushOnUncaughtException) {
+    process.on("uncaughtException", onUncaughtException);
+  }
+  for (const signal of signals) {
+    const handler = () => onSignal(signal);
+    signalHandlers.set(signal, handler);
+    process.on(signal, handler);
+  }
+  process.on("exit", onExit);
+  return {
+    flush,
+    dispose() {
+      disposed = true;
+      process.removeListener("beforeExit", onBeforeExit);
+      process.removeListener("uncaughtException", onUncaughtException);
+      process.removeListener("exit", onExit);
+      for (const [signal, handler] of signalHandlers) {
+        process.removeListener(signal, handler);
+      }
+      signalHandlers.clear();
+    }
+  };
+}
+
+// src/compat.ts
+var _http = require('http');
+var _https = require('https');
+
+// package.json
+var package_default = {
+  name: "@autter/runtime-node",
+  version: "1.6.0",
+  description: "Autter Runtime for Node.js: request wide events, coded errors, operation logging, same-origin browser relay and a curated OpenTelemetry server tracker",
+  license: "MIT",
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      require: "./dist/index.cjs"
+    },
+    "./testing": {
+      types: "./dist/testing.d.ts",
+      import: "./dist/testing.js",
+      require: "./dist/testing.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  bin: {
+    "autter-runtime": "./dist/cli.js"
+  },
+  files: [
+    "dist"
+  ],
+  repository: {
+    type: "git",
+    url: "https://github.com/Autter-dev/autter-runtime.git",
+    directory: "packages/runtime-node"
+  },
+  scripts: {
+    build: "node ../../scripts/ensure-built.mjs runtime-core && tsup",
+    test: "npm run build -w @autter/runtime-core && npm run build && npm run build -w @autter/otlp-ingester && node --test test/*.test.mjs"
+  },
+  dependencies: {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/core": "^1.30.1",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.57.1",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.57.1",
+    "@opentelemetry/instrumentation-http": "^0.57.1",
+    "@opentelemetry/resources": "^1.30.1",
+    "@opentelemetry/sdk-metrics": "^1.30.1",
+    "@opentelemetry/sdk-node": "^0.57.1",
+    "@opentelemetry/sdk-trace-base": "^1.30.1",
+    "@opentelemetry/semantic-conventions": "^1.28.0"
+  },
+  devDependencies: {
+    "@autter/runtime-core": "0.0.0",
+    "@types/node": "^22.10.0",
+    express: "^4.21.2",
+    fastify: "^5.12.5",
+    koa: "^3.2.1",
+    tsup: "^8.3.5",
+    typescript: "^5.7.0"
+  },
+  engines: {
+    node: ">=20"
+  },
+  publishConfig: {
+    access: "public",
+    provenance: true
+  },
+  homepage: "https://github.com/Autter-dev/autter-runtime#readme",
+  bugs: "https://github.com/Autter-dev/autter-runtime/issues",
+  keywords: [
+    "opentelemetry",
+    "otlp",
+    "error-tracking",
+    "telemetry",
+    "nodejs",
+    "express"
+  ]
+};
+
+// src/compat.ts
+var SDK_IDENTITY = {
+  name: "@autter/runtime-node",
+  version: package_default.version
+};
+var TIMEOUT_MS = 3e3;
+function compatRequest(method, url, options = {}) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const done = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const timer = setTimeout(() => {
+      _optionalChain([req, 'optionalAccess', _11 => _11.destroy, 'call', _12 => _12()]);
+      done(null);
+    }, _nullishCoalesce(options.timeoutMs, () => ( TIMEOUT_MS)));
+    if (options.unref !== false) timer.unref();
+    let req;
+    try {
+      const target = new URL(url);
+      const send = target.protocol === "https:" ? _https.request : _http.request;
+      req = send(
+        target,
+        {
+          method,
+          headers: {
+            accept: "application/json",
+            "user-agent": `${SDK_IDENTITY.name}/${SDK_IDENTITY.version}`,
+            ...options.body !== void 0 ? { "content-type": "application/json", "content-length": String(Buffer.byteLength(options.body)) } : {},
+            ...options.headers
+          }
+        },
+        (res) => {
+          let body = "";
+          res.setEncoding("utf8");
+          res.on("data", (chunk) => {
+            if (body.length < 256 * 1024) body += chunk;
+          });
+          res.on("end", () => done({ status: _nullishCoalesce(res.statusCode, () => ( 0)), headers: res.headers, body }));
+          res.on("error", () => done(null));
+        }
+      );
+      if (options.unref !== false) req.on("socket", (socket) => socket.unref());
+      req.on("error", () => done(null));
+      req.end(options.body);
+    } catch (e) {
+      done(null);
+    }
+  });
+}
+async function fetchIngesterCompat(endpoint, options = {}) {
+  const base = endpoint.replace(/\/$/, "");
+  const res = await compatRequest("GET", `${base}/v1/compat`, options);
+  if (!res) return { info: null, report: null, error: `could not reach ${base}/v1/compat` };
+  if (res.status === 200) {
+    let report = null;
+    try {
+      report = JSON.parse(res.body);
+    } catch (e2) {
+    }
+    const info = _nullishCoalesce(ingesterInfoFromReport(report), () => ( headerInfo(res.headers)));
+    return info ? { info, report } : { info: null, report, error: "unrecognised /v1/compat response" };
+  }
+  if (res.status === 404) {
+    const fromHeader = headerInfo(res.headers);
+    if (fromHeader) return { info: fromHeader, report: null };
+    const routes = {};
+    for (const route of _nullishCoalesce(options.probeRoutes, () => ( []))) {
+      const exists = await probeRoute(base, route, options);
+      if (exists !== null) routes[route] = exists;
+    }
+    return { info: { version: null, legacy: true, routes }, report: null };
+  }
+  return { info: headerInfo(res.headers), report: null, error: `/v1/compat answered ${res.status}` };
+}
+async function probeRoute(base, route, options) {
+  const res = await compatRequest("POST", `${base}${route}`, { ...options, body: "{}" });
+  return res ? res.status !== 404 : null;
+}
+function headerInfo(headers) {
+  const raw = typeof headers.get === "function" ? headers.get(INGESTER_VERSION_HEADER) : headers[INGESTER_VERSION_HEADER];
+  const version = Array.isArray(raw) ? raw[0] : raw;
+  return version ? ingesterInfoFromReport({ ingester: { version } }) : null;
+}
+function envDisabled() {
+  const value = _optionalChain([process, 'access', _13 => _13.env, 'access', _14 => _14.AUTTER_COMPAT_CHECK, 'optionalAccess', _15 => _15.trim, 'call', _16 => _16(), 'access', _17 => _17.toLowerCase, 'call', _18 => _18()]);
+  return value === "0" || value === "false" || value === "off";
+}
+var defaultWarn = (message) => console.warn(`[autter-runtime] ${message}`);
+var state = freshState(null, false);
+function freshState(endpoint, enabled, sdk = SDK_IDENTITY, warn = defaultWarn) {
+  return {
+    endpoint,
+    enabled,
+    sdk,
+    features: /* @__PURE__ */ new Set(),
+    info: null,
+    started: false,
+    pendingProbes: /* @__PURE__ */ new Set(),
+    warned: /* @__PURE__ */ new Set(),
+    warn
+  };
+}
+function configureCompatCheck(options) {
+  state = freshState(
+    options.endpoint.replace(/\/$/, ""),
+    options.enabled !== false && !envDisabled(),
+    _nullishCoalesce(options.sdk, () => ( SDK_IDENTITY)),
+    _nullishCoalesce(options.warn, () => ( defaultWarn))
+  );
+}
+function ensureCompatConfigured(endpoint) {
+  if (state.endpoint === null && !envDisabled()) {
+    state = freshState(endpoint.replace(/\/$/, ""), true);
+  }
+}
+function noteCompatFeature(id) {
+  try {
+    if (!state.enabled || state.features.has(id) || !featureById(id)) return;
+    state.features.add(id);
+    if (state.info) {
+      evaluateAndWarn();
+      return;
+    }
+    if (state.started) return;
+    state.started = true;
+    const current = state;
+    setTimeout(() => void runCheck(current), 0).unref();
+  } catch (e3) {
+  }
+}
+async function runCheck(current) {
+  try {
+    if (!current.endpoint) return;
+    const { info, error } = await fetchIngesterCompat(current.endpoint, {
+      probeRoutes: routesFor(current.features)
+    });
+    if (state !== current) return;
+    if (!info) {
+      debugLog(`compat check skipped: ${_nullishCoalesce(error, () => ( "ingester version unknown"))}`);
+      return;
+    }
+    mergeInfo(info);
+    for (const route of routesFor(current.features)) current.pendingProbes.add(route);
+    debugLog(
+      `compat check: ingester ${_nullishCoalesce(info.version, () => ( "1.4.0 or older (no /v1/compat)"))}` + (info.schema ? `, schema ${info.schema.status}` : "") + `, sdk ${current.sdk.name}@${current.sdk.version}, features ${[...current.features].join(", ") || "none"}`
+    );
+    evaluateAndWarn();
+  } catch (err) {
+    debugLog("compat check failed", err);
+  }
+}
+function routesFor(features) {
+  const routes = [];
+  for (const id of features) {
+    const route = _optionalChain([featureById, 'call', _19 => _19(id), 'optionalAccess', _20 => _20.route]);
+    if (route && !routes.includes(route)) routes.push(route);
+  }
+  return routes;
+}
+function mergeInfo(next) {
+  const prev = state.info;
+  state.info = {
+    version: _nullishCoalesce(_nullishCoalesce(next.version, () => ( _optionalChain([prev, 'optionalAccess', _21 => _21.version]))), () => ( null)),
+    ...next.legacy || _optionalChain([prev, 'optionalAccess', _22 => _22.legacy]) ? { legacy: true } : {},
+    ..._nullishCoalesce(next.schema, () => ( _optionalChain([prev, 'optionalAccess', _23 => _23.schema]))) ? { schema: _nullishCoalesce(next.schema, () => ( _optionalChain([prev, 'optionalAccess', _24 => _24.schema]))) } : {},
+    routes: { ..._optionalChain([prev, 'optionalAccess', _25 => _25.routes]), ...next.routes }
+  };
+}
+function evaluateAndWarn() {
+  const info = state.info;
+  if (!info) return;
+  if (info.version === null && state.endpoint) {
+    const unprobed = routesFor(state.features).filter(
+      (route) => _optionalChain([info, 'access', _26 => _26.routes, 'optionalAccess', _27 => _27[route]]) === void 0 && !state.pendingProbes.has(route)
+    );
+    if (unprobed.length) {
+      const current = state;
+      for (const route of unprobed) current.pendingProbes.add(route);
+      void Promise.all(unprobed.map((route) => probeRoute(current.endpoint, route, {}).then((exists) => [route, exists]))).then((results) => {
+        if (state !== current) return;
+        const routes = {};
+        for (const [route, exists] of results) if (exists !== null) routes[route] = exists;
+        mergeInfo({ version: null, legacy: true, routes });
+        evaluateAndWarn();
+      }).catch(() => {
+      });
+    }
+  }
+  for (const issue of evaluateCompat({ features: state.features, ingester: info })) {
+    warnOnce(issue);
+  }
+}
+function warnOnce(issue) {
+  const key = `${issue.feature}:${issue.kind}`;
+  if (state.warned.has(key)) return;
+  state.warned.add(key);
+  try {
+    state.warn(issue.message);
+  } catch (e4) {
+  }
+}
+function observeIngesterResponse(response) {
+  try {
+    if (!state.enabled) return;
+    const fromHeader = headerInfo(response.headers);
+    if (fromHeader) {
+      if (_optionalChain([state, 'access', _28 => _28.info, 'optionalAccess', _29 => _29.version]) !== fromHeader.version) {
+        mergeInfo(fromHeader);
+        evaluateAndWarn();
+      }
+      return;
+    }
+    if (response.status === 404 && response.route && !_optionalChain([state, 'access', _30 => _30.info, 'optionalAccess', _31 => _31.version])) {
+      mergeInfo({ version: null, legacy: true, routes: { [response.route]: false } });
+      evaluateAndWarn();
+    }
+  } catch (e5) {
+  }
+}
+function noteRelayRejection(eventTypes, status, headers) {
+  try {
+    if (!state.enabled || status !== 400 || headerInfo(headers)) return [];
+    const named = [];
+    for (const id of featuresForBrowserEvents(eventTypes)) {
+      const feature = featureById(id);
+      const key = `${id}:relay_rejected`;
+      if (state.warned.has(key)) continue;
+      state.warned.add(key);
+      named.push(id);
+      try {
+        state.warn(
+          `The ingester rejected a browser batch containing ${feature.title.toLowerCase()} events. ${feature.title} needs ingester >= ${feature.ingester}; yours is 1.4.0 or older (it predates version reporting), so those batches are dropped. ${ingesterUpgradeHint(COMPAT_MANIFEST)}`
+        );
+      } catch (e6) {
+      }
+    }
+    return named;
+  } catch (e7) {
+    return [];
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.COMPAT_MANIFEST = COMPAT_MANIFEST; exports.INGESTER_VERSION_HEADER = INGESTER_VERSION_HEADER; exports.versionAtLeast = versionAtLeast; exports.featuresForBrowserEvents = featuresForBrowserEvents; exports.evaluateCompat = evaluateCompat; exports.setDebugMode = setDebugMode; exports.isDebugEnabled = isDebugEnabled; exports.debugLog = debugLog; exports.telemetryStats = telemetryStats; exports.CountingExporter = CountingExporter; exports.registerFlushTarget = registerFlushTarget; exports.unregisterFlushTargets = unregisterFlushTargets; exports.installAutterAutoFlush = installAutterAutoFlush; exports.SDK_IDENTITY = SDK_IDENTITY; exports.compatRequest = compatRequest; exports.fetchIngesterCompat = fetchIngesterCompat; exports.configureCompatCheck = configureCompatCheck; exports.ensureCompatConfigured = ensureCompatConfigured; exports.noteCompatFeature = noteCompatFeature; exports.observeIngesterResponse = observeIngesterResponse; exports.noteRelayRejection = noteRelayRejection;