theokit 0.48.13 → 0.50.0

package/dist/chunk-7PM6K5EV.js

@@ -0,0 +1,513 @@
+#!/usr/bin/env node
+import "tsx/esm";
+import {
+  warnOnce
+} from "./chunk-2AMLGJJA.js";
+import {
+  observabilitySchema
+} from "./chunk-VI7ZANB3.js";
+
+// src/server/observability/trace-context-propagation.ts
+function generateNewTraceContext() {
+  return {
+    trace_id: newTraceId(),
+    span_id: newSpanId(),
+    flags: "01"
+  };
+}
+function newTraceId() {
+  return randomHex(16);
+}
+function newSpanId() {
+  return randomHex(8);
+}
+function randomHex(bytes) {
+  for (; ; ) {
+    const buf = new Uint8Array(bytes);
+    globalThis.crypto.getRandomValues(buf);
+    let hex = "";
+    for (const b of buf) hex += b.toString(16).padStart(2, "0");
+    if (!/^0+$/.test(hex)) return hex;
+  }
+}
+
+// src/server/observability/span.ts
+var SpanImpl = class {
+  data;
+  ended = false;
+  constructor(name, attributes, context) {
+    this.data = {
+      name,
+      traceId: context?.traceId ?? newTraceId(),
+      spanId: context?.spanId ?? newSpanId(),
+      attributes: {},
+      status: "ok",
+      startTimeMs: Date.now()
+    };
+    if (context?.parentSpanId !== void 0) this.data.parentSpanId = context.parentSpanId;
+    if (attributes) {
+      for (const [k, v] of Object.entries(attributes)) {
+        if (v !== void 0) this.data.attributes[k] = v;
+      }
+    }
+  }
+  setAttribute(key, value) {
+    if (!this.ended) this.data.attributes[key] = value;
+  }
+  setStatus(status, message) {
+    if (!this.ended) {
+      this.data.status = status;
+      this.data.statusMessage = message;
+    }
+  }
+  end() {
+    if (this.ended) return;
+    this.ended = true;
+    this.data.endTimeMs = Date.now();
+    this.data.durationMs = this.data.endTimeMs - this.data.startTimeMs;
+  }
+  /** Read-only access to span data (for adapters to export). */
+  getData() {
+    return { ...this.data, attributes: { ...this.data.attributes } };
+  }
+  isEnded() {
+    return this.ended;
+  }
+};
+var NoopSpan = class {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function -- Null Object, see above
+  setAttribute() {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function -- Null Object, see above
+  setStatus() {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function -- Null Object, see above
+  end() {
+  }
+};
+
+// src/server/observability/adapters/console.ts
+var ConsoleObservabilityAdapter = class {
+  name = "console";
+  write;
+  isShutdown = false;
+  spans = [];
+  constructor(options = {}) {
+    this.write = options.write ?? ((line) => process.stderr.write(line + "\n"));
+  }
+  startSpan(name, attributes, context) {
+    if (this.isShutdown) return new NoopSpan();
+    const span = new SpanImpl(name, attributes, context);
+    this.spans.push(span);
+    return {
+      setAttribute: (k, v) => {
+        span.setAttribute(k, v);
+      },
+      setStatus: (s, m) => {
+        span.setStatus(s, m);
+      },
+      end: () => {
+        span.end();
+        this.emitSpan(span.getData());
+      }
+    };
+  }
+  counter(name, value, attributes) {
+    if (this.isShutdown) return;
+    this.emit({
+      type: "counter",
+      metric: name,
+      value,
+      attributes: attributes ?? {},
+      timestamp: Date.now()
+    });
+  }
+  histogram(name, value, attributes) {
+    if (this.isShutdown) return;
+    this.emit({
+      type: "histogram",
+      metric: name,
+      value,
+      attributes: attributes ?? {},
+      timestamp: Date.now()
+    });
+  }
+  log(level, message, attributes) {
+    if (this.isShutdown) return;
+    this.emit({ type: "log", level, message, attributes: attributes ?? {}, timestamp: Date.now() });
+  }
+  // Not `async`: this adapter writes synchronously, so there is nothing to await.
+  flush() {
+    return Promise.resolve();
+  }
+  shutdown() {
+    this.isShutdown = true;
+    return Promise.resolve();
+  }
+  emitSpan(data) {
+    this.emit({
+      type: "span",
+      name: data.name,
+      status: data.status,
+      duration_ms: data.durationMs ?? 0,
+      attributes: data.attributes,
+      timestamp: data.startTimeMs
+    });
+  }
+  emit(record) {
+    this.write(JSON.stringify(record));
+  }
+};
+
+// src/server/observability/adapters/noop.ts
+var NoopObservabilityAdapter = class {
+  name = "noop";
+  isShutdown = false;
+  startSpan(_name, _attributes) {
+    return new NoopSpan();
+  }
+  // Null Object: discarding the call IS the behaviour. An empty body is the honest
+  // implementation — a fabricated one would only hide that from the next reader.
+  /* eslint-disable @typescript-eslint/no-empty-function -- no-op adapter by design */
+  counter(_name, _value, _attributes) {
+  }
+  histogram(_name, _value, _attributes) {
+  }
+  log(_level, _message, _attributes) {
+  }
+  /* eslint-enable @typescript-eslint/no-empty-function */
+  // Not `async`: there is nothing to await, and declaring it so would claim otherwise.
+  flush() {
+    return Promise.resolve();
+  }
+  shutdown() {
+    this.isShutdown = true;
+    return Promise.resolve();
+  }
+};
+
+// src/server/observability/otlp-serializer.ts
+function paraValorOtlp(value) {
+  switch (typeof value) {
+    case "string":
+      return { stringValue: value };
+    case "number":
+      return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
+    default:
+      return { boolValue: value };
+  }
+}
+function serializeSpansToOtlp(spans, serviceName = "theokit") {
+  const otlpSpans = spans.map((s) => ({
+    // #368 — read, never minted. This used to call `randomHex` for both, which
+    // gave every span a trace of its own and made a multi-span run unreadable at
+    // the collector. The ids now arrive on the span, decided when it started.
+    traceId: s.traceId,
+    spanId: s.spanId,
+    ...s.parentSpanId === void 0 ? {} : { parentSpanId: s.parentSpanId },
+    name: s.name,
+    kind: 2,
+    // SPAN_KIND_SERVER
+    startTimeUnixNano: String(s.startTimeMs * 1e6),
+    endTimeUnixNano: String((s.endTimeMs ?? s.startTimeMs) * 1e6),
+    attributes: Object.entries(s.attributes).map(([key, value]) => ({
+      key,
+      value: paraValorOtlp(value)
+    })),
+    status: { code: s.status === "ok" ? 1 : 2, message: s.statusMessage }
+  }));
+  const request = {
+    resourceSpans: [
+      {
+        scopeSpans: [
+          {
+            scope: { name: serviceName, version: "1.0.0" },
+            spans: otlpSpans
+          }
+        ]
+      }
+    ]
+  };
+  return new TextEncoder().encode(JSON.stringify(request));
+}
+
+// src/server/observability/adapters/theo-cloud.ts
+var TheoCloudObservabilityAdapter = class {
+  name = "theo-cloud";
+  pendingSpans = [];
+  isShutdown = false;
+  dropped = 0;
+  flushTimer;
+  opts;
+  constructor(options) {
+    this.opts = { flushIntervalMs: 5e3, maxPendingSpans: 1e4, ...options };
+    this.flushTimer = setInterval(() => {
+      void this.flush();
+    }, this.opts.flushIntervalMs);
+    this.flushTimer.unref();
+  }
+  /** How many spans were dropped because the buffer was full. */
+  droppedSpanCount() {
+    return this.dropped;
+  }
+  /**
+   * Whether the periodic flush is unref'd. A test seam: "the timer does not hold
+   * the process open" is otherwise only observable by hanging.
+   */
+  hasUnrefdFlushTimer() {
+    return !this.flushTimer.hasRef();
+  }
+  startSpan(name, attributes, context) {
+    if (this.isShutdown) return new NoopSpan();
+    const span = new SpanImpl(name, attributes, context);
+    return {
+      setAttribute: (k, v) => {
+        span.setAttribute(k, v);
+      },
+      setStatus: (s, m) => {
+        span.setStatus(s, m);
+      },
+      end: () => {
+        span.end();
+        if (this.pendingSpans.length >= this.opts.maxPendingSpans) {
+          this.pendingSpans.shift();
+          this.dropped++;
+        }
+        this.pendingSpans.push(span.getData());
+      }
+    };
+  }
+  /* eslint-disable @typescript-eslint/no-empty-function -- metrics not shipped by this adapter yet; an empty body is honest, a fabricated one is not */
+  counter(_name, _value, _attributes) {
+  }
+  histogram(_name, _value, _attributes) {
+  }
+  log(_level, _message, _attributes) {
+  }
+  /* eslint-enable @typescript-eslint/no-empty-function */
+  async flush() {
+    if (this.isShutdown || this.pendingSpans.length === 0) return;
+    const spans = this.pendingSpans.splice(0);
+    const body = serializeSpansToOtlp(spans);
+    const fetchFn = this.opts._mockFetch ?? globalThis.fetch;
+    try {
+      await fetchFn(this.opts.ingestUrl, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${this.opts.token}`
+        },
+        body
+      });
+    } catch (err) {
+      console.error(
+        `[theokit:observability] flush failed: ${err instanceof Error ? err.message : "unknown error"}`
+      );
+    }
+  }
+  async shutdown() {
+    if (this.isShutdown) return;
+    clearInterval(this.flushTimer);
+    await this.flush();
+    this.isShutdown = true;
+  }
+};
+
+// src/server/observability/adapter-registry.ts
+function resolveAdapter(options) {
+  if (options.config?.provider) {
+    return options.config.provider;
+  }
+  const ingestUrl = options.env.THEO_CLOUD_INGEST_URL;
+  const apiKey = options.env.THEO_CLOUD_API_KEY;
+  if (ingestUrl && apiKey) {
+    return new TheoCloudObservabilityAdapter({ ingestUrl, token: apiKey });
+  }
+  if (options.env.NODE_ENV === "development") {
+    return new ConsoleObservabilityAdapter();
+  }
+  return new NoopObservabilityAdapter();
+}
+
+// src/server/http/trace-context.ts
+var TRACE_HEADER = "x-trace-id";
+var TRACE_PARENT_HEADER = "traceparent";
+var REQUEST_ID_HEADER = "x-request-id";
+var TRACEPARENT_RE = /^00-([0-9a-f]{32})-([0-9a-f]{16})-[0-9a-f]{2}$/;
+function parseTraceparentContext(value) {
+  if (!value) return null;
+  const m = TRACEPARENT_RE.exec(value);
+  if (!m) return null;
+  const traceId = m[1];
+  if (/^0+$/.test(traceId)) return null;
+  const parentSpanId = m[2];
+  return /^0+$/.test(parentSpanId) ? { traceId } : { traceId, parentSpanId };
+}
+function parseTraceparent(value) {
+  return parseTraceparentContext(value)?.traceId ?? null;
+}
+var REQUEST_ID_RE = /^[A-Za-z0-9_.:-]{1,128}$/;
+function isTrustedRequestId(value) {
+  return REQUEST_ID_RE.test(value);
+}
+function pickHeader(value, isTrusted = () => true) {
+  if (Array.isArray(value)) {
+    for (const v of value) {
+      if (typeof v === "string" && v.length > 0 && isTrusted(v)) return v;
+    }
+    return null;
+  }
+  if (typeof value === "string" && value.length > 0 && isTrusted(value)) return value;
+  return null;
+}
+function resolveTraceIdFromHeaders(traceparent, requestId) {
+  if (traceparent !== null) {
+    const parsed = parseTraceparent(traceparent);
+    if (parsed !== null) return parsed;
+  }
+  if (requestId !== null) return requestId;
+  return globalThis.crypto.randomUUID();
+}
+function extractTraceId(req) {
+  return resolveTraceIdFromHeaders(
+    pickHeader(req.headers[TRACE_PARENT_HEADER]),
+    pickHeader(req.headers[REQUEST_ID_HEADER], isTrustedRequestId)
+  );
+}
+function extractW3CTraceContext(request) {
+  const traceparent = request.headers.get(TRACE_PARENT_HEADER);
+  if (traceparent === null) return void 0;
+  return parseTraceparentContext(traceparent) ?? void 0;
+}
+
+// src/server/observability/request-trace.ts
+var resolved = /* @__PURE__ */ new WeakMap();
+function requestTrace(request) {
+  const existing = resolved.get(request);
+  if (existing !== void 0) return existing;
+  const trace = resolve(request);
+  resolved.set(request, trace);
+  return trace;
+}
+function resolve(request) {
+  const inbound = extractW3CTraceContext(request);
+  if (inbound === void 0) return { traceId: newTraceId() };
+  if (inbound.parentSpanId === void 0) return { traceId: inbound.traceId };
+  return { traceId: inbound.traceId, parentSpanId: inbound.parentSpanId };
+}
+function recordOutermostSpan(request, spanId) {
+  const trace = requestTrace(request);
+  trace.outermostSpanId ??= spanId;
+}
+
+// src/server/observability/middleware.ts
+var DEFAULT_MAX_ACTIVE_SPANS = 1024;
+function createObservabilityPlugin(adapter, options = {}) {
+  const maxActiveSpans = options.maxActiveSpans ?? DEFAULT_MAX_ACTIVE_SPANS;
+  const activeSpans = /* @__PURE__ */ new Map();
+  function evictUntilRoom() {
+    while (activeSpans.size >= maxActiveSpans) {
+      const oldest = activeSpans.keys().next();
+      if (oldest.done === true) return;
+      const span = activeSpans.get(oldest.value);
+      activeSpans.delete(oldest.value);
+      if (span === void 0) continue;
+      span.setAttribute("span.abandoned", true);
+      span.setStatus("error", "span abandoned: onResponse never fired for this request");
+      span.end();
+    }
+  }
+  function requestSpanContext(request) {
+    const trace = requestTrace(request);
+    const spanId = newSpanId();
+    recordOutermostSpan(request, spanId);
+    return trace.parentSpanId === void 0 ? { traceId: trace.traceId, spanId } : { traceId: trace.traceId, spanId, parentSpanId: trace.parentSpanId };
+  }
+  function claim(requestId) {
+    const span = activeSpans.get(requestId);
+    if (span === void 0) return void 0;
+    activeSpans.delete(requestId);
+    return span;
+  }
+  return {
+    name: "theokit:observability",
+    register(app) {
+      app.addHook("onRequest", (ctx) => {
+        evictUntilRoom();
+        const span = adapter.startSpan(
+          "http.request",
+          {
+            method: ctx.request.method,
+            // `ctx.request.url` is absolute, because that is what a Web `Request`
+            // carries (`plugin-types.ts` says so, at length, for this reason).
+            path: new URL(ctx.request.url).pathname,
+            requestId: ctx.requestId
+          },
+          requestSpanContext(ctx.request)
+        );
+        activeSpans.set(ctx.requestId, span);
+      });
+      app.addHook("onResponse", (ctx) => {
+        const span = claim(ctx.requestId);
+        if (span === void 0) return;
+        const status = ctx.response.statusCode;
+        span.setAttribute("status", status);
+        span.setStatus("ok");
+        span.end();
+        adapter.counter("http.requests", 1, { method: ctx.request.method, status });
+      });
+      app.addHook("onError", (ctx) => {
+        const span = claim(ctx.requestId);
+        if (span === void 0) return;
+        const message = ctx.error instanceof Error ? ctx.error.message : "unknown error";
+        span.setAttribute("error", true);
+        span.setStatus("error", message);
+        span.end();
+        adapter.counter("http.errors", 1, { method: ctx.request.method });
+      });
+    }
+  };
+}
+
+// src/server/observability-bootstrap.ts
+var activeAdapter;
+function getObservabilityAdapter() {
+  return activeAdapter;
+}
+function _resetObservabilityAdapter() {
+  activeAdapter = void 0;
+}
+function createObservabilityPluginFromConfig(observabilityConfig, env) {
+  const parsed = observabilityConfig === void 0 || observabilityConfig === null ? void 0 : observabilitySchema.parse(observabilityConfig);
+  if (parsed?.enabled === false) return void 0;
+  const cloudConfigured = Boolean(env.THEO_CLOUD_INGEST_URL) && Boolean(env.THEO_CLOUD_API_KEY);
+  if (parsed === void 0 && !cloudConfigured) return void 0;
+  const adapter = resolveAdapter({
+    env,
+    config: { provider: parsed?.provider }
+  });
+  if (adapter.name === "noop") {
+    if (parsed !== void 0) {
+      warnOnce("observability.no_exporter", {
+        event: "observability.no_exporter",
+        message: "observability is configured but no exporter resolved, so no spans will be recorded. Set THEO_CLOUD_INGEST_URL and THEO_CLOUD_API_KEY, or pass observability.provider with your own adapter. In development, NODE_ENV=development resolves the console exporter."
+      });
+    }
+    return void 0;
+  }
+  activeAdapter = adapter;
+  return createObservabilityPlugin(adapter);
+}
+
+export {
+  TRACE_HEADER,
+  extractTraceId,
+  generateNewTraceContext,
+  newTraceId,
+  newSpanId,
+  requestTrace,
+  getObservabilityAdapter,
+  _resetObservabilityAdapter,
+  createObservabilityPluginFromConfig
+};
+//# sourceMappingURL=chunk-7PM6K5EV.js.map

package/dist/chunk-7PM6K5EV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server/observability/trace-context-propagation.ts","../src/server/observability/span.ts","../src/server/observability/adapters/console.ts","../src/server/observability/adapters/noop.ts","../src/server/observability/otlp-serializer.ts","../src/server/observability/adapters/theo-cloud.ts","../src/server/observability/adapter-registry.ts","../src/server/http/trace-context.ts","../src/server/observability/request-trace.ts","../src/server/observability/middleware.ts","../src/server/observability-bootstrap.ts"],"sourcesContent":["// T5a.1a — Web Standards migration (leaf-first slice). Web Crypto's\n// `crypto.getRandomValues()` is available on globalThis in every supported\n// runtime per ADR-0028 (Node 22+, CF Workers, Bun, Deno, browsers). No\n// node:crypto import needed — Web Crypto returns a typed array filled with\n// CSPRNG bytes, which we hex-encode locally instead of relying on Buffer.\n\n/**\n * W3C Trace Context propagation helpers for non-HTTP carriers (job\n * leases, webhook reply headers, agent SSE frames). Works against any\n * `Headers`-shaped carrier — Web Standards only.\n *\n * The HTTP-side extractor `extractTraceId` in `../http/trace-context.ts`\n * is request-scoped and returns only the trace_id string. This module\n * exposes the full `TraceContext` shape (trace_id + span_id + flags)\n * because downstream jobs/webhooks need to propagate a NEW span_id\n * (child span) while keeping the same trace_id.\n *\n * Format spec (W3C Trace Context Level 2):\n *   traceparent: version-trace_id-parent_id-trace_flags\n *   - version    = '00' (current)\n *   - trace_id   = 32 hex chars (128-bit)\n *   - parent_id  = 16 hex chars (64-bit) — \"span_id\" of the producer\n *   - trace_flags = 2 hex chars (sampled bit)\n *\n * @see https://www.w3.org/TR/trace-context/\n */\n\nexport interface TraceContext {\n  /** 32 hex chars. NEVER the reserved all-zeros value. */\n  readonly trace_id: string\n  /** 16 hex chars. NEVER the reserved all-zeros value. */\n  readonly span_id: string\n  /** 2 hex chars. Sampled bit + reserved. */\n  readonly flags: string\n}\n\nconst TRACEPARENT_RE = /^00-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/\nconst ALL_ZEROS_TRACE = '00000000000000000000000000000000'\nconst ALL_ZEROS_SPAN = '0000000000000000'\n\n/**\n * Extract a TraceContext from a Web Headers object. Returns `null` for:\n * - missing header\n * - malformed (not matching the version-trace-span-flags regex)\n * - reserved all-zeros trace_id (W3C-invalid)\n * - reserved all-zeros span_id (W3C-invalid)\n *\n * NEVER throws — defensive read.\n */\nexport function extractTraceContext(headers: Headers): TraceContext | null {\n  const value = headers.get('traceparent')\n  if (!value) return null\n  const m = TRACEPARENT_RE.exec(value)\n  if (!m) return null\n  const trace_id = m[1]\n  const span_id = m[2]\n  const flags = m[3]\n  if (trace_id === ALL_ZEROS_TRACE) return null\n  if (span_id === ALL_ZEROS_SPAN) return null\n  return { trace_id, span_id, flags }\n}\n\n/**\n * Write a canonical traceparent into a Web Headers object. Always\n * succeeds (defensive write — the caller is responsible for passing\n * a valid TraceContext; passing malformed input is a programming bug).\n */\nexport function injectTraceContext(headers: Headers, ctx: TraceContext): void {\n  headers.set('traceparent', `00-${ctx.trace_id}-${ctx.span_id}-${ctx.flags}`)\n}\n\n/**\n * Generate a fresh TraceContext (new trace_id + span_id, flags='01' for\n * sampled). Used when no upstream traceparent exists — e.g., when a\n * cron fires or a webhook arrives without an upstream tracer.\n */\nexport function generateNewTraceContext(): TraceContext {\n  return {\n    trace_id: newTraceId(),\n    span_id: newSpanId(),\n    flags: '01',\n  }\n}\n\n/**\n * A fresh 128-bit trace id, 32 hex chars, never the reserved all-zeros.\n *\n * Exported next to its span-id sibling because span identity needs the two\n * halves separately: a child span mints only an id and inherits the trace, and\n * a caller that had to mint a whole `TraceContext` to get one span id would be\n * discarding a trace id it never used. `span.ts` is the consumer.\n */\nexport function newTraceId(): string {\n  return randomHex(16) // 16 bytes = 32 hex chars\n}\n\n/** A fresh 64-bit span id, 16 hex chars, never the reserved all-zeros. */\nexport function newSpanId(): string {\n  return randomHex(8) // 8 bytes = 16 hex chars\n}\n\nfunction randomHex(bytes: number): string {\n  // crypto.getRandomValues is overwhelmingly unlikely to produce all-zeros,\n  // but we guard anyway — the W3C spec rejects all-zeros and tests assert\n  // this. Web Crypto API returns a Uint8Array; we hex-encode without Buffer\n  // to stay runtime-agnostic (CF Workers / Bun / Deno have no Buffer global).\n  for (;;) {\n    const buf = new Uint8Array(bytes)\n    globalThis.crypto.getRandomValues(buf)\n    let hex = ''\n    for (const b of buf) hex += b.toString(16).padStart(2, '0')\n    if (!/^0+$/.test(hex)) return hex\n  }\n}\n","/**\n * SpanHandle implementation — records timing + attributes.\n *\n * Used by console and theo-cloud adapters. Noop adapter uses NoopSpan.\n */\nimport type { SpanHandle, SpanAttributes, SpanContextInput } from './adapters/types.js'\nimport { newSpanId, newTraceId } from './trace-context-propagation.js'\n\nexport interface SpanData {\n  name: string\n  /**\n   * The trace this span belongs to, and the span's own id within it.\n   *\n   * These used to not exist, and the OTLP serializer minted a `traceId` per span\n   * at export time. Every export was well-formed and every span was an island: a\n   * five-span agent run reached the collector as five unrelated single-span\n   * traces, so \"read the run back from an exported trace\" had nothing to read\n   * (usetheokit/theokit#368). Identity belongs to the span, decided when it\n   * starts, not to the exporter, guessed when it leaves.\n   */\n  traceId: string\n  spanId: string\n  /** Absent on the root span of a trace. */\n  parentSpanId?: string\n  attributes: Record<string, string | number | boolean>\n  status: 'ok' | 'error'\n  statusMessage?: string\n  startTimeMs: number\n  endTimeMs?: number\n  durationMs?: number\n}\n\nexport class SpanImpl implements SpanHandle {\n  private readonly data: SpanData\n  private ended = false\n\n  constructor(name: string, attributes?: SpanAttributes, context?: SpanContextInput) {\n    this.data = {\n      name,\n      traceId: context?.traceId ?? newTraceId(),\n      spanId: context?.spanId ?? newSpanId(),\n      attributes: {},\n      status: 'ok',\n      startTimeMs: Date.now(),\n    }\n    if (context?.parentSpanId !== undefined) this.data.parentSpanId = context.parentSpanId\n    if (attributes) {\n      for (const [k, v] of Object.entries(attributes)) {\n        if (v !== undefined) this.data.attributes[k] = v\n      }\n    }\n  }\n\n  setAttribute(key: string, value: string | number | boolean): void {\n    if (!this.ended) this.data.attributes[key] = value\n  }\n\n  setStatus(status: 'ok' | 'error', message?: string): void {\n    if (!this.ended) {\n      this.data.status = status\n      this.data.statusMessage = message\n    }\n  }\n\n  end(): void {\n    if (this.ended) return // idempotent\n    this.ended = true\n    this.data.endTimeMs = Date.now()\n    this.data.durationMs = this.data.endTimeMs - this.data.startTimeMs\n  }\n\n  /** Read-only access to span data (for adapters to export). */\n  getData(): SpanData {\n    return { ...this.data, attributes: { ...this.data.attributes } }\n  }\n\n  isEnded(): boolean {\n    return this.ended\n  }\n}\n\n/**\n * Noop span — used by NoopAdapter and post-shutdown fallback (EC-2).\n *\n * The three empty bodies are the Null Object, not forgetfulness (agent-builder#319): **doing\n * nothing** is the contracted behaviour. Filling them with a `void 0` or a log just to silence the\n * lint would trade a readable intention for noise — and a log here would run on the post-shutdown\n * path, which is precisely where there must be no effect at all.\n */\nexport class NoopSpan implements SpanHandle {\n  // eslint-disable-next-line @typescript-eslint/no-empty-function -- Null Object, see above\n  setAttribute(): void {}\n  // eslint-disable-next-line @typescript-eslint/no-empty-function -- Null Object, see above\n  setStatus(): void {}\n  // eslint-disable-next-line @typescript-eslint/no-empty-function -- Null Object, see above\n  end(): void {}\n}\n","/**\n * ConsoleObservabilityAdapter — dev-mode console output.\n *\n * Emits JSON-structured lines to a configurable writer (default: process.stderr).\n * Inspired by Hono middleware timing pattern.\n */\nimport { SpanImpl, NoopSpan, type SpanData } from '../span.js'\n\nimport type { ObservabilityAdapter, SpanHandle, SpanAttributes, SpanContextInput } from './types.js'\n\ninterface ConsoleAdapterOptions {\n  /** Writer function — defaults to process.stderr.write. */\n  write?: (line: string) => void\n}\n\nexport class ConsoleObservabilityAdapter implements ObservabilityAdapter {\n  readonly name = 'console'\n  private write: (line: string) => void\n  private isShutdown = false\n  private spans: SpanImpl[] = []\n\n  constructor(options: ConsoleAdapterOptions = {}) {\n    this.write = options.write ?? ((line: string) => process.stderr.write(line + '\\n'))\n  }\n\n  startSpan(name: string, attributes?: SpanAttributes, context?: SpanContextInput): SpanHandle {\n    if (this.isShutdown) return new NoopSpan()\n    const span = new SpanImpl(name, attributes, context)\n    this.spans.push(span)\n    return {\n      setAttribute: (k, v) => {\n        span.setAttribute(k, v)\n      },\n      setStatus: (s, m) => {\n        span.setStatus(s, m)\n      },\n      end: () => {\n        span.end()\n        this.emitSpan(span.getData())\n      },\n    }\n  }\n\n  counter(name: string, value: number, attributes?: SpanAttributes): void {\n    if (this.isShutdown) return\n    this.emit({\n      type: 'counter',\n      metric: name,\n      value,\n      attributes: attributes ?? {},\n      timestamp: Date.now(),\n    })\n  }\n\n  histogram(name: string, value: number, attributes?: SpanAttributes): void {\n    if (this.isShutdown) return\n    this.emit({\n      type: 'histogram',\n      metric: name,\n      value,\n      attributes: attributes ?? {},\n      timestamp: Date.now(),\n    })\n  }\n\n  log(\n    level: 'debug' | 'info' | 'warn' | 'error',\n    message: string,\n    attributes?: SpanAttributes,\n  ): void {\n    if (this.isShutdown) return\n    this.emit({ type: 'log', level, message, attributes: attributes ?? {}, timestamp: Date.now() })\n  }\n\n  // Not `async`: this adapter writes synchronously, so there is nothing to await.\n  flush(): Promise<void> {\n    return Promise.resolve()\n  }\n\n  shutdown(): Promise<void> {\n    this.isShutdown = true\n    return Promise.resolve()\n  }\n\n  private emitSpan(data: SpanData): void {\n    this.emit({\n      type: 'span',\n      name: data.name,\n      status: data.status,\n      duration_ms: data.durationMs ?? 0,\n      attributes: data.attributes,\n      timestamp: data.startTimeMs,\n    })\n  }\n\n  private emit(record: Record<string, unknown>): void {\n    this.write(JSON.stringify(record))\n  }\n}\n","/**\n * NoopObservabilityAdapter — silent fallback.\n *\n * All methods are no-ops. Never throws, never blocks.\n * Used as the default when no other adapter is configured.\n * EC-2: startSpan after shutdown returns a noop span (no crash).\n */\nimport { NoopSpan } from '../span.js'\n\nimport type { ObservabilityAdapter, SpanHandle, SpanAttributes } from './types.js'\n\nexport class NoopObservabilityAdapter implements ObservabilityAdapter {\n  readonly name = 'noop'\n  private isShutdown = false\n\n  startSpan(_name: string, _attributes?: SpanAttributes): SpanHandle {\n    return new NoopSpan()\n  }\n\n  // Null Object: discarding the call IS the behaviour. An empty body is the honest\n  // implementation — a fabricated one would only hide that from the next reader.\n  /* eslint-disable @typescript-eslint/no-empty-function -- no-op adapter by design */\n  counter(_name: string, _value: number, _attributes?: SpanAttributes): void {}\n  histogram(_name: string, _value: number, _attributes?: SpanAttributes): void {}\n  log(\n    _level: 'debug' | 'info' | 'warn' | 'error',\n    _message: string,\n    _attributes?: SpanAttributes,\n  ): void {}\n  /* eslint-enable @typescript-eslint/no-empty-function */\n\n  // Not `async`: there is nothing to await, and declaring it so would claim otherwise.\n  flush(): Promise<void> {\n    return Promise.resolve()\n  }\n\n  shutdown(): Promise<void> {\n    this.isShutdown = true\n    return Promise.resolve()\n  }\n}\n","/**\n * Lightweight OTLP JSON serializer — ~50 LoC, no @opentelemetry/* dependency.\n *\n * Per ADR D456: in-house serializer for the theo-cloud adapter.\n * Produces valid ExportTraceServiceRequest JSON (OTLP v1.0).\n * Pinned to OTLP JSON v1.0 (stable since 2023).\n */\nimport type { SpanData } from './span.js'\n\ninterface OtlpSpan {\n  traceId: string\n  spanId: string\n  /** Omitted on the root span — OTLP reads an absent parent as \"this is the root\". */\n  parentSpanId?: string\n  name: string\n  kind: number\n  startTimeUnixNano: string\n  endTimeUnixNano: string\n  attributes: {\n    key: string\n    value: { stringValue?: string; intValue?: string; doubleValue?: number; boolValue?: boolean }\n  }[]\n  status: { code: number; message?: string }\n}\n\ninterface ExportTraceServiceRequest {\n  resourceSpans: [\n    {\n      scopeSpans: [\n        {\n          scope: { name: string; version: string }\n          spans: OtlpSpan[]\n        },\n      ]\n    },\n  ]\n}\n\ninterface OtlpAttributeValue {\n  stringValue?: string\n  intValue?: string\n  doubleValue?: number\n  boolValue?: boolean\n}\n\n/**\n * OTLP's `AnyValue`: one field filled in, the others absent.\n *\n * It was an inline nested ternary (agent-builder#319). Extracted with a `switch`, and not flattened\n * into a cleverer ternary, because OTLP's type list is open — `arrayValue`, `doubleValue` and\n * `kvlistValue` exist in the spec and are not emitted here yet. With the `switch`, each becomes a new\n * `case`; with the ternary, each would become one more level of nesting.\n */\nfunction paraValorOtlp(value: string | number | boolean): OtlpAttributeValue {\n  switch (typeof value) {\n    case 'string':\n      return { stringValue: value }\n    case 'number':\n      // usetheokit/theokit#380 — every number used to go out as `intValue`, so\n      // `cost.usd` reached the collector as `{\"intValue\":\"0.0031\"}`: a string\n      // that is not an integer, in the field reserved for integers. A collector\n      // may reject it, coerce it to 0, or keep the string; none of those is the\n      // number, and cost is the one attribute that answers what a run cost.\n      //\n      // `Number.isInteger` and not a decimal-point test: `2.0` IS `2` in\n      // JavaScript, and making the wire shape depend on how a literal was typed\n      // rather than on the value would be a stranger rule than the bug.\n      return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value }\n    default:\n      return { boolValue: value }\n  }\n}\n\n/** Convert SpanData[] to OTLP JSON bytes (Uint8Array). */\nexport function serializeSpansToOtlp(spans: SpanData[], serviceName = 'theokit'): Uint8Array {\n  const otlpSpans: OtlpSpan[] = spans.map((s) => ({\n    // #368 — read, never minted. This used to call `randomHex` for both, which\n    // gave every span a trace of its own and made a multi-span run unreadable at\n    // the collector. The ids now arrive on the span, decided when it started.\n    traceId: s.traceId,\n    spanId: s.spanId,\n    ...(s.parentSpanId === undefined ? {} : { parentSpanId: s.parentSpanId }),\n    name: s.name,\n    kind: 2, // SPAN_KIND_SERVER\n    startTimeUnixNano: String(s.startTimeMs * 1_000_000),\n    endTimeUnixNano: String((s.endTimeMs ?? s.startTimeMs) * 1_000_000),\n    attributes: Object.entries(s.attributes).map(([key, value]) => ({\n      key,\n      value: paraValorOtlp(value),\n    })),\n    status: { code: s.status === 'ok' ? 1 : 2, message: s.statusMessage },\n  }))\n\n  const request: ExportTraceServiceRequest = {\n    resourceSpans: [\n      {\n        scopeSpans: [\n          {\n            scope: { name: serviceName, version: '1.0.0' },\n            spans: otlpSpans,\n          },\n        ],\n      },\n    ],\n  }\n\n  return new TextEncoder().encode(JSON.stringify(request))\n}\n","/**\n * TheoCloudObservabilityAdapter — OTLP/HTTP batched export for TheoCloud.\n *\n * Zero-config via env vars (THEO_CLOUD_INGEST_URL, THEO_CLOUD_API_KEY).\n * Batches spans and flushes via native fetch() POST.\n *\n * EC-1: flush failure logs warning, does NOT throw, does NOT retry (KISS).\n * EC-2: startSpan after shutdown returns noop span.\n */\nimport { serializeSpansToOtlp } from '../otlp-serializer.js'\nimport { SpanImpl, NoopSpan, type SpanData } from '../span.js'\n\nimport type { ObservabilityAdapter, SpanHandle, SpanAttributes, SpanContextInput } from './types.js'\n\ninterface TheoCloudAdapterOptions {\n  /** TheoCloud ingest endpoint URL. */\n  ingestUrl: string\n  /** TheoCloud API key for authentication. */\n  token: string\n  /** Flush interval in ms (default: 5000). */\n  flushIntervalMs?: number\n  /**\n   * Most spans held before the oldest are dropped (default: 10 000).\n   *\n   * A collector that is unreachable does not make the spans stop arriving, and a\n   * buffer with no ceiling turns a telemetry outage into an out-of-memory. The\n   * drop is counted rather than silent: losing data is a real cost, losing it\n   * without saying so is a worse one.\n   */\n  maxPendingSpans?: number\n  /** Mock fetch for testing (never in production). */\n  _mockFetch?: typeof globalThis.fetch\n}\n\nexport class TheoCloudObservabilityAdapter implements ObservabilityAdapter {\n  readonly name = 'theo-cloud'\n  private pendingSpans: SpanData[] = []\n  private isShutdown = false\n  private dropped = 0\n  private readonly flushTimer: ReturnType<typeof setInterval>\n  private readonly opts: Required<\n    Pick<TheoCloudAdapterOptions, 'ingestUrl' | 'token' | 'flushIntervalMs' | 'maxPendingSpans'>\n  > &\n    TheoCloudAdapterOptions\n\n  constructor(options: TheoCloudAdapterOptions) {\n    this.opts = { flushIntervalMs: 5000, maxPendingSpans: 10_000, ...options }\n\n    // `flushIntervalMs` was accepted and defaulted here and read nowhere — there\n    // was no timer in the file. `shutdown()` was the only drain, and nothing\n    // called it, so a long-running server exported nothing at all\n    // (usetheokit/theokit#353).\n    //\n    // `unref()` is not optional: a telemetry exporter that pins the event loop\n    // turns a clean process exit into a hang, which is worse than the defect it\n    // was added to fix.\n    this.flushTimer = setInterval(() => {\n      void this.flush()\n    }, this.opts.flushIntervalMs)\n    this.flushTimer.unref()\n  }\n\n  /** How many spans were dropped because the buffer was full. */\n  droppedSpanCount(): number {\n    return this.dropped\n  }\n\n  /**\n   * Whether the periodic flush is unref'd. A test seam: \"the timer does not hold\n   * the process open\" is otherwise only observable by hanging.\n   */\n  hasUnrefdFlushTimer(): boolean {\n    return !this.flushTimer.hasRef()\n  }\n\n  startSpan(name: string, attributes?: SpanAttributes, context?: SpanContextInput): SpanHandle {\n    if (this.isShutdown) return new NoopSpan()\n    const span = new SpanImpl(name, attributes, context)\n    return {\n      setAttribute: (k, v) => {\n        span.setAttribute(k, v)\n      },\n      setStatus: (s, m) => {\n        span.setStatus(s, m)\n      },\n      end: () => {\n        span.end()\n        if (this.pendingSpans.length >= this.opts.maxPendingSpans) {\n          this.pendingSpans.shift()\n          this.dropped++\n        }\n        this.pendingSpans.push(span.getData())\n      },\n    }\n  }\n\n  /* eslint-disable @typescript-eslint/no-empty-function -- metrics not shipped by this adapter yet; an empty body is honest, a fabricated one is not */\n  counter(_name: string, _value: number, _attributes?: SpanAttributes): void {}\n  histogram(_name: string, _value: number, _attributes?: SpanAttributes): void {}\n  log(\n    _level: 'debug' | 'info' | 'warn' | 'error',\n    _message: string,\n    _attributes?: SpanAttributes,\n  ): void {}\n  /* eslint-enable @typescript-eslint/no-empty-function */\n\n  async flush(): Promise<void> {\n    if (this.isShutdown || this.pendingSpans.length === 0) return\n\n    const spans = this.pendingSpans.splice(0)\n    const body = serializeSpansToOtlp(spans) as unknown as BodyInit\n    const fetchFn = this.opts._mockFetch ?? globalThis.fetch\n\n    try {\n      await fetchFn(this.opts.ingestUrl, {\n        method: 'POST',\n        headers: {\n          'content-type': 'application/json',\n          authorization: `Bearer ${this.opts.token}`,\n        },\n        body,\n      })\n    } catch (err) {\n      // EC-1: log warning, don't throw, don't retry\n      console.error(\n        `[theokit:observability] flush failed: ${err instanceof Error ? err.message : 'unknown error'}`,\n      )\n    }\n  }\n\n  async shutdown(): Promise<void> {\n    if (this.isShutdown) return\n    // Cleared, not merely ignored: `isShutdown` would make later ticks no-ops,\n    // and a live handle on a process that is trying to exit is the thing to\n    // remove rather than to tolerate.\n    clearInterval(this.flushTimer)\n    await this.flush()\n    this.isShutdown = true\n  }\n}\n","/**\n * Adapter registry — resolves the active observability adapter.\n *\n * Per ADR D457 (v1.1) priority chain:\n *   1. Explicit config (theo.config.ts observability.provider) — ALWAYS wins\n *   2. THEO_CLOUD_INGEST_URL env → theo-cloud adapter\n *   3. NODE_ENV=development → console adapter\n *   4. Fallback → noop adapter\n */\nimport { ConsoleObservabilityAdapter } from './adapters/console.js'\nimport { NoopObservabilityAdapter } from './adapters/noop.js'\nimport { TheoCloudObservabilityAdapter } from './adapters/theo-cloud.js'\nimport type { ObservabilityAdapter } from './adapters/types.js'\n\ninterface ResolveAdapterOptions {\n  env: Record<string, string | undefined>\n  config?: {\n    provider?: ObservabilityAdapter\n  }\n}\n\n/**\n * Resolve the observability adapter from config + env.\n * Called once at boot — returns the active adapter for the process lifetime.\n */\nexport function resolveAdapter(options: ResolveAdapterOptions): ObservabilityAdapter {\n  // 1. Explicit config ALWAYS wins (EC-4)\n  if (options.config?.provider) {\n    return options.config.provider\n  }\n\n  // 2. TheoCloud env vars → theo-cloud adapter\n  const ingestUrl = options.env.THEO_CLOUD_INGEST_URL\n  const apiKey = options.env.THEO_CLOUD_API_KEY\n  if (ingestUrl && apiKey) {\n    return new TheoCloudObservabilityAdapter({ ingestUrl, token: apiKey })\n  }\n\n  // 3. Development → console adapter\n  if (options.env.NODE_ENV === 'development') {\n    return new ConsoleObservabilityAdapter()\n  }\n\n  // 4. Fallback → noop\n  return new NoopObservabilityAdapter()\n}\n","// T5a.1b — Web Crypto migration. randomUUID() moved to globalThis.crypto.\n// IncomingMessage stays as a type-only import (runtime-clean — TS erases at\n// build); full IncomingMessage→Request boundary migration deferred to a\n// later T5a.1c+ slice per ADR-0028 incremental leaf-first sequence.\nimport type { IncomingMessage } from 'node:http'\n\n/**\n * Phase 7 — Observability: traceId propagation (D7).\n *\n * Extract a stable identifier from incoming requests so a single value\n * correlates the client request, every server log line, the response\n * envelope, and any downstream span. Precedence:\n *\n *   1. `traceparent` (W3C Trace Context — `00-{32-hex}-{16-hex}-{flags}`)\n *   2. `x-request-id` (Heroku / GCP / generic proxy header)\n *   3. Generated UUID (fresh per request)\n *\n * UUIDs are accepted as trace identifiers by every major vendor that\n * does not enforce strict 32-hex (Datadog, Honeycomb, Sentry, Logflare,\n * Axiom, etc). We don't need ULIDs to ship this surface.\n */\n\nexport const TRACE_HEADER = 'x-trace-id'\nexport const TRACE_PARENT_HEADER = 'traceparent'\nconst REQUEST_ID_HEADER = 'x-request-id'\n\n// W3C Trace Context: 00-<trace-id 32 hex>-<span-id 16 hex>-<flags 2 hex>\nconst TRACEPARENT_RE = /^00-([0-9a-f]{32})-([0-9a-f]{16})-[0-9a-f]{2}$/\n\n/**\n * What a valid `traceparent` says: the trace to join, and the caller's span\n * inside it.\n *\n * Both halves are on the wire and only the first was ever read, so a span this\n * process opened for an incoming request became a SECOND root of the caller's\n * trace instead of a child of the caller's span — the trace correlated and the\n * waterfall lost its shape (usetheokit/theokit#385).\n */\nexport interface W3CTraceContext {\n  /** The trace this request belongs to. 32 hex chars. */\n  readonly traceId: string\n  /**\n   * The caller's span, which a span opened for this request hangs under.\n   *\n   * Absent when the caller sent the reserved all-zero parent id, which W3C\n   * defines as \"no parent\" rather than as a span to point at.\n   */\n  readonly parentSpanId?: string\n}\n\n/**\n * Parse a W3C Trace Context `traceparent` header value into the trace it names\n * and the caller's span within it. `null` when the value is not a well-formed\n * `traceparent` or names the reserved all-zero trace.\n */\nexport function parseTraceparentContext(value: string): W3CTraceContext | null {\n  if (!value) return null\n  const m = TRACEPARENT_RE.exec(value)\n  if (!m) return null\n  const traceId = m[1]\n  // W3C: trace-id of all zeroes is invalid by spec\n  if (/^0+$/.test(traceId)) return null\n  const parentSpanId = m[2]\n  // Same rule one field over: an all-zero parent-id is the spec's way of saying\n  // there is no parent, so it is dropped rather than exported as a span id no\n  // backend can resolve.\n  return /^0+$/.test(parentSpanId) ? { traceId } : { traceId, parentSpanId }\n}\n\n/**\n * Parse a W3C Trace Context `traceparent` header value. Returns the\n * 32-hex trace-id when valid (and not the reserved all-zeros), else\n * `null`.\n */\nexport function parseTraceparent(value: string): string | null {\n  return parseTraceparentContext(value)?.traceId ?? null\n}\n\n/**\n * Shape a correlation id must have to be trusted: printable, unpunctuated beyond\n * the separators real id formats use, and bounded.\n *\n * `x-request-id` is chosen by the caller and ends up in the structured logs an\n * operator reads. Unvalidated, a newline in it splits one log line into two with\n * the second forged, and a megabyte of it is a megabyte per request through the\n * whole log pipeline (usetheokit/theokit#353). The character set covers what real\n * id formats use — UUID, ULID, hex, dotted and colon-separated ids — and excludes\n * whitespace and control characters, which no id format needs and every injection\n * does.\n *\n * 128 is comfortably above any of those formats and far below a payload.\n */\nconst REQUEST_ID_RE = /^[A-Za-z0-9_.:-]{1,128}$/\n\nfunction isTrustedRequestId(value: string): boolean {\n  return REQUEST_ID_RE.test(value)\n}\n\n/**\n * Pick the first TRUSTED string value out of an IncomingMessage header. Node\n * collapses repeated headers into arrays; proxies sometimes do this for\n * `x-request-id`. Empty strings count as absent.\n *\n * \"First trusted\" rather than \"first non-empty\": taking the first value and\n * validating afterwards would let a proxy prepending a hostile value defeat a\n * good one sitting behind it.\n */\nfunction pickHeader(\n  value: string | string[] | undefined,\n  isTrusted: (candidate: string) => boolean = () => true,\n): string | null {\n  if (Array.isArray(value)) {\n    for (const v of value) {\n      if (typeof v === 'string' && v.length > 0 && isTrusted(v)) return v\n    }\n    return null\n  }\n  if (typeof value === 'string' && value.length > 0 && isTrusted(value)) return value\n  return null\n}\n\n/**\n * T5a.2 Phase C slice 1/2 — pure traceId resolution from pre-extracted\n * header values. Shared between IncomingMessage and Web Request wrappers.\n */\nfunction resolveTraceIdFromHeaders(traceparent: string | null, requestId: string | null): string {\n  if (traceparent !== null) {\n    const parsed = parseTraceparent(traceparent)\n    if (parsed !== null) return parsed\n  }\n  if (requestId !== null) return requestId\n  return globalThis.crypto.randomUUID()\n}\n\n/**\n * Resolve the request's traceId following the precedence above.\n */\nexport function extractTraceId(req: IncomingMessage): string {\n  return resolveTraceIdFromHeaders(\n    pickHeader(req.headers[TRACE_PARENT_HEADER]),\n    pickHeader(req.headers[REQUEST_ID_HEADER], isTrustedRequestId),\n  )\n}\n\n/**\n * T5a.2 Phase C slice 1/2 — Web-Standards-shaped traceId resolver.\n *\n * Mirror of `extractTraceId(req: IncomingMessage)` for the Web `Request`\n * shape. Same precedence (`traceparent` → `x-request-id` → generated\n * UUID). Uses `request.headers.get(name)` (native Web `Headers` API)\n * instead of the Node indexer.\n *\n * **Multi-value note:** Web `Headers` collapses repeated headers into a\n * single comma-separated string at parse. The IncomingMessage path's\n * `pickHeader` \"first non-empty value\" semantic is naturally satisfied\n * because there's no array to pick from on the Web side — `.get()`\n * returns the comma-joined value, which for `traceparent` / `x-request-id`\n * is treated as a single string anyway (both headers are conventionally\n * single-valued).\n */\n/**\n * The request's W3C trace context — the trace to join and the caller's span\n * within it — or `undefined` when the caller supplied no usable `traceparent`.\n *\n * Deliberately narrower than {@link extractTraceIdFromRequest}, which always\n * returns something and may return an `x-request-id` or a generated UUID. Those\n * are fine as a log correlation key and are NOT trace ids: OTLP wants 32 hex\n * characters, and a dashed UUID exported as a `traceId` is a malformed span.\n *\n * So a span-emitting caller asks this question instead — \"is there a real trace\n * to join?\" — and mints its own when the answer is no (usetheokit/theokit#368).\n *\n * It answers with the whole context rather than the trace id alone, because a\n * span opened for this request belongs in the caller's trace AND under the\n * caller's span. Returning only the first half is what made one request arrive\n * as a trace with two roots (usetheokit/theokit#385).\n */\nexport function extractW3CTraceContext(request: Request): W3CTraceContext | undefined {\n  const traceparent = request.headers.get(TRACE_PARENT_HEADER)\n  if (traceparent === null) return undefined\n  return parseTraceparentContext(traceparent) ?? undefined\n}\n\nexport function extractTraceIdFromRequest(request: Request): string {\n  const requestId = request.headers.get(REQUEST_ID_HEADER)\n  return resolveTraceIdFromHeaders(\n    request.headers.get(TRACE_PARENT_HEADER),\n    // Same policy on both resolvers. A validation living on one side only is the\n    // gap an attacker picks the other transport to reach.\n    requestId !== null && isTrustedRequestId(requestId) ? requestId : null,\n  )\n}\n","/**\n * One request, one trace — the side table both consumers read (usetheokit/theokit#404).\n *\n * ## The defect this exists to remove\n *\n * Two places decide what trace a request belongs to: the observability plugin, which opens the\n * `http.request` span, and `observeServedRun`, which opens `agent.run`. Both used to answer the\n * question the same way and *independently* — by reading the inbound `traceparent` header. That\n * agrees only while the header is there. A browser sends none, and neither does `curl` or an\n * uninstrumented `fetch`, so on the majority path each side took its own `?? newTraceId()` branch\n * and one request reached the collector as two disconnected traces, neither naming the other.\n *\n * Reading the same header is not sharing. This module is the sharing: the request's trace is\n * resolved ONCE, on first ask, and every later ask gets the same answer.\n *\n * ## Why a `WeakMap` keyed on the `Request`\n *\n * The two consumers already hold the same `Request` object — `serveThroughPluginLifecycle` builds\n * it once and hands that instance both to the hooks (as `PluginContext.request`) and to the\n * handler that calls `mountAgent`. So the request itself is already the shared thing, and a side\n * table keyed on it needs no new parameter threaded through `mountAgent`, no decoration contract,\n * and no signature change on either side.\n *\n * The two alternatives were weighed and rejected for reasons that outlive this comment:\n *\n * - `AsyncLocalStorage` is what an OTel Node SDK does, and it would work here — but it imports\n *   `node:async_hooks`, and `server/` holds a no-`node:*` invariant precisely so the same code\n *   serves the Web, Tauri and TUI targets (`rules/three-target-parity.md`). A `WeakMap` is plain\n *   ECMAScript and runs unchanged on every one of them.\n * - Threading a resolved context through `mountAgent`'s options is explicit, and it puts a\n *   telemetry concern in the signature of every route that might one day open a span. The entry\n *   above is the same value, reachable without the parameter.\n *\n * Keying on the object also disposes of the entry: the record dies with the request, with no cap,\n * no eviction and no leak — unlike the plugin's own span map, which is keyed by `requestId` and\n * needs `evictUntilRoom` for exactly that reason.\n *\n * ## What this does NOT do\n *\n * It does not open a span, and it does not claim one was opened. `outermostSpanId` stays unset\n * until something actually emits the request's outermost span, so a run with no `http.request`\n * span in scope stays the root of its own trace rather than naming a parent this process never\n * emitted. A dangling parent reads as a span that was lost in transit, which is a worse report\n * than an honest root.\n */\nimport { extractW3CTraceContext } from '../http/trace-context.js'\n\nimport { newTraceId } from './trace-context-propagation.js'\n\nexport interface RequestTrace {\n  /** The trace every span caused by this request belongs to. 32 hex chars. */\n  readonly traceId: string\n  /** The CALLER's span, when the caller sent a well-formed `traceparent`. */\n  readonly parentSpanId?: string\n  /**\n   * The outermost span THIS process opened for the request, once one has been opened.\n   *\n   * Undefined means nothing opened one — no observability plugin on this path, or a run started\n   * outside an HTTP turn. Consumers treat it as \"no local parent\", never as an id to point at.\n   */\n  outermostSpanId?: string\n}\n\nconst resolved = new WeakMap<Request, RequestTrace>()\n\n/**\n * The request's trace, resolved once and memoized on the request itself.\n *\n * Idempotent by construction: the first caller decides — from the inbound `traceparent` when there\n * is one, from a fresh mint when there is not — and every caller after it, on either side of the\n * request, is handed that same decision.\n */\nexport function requestTrace(request: Request): RequestTrace {\n  const existing = resolved.get(request)\n  if (existing !== undefined) return existing\n\n  const trace = resolve(request)\n  resolved.set(request, trace)\n  return trace\n}\n\n/** Decide a request's trace from what it carries. Called once per request, by `requestTrace`. */\nfunction resolve(request: Request): RequestTrace {\n  const inbound = extractW3CTraceContext(request)\n  if (inbound === undefined) return { traceId: newTraceId() }\n  if (inbound.parentSpanId === undefined) return { traceId: inbound.traceId }\n  return { traceId: inbound.traceId, parentSpanId: inbound.parentSpanId }\n}\n\n/**\n * Record the span this process opened as the request's outermost one, so spans opened later in the\n * same request hang under it instead of beside it.\n *\n * First writer wins. A second outermost span for one request is a bug in the caller, and silently\n * re-pointing every later child at it would hide that bug behind a plausible waterfall.\n */\nexport function recordOutermostSpan(request: Request, spanId: string): void {\n  const trace = requestTrace(request)\n  trace.outermostSpanId ??= spanId\n}\n","/**\n * Auto-instrumentation plugin — one span per HTTP request.\n *\n * Per blueprint Pattern 2 (Hono middleware timing):\n * - onRequest: start span with method + path\n * - onResponse: end span with status + duration\n * - onError: set span status to error\n *\n * ## It used to be unregistrable, and nothing said so\n *\n * This returned `{ name, onRequest, onResponse, onError }` against a plugin\n * contract of `{ name, register }`, so the obvious wiring — putting it in\n * `config.plugins` — threw `InvalidPluginShapeError` at boot\n * (`../plugins/load-plugins.ts:20`). Its own context type was a second, narrower\n * invention: `request: { method, url }` where the real hook receives a Web\n * `Request` with an ABSOLUTE url, and `response?: { statusCode }` where the real\n * one is a `ServerResponse`. The tests passed because they called the hooks\n * directly with the invented shape, which verified the implementation and never\n * the contract (usetheokit/theokit#353).\n *\n * ## Span state is per-instance, and bounded\n *\n * The active-span map used to be a module-level `Map` with no cap and no TTL.\n * Two consequences, both real once anything registered this:\n *\n *   - two plugin instances shared one map, so one app's response closed\n *     another's span;\n *   - a request whose `onResponse` never fires leaked its span forever. That is\n *     not an edge case here: the SSE path is exactly where `onResponse` does not\n *     fire on stream open, and an agent run is the longest-lived stream the\n *     framework serves.\n *\n * The map now lives in the closure and is capped. An evicted span is ENDED with\n * an `span.abandoned` attribute rather than dropped, so it still reaches the\n * exporter carrying the reason it was cut — trading a memory leak for a silent\n * hole in the trace would be the worse bargain.\n */\nimport type { PluginContext, PluginErrorContext, TheoApp, TheoPlugin } from '../plugin-types.js'\n\nimport type { ObservabilityAdapter, SpanContextInput, SpanHandle } from './adapters/types.js'\nimport { recordOutermostSpan, requestTrace } from './request-trace.js'\nimport { newSpanId } from './trace-context-propagation.js'\n\n/**\n * How many requests may be in flight with an unclosed span before the oldest is\n * force-ended. Sized to be far above any real concurrent-request count on a\n * single Node process, so eviction signals a leak rather than back-pressure.\n */\nconst DEFAULT_MAX_ACTIVE_SPANS = 1024\n\nexport interface ObservabilityPluginOptions {\n  /** Override the in-flight span cap. Mainly a test seam. */\n  maxActiveSpans?: number\n}\n\nexport function createObservabilityPlugin(\n  adapter: ObservabilityAdapter,\n  options: ObservabilityPluginOptions = {},\n): TheoPlugin {\n  const maxActiveSpans = options.maxActiveSpans ?? DEFAULT_MAX_ACTIVE_SPANS\n  const activeSpans = new Map<string, SpanHandle>()\n\n  /** Force-end the oldest spans until there is room for one more. */\n  function evictUntilRoom(): void {\n    while (activeSpans.size >= maxActiveSpans) {\n      const oldest = activeSpans.keys().next()\n      if (oldest.done === true) return\n      const span = activeSpans.get(oldest.value)\n      activeSpans.delete(oldest.value)\n      if (span === undefined) continue\n      span.setAttribute('span.abandoned', true)\n      span.setStatus('error', 'span abandoned: onResponse never fired for this request')\n      span.end()\n    }\n  }\n\n  /**\n   * Where the request's span sits: in the request's trace — the caller's when the caller sent a\n   * `traceparent` (usetheokit/theokit#385), a freshly minted one otherwise — under the caller's\n   * span when there is one.\n   *\n   * This is the OUTERMOST span of a request, which makes it precisely the caller\n   * `startSpan`'s optional `context` was written for — and precisely the caller\n   * that went on passing the two-argument form. The consequence was worse than\n   * \"the HTTP span is a root\": once `mountAgent` learned to continue an incoming\n   * trace, one request that ran an agent reached the collector as TWO\n   * disconnected traces, and the caller's trace id was present on the HTTP span\n   * as the `requestId` attribute rather than as its `traceId` — resolved,\n   * carried, and written to a field no tracing backend correlates on.\n   *\n   * No `traceparent` (or a malformed one) mints a fresh trace, which is the\n   * correct answer for a request nothing upstream traced — and it is minted by\n   * `requestTrace`, ONCE, so the run joins that trace instead of minting a\n   * second one of its own (usetheokit/theokit#404). The extraction there\n   * deliberately refuses `x-request-id` and dashed UUIDs: those are fine\n   * correlation keys and are not trace ids.\n   */\n  function requestSpanContext(request: Request): SpanContextInput {\n    const trace = requestTrace(request)\n    // Pinned rather than left to the adapter, because this id is what everything else the request\n    // causes hangs under — `SpanContextInput.spanId` exists for exactly this caller. Recording it\n    // is what makes the run a child instead of a second root (usetheokit/theokit#404).\n    const spanId = newSpanId()\n    recordOutermostSpan(request, spanId)\n    return trace.parentSpanId === undefined\n      ? { traceId: trace.traceId, spanId }\n      : { traceId: trace.traceId, spanId, parentSpanId: trace.parentSpanId }\n  }\n\n  /** Take the span for a request, if one is still open. */\n  function claim(requestId: string): SpanHandle | undefined {\n    const span = activeSpans.get(requestId)\n    if (span === undefined) return undefined\n    activeSpans.delete(requestId)\n    return span\n  }\n\n  return {\n    name: 'theokit:observability',\n\n    register(app: TheoApp): void {\n      app.addHook('onRequest', (ctx: PluginContext) => {\n        evictUntilRoom()\n        const span = adapter.startSpan(\n          'http.request',\n          {\n            method: ctx.request.method,\n            // `ctx.request.url` is absolute, because that is what a Web `Request`\n            // carries (`plugin-types.ts` says so, at length, for this reason).\n            path: new URL(ctx.request.url).pathname,\n            requestId: ctx.requestId,\n          },\n          requestSpanContext(ctx.request),\n        )\n        activeSpans.set(ctx.requestId, span)\n      })\n\n      app.addHook('onResponse', (ctx: PluginContext) => {\n        const span = claim(ctx.requestId)\n        if (span === undefined) return\n\n        const status = ctx.response.statusCode\n        span.setAttribute('status', status)\n        span.setStatus('ok')\n        span.end()\n\n        // Deliberately no `path` label: a counter is an aggregated series, and\n        // a dynamic route would mint one series per id.\n        adapter.counter('http.requests', 1, { method: ctx.request.method, status })\n      })\n\n      app.addHook('onError', (ctx: PluginErrorContext) => {\n        const span = claim(ctx.requestId)\n        if (span === undefined) return\n\n        const message = ctx.error instanceof Error ? ctx.error.message : 'unknown error'\n        span.setAttribute('error', true)\n        span.setStatus('error', message)\n        span.end()\n\n        adapter.counter('http.errors', 1, { method: ctx.request.method })\n      })\n    },\n  }\n}\n","/**\n * Build the observability plugin from `theo.config.ts > observability` + the\n * environment (#353).\n *\n * Until this existed, `createObservabilityPlugin` had no production caller and\n * `startSpan` was invoked in exactly one production file — the one nothing\n * called. Every adapter, the OTLP serializer and the span implementation were\n * tested, published and unreachable: the framework emitted no spans at all.\n *\n * ## When the plugin is wired, and one deliberate divergence\n *\n * `adapter-registry.ts` documents a four-step chain: explicit config, then\n * TheoCloud env vars, then `NODE_ENV=development` → console, then noop. This\n * function honours the first two and does NOT treat the third as an opt-in.\n *\n * The reason is that step 3 would turn telemetry on for every `theo dev` that\n * never asked for it, and the console adapter writes JSON lines to `stderr`\n * (`adapters/console.ts:23`) — the same stream `observability/logger.ts` already\n * writes a different JSON shape to. Two interleaved formats on one stream is a\n * downgrade for every developer, bought in exchange for telemetry nobody\n * requested.\n *\n * So: `observability: {}` in the config turns it on, and in dev that still\n * resolves to the console adapter exactly as the chain says. What changes is\n * that `NODE_ENV=development` alone no longer counts as asking.\n *\n * Returns `undefined` when nothing asked for telemetry, which preserves the\n * zero-plugin path for applications that configure none.\n */\nimport { observabilitySchema } from '../config/schemas/index.js'\n\nimport { resolveAdapter } from './observability/adapter-registry.js'\nimport type { ObservabilityAdapter } from './observability/adapters/types.js'\nimport { warnOnce } from './observability/logger.js'\nimport { createObservabilityPlugin } from './observability/middleware.js'\nimport type { TheoPlugin } from './plugin-types.js'\n\n/**\n * The adapter resolved at boot, for callers that are not the HTTP plugin.\n *\n * An agent run is the case that forced this: its spans are produced by\n * `observeAgentRun` from the wire chunk stream, far from the request hooks, and\n * it must be the SAME adapter — two independently resolved adapters mean two\n * exporters and two half-complete pictures of one run.\n *\n * `undefined` when nothing asked for telemetry, which is what keeps the\n * zero-cost path zero-cost.\n */\nlet activeAdapter: ObservabilityAdapter | undefined\n\nexport function getObservabilityAdapter(): ObservabilityAdapter | undefined {\n  return activeAdapter\n}\n\n/** Test-only: forget the boot-resolved adapter. Production code must not call this. */\nexport function _resetObservabilityAdapter(): void {\n  activeAdapter = undefined\n}\n\nexport function createObservabilityPluginFromConfig(\n  observabilityConfig: unknown,\n  env: Record<string, string | undefined>,\n): TheoPlugin | undefined {\n  const parsed =\n    observabilityConfig === undefined || observabilityConfig === null\n      ? undefined\n      : observabilitySchema.parse(observabilityConfig)\n\n  if (parsed?.enabled === false) return undefined\n\n  // An ingest URL plus a key is an explicit deployment decision, so it opts in\n  // on its own — that is what makes the env half of the documented chain reachable\n  // without a config file.\n  const cloudConfigured = Boolean(env.THEO_CLOUD_INGEST_URL) && Boolean(env.THEO_CLOUD_API_KEY)\n  if (parsed === undefined && !cloudConfigured) return undefined\n\n  const adapter = resolveAdapter({\n    env,\n    config: { provider: parsed?.provider as ObservabilityAdapter | undefined },\n  })\n\n  // The registry never fails; it falls back to noop. Wiring a plugin whose every\n  // hook is a no-op would cost a runner on the request path and buy nothing.\n  if (adapter.name === 'noop') {\n    // Silence here is the defect. An application that WROTE `observability: {}`\n    // asked for telemetry, and returning quietly gives it a passing boot, no\n    // spans, and nothing to search for — the config-validates-and-does-nothing\n    // shape usetheokit/theokit#321 recorded for `rateLimit`.\n    //\n    // Only when it was asked for: an application that configured nothing is not\n    // owed a warning about a thing it never requested.\n    if (parsed !== undefined) {\n      warnOnce('observability.no_exporter', {\n        event: 'observability.no_exporter',\n        message:\n          'observability is configured but no exporter resolved, so no spans will be recorded. ' +\n          'Set THEO_CLOUD_INGEST_URL and THEO_CLOUD_API_KEY, or pass observability.provider with ' +\n          'your own adapter. In development, NODE_ENV=development resolves the console exporter.',\n      })\n    }\n    return undefined\n  }\n\n  activeAdapter = adapter\n  return createObservabilityPlugin(adapter)\n}\n"],"mappings":";;;;;;;;;;AA4EO,SAAS,0BAAwC;AACtD,SAAO;AAAA,IACL,UAAU,WAAW;AAAA,IACrB,SAAS,UAAU;AAAA,IACnB,OAAO;AAAA,EACT;AACF;AAUO,SAAS,aAAqB;AACnC,SAAO,UAAU,EAAE;AACrB;AAGO,SAAS,YAAoB;AAClC,SAAO,UAAU,CAAC;AACpB;AAEA,SAAS,UAAU,OAAuB;AAKxC,aAAS;AACP,UAAM,MAAM,IAAI,WAAW,KAAK;AAChC,eAAW,OAAO,gBAAgB,GAAG;AACrC,QAAI,MAAM;AACV,eAAW,KAAK,IAAK,QAAO,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAC1D,QAAI,CAAC,OAAO,KAAK,GAAG,EAAG,QAAO;AAAA,EAChC;AACF;;;ACjFO,IAAM,WAAN,MAAqC;AAAA,EACzB;AAAA,EACT,QAAQ;AAAA,EAEhB,YAAY,MAAc,YAA6B,SAA4B;AACjF,SAAK,OAAO;AAAA,MACV;AAAA,MACA,SAAS,SAAS,WAAW,WAAW;AAAA,MACxC,QAAQ,SAAS,UAAU,UAAU;AAAA,MACrC,YAAY,CAAC;AAAA,MACb,QAAQ;AAAA,MACR,aAAa,KAAK,IAAI;AAAA,IACxB;AACA,QAAI,SAAS,iBAAiB,OAAW,MAAK,KAAK,eAAe,QAAQ;AAC1E,QAAI,YAAY;AACd,iBAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,UAAU,GAAG;AAC/C,YAAI,MAAM,OAAW,MAAK,KAAK,WAAW,CAAC,IAAI;AAAA,MACjD;AAAA,IACF;AAAA,EACF;AAAA,EAEA,aAAa,KAAa,OAAwC;AAChE,QAAI,CAAC,KAAK,MAAO,MAAK,KAAK,WAAW,GAAG,IAAI;AAAA,EAC/C;AAAA,EAEA,UAAU,QAAwB,SAAwB;AACxD,QAAI,CAAC,KAAK,OAAO;AACf,WAAK,KAAK,SAAS;AACnB,WAAK,KAAK,gBAAgB;AAAA,IAC5B;AAAA,EACF;AAAA,EAEA,MAAY;AACV,QAAI,KAAK,MAAO;AAChB,SAAK,QAAQ;AACb,SAAK,KAAK,YAAY,KAAK,IAAI;AAC/B,SAAK,KAAK,aAAa,KAAK,KAAK,YAAY,KAAK,KAAK;AAAA,EACzD;AAAA;AAAA,EAGA,UAAoB;AAClB,WAAO,EAAE,GAAG,KAAK,MAAM,YAAY,EAAE,GAAG,KAAK,KAAK,WAAW,EAAE;AAAA,EACjE;AAAA,EAEA,UAAmB;AACjB,WAAO,KAAK;AAAA,EACd;AACF;AAUO,IAAM,WAAN,MAAqC;AAAA;AAAA,EAE1C,eAAqB;AAAA,EAAC;AAAA;AAAA,EAEtB,YAAkB;AAAA,EAAC;AAAA;AAAA,EAEnB,MAAY;AAAA,EAAC;AACf;;;ACjFO,IAAM,8BAAN,MAAkE;AAAA,EAC9D,OAAO;AAAA,EACR;AAAA,EACA,aAAa;AAAA,EACb,QAAoB,CAAC;AAAA,EAE7B,YAAY,UAAiC,CAAC,GAAG;AAC/C,SAAK,QAAQ,QAAQ,UAAU,CAAC,SAAiB,QAAQ,OAAO,MAAM,OAAO,IAAI;AAAA,EACnF;AAAA,EAEA,UAAU,MAAc,YAA6B,SAAwC;AAC3F,QAAI,KAAK,WAAY,QAAO,IAAI,SAAS;AACzC,UAAM,OAAO,IAAI,SAAS,MAAM,YAAY,OAAO;AACnD,SAAK,MAAM,KAAK,IAAI;AACpB,WAAO;AAAA,MACL,cAAc,CAAC,GAAG,MAAM;AACtB,aAAK,aAAa,GAAG,CAAC;AAAA,MACxB;AAAA,MACA,WAAW,CAAC,GAAG,MAAM;AACnB,aAAK,UAAU,GAAG,CAAC;AAAA,MACrB;AAAA,MACA,KAAK,MAAM;AACT,aAAK,IAAI;AACT,aAAK,SAAS,KAAK,QAAQ,CAAC;AAAA,MAC9B;AAAA,IACF;AAAA,EACF;AAAA,EAEA,QAAQ,MAAc,OAAe,YAAmC;AACtE,QAAI,KAAK,WAAY;AACrB,SAAK,KAAK;AAAA,MACR,MAAM;AAAA,MACN,QAAQ;AAAA,MACR;AAAA,MACA,YAAY,cAAc,CAAC;AAAA,MAC3B,WAAW,KAAK,IAAI;AAAA,IACtB,CAAC;AAAA,EACH;AAAA,EAEA,UAAU,MAAc,OAAe,YAAmC;AACxE,QAAI,KAAK,WAAY;AACrB,SAAK,KAAK;AAAA,MACR,MAAM;AAAA,MACN,QAAQ;AAAA,MACR;AAAA,MACA,YAAY,cAAc,CAAC;AAAA,MAC3B,WAAW,KAAK,IAAI;AAAA,IACtB,CAAC;AAAA,EACH;AAAA,EAEA,IACE,OACA,SACA,YACM;AACN,QAAI,KAAK,WAAY;AACrB,SAAK,KAAK,EAAE,MAAM,OAAO,OAAO,SAAS,YAAY,cAAc,CAAC,GAAG,WAAW,KAAK,IAAI,EAAE,CAAC;AAAA,EAChG;AAAA;AAAA,EAGA,QAAuB;AACrB,WAAO,QAAQ,QAAQ;AAAA,EACzB;AAAA,EAEA,WAA0B;AACxB,SAAK,aAAa;AAClB,WAAO,QAAQ,QAAQ;AAAA,EACzB;AAAA,EAEQ,SAAS,MAAsB;AACrC,SAAK,KAAK;AAAA,MACR,MAAM;AAAA,MACN,MAAM,KAAK;AAAA,MACX,QAAQ,KAAK;AAAA,MACb,aAAa,KAAK,cAAc;AAAA,MAChC,YAAY,KAAK;AAAA,MACjB,WAAW,KAAK;AAAA,IAClB,CAAC;AAAA,EACH;AAAA,EAEQ,KAAK,QAAuC;AAClD,SAAK,MAAM,KAAK,UAAU,MAAM,CAAC;AAAA,EACnC;AACF;;;ACvFO,IAAM,2BAAN,MAA+D;AAAA,EAC3D,OAAO;AAAA,EACR,aAAa;AAAA,EAErB,UAAU,OAAe,aAA0C;AACjE,WAAO,IAAI,SAAS;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA,EAKA,QAAQ,OAAe,QAAgB,aAAoC;AAAA,EAAC;AAAA,EAC5E,UAAU,OAAe,QAAgB,aAAoC;AAAA,EAAC;AAAA,EAC9E,IACE,QACA,UACA,aACM;AAAA,EAAC;AAAA;AAAA;AAAA,EAIT,QAAuB;AACrB,WAAO,QAAQ,QAAQ;AAAA,EACzB;AAAA,EAEA,WAA0B;AACxB,SAAK,aAAa;AAClB,WAAO,QAAQ,QAAQ;AAAA,EACzB;AACF;;;ACaA,SAAS,cAAc,OAAsD;AAC3E,UAAQ,OAAO,OAAO;AAAA,IACpB,KAAK;AACH,aAAO,EAAE,aAAa,MAAM;AAAA,IAC9B,KAAK;AAUH,aAAO,OAAO,UAAU,KAAK,IAAI,EAAE,UAAU,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,MAAM;AAAA,IACtF;AACE,aAAO,EAAE,WAAW,MAAM;AAAA,EAC9B;AACF;AAGO,SAAS,qBAAqB,OAAmB,cAAc,WAAuB;AAC3F,QAAM,YAAwB,MAAM,IAAI,CAAC,OAAO;AAAA;AAAA;AAAA;AAAA,IAI9C,SAAS,EAAE;AAAA,IACX,QAAQ,EAAE;AAAA,IACV,GAAI,EAAE,iBAAiB,SAAY,CAAC,IAAI,EAAE,cAAc,EAAE,aAAa;AAAA,IACvE,MAAM,EAAE;AAAA,IACR,MAAM;AAAA;AAAA,IACN,mBAAmB,OAAO,EAAE,cAAc,GAAS;AAAA,IACnD,iBAAiB,QAAQ,EAAE,aAAa,EAAE,eAAe,GAAS;AAAA,IAClE,YAAY,OAAO,QAAQ,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,OAAO;AAAA,MAC9D;AAAA,MACA,OAAO,cAAc,KAAK;AAAA,IAC5B,EAAE;AAAA,IACF,QAAQ,EAAE,MAAM,EAAE,WAAW,OAAO,IAAI,GAAG,SAAS,EAAE,cAAc;AAAA,EACtE,EAAE;AAEF,QAAM,UAAqC;AAAA,IACzC,eAAe;AAAA,MACb;AAAA,QACE,YAAY;AAAA,UACV;AAAA,YACE,OAAO,EAAE,MAAM,aAAa,SAAS,QAAQ;AAAA,YAC7C,OAAO;AAAA,UACT;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO,IAAI,YAAY,EAAE,OAAO,KAAK,UAAU,OAAO,CAAC;AACzD;;;ACzEO,IAAM,gCAAN,MAAoE;AAAA,EAChE,OAAO;AAAA,EACR,eAA2B,CAAC;AAAA,EAC5B,aAAa;AAAA,EACb,UAAU;AAAA,EACD;AAAA,EACA;AAAA,EAKjB,YAAY,SAAkC;AAC5C,SAAK,OAAO,EAAE,iBAAiB,KAAM,iBAAiB,KAAQ,GAAG,QAAQ;AAUzE,SAAK,aAAa,YAAY,MAAM;AAClC,WAAK,KAAK,MAAM;AAAA,IAClB,GAAG,KAAK,KAAK,eAAe;AAC5B,SAAK,WAAW,MAAM;AAAA,EACxB;AAAA;AAAA,EAGA,mBAA2B;AACzB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,sBAA+B;AAC7B,WAAO,CAAC,KAAK,WAAW,OAAO;AAAA,EACjC;AAAA,EAEA,UAAU,MAAc,YAA6B,SAAwC;AAC3F,QAAI,KAAK,WAAY,QAAO,IAAI,SAAS;AACzC,UAAM,OAAO,IAAI,SAAS,MAAM,YAAY,OAAO;AACnD,WAAO;AAAA,MACL,cAAc,CAAC,GAAG,MAAM;AACtB,aAAK,aAAa,GAAG,CAAC;AAAA,MACxB;AAAA,MACA,WAAW,CAAC,GAAG,MAAM;AACnB,aAAK,UAAU,GAAG,CAAC;AAAA,MACrB;AAAA,MACA,KAAK,MAAM;AACT,aAAK,IAAI;AACT,YAAI,KAAK,aAAa,UAAU,KAAK,KAAK,iBAAiB;AACzD,eAAK,aAAa,MAAM;AACxB,eAAK;AAAA,QACP;AACA,aAAK,aAAa,KAAK,KAAK,QAAQ,CAAC;AAAA,MACvC;AAAA,IACF;AAAA,EACF;AAAA;AAAA,EAGA,QAAQ,OAAe,QAAgB,aAAoC;AAAA,EAAC;AAAA,EAC5E,UAAU,OAAe,QAAgB,aAAoC;AAAA,EAAC;AAAA,EAC9E,IACE,QACA,UACA,aACM;AAAA,EAAC;AAAA;AAAA,EAGT,MAAM,QAAuB;AAC3B,QAAI,KAAK,cAAc,KAAK,aAAa,WAAW,EAAG;AAEvD,UAAM,QAAQ,KAAK,aAAa,OAAO,CAAC;AACxC,UAAM,OAAO,qBAAqB,KAAK;AACvC,UAAM,UAAU,KAAK,KAAK,cAAc,WAAW;AAEnD,QAAI;AACF,YAAM,QAAQ,KAAK,KAAK,WAAW;AAAA,QACjC,QAAQ;AAAA,QACR,SAAS;AAAA,UACP,gBAAgB;AAAA,UAChB,eAAe,UAAU,KAAK,KAAK,KAAK;AAAA,QAC1C;AAAA,QACA;AAAA,MACF,CAAC;AAAA,IACH,SAAS,KAAK;AAEZ,cAAQ;AAAA,QACN,yCAAyC,eAAe,QAAQ,IAAI,UAAU,eAAe;AAAA,MAC/F;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,WAA0B;AAC9B,QAAI,KAAK,WAAY;AAIrB,kBAAc,KAAK,UAAU;AAC7B,UAAM,KAAK,MAAM;AACjB,SAAK,aAAa;AAAA,EACpB;AACF;;;AClHO,SAAS,eAAe,SAAsD;AAEnF,MAAI,QAAQ,QAAQ,UAAU;AAC5B,WAAO,QAAQ,OAAO;AAAA,EACxB;AAGA,QAAM,YAAY,QAAQ,IAAI;AAC9B,QAAM,SAAS,QAAQ,IAAI;AAC3B,MAAI,aAAa,QAAQ;AACvB,WAAO,IAAI,8BAA8B,EAAE,WAAW,OAAO,OAAO,CAAC;AAAA,EACvE;AAGA,MAAI,QAAQ,IAAI,aAAa,eAAe;AAC1C,WAAO,IAAI,4BAA4B;AAAA,EACzC;AAGA,SAAO,IAAI,yBAAyB;AACtC;;;ACvBO,IAAM,eAAe;AACrB,IAAM,sBAAsB;AACnC,IAAM,oBAAoB;AAG1B,IAAM,iBAAiB;AA4BhB,SAAS,wBAAwB,OAAuC;AAC7E,MAAI,CAAC,MAAO,QAAO;AACnB,QAAM,IAAI,eAAe,KAAK,KAAK;AACnC,MAAI,CAAC,EAAG,QAAO;AACf,QAAM,UAAU,EAAE,CAAC;AAEnB,MAAI,OAAO,KAAK,OAAO,EAAG,QAAO;AACjC,QAAM,eAAe,EAAE,CAAC;AAIxB,SAAO,OAAO,KAAK,YAAY,IAAI,EAAE,QAAQ,IAAI,EAAE,SAAS,aAAa;AAC3E;AAOO,SAAS,iBAAiB,OAA8B;AAC7D,SAAO,wBAAwB,KAAK,GAAG,WAAW;AACpD;AAgBA,IAAM,gBAAgB;AAEtB,SAAS,mBAAmB,OAAwB;AAClD,SAAO,cAAc,KAAK,KAAK;AACjC;AAWA,SAAS,WACP,OACA,YAA4C,MAAM,MACnC;AACf,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,eAAW,KAAK,OAAO;AACrB,UAAI,OAAO,MAAM,YAAY,EAAE,SAAS,KAAK,UAAU,CAAC,EAAG,QAAO;AAAA,IACpE;AACA,WAAO;AAAA,EACT;AACA,MAAI,OAAO,UAAU,YAAY,MAAM,SAAS,KAAK,UAAU,KAAK,EAAG,QAAO;AAC9E,SAAO;AACT;AAMA,SAAS,0BAA0B,aAA4B,WAAkC;AAC/F,MAAI,gBAAgB,MAAM;AACxB,UAAM,SAAS,iBAAiB,WAAW;AAC3C,QAAI,WAAW,KAAM,QAAO;AAAA,EAC9B;AACA,MAAI,cAAc,KAAM,QAAO;AAC/B,SAAO,WAAW,OAAO,WAAW;AACtC;AAKO,SAAS,eAAe,KAA8B;AAC3D,SAAO;AAAA,IACL,WAAW,IAAI,QAAQ,mBAAmB,CAAC;AAAA,IAC3C,WAAW,IAAI,QAAQ,iBAAiB,GAAG,kBAAkB;AAAA,EAC/D;AACF;AAmCO,SAAS,uBAAuB,SAA+C;AACpF,QAAM,cAAc,QAAQ,QAAQ,IAAI,mBAAmB;AAC3D,MAAI,gBAAgB,KAAM,QAAO;AACjC,SAAO,wBAAwB,WAAW,KAAK;AACjD;;;ACtHA,IAAM,WAAW,oBAAI,QAA+B;AAS7C,SAAS,aAAa,SAAgC;AAC3D,QAAM,WAAW,SAAS,IAAI,OAAO;AACrC,MAAI,aAAa,OAAW,QAAO;AAEnC,QAAM,QAAQ,QAAQ,OAAO;AAC7B,WAAS,IAAI,SAAS,KAAK;AAC3B,SAAO;AACT;AAGA,SAAS,QAAQ,SAAgC;AAC/C,QAAM,UAAU,uBAAuB,OAAO;AAC9C,MAAI,YAAY,OAAW,QAAO,EAAE,SAAS,WAAW,EAAE;AAC1D,MAAI,QAAQ,iBAAiB,OAAW,QAAO,EAAE,SAAS,QAAQ,QAAQ;AAC1E,SAAO,EAAE,SAAS,QAAQ,SAAS,cAAc,QAAQ,aAAa;AACxE;AASO,SAAS,oBAAoB,SAAkB,QAAsB;AAC1E,QAAM,QAAQ,aAAa,OAAO;AAClC,QAAM,oBAAoB;AAC5B;;;ACnDA,IAAM,2BAA2B;AAO1B,SAAS,0BACd,SACA,UAAsC,CAAC,GAC3B;AACZ,QAAM,iBAAiB,QAAQ,kBAAkB;AACjD,QAAM,cAAc,oBAAI,IAAwB;AAGhD,WAAS,iBAAuB;AAC9B,WAAO,YAAY,QAAQ,gBAAgB;AACzC,YAAM,SAAS,YAAY,KAAK,EAAE,KAAK;AACvC,UAAI,OAAO,SAAS,KAAM;AAC1B,YAAM,OAAO,YAAY,IAAI,OAAO,KAAK;AACzC,kBAAY,OAAO,OAAO,KAAK;AAC/B,UAAI,SAAS,OAAW;AACxB,WAAK,aAAa,kBAAkB,IAAI;AACxC,WAAK,UAAU,SAAS,yDAAyD;AACjF,WAAK,IAAI;AAAA,IACX;AAAA,EACF;AAuBA,WAAS,mBAAmB,SAAoC;AAC9D,UAAM,QAAQ,aAAa,OAAO;AAIlC,UAAM,SAAS,UAAU;AACzB,wBAAoB,SAAS,MAAM;AACnC,WAAO,MAAM,iBAAiB,SAC1B,EAAE,SAAS,MAAM,SAAS,OAAO,IACjC,EAAE,SAAS,MAAM,SAAS,QAAQ,cAAc,MAAM,aAAa;AAAA,EACzE;AAGA,WAAS,MAAM,WAA2C;AACxD,UAAM,OAAO,YAAY,IAAI,SAAS;AACtC,QAAI,SAAS,OAAW,QAAO;AAC/B,gBAAY,OAAO,SAAS;AAC5B,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IAEN,SAAS,KAAoB;AAC3B,UAAI,QAAQ,aAAa,CAAC,QAAuB;AAC/C,uBAAe;AACf,cAAM,OAAO,QAAQ;AAAA,UACnB;AAAA,UACA;AAAA,YACE,QAAQ,IAAI,QAAQ;AAAA;AAAA;AAAA,YAGpB,MAAM,IAAI,IAAI,IAAI,QAAQ,GAAG,EAAE;AAAA,YAC/B,WAAW,IAAI;AAAA,UACjB;AAAA,UACA,mBAAmB,IAAI,OAAO;AAAA,QAChC;AACA,oBAAY,IAAI,IAAI,WAAW,IAAI;AAAA,MACrC,CAAC;AAED,UAAI,QAAQ,cAAc,CAAC,QAAuB;AAChD,cAAM,OAAO,MAAM,IAAI,SAAS;AAChC,YAAI,SAAS,OAAW;AAExB,cAAM,SAAS,IAAI,SAAS;AAC5B,aAAK,aAAa,UAAU,MAAM;AAClC,aAAK,UAAU,IAAI;AACnB,aAAK,IAAI;AAIT,gBAAQ,QAAQ,iBAAiB,GAAG,EAAE,QAAQ,IAAI,QAAQ,QAAQ,OAAO,CAAC;AAAA,MAC5E,CAAC;AAED,UAAI,QAAQ,WAAW,CAAC,QAA4B;AAClD,cAAM,OAAO,MAAM,IAAI,SAAS;AAChC,YAAI,SAAS,OAAW;AAExB,cAAM,UAAU,IAAI,iBAAiB,QAAQ,IAAI,MAAM,UAAU;AACjE,aAAK,aAAa,SAAS,IAAI;AAC/B,aAAK,UAAU,SAAS,OAAO;AAC/B,aAAK,IAAI;AAET,gBAAQ,QAAQ,eAAe,GAAG,EAAE,QAAQ,IAAI,QAAQ,OAAO,CAAC;AAAA,MAClE,CAAC;AAAA,IACH;AAAA,EACF;AACF;;;ACpHA,IAAI;AAEG,SAAS,0BAA4D;AAC1E,SAAO;AACT;AAGO,SAAS,6BAAmC;AACjD,kBAAgB;AAClB;AAEO,SAAS,oCACd,qBACA,KACwB;AACxB,QAAM,SACJ,wBAAwB,UAAa,wBAAwB,OACzD,SACA,oBAAoB,MAAM,mBAAmB;AAEnD,MAAI,QAAQ,YAAY,MAAO,QAAO;AAKtC,QAAM,kBAAkB,QAAQ,IAAI,qBAAqB,KAAK,QAAQ,IAAI,kBAAkB;AAC5F,MAAI,WAAW,UAAa,CAAC,gBAAiB,QAAO;AAErD,QAAM,UAAU,eAAe;AAAA,IAC7B;AAAA,IACA,QAAQ,EAAE,UAAU,QAAQ,SAA6C;AAAA,EAC3E,CAAC;AAID,MAAI,QAAQ,SAAS,QAAQ;AAQ3B,QAAI,WAAW,QAAW;AACxB,eAAS,6BAA6B;AAAA,QACpC,OAAO;AAAA,QACP,SACE;AAAA,MAGJ,CAAC;AAAA,IACH;AACA,WAAO;AAAA,EACT;AAEA,kBAAgB;AAChB,SAAO,0BAA0B,OAAO;AAC1C;","names":[]}