@atolljs/devtools 0.1.7 → 0.1.9

package/dist/chunk-WIL2P7HG.js

@@ -0,0 +1,661 @@
+// src/otelMap.ts
+var SPAN_KIND_CLIENT = 3;
+var STATUS_ERROR = 2;
+var TEMPORALITY_CUMULATIVE = 2;
+var SEVERITY = {
+  trace: 1,
+  debug: 5,
+  info: 9,
+  warn: 13,
+  error: 17
+};
+var OTEL_SCOPE = { name: "@atolljs/devtools" };
+var attr = {
+  str: (key, v) => ({ key, value: { stringValue: v } }),
+  int: (key, v) => ({ key, value: { intValue: String(Math.trunc(v)) } }),
+  dbl: (key, v) => ({ key, value: { doubleValue: v } }),
+  bool: (key, v) => ({ key, value: { boolValue: v } })
+};
+var toAttributes = (bag) => {
+  const out = [];
+  for (const [k, v] of Object.entries(bag)) {
+    if (v === void 0) continue;
+    if (typeof v === "string") out.push(attr.str(k, v));
+    else if (typeof v === "boolean") out.push(attr.bool(k, v));
+    else if (Number.isSafeInteger(v)) out.push(attr.int(k, v));
+    else if (Number.isFinite(v)) out.push(attr.dbl(k, v));
+  }
+  return out;
+};
+var toUnixNano = (epochMs) => {
+  let whole = Math.floor(epochMs);
+  let frac = Math.round((epochMs - whole) * 1e6);
+  if (frac >= 1e6) {
+    whole += 1;
+    frac -= 1e6;
+  }
+  return (BigInt(whole) * 1000000n + BigInt(frac)).toString();
+};
+var hex = (bytes) => {
+  const a = new Uint8Array(bytes);
+  const c = globalThis.crypto;
+  if (c?.getRandomValues) c.getRandomValues(a);
+  else for (let i = 0; i < bytes; i++) a[i] = Math.random() * 256 | 0;
+  if (a.every((b) => b === 0)) a[bytes - 1] = 1;
+  let s = "";
+  for (const b of a) s += b.toString(16).padStart(2, "0");
+  return s;
+};
+var newTraceId = () => hex(16);
+var newSpanId = () => hex(8);
+var ClockRebaser = class {
+  constructor(originMs, resetMs = 1e3) {
+    this.originMs = originMs;
+    this.resetMs = resetMs;
+  }
+  originMs;
+  resetMs;
+  offsets = /* @__PURE__ */ new Map();
+  epochMs(ev, recvEpochMs) {
+    if (!ev.worker && this.originMs !== void 0) return this.originMs + ev.at;
+    const key = ev.worker ? `${ev.worker.poolId}#${ev.worker.slot}` : ev.thread;
+    const d = recvEpochMs - ev.at;
+    const cur = this.offsets.get(key);
+    const off = cur === void 0 || d < cur || d - cur > this.resetMs ? d : cur;
+    this.offsets.set(key, off);
+    return ev.at + off;
+  }
+};
+var MS_BOUNDS = [0, 1, 2, 5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3, 1e4];
+var seriesKey = (attrs) => attrs.map((a) => `${a.key}=${JSON.stringify(a.value)}`).join("|");
+var Instrument = class {
+  constructor(name, unit, description, kind, int, maxSeries, bounds = MS_BOUNDS) {
+    this.name = name;
+    this.unit = unit;
+    this.description = description;
+    this.kind = kind;
+    this.int = int;
+    this.maxSeries = maxSeries;
+    this.bounds = bounds;
+  }
+  name;
+  unit;
+  description;
+  kind;
+  int;
+  maxSeries;
+  bounds;
+  series = /* @__PURE__ */ new Map();
+  at(attrs, nowNs) {
+    const k = seriesKey(attrs);
+    let s = this.series.get(k);
+    if (!s) {
+      if (this.series.size >= this.maxSeries) return void 0;
+      s = {
+        attrs,
+        startNs: nowNs,
+        timeNs: nowNs,
+        value: 0,
+        count: 0,
+        sum: 0,
+        min: Infinity,
+        max: -Infinity,
+        buckets: new Array(this.bounds.length + 1).fill(0)
+      };
+      this.series.set(k, s);
+    }
+    return s;
+  }
+  add(attrs, v, nowNs) {
+    const s = this.at(attrs, nowNs);
+    if (s) s.value += v;
+  }
+  set(attrs, v, nowNs) {
+    const s = this.at(attrs, nowNs);
+    if (s) {
+      s.value = v;
+      s.timeNs = nowNs;
+    }
+  }
+  record(attrs, v, nowNs) {
+    const s = this.at(attrs, nowNs);
+    if (!s) return;
+    s.count++;
+    s.sum += v;
+    if (v < s.min) s.min = v;
+    if (v > s.max) s.max = v;
+    let i = 0;
+    while (i < this.bounds.length && v > this.bounds[i]) i++;
+    s.buckets[i]++;
+  }
+  delete(attrs) {
+    this.series.delete(seriesKey(attrs));
+  }
+  encode(nowNs) {
+    if (this.series.size === 0) return null;
+    const base = { name: this.name, unit: this.unit, description: this.description };
+    const num = (s) => this.int ? { asInt: String(Math.trunc(s.value)) } : { asDouble: s.value };
+    const all = [...this.series.values()];
+    if (this.kind === "counter") {
+      return {
+        ...base,
+        sum: {
+          aggregationTemporality: TEMPORALITY_CUMULATIVE,
+          isMonotonic: true,
+          dataPoints: all.map((s) => ({ attributes: s.attrs, startTimeUnixNano: s.startNs, timeUnixNano: nowNs, ...num(s) }))
+        }
+      };
+    }
+    if (this.kind === "gauge") {
+      return {
+        ...base,
+        gauge: { dataPoints: all.map((s) => ({ attributes: s.attrs, timeUnixNano: s.timeNs, ...num(s) })) }
+      };
+    }
+    const points = all.filter((s) => s.count > 0);
+    if (points.length === 0) return null;
+    return {
+      ...base,
+      histogram: {
+        aggregationTemporality: TEMPORALITY_CUMULATIVE,
+        dataPoints: points.map((s) => ({
+          attributes: s.attrs,
+          startTimeUnixNano: s.startNs,
+          timeUnixNano: nowNs,
+          count: String(s.count),
+          sum: s.sum,
+          min: s.min,
+          max: s.max,
+          bucketCounts: s.buckets.map(String),
+          explicitBounds: this.bounds
+        }))
+      }
+    };
+  }
+};
+var ERROR_OUTCOMES = /* @__PURE__ */ new Set(["error", "timeout", "queue-full", "crashed"]);
+var KNOWN_METHODS = /* @__PURE__ */ new Set(["CONNECT", "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "TRACE", "QUERY"]);
+var redactUrl = (url) => url.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/@]*@/i, "$1REDACTED:REDACTED@");
+var workerKey = (w) => w ? `${w.poolId}#${w.slot}` : void 0;
+var OtelMapper = class {
+  resource;
+  spans = [];
+  logs = [];
+  /** Items dropped by the queue bound since creation. */
+  dropped = 0;
+  clock;
+  traces;
+  metricsOn;
+  logsOn;
+  maxQueue;
+  maxPending;
+  ignoreUrl;
+  pending = /* @__PURE__ */ new Map();
+  pools = /* @__PURE__ */ new Set();
+  instruments = [];
+  m;
+  constructor(opts) {
+    this.resource = opts.resource;
+    this.clock = new ClockRebaser(opts.originMs);
+    this.traces = opts.signals?.traces !== false;
+    this.metricsOn = opts.signals?.metrics !== false;
+    this.logsOn = opts.signals?.logs !== false;
+    this.maxQueue = opts.maxQueue ?? 2048;
+    this.maxPending = opts.maxPending ?? 1e4;
+    this.ignoreUrl = opts.ignoreUrl;
+    const cap = opts.maxSeries ?? 2e3;
+    const mk = (name, unit, description, kind, int) => {
+      const i = new Instrument(name, unit, description, kind, int, cap);
+      this.instruments.push(i);
+      return i;
+    };
+    this.m = {
+      settled: mk("atoll.task.settled", "{call}", "Task calls settled, by outcome", "counter", true),
+      duration: mk("atoll.task.duration", "ms", "Task run time, dispatch to reply", "histogram", false),
+      wait: mk("atoll.task.queue_wait", "ms", "Task queue wait, enqueue to dispatch", "histogram", false),
+      inFlight: mk("atoll.task.in_flight", "{call}", "Task calls enqueued and not yet settled", "gauge", true),
+      islandOps: mk("atoll.island.ops", "{op}", "Island DOM ops replayed on the main thread", "counter", true),
+      heap: mk("atoll.runtime.heap", "By", "JS heap in use, per thread", "gauge", true),
+      rss: mk("atoll.runtime.rss", "By", "Resident set size, per thread (Node)", "gauge", true),
+      longFrames: mk("atoll.runtime.long_frames", "{frame}", "Main-thread frames over the 50ms budget", "counter", true),
+      blocking: mk("atoll.runtime.blocking", "ms", "Main-thread time past the 50ms frame budget", "counter", false),
+      fps: mk("atoll.runtime.fps", "{frame}/s", "Main-thread frame rate", "gauge", false),
+      writes: mk("atoll.memory.writes", "{write}", "Shared-memory field writes", "counter", true),
+      workerErrors: mk("atoll.worker.errors", "{error}", "Worker error events", "counter", true),
+      respawns: mk("atoll.worker.respawns", "{respawn}", "Crashed workers respawned", "counter", true)
+    };
+  }
+  pushSpan(s) {
+    this.spans.push(s);
+    if (this.spans.length > this.maxQueue) {
+      this.spans.shift();
+      this.dropped++;
+    }
+  }
+  pushLog(r) {
+    this.logs.push(r);
+    if (this.logs.length > this.maxQueue) {
+      this.logs.shift();
+      this.dropped++;
+    }
+  }
+  log(level, body, attrs, tMs, recvMs) {
+    if (!this.logsOn) return;
+    this.pushLog({
+      timeUnixNano: toUnixNano(tMs),
+      observedTimeUnixNano: toUnixNano(recvMs),
+      severityNumber: SEVERITY[level],
+      severityText: level.toUpperCase(),
+      body: { stringValue: body },
+      attributes: attrs
+    });
+  }
+  /** Thread attribution shared by logs and runtime metrics. */
+  threadAttrs(ev) {
+    const w = workerKey(ev.worker);
+    return w ? [attr.str("atoll.thread", "worker"), attr.str("atoll.worker", w)] : [attr.str("atoll.thread", ev.thread)];
+  }
+  /** Feed one event; `recvEpochMs` is when the sink saw it (rebases foreign clocks). */
+  ingest(ev, recvEpochMs) {
+    const t = this.clock.epochMs(ev, recvEpochMs);
+    const ns = () => toUnixNano(t);
+    switch (ev.type) {
+      case "pool:init":
+        this.pools.add(ev.poolId);
+        return;
+      case "pool:terminate":
+        this.pools.delete(ev.poolId);
+        if (this.metricsOn) this.m.inFlight.delete([attr.str("atoll.pool.id", ev.poolId)]);
+        return;
+      case "task:enqueue": {
+        if (!this.traces && !this.metricsOn) return;
+        this.pools.add(ev.poolId);
+        this.pending.set(`${ev.poolId}:${ev.callId}`, { poolId: ev.poolId, taskId: ev.taskId, startMs: t });
+        if (this.pending.size > this.maxPending) this.pending.delete(this.pending.keys().next().value);
+        return;
+      }
+      case "task:dispatch": {
+        const p = this.pending.get(`${ev.poolId}:${ev.callId}`);
+        if (p) {
+          p.slot = ev.slot;
+          p.waitMs = ev.waitMs;
+          p.argBytes = ev.argBytes;
+          p.dispatchMs = t;
+        }
+        if (this.metricsOn) {
+          this.m.wait.record([attr.str("atoll.pool.id", ev.poolId), attr.str("atoll.task.id", ev.taskId)], ev.waitMs, ns());
+        }
+        return;
+      }
+      case "task:settle": {
+        const key = `${ev.poolId}:${ev.callId}`;
+        const p = this.pending.get(key);
+        this.pending.delete(key);
+        if (this.metricsOn) {
+          const base = [attr.str("atoll.pool.id", ev.poolId), attr.str("atoll.task.id", ev.taskId)];
+          this.m.settled.add([...base, attr.str("atoll.outcome", ev.outcome)], 1, ns());
+          if (ev.runMs !== void 0) this.m.duration.record(base, ev.runMs, ns());
+        }
+        if (!this.traces) return;
+        const attributes = [
+          attr.str("atoll.pool.id", ev.poolId),
+          attr.str("atoll.task.id", ev.taskId),
+          attr.str("atoll.outcome", ev.outcome)
+        ];
+        if (p?.slot !== void 0) attributes.push(attr.int("atoll.worker.slot", p.slot));
+        if (p?.waitMs !== void 0) attributes.push(attr.dbl("atoll.queue_wait_ms", p.waitMs));
+        if (ev.runMs !== void 0) attributes.push(attr.dbl("atoll.run_ms", ev.runMs));
+        if (p?.argBytes !== void 0) attributes.push(attr.int("atoll.arg_bytes", p.argBytes));
+        if (ev.resultBytes !== void 0) attributes.push(attr.int("atoll.result_bytes", ev.resultBytes));
+        const fwd = workerKey(ev.worker);
+        if (fwd) attributes.push(attr.str("atoll.worker", fwd));
+        const span = {
+          traceId: newTraceId(),
+          spanId: newSpanId(),
+          name: `atoll.task ${ev.taskId}`,
+          kind: SPAN_KIND_CLIENT,
+          startTimeUnixNano: toUnixNano(p?.startMs ?? t - (ev.runMs ?? 0)),
+          endTimeUnixNano: ns(),
+          attributes
+        };
+        if (p?.dispatchMs !== void 0) {
+          span.events = [{
+            timeUnixNano: toUnixNano(p.dispatchMs),
+            name: "atoll.dispatch",
+            attributes: [attr.int("atoll.worker.slot", p.slot ?? -1), attr.dbl("atoll.queue_wait_ms", p.waitMs ?? 0)]
+          }];
+        }
+        if (ERROR_OUTCOMES.has(ev.outcome)) span.status = { code: STATUS_ERROR, message: ev.error ?? ev.outcome };
+        this.pushSpan(span);
+        return;
+      }
+      case "island:task": {
+        if (!this.traces) return;
+        const attributes = [attr.str("atoll.island.instance", ev.instance), attr.str("atoll.island.method", ev.method)];
+        if (ev.ops !== void 0) attributes.push(attr.int("atoll.island.ops", ev.ops));
+        const span = {
+          traceId: newTraceId(),
+          spanId: newSpanId(),
+          name: `atoll.island ${ev.instance} ${ev.method}`,
+          kind: SPAN_KIND_CLIENT,
+          startTimeUnixNano: toUnixNano(t - ev.ms),
+          endTimeUnixNano: ns(),
+          attributes
+        };
+        if (ev.error !== void 0) span.status = { code: STATUS_ERROR, message: ev.error };
+        this.pushSpan(span);
+        return;
+      }
+      case "island:ops":
+        if (this.metricsOn) {
+          this.m.islandOps.add(
+            [attr.str("atoll.island.instance", ev.instance), attr.str("atoll.island.via", ev.via)],
+            ev.count,
+            ns()
+          );
+        }
+        return;
+      case "net:fetch": {
+        if (!this.traces || this.ignoreUrl?.(ev.url)) return;
+        const known = KNOWN_METHODS.has(ev.method);
+        const attributes = [attr.str("http.request.method", known ? ev.method : "_OTHER")];
+        if (!known) attributes.push(attr.str("http.request.method_original", ev.method));
+        attributes.push(attr.str("url.full", redactUrl(ev.url)));
+        try {
+          const u = new URL(ev.url);
+          attributes.push(attr.str("server.address", u.hostname));
+          if (u.port) attributes.push(attr.int("server.port", Number(u.port)));
+        } catch {
+        }
+        if (ev.status !== void 0) attributes.push(attr.int("http.response.status_code", ev.status));
+        if (ev.error !== void 0) attributes.push(attr.str("error.type", "_OTHER"));
+        else if (ev.status !== void 0 && ev.status >= 400) attributes.push(attr.str("error.type", String(ev.status)));
+        const fwd = workerKey(ev.worker);
+        if (fwd) attributes.push(attr.str("atoll.worker", fwd));
+        const span = {
+          traceId: newTraceId(),
+          spanId: newSpanId(),
+          name: known ? ev.method : "HTTP",
+          kind: SPAN_KIND_CLIENT,
+          startTimeUnixNano: toUnixNano(t - ev.ms),
+          endTimeUnixNano: ns(),
+          attributes
+        };
+        if (ev.error !== void 0) span.status = { code: STATUS_ERROR, message: ev.error };
+        else if (ev.status !== void 0 && ev.status >= 400) span.status = { code: STATUS_ERROR };
+        this.pushSpan(span);
+        return;
+      }
+      case "runtime:memory":
+        if (this.metricsOn) {
+          const a = this.threadAttrs(ev);
+          this.m.heap.set(a, ev.heapBytes, ns());
+          if (ev.rssBytes !== void 0) this.m.rss.set(a, ev.rssBytes, ns());
+        }
+        return;
+      case "runtime:longframe":
+        if (this.metricsOn) {
+          this.m.longFrames.add([], 1, ns());
+          this.m.blocking.add([], ev.blockingMs, ns());
+        }
+        return;
+      case "runtime:frames":
+        if (this.metricsOn) this.m.fps.set([], ev.fps, ns());
+        return;
+      case "memory:write":
+        if (this.metricsOn) this.m.writes.add([attr.str("atoll.memory.field", ev.path)], 1, ns());
+        return;
+      case "worker:error": {
+        const a = [attr.str("atoll.pool.id", ev.poolId), attr.int("atoll.worker.slot", ev.slot)];
+        if (this.metricsOn) this.m.workerErrors.add([a[0]], 1, ns());
+        this.log("error", `worker error: ${ev.message}`, [...a, ...this.threadAttrs(ev)], t, recvEpochMs);
+        return;
+      }
+      case "worker:respawn": {
+        const a = [attr.str("atoll.pool.id", ev.poolId), attr.int("atoll.worker.slot", ev.slot)];
+        if (this.metricsOn) this.m.respawns.add([a[0]], 1, ns());
+        this.log("info", "worker respawned", [...a, ...this.threadAttrs(ev)], t, recvEpochMs);
+        return;
+      }
+      case "log": {
+        const a = [attr.str("atoll.log.scope", ev.scope), ...this.threadAttrs(ev)];
+        if (ev.data !== void 0) a.push(attr.str("atoll.log.data", ev.data));
+        this.log(ev.level, ev.message, a, t, recvEpochMs);
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  /** Remove up to `max` queued spans. */
+  takeSpans(max) {
+    return this.spans.splice(0, max);
+  }
+  /** Remove up to `max` queued log records. */
+  takeLogs(max) {
+    return this.logs.splice(0, max);
+  }
+  /** Cumulative snapshot of every metric with data; empty when metrics are off. */
+  collectMetrics(nowEpochMs) {
+    if (!this.metricsOn) return [];
+    const nowNs = toUnixNano(nowEpochMs);
+    const inFlight = /* @__PURE__ */ new Map();
+    for (const id of this.pools) inFlight.set(id, 0);
+    for (const p of this.pending.values()) inFlight.set(p.poolId, (inFlight.get(p.poolId) ?? 0) + 1);
+    for (const [id, n] of inFlight) this.m.inFlight.set([attr.str("atoll.pool.id", id)], n, nowNs);
+    const out = [];
+    for (const i of this.instruments) {
+      const m = i.encode(nowNs);
+      if (m) out.push(m);
+    }
+    return out;
+  }
+};
+var encodeTraces = (groups) => ({
+  resourceSpans: groups.map((g) => ({
+    resource: { attributes: g.resource },
+    scopeSpans: [{ scope: OTEL_SCOPE, spans: g.spans }]
+  }))
+});
+var encodeMetrics = (groups) => ({
+  resourceMetrics: groups.map((g) => ({
+    resource: { attributes: g.resource },
+    scopeMetrics: [{ scope: OTEL_SCOPE, metrics: g.metrics }]
+  }))
+});
+var encodeLogs = (groups) => ({
+  resourceLogs: groups.map((g) => ({
+    resource: { attributes: g.resource },
+    scopeLogs: [{ scope: OTEL_SCOPE, logRecords: g.logs }]
+  }))
+});
+
+// src/otelTransport.ts
+var RETRYABLE = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+var KEEPALIVE_MAX = 6e4;
+var sleep = (ms) => new Promise((r) => {
+  const t = setTimeout(r, ms);
+  t.unref?.();
+});
+var retryAfterMs = (h) => {
+  if (!h) return void 0;
+  const secs = Number(h);
+  if (Number.isFinite(secs)) return Math.max(0, secs * 1e3);
+  const at = Date.parse(h);
+  return Number.isNaN(at) ? void 0 : Math.max(0, at - Date.now());
+};
+var normalizeEndpoint = (endpoint = "http://localhost:4318") => endpoint.replace(/\/+$/, "");
+function createOtlpSender(opts = {}) {
+  const endpoint = normalizeEndpoint(opts.endpoint);
+  const doFetch = opts.fetch ?? (typeof fetch === "function" ? fetch.bind(globalThis) : void 0);
+  const maxRetries = opts.maxRetries ?? 3;
+  const base = opts.retryBaseMs ?? 500;
+  const cap = opts.retryMaxMs ?? 3e4;
+  const fail = (signal, message) => {
+    try {
+      opts.onError?.(new Error(message), signal);
+    } catch {
+    }
+  };
+  return {
+    endpoint,
+    async send(signal, body, sendOpts) {
+      if (!doFetch) {
+        fail(signal, "otlp: no fetch available");
+        return false;
+      }
+      const text = JSON.stringify(body);
+      const keepalive = !!sendOpts?.keepalive && text.length < KEEPALIVE_MAX;
+      for (let attempt = 0; ; attempt++) {
+        let delay;
+        let reason;
+        try {
+          const res = await doFetch(`${endpoint}/v1/${signal}`, {
+            method: "POST",
+            headers: { ...opts.headers, "content-type": "application/json" },
+            body: text,
+            keepalive
+          });
+          if (res.ok) return true;
+          reason = `otlp ${signal}: HTTP ${res.status}`;
+          if (!RETRYABLE.has(res.status)) {
+            fail(signal, reason);
+            return false;
+          }
+          delay = retryAfterMs(res.headers.get("retry-after"));
+        } catch (err) {
+          reason = `otlp ${signal}: ${err instanceof Error ? err.message : String(err)}`;
+        }
+        if (attempt >= maxRetries) {
+          fail(signal, `${reason} (gave up after ${attempt + 1} attempts)`);
+          return false;
+        }
+        const backoff = base * 2 ** attempt;
+        await sleep(Math.min(cap, delay ?? backoff * (0.5 + Math.random() / 2)));
+      }
+    }
+  };
+}
+function createOtelPipeline(opts) {
+  const { sender, newMapper } = opts;
+  const maxBatch = Math.max(1, opts.maxBatch ?? 512);
+  const now = opts.now ?? Date.now;
+  const traces = opts.signals?.traces !== false;
+  const metrics = opts.signals?.metrics !== false;
+  const logs = opts.signals?.logs !== false;
+  const mappers = /* @__PURE__ */ new Map();
+  const released = /* @__PURE__ */ new Set();
+  let chain = Promise.resolve();
+  let flushing = false;
+  let closed = false;
+  const sendQueued = async (signal, keepalive) => {
+    for (; ; ) {
+      let budget = maxBatch;
+      const groups = [];
+      for (const m of mappers.values()) {
+        if (budget === 0) break;
+        const items = signal === "traces" ? m.takeSpans(budget) : m.takeLogs(budget);
+        if (items.length) {
+          groups.push({ resource: m.resource, items });
+          budget -= items.length;
+        }
+      }
+      if (groups.length === 0) return;
+      const body = signal === "traces" ? encodeTraces(groups.map((g) => ({ resource: g.resource, spans: g.items }))) : encodeLogs(groups.map((g) => ({ resource: g.resource, logs: g.items })));
+      await sender.send(signal, body, { keepalive });
+    }
+  };
+  const doFlush = async (keepalive) => {
+    flushing = true;
+    try {
+      if (traces) await sendQueued("traces", keepalive);
+      if (logs) await sendQueued("logs", keepalive);
+      if (metrics) {
+        const t = now();
+        const groups = [...mappers.values()].map((m) => ({ resource: m.resource, metrics: m.collectMetrics(t) })).filter((g) => g.metrics.length > 0);
+        if (groups.length) await sender.send("metrics", encodeMetrics(groups), { keepalive });
+      }
+      for (const key of released) {
+        const m = mappers.get(key);
+        if (!m || m.spans.length === 0 && m.logs.length === 0) {
+          mappers.delete(key);
+          released.delete(key);
+        }
+      }
+    } finally {
+      flushing = false;
+    }
+  };
+  const flush = (f) => {
+    chain = chain.then(() => doFlush(!!f?.keepalive)).catch(() => {
+    });
+    return chain;
+  };
+  const interval = opts.flushIntervalMs ?? 5e3;
+  const timer = interval > 0 ? setInterval(() => void flush(), interval) : void 0;
+  timer?.unref?.();
+  return {
+    ingest(ev, recvEpochMs, key = "") {
+      if (closed) return;
+      let m = mappers.get(key);
+      if (!m) {
+        m = newMapper(key);
+        mappers.set(key, m);
+      }
+      released.delete(key);
+      m.ingest(ev, recvEpochMs);
+      if (!flushing && (m.spans.length >= maxBatch || m.logs.length >= maxBatch)) void flush();
+    },
+    release(key) {
+      if (mappers.has(key)) released.add(key);
+    },
+    flush,
+    async close() {
+      if (closed) return chain;
+      closed = true;
+      if (timer) clearInterval(timer);
+      return flush();
+    }
+  };
+}
+function localResource(serviceName, extra = {}) {
+  const g = globalThis;
+  const browser = typeof g.window !== "undefined" && typeof g.window.document !== "undefined";
+  const node = !browser && g.process?.versions?.node !== void 0;
+  return toAttributes({
+    "service.name": serviceName ?? "unknown_service",
+    "telemetry.sdk.name": "atoll",
+    "telemetry.sdk.language": node ? "nodejs" : "webjs",
+    ...node ? {
+      "process.pid": g.process?.pid,
+      "process.runtime.name": "nodejs",
+      "process.runtime.version": g.process?.versions?.node
+    } : { "user_agent.original": g.navigator?.userAgent },
+    ...extra
+  });
+}
+function sessionResource(session, serviceName, extra = {}) {
+  const node = session.runtime === "node";
+  return toAttributes({
+    "service.name": serviceName ?? session.name ?? "unknown_service",
+    "service.instance.id": session.id,
+    "telemetry.sdk.name": "atoll",
+    "telemetry.sdk.language": node ? "nodejs" : "webjs",
+    ...node ? { "process.runtime.name": "nodejs", "process.runtime.version": session.env?.node?.replace(/^v/, "") } : { "user_agent.original": session.env?.userAgent },
+    "atoll.session.hint": session.hint,
+    "atoll.framework": session.framework,
+    ...extra
+  });
+}
+
+export {
+  SEVERITY,
+  toUnixNano,
+  newTraceId,
+  newSpanId,
+  OtelMapper,
+  createOtlpSender,
+  createOtelPipeline,
+  localResource,
+  sessionResource
+};

package/dist/client.d.ts

@@ -13,6 +13,7 @@ export interface ConnectDevtoolsOptions {
     session?: {
         name?: string;
         hint?: string;
+        framework?: string;
     };
     /** Batch flush interval ms (default 100). */
     flushMs?: number;
@@ -24,6 +25,12 @@ export interface ConnectDevtoolsOptions {
     network?: boolean;
     /** Sample JS heap usage periodically — Chrome/Blink only (default true). */
     memory?: boolean;
+    /**
+     * Main-thread jank probe (default true): long frames (`runtime:longframe`,
+     * Long Animation Frames or `longtask`) and a rAF fps sampler
+     * (`runtime:frames`). Browser main thread only.
+     */
+    jank?: boolean;
 }
 export interface DevtoolsConnection {
     readonly open: boolean;

package/dist/control.d.ts

@@ -0,0 +1,4 @@
+import type { ControlRequest, ControlResult, SessionEnv } from './protocol.js';
+export declare const answerControl: (req: ControlRequest, reply: (res: ControlResult) => void) => Promise<void>;
+/** Runtime facts for the session's `env` — what the audits panel reasons over. */
+export declare const captureEnv: () => SessionEnv;

package/dist/index.js

@@ -4,7 +4,8 @@ import {
   devtoolsEnabled,
   initDevtools,
   mountDevtoolsOverlay
-} from "./chunk-4N3NBFL3.js";
+} from "./chunk-6E54FXKS.js";
+import "./chunk-57NGHQUL.js";
 export {
   DEVTOOLS_PARAM,
   connectDevtools,