@agenthoney/analytics 0.0.0-stage → 0.14.0

package/dist/chunk-L22VERBM.js

@@ -0,0 +1,911 @@
+import { shouldRecord, normalisePath } from './chunk-F3PRHEXB.js';
+
+// src/core/breaker.ts
+function createBreaker(options = {}) {
+  const failureThreshold = options.failureThreshold ?? 5;
+  const openMs = options.openMs ?? 3e4;
+  const now = options.now ?? (() => Date.now());
+  let consecutiveFailures = 0;
+  let openedAt = 0;
+  let state = "closed";
+  return {
+    get state() {
+      return state;
+    },
+    allow() {
+      if (state === "closed") return true;
+      if (state === "half-open") return true;
+      if (now() - openedAt >= openMs) {
+        state = "half-open";
+        return true;
+      }
+      return false;
+    },
+    success() {
+      consecutiveFailures = 0;
+      state = "closed";
+    },
+    failure() {
+      consecutiveFailures += 1;
+      if (state === "half-open" || consecutiveFailures >= failureThreshold) {
+        state = "open";
+        openedAt = now();
+      }
+    }
+  };
+}
+
+// src/core/config.ts
+var UNSET_SITE_ID = "unset";
+var KEY_FAMILY = /^ep_[A-Za-z0-9]+_[A-Za-z0-9]+_[A-Za-z0-9-]+_([A-Za-z0-9_-]+)$/;
+var MIN_SECRET = 16;
+function looksLikeKey(value) {
+  const match = KEY_FAMILY.exec(value.trim());
+  return match !== null && (match[1]?.length ?? 0) >= MIN_SECRET;
+}
+var DEFAULTS = {
+  batchSize: 20,
+  maxBatchSize: 100,
+  flushIntervalMs: 2e3,
+  maxQueueEvents: 1e3,
+  maxBodyBytes: 512 * 1024,
+  requestTimeoutMs: 2e3
+};
+var PUBLIC_ENV_PREFIXES = ["NEXT_PUBLIC_", "VITE_", "PUBLIC_", "REACT_APP_", "NUXT_PUBLIC_"];
+var AgentHoneyConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AgentHoneyConfigError";
+  }
+};
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function boolFromEnv(raw) {
+  if (raw === void 0) return void 0;
+  const v = raw.trim().toLowerCase();
+  if (v === "1" || v === "true" || v === "yes") return true;
+  if (v === "0" || v === "false" || v === "no") return false;
+  return void 0;
+}
+function resolveConfig(options = {}, env = typeof process === "undefined" ? {} : process.env) {
+  for (const prefix of PUBLIC_ENV_PREFIXES) {
+    const name = `${prefix}AGENTHONEY_SERVER_KEY`;
+    if (env[name]) {
+      throw new AgentHoneyConfigError(
+        `${name} is set. The "${prefix}" prefix inlines a value into client-side JavaScript, so this key is already public. Revoke it, then set AGENTHONEY_SERVER_KEY instead (no prefix) so it stays on the server.`
+      );
+    }
+  }
+  const ingestUrl = options.ingestUrl ?? env["AGENTHONEY_INGEST_URL"] ?? "";
+  const serverKey = options.serverKey ?? env["AGENTHONEY_SERVER_KEY"] ?? "";
+  const siteId = options.siteId ?? env["AGENTHONEY_SITE_ID"] ?? UNSET_SITE_ID;
+  const enabled = options.enabled ?? boolFromEnv(env["AGENTHONEY_ENABLED"]) ?? true;
+  const debug = options.debug ?? boolFromEnv(env["AGENTHONEY_DEBUG"]) ?? false;
+  let disabled = null;
+  if (typeof window !== "undefined") {
+    disabled = "browser-environment";
+  } else if (!enabled) {
+    disabled = "explicitly-disabled";
+  } else if (!ingestUrl) {
+    disabled = "missing-url";
+  } else if (!serverKey) {
+    disabled = "missing-key";
+  } else if (!looksLikeKey(serverKey)) {
+    disabled = "malformed-key";
+  }
+  return Object.freeze({
+    ingestUrl,
+    serverKey,
+    siteId,
+    debug,
+    batchSize: clamp(options.batchSize ?? DEFAULTS.batchSize, 1, DEFAULTS.maxBatchSize),
+    flushIntervalMs: clamp(options.flushIntervalMs ?? DEFAULTS.flushIntervalMs, 100, 6e4),
+    maxQueueEvents: clamp(options.maxQueueEvents ?? DEFAULTS.maxQueueEvents, 1, 1e5),
+    maxBodyBytes: clamp(options.maxBodyBytes ?? DEFAULTS.maxBodyBytes, 1024, DEFAULTS.maxBodyBytes),
+    requestTimeoutMs: clamp(options.requestTimeoutMs ?? DEFAULTS.requestTimeoutMs, 100, 3e4),
+    routeTemplate: options.routeTemplate,
+    redactPatterns: options.redactPatterns ?? [],
+    // ⚠️ Defaults to TRUE. An `?? true` that a refactor turns into `?? false`
+    // is the entire bug returning, so `config.test.ts` asserts the default.
+    redactHighEntropyPaths: options.redactHighEntropyPaths ?? true,
+    isInternal: options.isInternal,
+    clientIp: normaliseClientIpOption(options.clientIp) ?? clientIpFromEnv(env["AGENTHONEY_CLIENT_IP"]) ?? "platform",
+    disabled
+  });
+}
+function normaliseClientIpOption(value) {
+  if (value === void 0 || value === false || typeof value === "function") return value;
+  return value === "platform" || value === "forwarded" ? value : void 0;
+}
+function clientIpFromEnv(value) {
+  if (value === void 0) return void 0;
+  const normalised = value.trim().toLowerCase();
+  if (normalised === "off" || normalised === "false") return false;
+  if (normalised === "platform" || normalised === "forwarded") return normalised;
+  return void 0;
+}
+function redact(text) {
+  return text.replace(/\bep_(live|test)_server_[A-Za-z0-9_-]+/g, "ep_$1_server_[redacted]");
+}
+
+// src/core/encode.ts
+var MAX_BODY_BYTES = 512 * 1024;
+var OPEN = '{"events":[';
+var CLOSE = "]}";
+var byteLength = typeof TextEncoder === "function" ? (s) => new TextEncoder().encode(s).length : (
+  // Node 18+ always has TextEncoder; this is here so the module cannot
+  // throw at import time on an exotic runtime, which would take the host
+  // application down with it.
+  (s) => s.length
+);
+function encodeBatch(events, maxBytes = MAX_BODY_BYTES) {
+  if (events.length === 0) {
+    return { body: OPEN + CLOSE, taken: 0, oversized: false };
+  }
+  const overhead = byteLength(OPEN) + byteLength(CLOSE);
+  let used = overhead;
+  const parts = [];
+  for (const event of events) {
+    const encoded = JSON.stringify(event);
+    const cost = byteLength(encoded) + (parts.length > 0 ? 1 : 0);
+    if (used + cost > maxBytes) break;
+    parts.push(encoded);
+    used += cost;
+  }
+  return {
+    body: OPEN + parts.join(",") + CLOSE,
+    taken: parts.length,
+    oversized: parts.length === 0
+  };
+}
+
+// src/core/queue.ts
+var BoundedQueue = class {
+  capacity;
+  #items;
+  #head = 0;
+  #size = 0;
+  #dropped = 0;
+  constructor(capacity) {
+    if (!Number.isInteger(capacity) || capacity < 1) {
+      throw new TypeError(`capacity must be a positive integer, got ${capacity}`);
+    }
+    this.capacity = capacity;
+    this.#items = new Array(capacity);
+  }
+  get size() {
+    return this.#size;
+  }
+  /** How many events have been discarded because the buffer was full. */
+  get dropped() {
+    return this.#dropped;
+  }
+  push(item) {
+    if (this.#size === this.capacity) {
+      this.#items[this.#head] = item;
+      this.#head = (this.#head + 1) % this.capacity;
+      this.#dropped += 1;
+      return;
+    }
+    this.#items[(this.#head + this.#size) % this.capacity] = item;
+    this.#size += 1;
+  }
+  /** The first `max` items, without removing them. */
+  peek(max) {
+    const n = Math.min(max, this.#size);
+    const out = new Array(n);
+    for (let i = 0; i < n; i += 1) {
+      out[i] = this.#items[(this.#head + i) % this.capacity];
+    }
+    return out;
+  }
+  /** Remove the first `n` items. Called only after they are safely sent. */
+  commit(n) {
+    const count = Math.min(n, this.#size);
+    for (let i = 0; i < count; i += 1) {
+      this.#items[(this.#head + i) % this.capacity] = void 0;
+    }
+    this.#head = (this.#head + count) % this.capacity;
+    this.#size -= count;
+  }
+  /** Reset the drop counter, once the count has been reported on the wire. */
+  clearDropped() {
+    this.#dropped = 0;
+  }
+};
+
+// src/observe/client-ip.ts
+var PLATFORM_IP_HEADERS = [
+  "cf-connecting-ip",
+  // Cloudflare, including a tunnel
+  "true-client-ip",
+  // Cloudflare Enterprise, Akamai
+  "x-vercel-forwarded-for",
+  // Vercel
+  "fly-client-ip",
+  // Fly.io
+  "x-nf-client-connection-ip",
+  // Netlify
+  "x-azure-clientip"
+  // Azure Front Door
+];
+var COUNTRY_HEADERS = [
+  "cf-ipcountry",
+  "x-vercel-ip-country",
+  "x-nf-geo-country",
+  "fastly-client-country",
+  "x-azure-clientip-country"
+];
+var NON_COUNTRIES = /* @__PURE__ */ new Set(["XX", "T1", "A1", "A2", "AP", "EU"]);
+var IPV4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
+var IPV6_CHARS = /^[0-9a-f:.]+$/;
+function normaliseIp(raw) {
+  if (!raw) return void 0;
+  let value = raw.trim().toLowerCase();
+  if (!value || value === "unknown") return void 0;
+  const bracketed = /^\[([^\]]+)\](?::\d+)?$/.exec(value);
+  if (bracketed) value = bracketed[1];
+  else if (value.split(":").length === 2 && value.includes(".")) {
+    value = value.slice(0, value.indexOf(":"));
+  }
+  if (value.startsWith("::ffff:") && value.includes(".")) value = value.slice(7);
+  const v4 = IPV4.exec(value);
+  if (v4) {
+    return v4.slice(1).every((octet) => Number(octet) <= 255) ? value : void 0;
+  }
+  if (value.includes(":") && IPV6_CHARS.test(value) && value.length <= 45) return value;
+  return void 0;
+}
+function leftmost(chain) {
+  if (!chain) return void 0;
+  return normaliseIp(chain.split(",")[0]);
+}
+function rightmost(chain) {
+  if (!chain) return void 0;
+  const hops = chain.split(",");
+  return normaliseIp(hops[hops.length - 1]);
+}
+function isUnroutable(ip) {
+  if (ip === "::1" || ip.startsWith("fe80:") || ip.startsWith("fc") || ip.startsWith("fd")) {
+    return true;
+  }
+  const v4 = IPV4.exec(ip);
+  if (!v4) return false;
+  const [a, b] = [Number(v4[1]), Number(v4[2])];
+  return a === 10 || a === 127 || a === 0 || a === 192 && b === 168 || a === 172 && b >= 16 && b <= 31 || a === 169 && b === 254 || a === 100 && b >= 64 && b <= 127;
+}
+function platformIp(facts) {
+  for (const name of PLATFORM_IP_HEADERS) {
+    const found = leftmost(facts.header(name));
+    if (found) return found;
+  }
+  return void 0;
+}
+function resolveClientIp(facts, source) {
+  if (source === false) return void 0;
+  if (typeof source === "function") {
+    try {
+      return normaliseIp(source(facts));
+    } catch {
+      return void 0;
+    }
+  }
+  if (source === "forwarded") {
+    const forwarded = rightmost(facts.header("x-forwarded-for"));
+    if (forwarded && !isUnroutable(forwarded)) return forwarded;
+  } else {
+    const platform = platformIp(facts);
+    if (platform) return platform;
+  }
+  const fallback = normaliseIp(facts.frameworkIp) ?? normaliseIp(facts.socketIp);
+  return fallback && !isUnroutable(fallback) ? fallback : void 0;
+}
+function resolveCountry(facts) {
+  for (const name of COUNTRY_HEADERS) {
+    const value = facts.header(name)?.trim().toUpperCase();
+    if (value && /^[A-Z]{2}$/.test(value) && !NON_COUNTRIES.has(value)) return value;
+  }
+  return void 0;
+}
+function ipSourceName(source) {
+  if (source === false) return "off";
+  if (typeof source === "function") return "custom";
+  return source;
+}
+function observeNetwork(facts, source) {
+  const ip = resolveClientIp(facts, source);
+  const countryCode = resolveCountry(facts);
+  return {
+    ...ip ? { ip } : {},
+    ...countryCode ? { countryCode } : {},
+    ipSource: ipSourceName(source)
+  };
+}
+
+// src/core/safe.ts
+function safe(fn, onError) {
+  try {
+    fn();
+  } catch (error) {
+    try {
+      onError?.(error);
+    } catch {
+    }
+  }
+}
+async function safeAsync(fn, onError) {
+  try {
+    await fn();
+  } catch (error) {
+    try {
+      onError?.(error);
+    } catch {
+    }
+  }
+}
+
+// src/core/transport.ts
+function outcomeForStatus(status, retryAfterMs) {
+  if (status >= 200 && status < 300) return { outcome: "accepted", status };
+  if (status === 408 || status === 429 || status >= 500) {
+    return retryAfterMs === void 0 ? { outcome: "retryable", status } : { outcome: "retryable", status, retryAfterMs };
+  }
+  return { outcome: "rejected", status };
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+  const date = Date.parse(value);
+  if (Number.isFinite(date)) return Math.max(0, date - Date.now());
+  return void 0;
+}
+function fetchTransport(url) {
+  return {
+    async send(body, headers, signal) {
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers,
+          body,
+          signal,
+          // Never follow a redirect: this request carries a bearer token, and
+          // a redirect is an instruction from the network to send that
+          // credential somewhere we did not choose.
+          redirect: "error",
+          keepalive: false
+        });
+        return outcomeForStatus(
+          response.status,
+          parseRetryAfter(response.headers.get("retry-after"))
+        );
+      } catch {
+        return { outcome: "retryable" };
+      }
+    }
+  };
+}
+
+// src/core/collector.ts
+var ADDRESSLESS_WARN_AFTER = 20;
+var MAX_RETRIES = 2;
+var MAX_NOT_RECORDED_COUNT = 1e7;
+function defaultSetTimer(fn, ms) {
+  const handle = setInterval(fn, ms);
+  handle.unref?.();
+  return { cancel: () => clearInterval(handle) };
+}
+function createCollector(config, deps = {}) {
+  const log = deps.log ?? ((message) => console.warn(redact(message)));
+  const debug = (message) => {
+    if (config.debug) log(`[AgentHoney] ${message}`);
+  };
+  if (config.disabled) {
+    debug(`collection disabled: ${config.disabled}`);
+    const noop = {
+      record: () => {
+      },
+      notRecorded: () => {
+      },
+      flush: async () => {
+      },
+      stats: { queued: 0, dropped: 0, sent: 0, failed: 0, notRecorded: 0, breaker: "closed" },
+      close: () => {
+      }
+    };
+    return noop;
+  }
+  debug(`collection on; client address from: ${ipSourceName(config.clientIp)}`);
+  const queue = new BoundedQueue(config.maxQueueEvents);
+  const transport = deps.transport ?? fetchTransport(config.ingestUrl);
+  const breaker = deps.breaker ?? createBreaker();
+  const random = deps.random ?? Math.random;
+  const setTimer = deps.setTimer ?? defaultSetTimer;
+  let sent = 0;
+  let failed = 0;
+  const tally = /* @__PURE__ */ new Map();
+  const tallyTotal = () => [...tally.values()].reduce((a, b) => a + b, 0);
+  const settle = (reported) => {
+    for (const [reason, n] of reported) {
+      const left = (tally.get(reason) ?? 0) - n;
+      if (left > 0) tally.set(reason, left);
+      else tally.delete(reason);
+    }
+  };
+  let inFlight = null;
+  let addressless = 0;
+  let warnedAddressless = false;
+  const watchAddress = (event) => {
+    if (warnedAddressless || config.clientIp === false) return;
+    if (event.network?.ip) {
+      warnedAddressless = true;
+      return;
+    }
+    if (++addressless < ADDRESSLESS_WARN_AFTER) return;
+    warnedAddressless = true;
+    log(
+      `[AgentHoney] ${addressless} requests have been recorded with no client address, so crawler verification cannot run and every bot will stay "claimed". This server is behind a proxy that writes no platform header. Set AGENTHONEY_CLIENT_IP=forwarded to read the hop your proxy already writes, or AGENTHONEY_CLIENT_IP=off to silence this and send no address at all.`
+    );
+  };
+  const timer = setTimer(() => {
+    void flush();
+  }, config.flushIntervalMs);
+  function headers() {
+    return {
+      "content-type": "application/json",
+      authorization: `Bearer ${config.serverKey}`
+    };
+  }
+  async function sendOnce(body) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), config.requestTimeoutMs);
+    timeout.unref?.();
+    try {
+      return await transport.send(body, headers(), controller.signal);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  function backoffMs(attempt, retryAfterMs) {
+    if (retryAfterMs !== void 0) return Math.min(retryAfterMs, 3e4);
+    return random() * Math.min(5e3, 200 * 3 ** attempt);
+  }
+  const sleep = (ms) => new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    t.unref?.();
+  });
+  async function flushOnce() {
+    if (queue.size === 0 && tally.size === 0) return;
+    if (!breaker.allow()) {
+      debug("breaker open, skipping flush");
+      return;
+    }
+    const candidates = queue.peek(config.batchSize);
+    const droppedSoFar = queue.dropped;
+    if (droppedSoFar > 0 && candidates[0]) {
+      candidates[0] = {
+        ...candidates[0],
+        sdk: { ...candidates[0].sdk, dropped: droppedSoFar }
+      };
+    }
+    const reported = new Map(tally);
+    const encoded = encodeBatch(candidates, config.maxBodyBytes - (reported.size > 0 ? 512 : 0));
+    if (reported.size > 0) {
+      const counts = Object.fromEntries([...reported].map(([reason, n]) => [reason, Math.min(n, MAX_NOT_RECORDED_COUNT)]));
+      encoded.body = `${encoded.body.slice(0, -1)},"notRecorded":${JSON.stringify(counts)}}`;
+    }
+    if (candidates.length > 0 && encoded.oversized) {
+      queue.commit(1);
+      debug("dropped one event larger than the body limit");
+      return;
+    }
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt += 1) {
+      const result = await sendOnce(encoded.body);
+      if (result.outcome === "accepted") {
+        settle(reported);
+        queue.commit(encoded.taken);
+        if (droppedSoFar > 0) queue.clearDropped();
+        sent += encoded.taken;
+        breaker.success();
+        return;
+      }
+      if (result.outcome === "rejected") {
+        settle(reported);
+        queue.commit(encoded.taken);
+        failed += encoded.taken;
+        debug(`batch rejected with ${result.status}; dropped ${encoded.taken} event(s)`);
+        return;
+      }
+      if (attempt === MAX_RETRIES) break;
+      await sleep(backoffMs(attempt, result.retryAfterMs));
+    }
+    failed += encoded.taken;
+    breaker.failure();
+    debug(`batch failed after ${MAX_RETRIES + 1} attempt(s); ${queue.size} event(s) still buffered`);
+  }
+  function flush() {
+    if (inFlight) return inFlight;
+    inFlight = safeAsync(flushOnce, (error) => debug(`flush failed: ${String(error)}`)).finally(
+      () => {
+        inFlight = null;
+      }
+    );
+    return inFlight;
+  }
+  return {
+    record(event) {
+      try {
+        queue.push(event);
+        watchAddress(event);
+      } catch {
+      }
+    },
+    notRecorded(reason) {
+      try {
+        tally.set(reason, (tally.get(reason) ?? 0) + 1);
+      } catch {
+      }
+    },
+    flush,
+    get stats() {
+      return {
+        queued: queue.size,
+        dropped: queue.dropped,
+        sent,
+        failed,
+        notRecorded: tallyTotal(),
+        breaker: breaker.state
+      };
+    },
+    close() {
+      timer.cancel();
+    }
+  };
+}
+
+// src/serve/accept.ts
+var QVALUE = /^\d*\.?\d+$/;
+function parseAccept(header) {
+  if (!header) return [];
+  const ranges = [];
+  for (const part of header.split(",")) {
+    const segments = part.trim().split(";");
+    const type = segments[0]?.trim().toLowerCase();
+    if (!type) continue;
+    let q = 1;
+    for (const segment of segments.slice(1)) {
+      const eq = segment.indexOf("=");
+      const key = (eq === -1 ? segment : segment.slice(0, eq)).trim().toLowerCase();
+      if (key === "q") {
+        const value = eq === -1 ? void 0 : segment.slice(eq + 1).trim().toLowerCase();
+        q = value !== void 0 && QVALUE.test(value) ? Math.min(1, Math.max(0, Number(value))) : 1;
+      }
+    }
+    ranges.push({ type, q });
+  }
+  return ranges;
+}
+function exactQ(ranges, type) {
+  let best = 0;
+  for (const range of ranges) {
+    if (range.type === type) best = Math.max(best, range.q);
+  }
+  return best;
+}
+function effectiveQ(ranges, type) {
+  const prefix = `${type.split("/")[0]}/*`;
+  let best = 0;
+  for (const range of ranges) {
+    if (range.type === type || range.type === prefix || range.type === "*/*") {
+      best = Math.max(best, range.q);
+    }
+  }
+  return best;
+}
+var MARKDOWN_TYPES = ["text/markdown", "text/x-markdown"];
+function prefersMarkdown(header) {
+  const ranges = parseAccept(header);
+  if (ranges.length === 0) return false;
+  let markdown = 0;
+  for (const type of MARKDOWN_TYPES) {
+    markdown = Math.max(markdown, exactQ(ranges, type));
+  }
+  if (markdown === 0) return false;
+  const html = effectiveQ(ranges, "text/html");
+  return markdown >= html;
+}
+
+// src/core/record-gate.ts
+function recordOrCount(collector, event, accept, background) {
+  let decision;
+  try {
+    decision = shouldRecord({ ...event, acceptPrefersMarkdown: prefersMarkdown(accept), background });
+  } catch {
+    decision = { record: true, because: "page" };
+  }
+  if (decision.record) collector.record(event);
+  else collector.notRecorded?.(decision.reason);
+}
+
+// src/observe/response.ts
+function observeResponse(facts) {
+  const response = { observation: facts.observation };
+  if (facts.observation === "unknown") {
+    if (typeof facts.latencyMs === "number" && Number.isFinite(facts.latencyMs)) {
+      response.latencyMs = Math.max(0, Math.round(facts.latencyMs));
+    }
+    return response;
+  }
+  if (typeof facts.status === "number" && facts.status >= 100 && facts.status <= 599) {
+    response.status = facts.status;
+  }
+  if (facts.contentType) {
+    response.contentType = String(facts.contentType).slice(0, 255);
+  }
+  const length = typeof facts.contentLength === "string" ? Number(facts.contentLength) : facts.contentLength;
+  if (typeof length === "number" && Number.isFinite(length) && length >= 0) {
+    response.contentLength = Math.round(length);
+  }
+  if (typeof facts.latencyMs === "number" && Number.isFinite(facts.latencyMs)) {
+    response.latencyMs = Math.max(0, Math.round(facts.latencyMs));
+  }
+  return response;
+}
+
+// src/runtime.ts
+var SDK_NAME = "@agenthoney/analytics";
+var SDK_VERSION = "0.14.0";
+function runtimeName() {
+  try {
+    const g = globalThis;
+    const deno = g["Deno"];
+    if (deno?.version?.deno) return `deno-${deno.version.deno}`;
+    const bun = g["Bun"];
+    if (bun?.version) return `bun-${bun.version}`;
+    if (typeof process !== "undefined" && process.versions?.node) {
+      return `node-${process.versions.node}`;
+    }
+    const nav = g["navigator"];
+    if (nav?.userAgent?.includes("Cloudflare-Workers")) return "workerd";
+  } catch {
+  }
+  return "unknown";
+}
+function newEventId() {
+  try {
+    const c = globalThis.crypto;
+    if (typeof c?.randomUUID === "function") return c.randomUUID();
+  } catch {
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`;
+}
+
+// src/serve/hosted.ts
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return void 0;
+  }
+}
+var PAGE_LIMIT = 2e3;
+function hostedTwins(options) {
+  const base = originOf(options.ingestUrl ?? "https://ingest.agenthoney.ai/v1/events");
+  const refreshMs = options.refreshMs ?? 3e5;
+  const coldTimeoutMs = options.coldTimeoutMs ?? 750;
+  const failureBackoffMs = options.failureBackoffMs ?? 3e4;
+  const refreshTimeoutMs = options.refreshTimeoutMs ?? 5e3;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const now = options.now ?? (() => Date.now());
+  let twins = /* @__PURE__ */ new Map();
+  let fetchedAt = 0;
+  let failedAt = 0;
+  let inFlight;
+  function abortAfter(ms) {
+    const Controller = globalThis.AbortController;
+    if (!Controller) return { signal: void 0, done: () => {
+    } };
+    const controller = new Controller();
+    const timer = setTimeout(() => controller.abort(), ms);
+    timer.unref?.();
+    return { signal: controller.signal, done: () => clearTimeout(timer) };
+  }
+  async function refresh() {
+    if (!base) return;
+    const deadline = abortAfter(refreshTimeoutMs);
+    try {
+      const response = await fetchImpl(`${base}/v1/twins`, {
+        headers: { authorization: `Bearer ${options.serverKey}` },
+        ...deadline.signal ? { signal: deadline.signal } : {}
+      });
+      if (!response.ok) {
+        failedAt = now();
+        return;
+      }
+      const body = await response.json();
+      if (!Array.isArray(body.twins)) {
+        failedAt = now();
+        return;
+      }
+      if (body.twins.length === 0 && twins.size > 0) {
+        fetchedAt = now();
+        failedAt = 0;
+        return;
+      }
+      const next = /* @__PURE__ */ new Map();
+      for (const row of body.twins.slice(0, PAGE_LIMIT)) {
+        if (typeof row?.path !== "string" || typeof row.markdown !== "string") continue;
+        next.set(normalisePath(row.path), { body: row.markdown });
+      }
+      twins = next;
+      fetchedAt = now();
+      failedAt = 0;
+    } catch {
+      failedAt = now();
+    } finally {
+      deadline.done();
+    }
+  }
+  function refreshIfStale() {
+    if (inFlight) return inFlight;
+    if (fetchedAt !== 0 && now() - fetchedAt < refreshMs) return Promise.resolve();
+    if (failedAt !== 0 && now() - failedAt < failureBackoffMs) return Promise.resolve();
+    inFlight = refresh().finally(() => {
+      inFlight = void 0;
+    });
+    return inFlight;
+  }
+  function withDeadline(work) {
+    return new Promise((done) => {
+      let settled = false;
+      const finish = (value) => {
+        if (settled) return;
+        settled = true;
+        done(value);
+      };
+      const timer = setTimeout(() => finish(void 0), coldTimeoutMs);
+      timer.unref?.();
+      work.then(finish, () => finish(void 0)).finally(() => clearTimeout(timer));
+    });
+  }
+  const lookup = (path) => twins.get(normalisePath(path));
+  async function fetchOne(path) {
+    if (!base) return void 0;
+    try {
+      const url = `${base}/v1/twins?path=${encodeURIComponent(normalisePath(path))}`;
+      const deadline = abortAfter(refreshTimeoutMs);
+      let body;
+      try {
+        const response = await fetchImpl(url, {
+          headers: { authorization: `Bearer ${options.serverKey}` },
+          ...deadline.signal ? { signal: deadline.signal } : {}
+        });
+        if (!response.ok) return void 0;
+        body = await response.json();
+      } finally {
+        deadline.done();
+      }
+      const row = Array.isArray(body.twins) ? body.twins[0] : void 0;
+      if (!row || typeof row.markdown !== "string") return void 0;
+      return { body: row.markdown };
+    } catch {
+      return void 0;
+    }
+  }
+  return {
+    lookup,
+    fetchOne,
+    /**
+     * ⚠️ Returns a VALUE when warm and a PROMISE when cold. `TwinOptions.resolve`
+     * accepts either, so a warm lookup never introduces a microtask and a cold
+     * one never answers "no twin" just because this isolate is new.
+     *
+     * ⚠️ **Only call this where the client has already asked for markdown.** On
+     * a cold process it waits, and the adapters route the advertise path to
+     * `lookup` for exactly that reason. The wait is bounded by `coldTimeoutMs`
+     * and its worst case is "no twin", which is a page that works normally.
+     */
+    resolve: (path) => {
+      if (fetchedAt !== 0) return lookup(path);
+      if (failedAt !== 0 && now() - failedAt < failureBackoffMs) return void 0;
+      void refreshIfStale();
+      return withDeadline(fetchOne(path));
+    },
+    refresh,
+    refreshIfStale,
+    get size() {
+      return twins.size;
+    }
+  };
+}
+
+// src/serve/twin.ts
+var DISCOVERY_PATHS = ["/llms.txt", "/llms-full.txt", "/install.md"];
+var DEFAULT_TWIN_CONTENT_TYPE = "text/markdown; charset=utf-8";
+var DEFAULT_TWIN_CACHE_CONTROL = "public, max-age=3600, s-maxage=86400";
+function decideTwin(input) {
+  const method = input.method.toUpperCase();
+  if (method !== "GET" && method !== "HEAD") {
+    return { action: "pass", reason: "not_get" };
+  }
+  if (input.path.endsWith(".md")) {
+    return { action: "serve", lookupPath: stripMdSuffix(input.path), reason: "md_path" };
+  }
+  if (prefersMarkdown(input.accept)) {
+    return { action: "serve", lookupPath: input.path, reason: "accept_header" };
+  }
+  return { action: "pass", reason: "no_signal" };
+}
+function stripMdSuffix(path) {
+  const withoutSuffix = path.slice(0, -3);
+  if (withoutSuffix === "" || withoutSuffix === "/index") return "/";
+  return withoutSuffix;
+}
+function twinPathFor(path) {
+  if (path === "/") return "/index.md";
+  return `${path}.md`;
+}
+function buildTwinResponse(twin, decision, options) {
+  const headers = {
+    "content-type": twin.contentType ?? DEFAULT_TWIN_CONTENT_TYPE,
+    "cache-control": options.cacheControl ?? DEFAULT_TWIN_CACHE_CONTROL
+  };
+  if (decision.reason === "accept_header") {
+    headers["vary"] = "Accept";
+  }
+  if (twin.etag) headers["etag"] = twin.etag;
+  if (twin.lastModified) headers["last-modified"] = twin.lastModified;
+  return { status: 200, headers, body: twin.body };
+}
+function isThenable(value) {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+function advertiseHeader(path) {
+  return `<${twinPathFor(path)}>; rel="alternate"; type="text/markdown"`;
+}
+
+// src/serve/source.ts
+var NOOP_WARM = async () => {
+};
+function twinSourceFor(twin, config) {
+  const hosted = hostedFor(twin, config);
+  const authored = twin.resolve;
+  const lookup = (path) => {
+    if (authored) {
+      try {
+        const found = authored(path);
+        if (!isThenable(found) && found) return found;
+      } catch {
+      }
+    }
+    return hosted?.lookup(path);
+  };
+  const resolve = (path) => {
+    if (!authored) return hosted ? hosted.resolve(path) : void 0;
+    if (!hosted) return authored(path);
+    const found = authored(path);
+    if (isThenable(found)) return found.then((t) => t ?? hosted.resolve(path));
+    return found ?? hosted.resolve(path);
+  };
+  return { lookup, resolve, warm: hosted ? () => hosted.refreshIfStale() : NOOP_WARM };
+}
+function hostedFor(twin, config) {
+  if (!twin.hosted) return void 0;
+  const opts = twin.hosted === true ? {} : twin.hosted;
+  const serverKey = opts.serverKey ?? config.serverKey;
+  if (!serverKey) return void 0;
+  return hostedTwins({
+    serverKey,
+    ingestUrl: opts.ingestUrl ?? config.ingestUrl,
+    ...opts.refreshMs === void 0 ? {} : { refreshMs: opts.refreshMs },
+    ...opts.coldTimeoutMs === void 0 ? {} : { coldTimeoutMs: opts.coldTimeoutMs },
+    ...opts.failureBackoffMs === void 0 ? {} : { failureBackoffMs: opts.failureBackoffMs },
+    ...opts.refreshTimeoutMs === void 0 ? {} : { refreshTimeoutMs: opts.refreshTimeoutMs },
+    ...opts.fetchImpl === void 0 ? {} : { fetchImpl: opts.fetchImpl }
+  });
+}
+
+export { AgentHoneyConfigError, BoundedQueue, DEFAULTS, DEFAULT_TWIN_CACHE_CONTROL, DEFAULT_TWIN_CONTENT_TYPE, DISCOVERY_PATHS, MARKDOWN_TYPES, MAX_BODY_BYTES, SDK_NAME, SDK_VERSION, UNSET_SITE_ID, advertiseHeader, buildTwinResponse, createBreaker, createCollector, decideTwin, encodeBatch, fetchTransport, hostedTwins, looksLikeKey, newEventId, observeNetwork, observeResponse, outcomeForStatus, parseAccept, prefersMarkdown, recordOrCount, redact, resolveConfig, runtimeName, safe, safeAsync, stripMdSuffix, twinPathFor, twinSourceFor };
+//# sourceMappingURL=chunk-L22VERBM.js.map
+//# sourceMappingURL=chunk-L22VERBM.js.map