@axlsdk/studio 0.14.0 → 0.15.0

package/dist/chunk-IPDMFFTQ.js

@@ -0,0 +1,2142 @@
+// src/server/index.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+import { Hono as Hono15 } from "hono";
+import { cors } from "hono/cors";
+import { serveStatic } from "@hono/node-server/serve-static";
+
+// src/server/redact.ts
+var REDACTED = "[redacted]";
+var SAFE_ERROR_NAMES = /* @__PURE__ */ new Set([
+  "QuorumNotMet",
+  "NoConsensus",
+  "TimeoutError",
+  "MaxTurnsError",
+  "BudgetExceededError",
+  "ToolDenied"
+]);
+function redactErrorMessage(err, redact) {
+  const raw = err instanceof Error ? err.message : String(err);
+  if (!redact) return raw;
+  const name = err instanceof Error ? err.name : "";
+  return SAFE_ERROR_NAMES.has(name) ? raw : REDACTED;
+}
+function redactValue(value, redact) {
+  if (!redact) return value;
+  return REDACTED;
+}
+function redactExecutionInfo(info, redact) {
+  if (!redact) return info;
+  return {
+    ...info,
+    ...info.result !== void 0 ? { result: REDACTED } : {},
+    ...info.error !== void 0 ? { error: REDACTED } : {}
+  };
+}
+function redactExecutionList(infos, redact) {
+  if (!redact) return infos;
+  return infos.map((info) => redactExecutionInfo(info, redact));
+}
+function redactMemoryValue(value, redact) {
+  if (!redact) return value;
+  return REDACTED;
+}
+function redactMemoryList(entries, redact) {
+  if (!redact) return entries;
+  return entries.map((entry) => ({ key: entry.key, value: REDACTED }));
+}
+function redactChatMessage(msg) {
+  const scrubbed = {
+    role: msg.role,
+    content: REDACTED,
+    ...msg.name !== void 0 ? { name: msg.name } : {},
+    ...msg.tool_call_id !== void 0 ? { tool_call_id: msg.tool_call_id } : {},
+    ...msg.tool_calls !== void 0 ? {
+      tool_calls: msg.tool_calls.map((tc) => ({
+        id: tc.id,
+        type: tc.type,
+        function: {
+          name: tc.function.name,
+          arguments: REDACTED
+        }
+      }))
+    } : {}
+    // providerMetadata deliberately omitted — opaque content.
+  };
+  return scrubbed;
+}
+function redactSessionHistory(history, redact) {
+  if (!redact) return history;
+  return history.map(redactChatMessage);
+}
+function redactStreamEvent(event, redact) {
+  if (!redact) return event;
+  switch (event.type) {
+    case "token":
+      return { type: "token", data: REDACTED };
+    case "tool_call":
+      return { ...event, args: REDACTED };
+    case "tool_result":
+      return { ...event, result: REDACTED };
+    case "tool_approval":
+      return {
+        ...event,
+        args: REDACTED,
+        ...event.reason !== void 0 ? { reason: REDACTED } : {}
+      };
+    case "done":
+      return { type: "done", data: REDACTED };
+    case "error":
+      return { type: "error", message: REDACTED };
+    // Structural events have no user content to scrub.
+    case "agent_start":
+    case "agent_end":
+    case "handoff":
+    case "step":
+      return event;
+  }
+}
+function redactEvalItem(item) {
+  const scrubbed = {
+    ...item,
+    input: REDACTED,
+    output: REDACTED,
+    ...item.annotations !== void 0 ? { annotations: REDACTED } : {},
+    ...item.error !== void 0 ? { error: REDACTED } : {},
+    ...item.scorerErrors !== void 0 ? { scorerErrors: item.scorerErrors.map(() => REDACTED) } : {}
+  };
+  if (item.scoreDetails) {
+    const detailsOut = {};
+    for (const [name, detail] of Object.entries(item.scoreDetails)) {
+      detailsOut[name] = {
+        score: detail.score,
+        ...detail.duration !== void 0 ? { duration: detail.duration } : {},
+        ...detail.cost !== void 0 ? { cost: detail.cost } : {}
+        // metadata deliberately omitted — may contain LLM scorer reasoning
+      };
+    }
+    scrubbed.scoreDetails = detailsOut;
+  }
+  return scrubbed;
+}
+function redactEvalResult(result, redact) {
+  if (!redact) return result;
+  return {
+    ...result,
+    items: result.items.map(redactEvalItem)
+  };
+}
+function redactEvalHistoryEntry(entry, redact) {
+  if (!redact) return entry;
+  return {
+    ...entry,
+    data: redactEvalResult(entry.data, redact)
+  };
+}
+function redactEvalHistoryList(entries, redact) {
+  if (!redact) return entries;
+  return entries.map((e) => redactEvalHistoryEntry(e, redact));
+}
+function redactPendingDecision(decision, redact) {
+  if (!redact) return decision;
+  return {
+    ...decision,
+    prompt: REDACTED,
+    ...decision.metadata !== void 0 ? { metadata: { redacted: true } } : {}
+  };
+}
+function redactPendingDecisionList(decisions, redact) {
+  if (!redact) return decisions;
+  return decisions.map((d) => redactPendingDecision(d, redact));
+}
+
+// src/server/middleware/error-handler.ts
+async function errorHandler(c, next) {
+  try {
+    await next();
+  } catch (err) {
+    const rawMessage = err instanceof Error ? err.message : String(err);
+    const code = err.code ?? "INTERNAL_ERROR";
+    let status = 500;
+    if ("status" in err) {
+      const errStatus = err.status;
+      if (typeof errStatus === "number" && errStatus >= 400 && errStatus < 600) {
+        status = errStatus;
+      }
+    } else if (code === "NOT_FOUND" || rawMessage.includes("not found") || rawMessage.includes("not registered")) {
+      status = 404;
+    } else if (code === "VALIDATION_ERROR" || rawMessage.includes("Expected") || rawMessage.includes("invalid")) {
+      status = 400;
+    }
+    const runtime = c.get("runtime");
+    const redactOn = runtime?.isRedactEnabled?.() ?? false;
+    const body = {
+      ok: false,
+      error: { code, message: redactErrorMessage(err, redactOn) }
+    };
+    return c.json(body, status);
+  }
+}
+
+// src/server/ws/connection-manager.ts
+var BUFFER_TTL_MS = 3e4;
+var MAX_BUFFER_EVENTS = 500;
+var MAX_WS_FRAME_BYTES = 65536;
+function isBufferedChannel(channel) {
+  return channel.startsWith("execution:") || channel.startsWith("eval:");
+}
+function truncateIfOversized(msg, channel, data) {
+  if (msg.length <= MAX_WS_FRAME_BYTES) return msg;
+  const event = data ?? {};
+  const truncated = {
+    type: "event",
+    channel,
+    data: {
+      ...event,
+      data: {
+        __truncated: true,
+        originalBytes: msg.length,
+        maxBytes: MAX_WS_FRAME_BYTES,
+        hint: "Event exceeded WS frame budget (likely a verbose agent_call with a large messages[] snapshot). Fetch via REST if you need the full payload."
+      }
+    }
+  };
+  return JSON.stringify(truncated);
+}
+var ConnectionManager = class {
+  /** channel -> set of WS connections */
+  channels = /* @__PURE__ */ new Map();
+  /** ws -> subscribed channels + optional integrator-supplied metadata */
+  connections = /* @__PURE__ */ new Map();
+  /** channel -> replay buffer for execution streams */
+  buffers = /* @__PURE__ */ new Map();
+  maxConnections = 100;
+  filter;
+  /**
+   * Register a broadcast filter. Called once at middleware construction.
+   * The filter runs on every outbound event and can drop or deliver based
+   * on the destination connection's metadata.
+   */
+  setFilter(filter) {
+    this.filter = filter;
+  }
+  /** Attach integrator-supplied metadata to an already-added connection. */
+  setMetadata(ws, metadata) {
+    const entry = this.connections.get(ws);
+    if (entry) entry.metadata = metadata;
+  }
+  /** Register a new WS connection. */
+  add(ws) {
+    if (this.connections.size >= this.maxConnections) {
+      ws.close?.();
+      return;
+    }
+    this.connections.set(ws, { channels: /* @__PURE__ */ new Set() });
+  }
+  /** Remove a WS connection and all its subscriptions. */
+  remove(ws) {
+    const entry = this.connections.get(ws);
+    if (entry) {
+      for (const ch of entry.channels) {
+        this.channels.get(ch)?.delete(ws);
+        if (this.channels.get(ch)?.size === 0) {
+          this.channels.delete(ch);
+        }
+      }
+    }
+    this.connections.delete(ws);
+  }
+  /** Subscribe a connection to a channel. Replays buffered events for execution channels. */
+  subscribe(ws, channel) {
+    if (!this.connections.has(ws)) return;
+    let subs = this.channels.get(channel);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.channels.set(channel, subs);
+    }
+    subs.add(ws);
+    this.connections.get(ws).channels.add(channel);
+    const buffer = this.buffers.get(channel);
+    if (buffer) {
+      const metadata = this.connections.get(ws)?.metadata;
+      for (const event of buffer.events) {
+        if (this.filter) {
+          try {
+            if (!this.filter(event.data, metadata)) continue;
+          } catch {
+            continue;
+          }
+        }
+        try {
+          ws.send(event.msg);
+        } catch {
+          this.remove(ws);
+          return;
+        }
+      }
+    }
+  }
+  /** Unsubscribe a connection from a channel. */
+  unsubscribe(ws, channel) {
+    this.channels.get(channel)?.delete(ws);
+    if (this.channels.get(channel)?.size === 0) {
+      this.channels.delete(channel);
+    }
+    this.connections.get(ws)?.channels.delete(channel);
+  }
+  /** Broadcast data to all subscribers of a channel. Buffers events for execution channels. */
+  broadcast(channel, data) {
+    const msg = truncateIfOversized(
+      JSON.stringify({ type: "event", channel, data }),
+      channel,
+      data
+    );
+    if (isBufferedChannel(channel)) {
+      let buffer = this.buffers.get(channel);
+      if (!buffer) {
+        buffer = { events: [], complete: false };
+        this.buffers.set(channel, buffer);
+      }
+      const event = data;
+      const isTerminal = event.type === "done" || event.type === "error";
+      if (buffer.events.length < MAX_BUFFER_EVENTS || isTerminal) {
+        buffer.events.push({ msg, data });
+      }
+      if (isTerminal) {
+        buffer.complete = true;
+        if (buffer.timer) clearTimeout(buffer.timer);
+        buffer.timer = setTimeout(() => {
+          this.buffers.delete(channel);
+        }, BUFFER_TTL_MS);
+      }
+    }
+    const subs = this.channels.get(channel);
+    if (!subs || subs.size === 0) return;
+    for (const ws of [...subs]) {
+      if (this.filter) {
+        const metadata = this.connections.get(ws)?.metadata;
+        try {
+          if (!this.filter(data, metadata)) continue;
+        } catch {
+          continue;
+        }
+      }
+      try {
+        ws.send(msg);
+      } catch {
+        this.remove(ws);
+      }
+    }
+  }
+  /** Broadcast to channel and all wildcard subscribers (e.g., trace:* matches trace:abc). */
+  broadcastWithWildcard(channel, data) {
+    this.broadcast(channel, data);
+    const colonIdx = channel.indexOf(":");
+    if (colonIdx > 0) {
+      const wildcardChannel = channel.substring(0, colonIdx) + ":*";
+      const subs = this.channels.get(wildcardChannel);
+      if (!subs || subs.size === 0) return;
+      const msg = truncateIfOversized(
+        JSON.stringify({ type: "event", channel, data }),
+        channel,
+        data
+      );
+      for (const ws of [...subs]) {
+        if (this.filter) {
+          const metadata = this.connections.get(ws)?.metadata;
+          try {
+            if (!this.filter(data, metadata)) continue;
+          } catch {
+            continue;
+          }
+        }
+        try {
+          ws.send(msg);
+        } catch {
+          this.remove(ws);
+        }
+      }
+    }
+  }
+  /** Close all connections, clear all state and buffers. Used during shutdown. */
+  closeAll() {
+    for (const ws of this.connections.keys()) {
+      ws.close?.();
+    }
+    for (const buffer of this.buffers.values()) {
+      if (buffer.timer) clearTimeout(buffer.timer);
+    }
+    this.connections.clear();
+    this.channels.clear();
+    this.buffers.clear();
+  }
+  /** Get the number of active connections. */
+  get connectionCount() {
+    return this.connections.size;
+  }
+  /** Check if any connections are subscribed to a channel. */
+  hasSubscribers(channel) {
+    return (this.channels.get(channel)?.size ?? 0) > 0;
+  }
+};
+
+// src/server/ws/protocol.ts
+var VALID_CHANNEL_PREFIXES = ["execution:", "trace:", "eval:"];
+var VALID_EXACT_CHANNELS = ["costs", "decisions", "eval-trends", "workflow-stats", "trace-stats"];
+var MAX_CHANNEL_LENGTH = 256;
+function handleWsMessage(raw, socket, connMgr) {
+  if (raw.length > MAX_WS_FRAME_BYTES) {
+    return JSON.stringify({ type: "error", message: "Message too large" });
+  }
+  let msg;
+  try {
+    msg = JSON.parse(raw);
+  } catch {
+    return JSON.stringify({ type: "error", message: "Invalid JSON" });
+  }
+  switch (msg.type) {
+    case "subscribe": {
+      const error = validateChannel(msg.channel);
+      if (error) return JSON.stringify({ type: "error", message: error });
+      connMgr.subscribe(socket, msg.channel);
+      return JSON.stringify({ type: "subscribed", channel: msg.channel });
+    }
+    case "unsubscribe": {
+      const error = validateChannel(msg.channel);
+      if (error) return JSON.stringify({ type: "error", message: error });
+      connMgr.unsubscribe(socket, msg.channel);
+      return JSON.stringify({ type: "unsubscribed", channel: msg.channel });
+    }
+    case "ping":
+      return JSON.stringify({ type: "pong" });
+    default:
+      return JSON.stringify({ type: "error", message: "Unknown message type" });
+  }
+}
+function validateChannel(channel) {
+  if (typeof channel !== "string" || !channel) {
+    return "Missing or invalid channel";
+  }
+  if (channel.length > MAX_CHANNEL_LENGTH) {
+    return `Channel name exceeds ${MAX_CHANNEL_LENGTH} characters`;
+  }
+  if (!VALID_EXACT_CHANNELS.includes(channel) && !VALID_CHANNEL_PREFIXES.some((p) => channel.startsWith(p))) {
+    return `Invalid channel: ${channel}`;
+  }
+  return null;
+}
+
+// src/server/ws/handler.ts
+function createWsHandlers(connMgr) {
+  return {
+    onOpen(_event, ws) {
+      connMgr.add(ws);
+    },
+    onMessage(event, ws) {
+      const reply = handleWsMessage(String(event.data), ws, connMgr);
+      if (reply) ws.send(reply);
+    },
+    onClose(_event, ws) {
+      connMgr.remove(ws);
+    },
+    onError(_event, ws) {
+      connMgr.remove(ws);
+    }
+  };
+}
+
+// src/server/aggregates/aggregate-snapshots.ts
+var WINDOW_MS = {
+  "24h": 24 * 60 * 60 * 1e3,
+  "7d": 7 * 24 * 60 * 60 * 1e3,
+  "30d": 30 * 24 * 60 * 60 * 1e3,
+  all: Number.POSITIVE_INFINITY
+};
+function withinWindow(ts, window, now) {
+  return ts >= now - WINDOW_MS[window];
+}
+var REBUILD_INTERVAL_MS = 5 * 6e4;
+var ALL_WINDOWS = new Set(Object.keys(WINDOW_MS));
+function parseWindowParam(raw, fallback = "7d") {
+  return raw && ALL_WINDOWS.has(raw) ? raw : fallback;
+}
+var AggregateSnapshots = class {
+  constructor(windows, emptyState, connMgr, channel, broadcastTransform) {
+    this.windows = windows;
+    this.emptyState = emptyState;
+    this.connMgr = connMgr;
+    this.channel = channel;
+    this.broadcastTransform = broadcastTransform;
+    this.snapshots = new Map(windows.map((w) => [w, emptyState()]));
+  }
+  snapshots;
+  /** Replace all snapshots atomically — used after a full rebuild. */
+  replace(fresh) {
+    this.snapshots = fresh;
+    this.broadcast();
+  }
+  /** Apply a reducer update to every window where `ts` falls inside the window. */
+  fold(ts, update) {
+    const now = Date.now();
+    let changed = false;
+    for (const window of this.windows) {
+      if (withinWindow(ts, window, now)) {
+        const prev = this.snapshots.get(window);
+        this.snapshots.set(window, update(prev));
+        changed = true;
+      }
+    }
+    if (changed) this.broadcast();
+  }
+  get(window) {
+    return this.snapshots.get(window) ?? this.emptyState();
+  }
+  getAll() {
+    return Object.fromEntries(this.snapshots);
+  }
+  broadcast() {
+    const snapshots = this.broadcastTransform ? Object.fromEntries(
+      this.windows.map((w) => [w, this.broadcastTransform(this.snapshots.get(w))])
+    ) : this.getAll();
+    this.connMgr.broadcast(this.channel, {
+      snapshots,
+      updatedAt: Date.now()
+    });
+  }
+};
+
+// src/server/aggregates/trace-aggregator.ts
+var TraceAggregator = class {
+  snaps;
+  interval;
+  listener;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.snaps = new AggregateSnapshots(
+      options.windows,
+      options.emptyState,
+      options.connMgr,
+      options.channel,
+      options.broadcastTransform
+    );
+  }
+  async start() {
+    await this.rebuild();
+    this.listener = (event) => {
+      this.snaps.fold(event.timestamp, (prev) => this.options.reducer(prev, event));
+    };
+    this.options.runtime.on("trace", this.listener);
+    this.interval = setInterval(
+      () => this.rebuild().catch((err) => console.error("[axl-studio] rebuild failed:", err)),
+      REBUILD_INTERVAL_MS
+    );
+  }
+  async rebuild() {
+    const executions = await this.options.runtime.getExecutions();
+    const cap = this.options.executionCap ?? 2e3;
+    const capped = executions.slice(0, cap);
+    const now = Date.now();
+    const fresh = new Map(
+      this.options.windows.map((w) => [w, this.options.emptyState()])
+    );
+    for (const exec of capped) {
+      for (const event of exec.steps) {
+        for (const window of this.options.windows) {
+          if (withinWindow(event.timestamp, window, now)) {
+            fresh.set(window, this.options.reducer(fresh.get(window), event));
+          }
+        }
+      }
+    }
+    this.snaps.replace(fresh);
+  }
+  getSnapshot(window) {
+    return this.snaps.get(window);
+  }
+  getAllSnapshots() {
+    return this.snaps.getAll();
+  }
+  close() {
+    if (this.listener) this.options.runtime.off("trace", this.listener);
+    if (this.interval) clearInterval(this.interval);
+  }
+};
+
+// src/server/aggregates/reducers.ts
+var finite = (v) => Number.isFinite(v) ? v : 0;
+function isLogEvent(event, eventName) {
+  if (event.type === eventName) return true;
+  if (event.type === "log" && event.data != null && typeof event.data === "object") {
+    return event.data.event === eventName;
+  }
+  return false;
+}
+function emptyRetry() {
+  return {
+    primary: 0,
+    primaryCalls: 0,
+    schema: 0,
+    schemaCalls: 0,
+    validate: 0,
+    validateCalls: 0,
+    guardrail: 0,
+    guardrailCalls: 0,
+    retryCalls: 0
+  };
+}
+function emptyCostData() {
+  return {
+    totalCost: 0,
+    totalTokens: { input: 0, output: 0, reasoning: 0 },
+    byAgent: {},
+    byModel: {},
+    byWorkflow: {},
+    retry: emptyRetry(),
+    byEmbedder: {}
+  };
+}
+function reduceCost(acc, event) {
+  const isWorkflowStart = isLogEvent(event, "workflow_start");
+  if (isWorkflowStart && event.workflow) {
+    const byWorkflow2 = { ...acc.byWorkflow };
+    const prev = byWorkflow2[event.workflow] ?? { cost: 0, executions: 0 };
+    byWorkflow2[event.workflow] = { ...prev, executions: prev.executions + 1 };
+    return { ...acc, byWorkflow: byWorkflow2 };
+  }
+  if (event.cost == null && !event.tokens) return acc;
+  const cost = finite(event.cost);
+  const tokens = event.tokens ?? {};
+  const totalTokens = event.type === "agent_call" ? {
+    input: acc.totalTokens.input + finite(tokens.input),
+    output: acc.totalTokens.output + finite(tokens.output),
+    reasoning: acc.totalTokens.reasoning + finite(tokens.reasoning)
+  } : acc.totalTokens;
+  const byAgent = { ...acc.byAgent };
+  if (event.agent) {
+    const prev = byAgent[event.agent] ?? { cost: 0, calls: 0 };
+    byAgent[event.agent] = { cost: prev.cost + cost, calls: prev.calls + 1 };
+  }
+  const byModel = { ...acc.byModel };
+  if (event.model) {
+    const prev = byModel[event.model] ?? { cost: 0, calls: 0, tokens: { input: 0, output: 0 } };
+    byModel[event.model] = {
+      cost: prev.cost + cost,
+      calls: prev.calls + 1,
+      tokens: {
+        input: prev.tokens.input + finite(tokens.input),
+        output: prev.tokens.output + finite(tokens.output)
+      }
+    };
+  }
+  const byWorkflow = { ...acc.byWorkflow };
+  if (event.workflow) {
+    const prev = byWorkflow[event.workflow] ?? { cost: 0, executions: 0 };
+    byWorkflow[event.workflow] = {
+      cost: prev.cost + cost,
+      executions: prev.executions + (isWorkflowStart ? 1 : 0)
+    };
+  }
+  let retry = acc.retry;
+  if (event.type === "agent_call") {
+    const d = event.data ?? {};
+    const reason = d.retryReason;
+    retry = { ...acc.retry };
+    if (reason === "schema") {
+      retry.schema += cost;
+      retry.schemaCalls += 1;
+      retry.retryCalls += 1;
+    } else if (reason === "validate") {
+      retry.validate += cost;
+      retry.validateCalls += 1;
+      retry.retryCalls += 1;
+    } else if (reason === "guardrail") {
+      retry.guardrail += cost;
+      retry.guardrailCalls += 1;
+      retry.retryCalls += 1;
+    } else {
+      retry.primary += cost;
+      retry.primaryCalls += 1;
+    }
+  }
+  let byEmbedder = acc.byEmbedder;
+  if (event.type === "log") {
+    const d = event.data ?? {};
+    if (d.event === "memory_remember" || d.event === "memory_recall") {
+      byEmbedder = { ...acc.byEmbedder };
+      const modelKey = d.usage?.model ?? "unknown";
+      const embedTokens = typeof d.usage?.tokens === "number" ? finite(d.usage.tokens) : 0;
+      const prev = byEmbedder[modelKey] ?? { cost: 0, calls: 0, tokens: 0 };
+      byEmbedder[modelKey] = {
+        cost: prev.cost + cost,
+        calls: prev.calls + 1,
+        tokens: prev.tokens + embedTokens
+      };
+    }
+  }
+  return {
+    totalCost: acc.totalCost + cost,
+    totalTokens,
+    byAgent,
+    byModel,
+    byWorkflow,
+    retry,
+    byEmbedder
+  };
+}
+function emptyEvalTrendData() {
+  return { byEval: {}, totalRuns: 0, totalCost: 0 };
+}
+function extractScores(data) {
+  if (!data || typeof data !== "object") return {};
+  const result = data;
+  const summary = result.summary;
+  const scorers = summary?.scorers;
+  if (!scorers) return {};
+  const out = {};
+  for (const [name, entry] of Object.entries(scorers)) {
+    if (typeof entry === "number" && Number.isFinite(entry)) {
+      out[name] = entry;
+    } else if (entry && typeof entry === "object" && Number.isFinite(entry.mean)) {
+      out[name] = entry.mean;
+    }
+  }
+  return out;
+}
+function extractCost(data) {
+  if (!data || typeof data !== "object") return 0;
+  const result = data;
+  if (Number.isFinite(result.totalCost)) return result.totalCost;
+  const summary = result.summary;
+  return Number.isFinite(summary?.totalCost) ? summary.totalCost : 0;
+}
+function extractModel(data) {
+  if (!data || typeof data !== "object") return void 0;
+  const result = data;
+  const metadata = result.metadata;
+  const counts = metadata?.modelCounts;
+  if (counts && typeof counts === "object" && !Array.isArray(counts)) {
+    const entries = Object.entries(counts).filter(
+      ([, v]) => typeof v === "number"
+    );
+    if (entries.length > 0) {
+      entries.sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+      return entries[0][0];
+    }
+  }
+  const models = metadata?.models;
+  if (Array.isArray(models) && typeof models[0] === "string") return models[0];
+  return void 0;
+}
+function extractDuration(data) {
+  if (!data || typeof data !== "object") return void 0;
+  const result = data;
+  return Number.isFinite(result.duration) ? result.duration : void 0;
+}
+function computeScoreStats(runs) {
+  const scorerNames = /* @__PURE__ */ new Set();
+  for (const run of runs) {
+    for (const name of Object.keys(run.scores)) scorerNames.add(name);
+  }
+  const mean = {};
+  const std = {};
+  for (const name of scorerNames) {
+    const values = runs.map((r) => r.scores[name]).filter((v) => v != null);
+    if (values.length === 0) continue;
+    const m = values.reduce((a, b) => a + b, 0) / values.length;
+    mean[name] = m;
+    const variance = values.reduce((sum, v) => sum + (v - m) ** 2, 0) / values.length;
+    std[name] = Math.sqrt(variance);
+  }
+  return { mean, std };
+}
+function reduceEvalTrends(acc, entry) {
+  const scores = extractScores(entry.data);
+  const cost = extractCost(entry.data);
+  const model = extractModel(entry.data);
+  const duration = extractDuration(entry.data);
+  const run = {
+    timestamp: entry.timestamp,
+    id: entry.id,
+    scores,
+    cost,
+    ...model !== void 0 ? { model } : {},
+    ...duration !== void 0 ? { duration } : {}
+  };
+  const byEval = { ...acc.byEval };
+  const prev = byEval[entry.eval];
+  const MAX_EVAL_RUNS = 50;
+  const allRuns = prev ? [...prev.runs, run] : [run];
+  const runs = allRuns.length > MAX_EVAL_RUNS ? allRuns.slice(-MAX_EVAL_RUNS) : allRuns;
+  const { mean, std } = computeScoreStats(runs);
+  const latestScores = prev && prev.runs.length > 0 && prev.runs[prev.runs.length - 1].timestamp > run.timestamp ? prev.latestScores : scores;
+  byEval[entry.eval] = {
+    runs,
+    latestScores,
+    scoreMean: mean,
+    scoreStd: std,
+    costTotal: (prev?.costTotal ?? 0) + cost,
+    runCount: (prev?.runCount ?? 0) + 1
+  };
+  return {
+    byEval,
+    totalRuns: acc.totalRuns + 1,
+    totalCost: acc.totalCost + cost
+  };
+}
+var MAX_DURATIONS = 200;
+function emptyWorkflowStatsData() {
+  return { byWorkflow: {}, totalExecutions: 0, failureRate: 0 };
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = p / 100 * (sorted.length - 1);
+  const lower = Math.floor(idx);
+  const upper = Math.ceil(idx);
+  if (lower === upper) return sorted[lower];
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * (idx - lower);
+}
+function reduceWorkflowStats(acc, execution) {
+  const byWorkflow = { ...acc.byWorkflow };
+  const prev = byWorkflow[execution.workflow] ?? {
+    total: 0,
+    completed: 0,
+    failed: 0,
+    durations: [],
+    durationSum: 0,
+    avgDuration: 0
+  };
+  const dur = finite(execution.duration);
+  const durations = [...prev.durations];
+  const insertIdx = durations.findIndex((d) => d > dur);
+  if (insertIdx === -1) durations.push(dur);
+  else durations.splice(insertIdx, 0, dur);
+  if (durations.length > MAX_DURATIONS) durations.shift();
+  const total = prev.total + 1;
+  const completed = prev.completed + (execution.status === "completed" ? 1 : 0);
+  const failed = prev.failed + (execution.status === "failed" ? 1 : 0);
+  const durationSum = prev.durationSum + dur;
+  const avgDuration = durationSum / total;
+  byWorkflow[execution.workflow] = {
+    total,
+    completed,
+    failed,
+    durations,
+    durationSum,
+    avgDuration
+  };
+  const totalExecutions = acc.totalExecutions + 1;
+  const totalFailed = Object.values(byWorkflow).reduce((sum, w) => sum + w.failed, 0);
+  const failureRate = totalExecutions > 0 ? totalFailed / totalExecutions : 0;
+  return { byWorkflow, totalExecutions, failureRate };
+}
+function getWorkflowPercentiles(entry) {
+  return {
+    durationP50: percentile(entry.durations, 50),
+    durationP95: percentile(entry.durations, 95)
+  };
+}
+function enrichWorkflowStats(data) {
+  const byWorkflow = {};
+  for (const [name, entry] of Object.entries(data.byWorkflow)) {
+    const { durationP50, durationP95 } = getWorkflowPercentiles(entry);
+    byWorkflow[name] = {
+      total: entry.total,
+      completed: entry.completed,
+      failed: entry.failed,
+      durationP50,
+      durationP95,
+      avgDuration: entry.avgDuration
+    };
+  }
+  return {
+    byWorkflow,
+    totalExecutions: data.totalExecutions,
+    failureRate: data.failureRate
+  };
+}
+function emptyTraceStatsData() {
+  return {
+    eventTypeCounts: {},
+    byTool: {},
+    retryByAgent: {},
+    totalEvents: 0
+  };
+}
+function reduceTraceStats(acc, event) {
+  const eventTypeCounts = { ...acc.eventTypeCounts };
+  eventTypeCounts[event.type] = (eventTypeCounts[event.type] ?? 0) + 1;
+  const byTool = { ...acc.byTool };
+  if (event.type === "tool_call" || event.type === "tool_denied" || event.type === "tool_approval") {
+    const toolName = event.tool;
+    const prev = byTool[toolName] ?? { calls: 0, denied: 0, approved: 0 };
+    const isDeniedEvent = event.type === "tool_denied";
+    const isApprovalEvent = event.type === "tool_approval";
+    const eventData = isDeniedEvent || isApprovalEvent ? event.data : void 0;
+    const isApproved = isDeniedEvent && eventData?.approved === true || isApprovalEvent && eventData?.approved === true;
+    const isDenied = isDeniedEvent && !eventData?.approved || isApprovalEvent && eventData?.approved === false;
+    byTool[toolName] = {
+      calls: prev.calls + (event.type === "tool_call" ? 1 : 0),
+      denied: prev.denied + (isDenied ? 1 : 0),
+      approved: prev.approved + (isApproved ? 1 : 0)
+    };
+  }
+  const retryByAgent = { ...acc.retryByAgent };
+  if (event.agent && event.type === "agent_call") {
+    const data = event.data;
+    if (data?.retryReason) {
+      const prev = retryByAgent[event.agent] ?? { schema: 0, validate: 0, guardrail: 0 };
+      const reason = data.retryReason;
+      if (reason in prev) {
+        retryByAgent[event.agent] = { ...prev, [reason]: prev[reason] + 1 };
+      }
+    }
+  }
+  return {
+    eventTypeCounts,
+    byTool,
+    retryByAgent,
+    totalEvents: acc.totalEvents + 1
+  };
+}
+
+// src/server/aggregates/execution-aggregator.ts
+var ExecutionAggregator = class {
+  snaps;
+  interval;
+  listener;
+  options;
+  /** Generation counter to prevent stale async fold after rebuild. */
+  generation = 0;
+  constructor(options) {
+    this.options = options;
+    this.snaps = new AggregateSnapshots(
+      options.windows,
+      options.emptyState,
+      options.connMgr,
+      options.channel,
+      options.broadcastTransform
+    );
+  }
+  async start() {
+    await this.rebuild();
+    this.listener = (event) => {
+      if (!isLogEvent(event, "workflow_end")) return;
+      const gen = this.generation;
+      this.options.runtime.getExecution(event.executionId).then((exec) => {
+        if (this.generation !== gen) return;
+        if (exec) {
+          this.snaps.fold(exec.startedAt, (prev) => this.options.reducer(prev, exec));
+        }
+      }).catch((err) => console.error("[axl-studio] execution fold failed:", err));
+    };
+    this.options.runtime.on("trace", this.listener);
+    this.interval = setInterval(
+      () => this.rebuild().catch((err) => console.error("[axl-studio] rebuild failed:", err)),
+      REBUILD_INTERVAL_MS
+    );
+  }
+  async rebuild() {
+    this.generation++;
+    const executions = await this.options.runtime.getExecutions();
+    const cap = this.options.executionCap ?? 2e3;
+    const capped = executions.slice(0, cap);
+    const now = Date.now();
+    const fresh = new Map(
+      this.options.windows.map((w) => [w, this.options.emptyState()])
+    );
+    for (const exec of capped) {
+      for (const window of this.options.windows) {
+        if (withinWindow(exec.startedAt, window, now)) {
+          fresh.set(window, this.options.reducer(fresh.get(window), exec));
+        }
+      }
+    }
+    this.snaps.replace(fresh);
+  }
+  getSnapshot(window) {
+    return this.snaps.get(window);
+  }
+  getAllSnapshots() {
+    return this.snaps.getAll();
+  }
+  close() {
+    if (this.listener) this.options.runtime.off("trace", this.listener);
+    if (this.interval) clearInterval(this.interval);
+  }
+};
+
+// src/server/aggregates/eval-aggregator.ts
+var EvalAggregator = class {
+  snaps;
+  interval;
+  listener;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.snaps = new AggregateSnapshots(
+      options.windows,
+      options.emptyState,
+      options.connMgr,
+      options.channel,
+      options.broadcastTransform
+    );
+  }
+  async start() {
+    await this.rebuild();
+    this.listener = (entry) => {
+      this.snaps.fold(entry.timestamp, (prev) => this.options.reducer(prev, entry));
+    };
+    this.options.runtime.on("eval_result", this.listener);
+    this.interval = setInterval(
+      () => this.rebuild().catch((err) => console.error("[axl-studio] rebuild failed:", err)),
+      REBUILD_INTERVAL_MS
+    );
+  }
+  async rebuild() {
+    const history = await this.options.runtime.getEvalHistory();
+    const cap = this.options.entryCap ?? 500;
+    const capped = history.slice(0, cap);
+    const now = Date.now();
+    const fresh = new Map(
+      this.options.windows.map((w) => [w, this.options.emptyState()])
+    );
+    for (const entry of capped) {
+      for (const window of this.options.windows) {
+        if (withinWindow(entry.timestamp, window, now)) {
+          fresh.set(window, this.options.reducer(fresh.get(window), entry));
+        }
+      }
+    }
+    this.snaps.replace(fresh);
+  }
+  getSnapshot(window) {
+    return this.snaps.get(window);
+  }
+  getAllSnapshots() {
+    return this.snaps.getAll();
+  }
+  close() {
+    if (this.listener) this.options.runtime.off("eval_result", this.listener);
+    if (this.interval) clearInterval(this.interval);
+  }
+};
+
+// src/server/routes/health.ts
+import { Hono } from "hono";
+function createHealthRoutes(readOnly) {
+  const app6 = new Hono();
+  app6.get("/health", (c) => {
+    const runtime = c.get("runtime");
+    return c.json({
+      ok: true,
+      data: {
+        status: "healthy",
+        readOnly,
+        workflows: runtime.getWorkflowNames().length,
+        agents: runtime.getAgents().length,
+        tools: runtime.getTools().length
+      }
+    });
+  });
+  return app6;
+}
+
+// src/server/routes/workflows.ts
+import { Hono as Hono2 } from "hono";
+import { zodToJsonSchema } from "@axlsdk/axl";
+function createWorkflowRoutes(connMgr) {
+  const app6 = new Hono2();
+  app6.get("/workflows", (c) => {
+    const runtime = c.get("runtime");
+    const workflows = runtime.getWorkflows().map((w) => ({
+      name: w.name,
+      hasInputSchema: !!w.inputSchema,
+      hasOutputSchema: !!w.outputSchema
+    }));
+    return c.json({ ok: true, data: workflows });
+  });
+  app6.get("/workflows/:name", (c) => {
+    const runtime = c.get("runtime");
+    const name = c.req.param("name");
+    const workflow = runtime.getWorkflow(name);
+    if (!workflow) {
+      return c.json(
+        { ok: false, error: { code: "NOT_FOUND", message: `Workflow "${name}" not found` } },
+        404
+      );
+    }
+    return c.json({
+      ok: true,
+      data: {
+        name: workflow.name,
+        inputSchema: workflow.inputSchema ? zodToJsonSchema(workflow.inputSchema) : null,
+        outputSchema: workflow.outputSchema ? zodToJsonSchema(workflow.outputSchema) : null
+      }
+    });
+  });
+  app6.post("/workflows/:name/execute", async (c) => {
+    const runtime = c.get("runtime");
+    const name = c.req.param("name");
+    const workflow = runtime.getWorkflow(name);
+    if (!workflow) {
+      return c.json(
+        { ok: false, error: { code: "NOT_FOUND", message: `Workflow "${name}" not found` } },
+        404
+      );
+    }
+    const body = await c.req.json();
+    if (body.stream) {
+      const stream = runtime.stream(name, body.input ?? {}, { metadata: body.metadata });
+      const executionId = `stream-${Date.now()}`;
+      const redactOn = runtime.isRedactEnabled();
+      (async () => {
+        for await (const event of stream) {
+          connMgr.broadcastWithWildcard(
+            `execution:${executionId}`,
+            redactStreamEvent(event, redactOn)
+          );
+        }
+      })();
+      return c.json({ ok: true, data: { executionId, streaming: true } });
+    }
+    const result = await runtime.execute(name, body.input ?? {}, { metadata: body.metadata });
+    return c.json({
+      ok: true,
+      data: { result: redactValue(result, runtime.isRedactEnabled()) }
+    });
+  });
+  return app6;
+}
+
+// src/server/routes/executions.ts
+import { Hono as Hono3 } from "hono";
+var app = new Hono3();
+app.get("/executions", async (c) => {
+  const runtime = c.get("runtime");
+  const executions = await runtime.getExecutions();
+  return c.json({
+    ok: true,
+    data: redactExecutionList(executions, runtime.isRedactEnabled())
+  });
+});
+app.get("/executions/:id", async (c) => {
+  const runtime = c.get("runtime");
+  const id = c.req.param("id");
+  const execution = await runtime.getExecution(id);
+  if (!execution) {
+    return c.json(
+      { ok: false, error: { code: "NOT_FOUND", message: `Execution "${id}" not found` } },
+      404
+    );
+  }
+  return c.json({
+    ok: true,
+    data: redactExecutionInfo(execution, runtime.isRedactEnabled())
+  });
+});
+app.post("/executions/:id/abort", (c) => {
+  const runtime = c.get("runtime");
+  const id = c.req.param("id");
+  runtime.abort(id);
+  return c.json({ ok: true, data: { aborted: true } });
+});
+var executions_default = app;
+
+// src/server/routes/sessions.ts
+import { Hono as Hono4 } from "hono";
+function createSessionRoutes(connMgr) {
+  const app6 = new Hono4();
+  app6.get("/sessions", async (c) => {
+    const runtime = c.get("runtime");
+    const store = runtime.getStateStore();
+    if (!store.listSessions) {
+      return c.json({ ok: true, data: [] });
+    }
+    const ids = await store.listSessions();
+    const sessions = [];
+    for (const id of ids) {
+      const history = await store.getSession(id);
+      sessions.push({ id, messageCount: history.length });
+    }
+    return c.json({ ok: true, data: sessions });
+  });
+  app6.get("/sessions/:id", async (c) => {
+    const runtime = c.get("runtime");
+    const store = runtime.getStateStore();
+    const id = c.req.param("id");
+    const history = await store.getSession(id);
+    const handoffHistory = await store.getSessionMeta(id, "handoffHistory");
+    return c.json({
+      ok: true,
+      data: {
+        id,
+        history: redactSessionHistory(history, runtime.isRedactEnabled()),
+        // HandoffRecord has no content fields (source/target/mode/
+        // timestamp/duration) — nothing to scrub.
+        handoffHistory: handoffHistory ?? []
+      }
+    });
+  });
+  app6.post("/sessions/:id/send", async (c) => {
+    const runtime = c.get("runtime");
+    const id = c.req.param("id");
+    const body = await c.req.json();
+    const session = runtime.session(id);
+    const result = await session.send(body.workflow, body.message);
+    return c.json({ ok: true, data: { result } });
+  });
+  app6.post("/sessions/:id/stream", async (c) => {
+    const runtime = c.get("runtime");
+    const id = c.req.param("id");
+    const body = await c.req.json();
+    const session = runtime.session(id);
+    const stream = await session.stream(body.workflow, body.message);
+    const executionId = `session-${id}-${Date.now()}`;
+    (async () => {
+      for await (const event of stream) {
+        connMgr.broadcastWithWildcard(`execution:${executionId}`, event);
+      }
+    })();
+    return c.json({ ok: true, data: { executionId, streaming: true } });
+  });
+  app6.delete("/sessions/:id", async (c) => {
+    const runtime = c.get("runtime");
+    const store = runtime.getStateStore();
+    const id = c.req.param("id");
+    await store.deleteSession(id);
+    return c.json({ ok: true, data: { deleted: true } });
+  });
+  return app6;
+}
+
+// src/server/routes/agents.ts
+import { Hono as Hono5 } from "hono";
+import { zodToJsonSchema as zodToJsonSchema2 } from "@axlsdk/axl";
+var app2 = new Hono5();
+app2.get("/agents", (c) => {
+  const runtime = c.get("runtime");
+  const agents = runtime.getAgents().map((a) => ({
+    name: a._name,
+    model: a.resolveModel(),
+    system: a.resolveSystem(),
+    tools: a._config.tools?.map((t) => t.name) ?? [],
+    handoffs: typeof a._config.handoffs === "function" ? ["(dynamic)"] : a._config.handoffs?.map((h) => h.agent._name) ?? [],
+    maxTurns: a._config.maxTurns,
+    temperature: a._config.temperature,
+    maxTokens: a._config.maxTokens,
+    effort: a._config.effort,
+    thinkingBudget: a._config.thinkingBudget,
+    includeThoughts: a._config.includeThoughts,
+    toolChoice: a._config.toolChoice,
+    stop: a._config.stop
+  }));
+  return c.json({ ok: true, data: agents });
+});
+app2.get("/agents/:name", (c) => {
+  const runtime = c.get("runtime");
+  const name = c.req.param("name");
+  const agent = runtime.getAgent(name);
+  if (!agent) {
+    return c.json(
+      { ok: false, error: { code: "NOT_FOUND", message: `Agent "${name}" not found` } },
+      404
+    );
+  }
+  const cfg = agent._config;
+  return c.json({
+    ok: true,
+    data: {
+      name: agent._name,
+      model: agent.resolveModel(),
+      system: agent.resolveSystem(),
+      tools: cfg.tools?.map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: zodToJsonSchema2(t.inputSchema)
+      })) ?? [],
+      handoffs: typeof cfg.handoffs === "function" ? [
+        {
+          agent: "(dynamic)",
+          description: "Resolved at runtime from metadata",
+          mode: "oneway"
+        }
+      ] : cfg.handoffs?.map((h) => ({
+        agent: h.agent._name,
+        description: h.description,
+        mode: h.mode ?? "oneway"
+      })) ?? [],
+      maxTurns: cfg.maxTurns,
+      temperature: cfg.temperature,
+      maxTokens: cfg.maxTokens,
+      effort: cfg.effort,
+      thinkingBudget: cfg.thinkingBudget,
+      includeThoughts: cfg.includeThoughts,
+      toolChoice: cfg.toolChoice,
+      stop: cfg.stop,
+      timeout: cfg.timeout,
+      maxContext: cfg.maxContext,
+      version: cfg.version,
+      mcp: cfg.mcp,
+      mcpTools: cfg.mcpTools,
+      hasGuardrails: !!cfg.guardrails,
+      guardrails: cfg.guardrails ? {
+        hasInput: !!cfg.guardrails.input,
+        hasOutput: !!cfg.guardrails.output,
+        onBlock: cfg.guardrails.onBlock ?? "throw",
+        maxRetries: cfg.guardrails.maxRetries
+      } : null
+    }
+  });
+});
+var agents_default = app2;
+
+// src/server/routes/tools.ts
+import { Hono as Hono6 } from "hono";
+import { zodToJsonSchema as zodToJsonSchema3 } from "@axlsdk/axl";
+var app3 = new Hono6();
+app3.get("/tools", (c) => {
+  const runtime = c.get("runtime");
+  const tools = runtime.getTools().map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema ? zodToJsonSchema3(t.inputSchema) : {},
+    sensitive: t.sensitive ?? false,
+    requireApproval: t.requireApproval ?? false
+  }));
+  return c.json({ ok: true, data: tools });
+});
+app3.get("/tools/:name", (c) => {
+  const runtime = c.get("runtime");
+  const name = c.req.param("name");
+  const tool = runtime.getTool(name);
+  if (!tool) {
+    return c.json(
+      { ok: false, error: { code: "NOT_FOUND", message: `Tool "${name}" not found` } },
+      404
+    );
+  }
+  return c.json({
+    ok: true,
+    data: {
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema ? zodToJsonSchema3(tool.inputSchema) : {},
+      sensitive: tool.sensitive,
+      requireApproval: tool.requireApproval,
+      retry: tool.retry,
+      hasHooks: !!tool.hooks,
+      hooks: tool.hooks ? {
+        hasBefore: !!tool.hooks.before,
+        hasAfter: !!tool.hooks.after
+      } : null
+    }
+  });
+});
+app3.post("/tools/:name/test", async (c) => {
+  const runtime = c.get("runtime");
+  const name = c.req.param("name");
+  const tool = runtime.getTool(name);
+  if (!tool) {
+    return c.json(
+      { ok: false, error: { code: "NOT_FOUND", message: `Tool "${name}" not found` } },
+      404
+    );
+  }
+  const body = await c.req.json();
+  const ctx = runtime.createContext();
+  const result = await tool.run(ctx, body.input);
+  return c.json({
+    ok: true,
+    data: { result: redactValue(result, runtime.isRedactEnabled()) }
+  });
+});
+var tools_default = app3;
+
+// src/server/routes/memory.ts
+import { Hono as Hono7 } from "hono";
+var app4 = new Hono7();
+app4.get("/memory/:scope", async (c) => {
+  const runtime = c.get("runtime");
+  const store = runtime.getStateStore();
+  const scope = c.req.param("scope");
+  if (!store.getAllMemory) {
+    return c.json({ ok: true, data: [] });
+  }
+  const entries = await store.getAllMemory(scope);
+  return c.json({ ok: true, data: redactMemoryList(entries, runtime.isRedactEnabled()) });
+});
+app4.get("/memory/:scope/:key", async (c) => {
+  const runtime = c.get("runtime");
+  const store = runtime.getStateStore();
+  const scope = c.req.param("scope");
+  const key = c.req.param("key");
+  if (!store.getMemory) {
+    return c.json(
+      { ok: false, error: { code: "NOT_SUPPORTED", message: "Memory not supported" } },
+      501
+    );
+  }
+  const value = await store.getMemory(scope, key);
+  if (value === null) {
+    return c.json(
+      { ok: false, error: { code: "NOT_FOUND", message: `Memory "${scope}/${key}" not found` } },
+      404
+    );
+  }
+  return c.json({
+    ok: true,
+    data: { key, value: redactMemoryValue(value, runtime.isRedactEnabled()) }
+  });
+});
+app4.put("/memory/:scope/:key", async (c) => {
+  const runtime = c.get("runtime");
+  const store = runtime.getStateStore();
+  const scope = c.req.param("scope");
+  const key = c.req.param("key");
+  if (!store.saveMemory) {
+    return c.json(
+      { ok: false, error: { code: "NOT_SUPPORTED", message: "Memory not supported" } },
+      501
+    );
+  }
+  const body = await c.req.json();
+  await store.saveMemory(scope, key, body.value);
+  return c.json({ ok: true, data: { saved: true } });
+});
+app4.delete("/memory/:scope/:key", async (c) => {
+  const runtime = c.get("runtime");
+  const store = runtime.getStateStore();
+  const scope = c.req.param("scope");
+  const key = c.req.param("key");
+  if (!store.deleteMemory) {
+    return c.json(
+      { ok: false, error: { code: "NOT_SUPPORTED", message: "Memory not supported" } },
+      501
+    );
+  }
+  await store.deleteMemory(scope, key);
+  return c.json({ ok: true, data: { deleted: true } });
+});
+app4.post("/memory/search", async (c) => {
+  return c.json({
+    ok: true,
+    data: { results: [], message: "Semantic search requires MemoryManager with vector store" }
+  });
+});
+var memory_default = app4;
+
+// src/server/routes/decisions.ts
+import { Hono as Hono8 } from "hono";
+var app5 = new Hono8();
+app5.get("/decisions", async (c) => {
+  const runtime = c.get("runtime");
+  const decisions = await runtime.getPendingDecisions();
+  return c.json({
+    ok: true,
+    data: redactPendingDecisionList(decisions, runtime.isRedactEnabled())
+  });
+});
+app5.post("/decisions/:executionId/resolve", async (c) => {
+  const runtime = c.get("runtime");
+  const executionId = c.req.param("executionId");
+  const body = await c.req.json();
+  await runtime.resolveDecision(executionId, body);
+  return c.json({ ok: true, data: { resolved: true } });
+});
+var decisions_default = app5;
+
+// src/server/routes/costs.ts
+import { Hono as Hono9 } from "hono";
+function createCostRoutes(costAggregator) {
+  const app6 = new Hono9();
+  app6.get("/costs", (c) => {
+    if (c.req.query("windows") === "all") {
+      return c.json({ ok: true, data: costAggregator.getAllSnapshots() });
+    }
+    const window = parseWindowParam(c.req.query("window"));
+    return c.json({ ok: true, data: costAggregator.getSnapshot(window) });
+  });
+  app6.post("/costs/reset", (c) => {
+    return c.json(
+      {
+        ok: false,
+        error: {
+          code: "GONE",
+          message: "POST /api/costs/reset was removed in @axlsdk/studio 0.15. Cost aggregates are now time-windowed and rebuilt from StateStore history. Use GET /api/costs?window=24h|7d|30d|all to narrow the view instead of resetting."
+        }
+      },
+      410
+    );
+  });
+  return app6;
+}
+
+// src/server/routes/evals.ts
+import { randomUUID } from "crypto";
+import { Hono as Hono10 } from "hono";
+function createEvalRoutes(connMgr, evalLoader) {
+  const app6 = new Hono10();
+  const activeRuns = /* @__PURE__ */ new Map();
+  app6.get("/evals", async (c) => {
+    if (evalLoader) await evalLoader();
+    const runtime = c.get("runtime");
+    const evals = runtime.getRegisteredEvals();
+    return c.json({ ok: true, data: evals });
+  });
+  app6.get("/evals/history", async (c) => {
+    const runtime = c.get("runtime");
+    const history = await runtime.getEvalHistory();
+    return c.json({
+      ok: true,
+      data: redactEvalHistoryList(history, runtime.isRedactEnabled())
+    });
+  });
+  app6.delete("/evals/history/:id", async (c) => {
+    const runtime = c.get("runtime");
+    const id = c.req.param("id");
+    const deleted = await runtime.deleteEvalResult(id);
+    if (!deleted) {
+      return c.json(
+        {
+          ok: false,
+          error: { code: "NOT_FOUND", message: `Eval history entry "${id}" not found` }
+        },
+        404
+      );
+    }
+    return c.json({ ok: true, data: { id, deleted: true } });
+  });
+  app6.post("/evals/:name/run", async (c) => {
+    if (evalLoader) await evalLoader();
+    const runtime = c.get("runtime");
+    const name = c.req.param("name");
+    const redactOn = runtime.isRedactEnabled();
+    const entry = runtime.getRegisteredEval(name);
+    if (!entry) {
+      return c.json(
+        { ok: false, error: { code: "NOT_FOUND", message: `Eval "${name}" not found` } },
+        404
+      );
+    }
+    let runs = 1;
+    let stream = false;
+    let captureTraces = false;
+    try {
+      const body = await c.req.json().catch(() => ({}));
+      if (typeof body.runs === "number" && Number.isFinite(body.runs) && body.runs > 1) {
+        runs = Math.min(Math.floor(body.runs), 25);
+      }
+      if (body.stream === true) {
+        stream = true;
+      }
+      if (body.captureTraces === true) {
+        captureTraces = true;
+      }
+    } catch {
+    }
+    if (stream) {
+      const evalRunId = `eval-${randomUUID()}`;
+      const ac = new AbortController();
+      activeRuns.set(evalRunId, ac);
+      (async () => {
+        try {
+          if (runs > 1) {
+            const runGroupId = randomUUID();
+            const results = [];
+            for (let r = 0; r < runs; r++) {
+              if (ac.signal.aborted) break;
+              const result = await runtime.runRegisteredEval(name, {
+                metadata: { runGroupId, runIndex: r },
+                signal: ac.signal,
+                captureTraces,
+                onProgress: (event) => {
+                  if (event.type === "run_done") return;
+                  connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
+                    ...event,
+                    run: r + 1,
+                    totalRuns: runs
+                  });
+                }
+              });
+              results.push(result);
+              connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
+                type: "run_done",
+                run: r + 1,
+                totalRuns: runs
+              });
+            }
+            if (results.length > 0) {
+              connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
+                type: "done",
+                evalResultId: results[0].id,
+                runGroupId
+              });
+            } else {
+              connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
+                type: "error",
+                message: "All runs were cancelled"
+              });
+            }
+          } else {
+            const result = await runtime.runRegisteredEval(name, {
+              signal: ac.signal,
+              captureTraces,
+              onProgress: (event) => {
+                if (event.type === "run_done") return;
+                connMgr.broadcastWithWildcard(`eval:${evalRunId}`, event);
+              }
+            });
+            connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
+              type: "done",
+              evalResultId: result.id
+            });
+          }
+        } catch (err) {
+          connMgr.broadcastWithWildcard(`eval:${evalRunId}`, {
+            type: "error",
+            message: redactErrorMessage(err, redactOn)
+          });
+        } finally {
+          activeRuns.delete(evalRunId);
+        }
+      })();
+      return c.json({ ok: true, data: { evalRunId } });
+    }
+    try {
+      if (runs > 1) {
+        const { aggregateRuns } = await import("@axlsdk/eval");
+        const runGroupId = randomUUID();
+        const results = [];
+        for (let r = 0; r < runs; r++) {
+          const result2 = await runtime.runRegisteredEval(name, {
+            metadata: { runGroupId, runIndex: r },
+            captureTraces
+          });
+          results.push(result2);
+        }
+        const typedResults = results;
+        const aggregate = aggregateRuns(typedResults);
+        const first = typedResults[0];
+        const result = {
+          ...first,
+          _multiRun: { aggregate, allRuns: typedResults }
+        };
+        return c.json({
+          ok: true,
+          data: redactEvalResult(result, redactOn)
+        });
+      } else {
+        const result = await runtime.runRegisteredEval(name, { captureTraces });
+        return c.json({
+          ok: true,
+          data: redactEvalResult(result, redactOn)
+        });
+      }
+    } catch (err) {
+      return c.json(
+        { ok: false, error: { code: "EVAL_ERROR", message: redactErrorMessage(err, redactOn) } },
+        400
+      );
+    }
+  });
+  app6.post("/evals/runs/:evalRunId/cancel", (c) => {
+    const evalRunId = c.req.param("evalRunId");
+    const ac = activeRuns.get(evalRunId);
+    if (!ac) {
+      return c.json(
+        { ok: false, error: { code: "NOT_FOUND", message: "No active eval run found" } },
+        404
+      );
+    }
+    ac.abort();
+    activeRuns.delete(evalRunId);
+    return c.json({ ok: true, data: { cancelled: true } });
+  });
+  app6.post("/evals/:name/rescore", async (c) => {
+    if (evalLoader) await evalLoader();
+    const runtime = c.get("runtime");
+    const redactOn = runtime.isRedactEnabled();
+    const name = c.req.param("name");
+    const body = await c.req.json();
+    if (!body.resultId || typeof body.resultId !== "string") {
+      return c.json(
+        { ok: false, error: { code: "BAD_REQUEST", message: "resultId is required" } },
+        400
+      );
+    }
+    const entry = runtime.getRegisteredEval(name);
+    if (!entry) {
+      return c.json(
+        { ok: false, error: { code: "NOT_FOUND", message: `Eval "${name}" not found` } },
+        404
+      );
+    }
+    const history = await runtime.getEvalHistory();
+    const historyEntry = history.find((h) => h.id === body.resultId);
+    if (!historyEntry) {
+      return c.json(
+        { ok: false, error: { code: "NOT_FOUND", message: `Result "${body.resultId}" not found` } },
+        404
+      );
+    }
+    try {
+      const { rescore } = await import("@axlsdk/eval");
+      const config = entry.config;
+      const result = await rescore(
+        historyEntry.data,
+        config.scorers,
+        runtime
+      );
+      await runtime.saveEvalResult({
+        id: result.id,
+        eval: name,
+        timestamp: Date.now(),
+        data: result
+      });
+      return c.json({
+        ok: true,
+        data: redactEvalResult(result, redactOn)
+      });
+    } catch (err) {
+      return c.json(
+        { ok: false, error: { code: "EVAL_ERROR", message: redactErrorMessage(err, redactOn) } },
+        400
+      );
+    }
+  });
+  app6.post("/evals/compare", async (c) => {
+    const runtime = c.get("runtime");
+    const redactOn = runtime.isRedactEnabled();
+    const body = await c.req.json();
+    const validateIdParam = (v, name) => {
+      if (typeof v === "string") return v === "" ? `${name} must be non-empty` : null;
+      if (Array.isArray(v)) {
+        if (v.length === 0) return `${name} must be a non-empty array`;
+        for (const elem of v) {
+          if (typeof elem !== "string" || elem === "") {
+            return `${name} array must contain only non-empty strings`;
+          }
+        }
+        return null;
+      }
+      return `${name} is required (string or string[])`;
+    };
+    const baselineErr = validateIdParam(body.baselineId, "baselineId");
+    const candidateErr = validateIdParam(body.candidateId, "candidateId");
+    if (baselineErr || candidateErr) {
+      return c.json(
+        {
+          ok: false,
+          error: {
+            code: "BAD_REQUEST",
+            message: [baselineErr, candidateErr].filter(Boolean).join("; ")
+          }
+        },
+        400
+      );
+    }
+    const history = await runtime.getEvalHistory();
+    const byId = new Map(history.map((h) => [h.id, h.data]));
+    const missing = [];
+    const resolveOne = (id) => {
+      const data = byId.get(id);
+      if (!data) missing.push(id);
+      return data;
+    };
+    const resolveSelection = (idOrIds) => {
+      if (Array.isArray(idOrIds)) {
+        const unique = Array.from(new Set(idOrIds));
+        if (unique.length === 1) return resolveOne(unique[0]);
+        const results = [];
+        for (const id of unique) {
+          const data = resolveOne(id);
+          if (data) results.push(data);
+        }
+        return results;
+      }
+      return resolveOne(idOrIds);
+    };
+    const baseline = resolveSelection(body.baselineId);
+    const candidate = resolveSelection(body.candidateId);
+    if (missing.length > 0) {
+      return c.json(
+        {
+          ok: false,
+          error: {
+            code: "NOT_FOUND",
+            message: `Eval result(s) not found in history: ${missing.join(", ")}`
+          }
+        },
+        404
+      );
+    }
+    try {
+      const result = await runtime.evalCompare(baseline, candidate, body.options);
+      return c.json({ ok: true, data: result });
+    } catch (err) {
+      return c.json(
+        {
+          ok: false,
+          error: { code: "COMPARE_FAILED", message: redactErrorMessage(err, redactOn) }
+        },
+        400
+      );
+    }
+  });
+  app6.post("/evals/import", async (c) => {
+    const runtime = c.get("runtime");
+    const body = await c.req.json();
+    const bad = (message) => c.json({ ok: false, error: { code: "BAD_REQUEST", message } }, 400);
+    if (!body.result || typeof body.result !== "object") {
+      return bad("result is required");
+    }
+    const result = body.result;
+    if (!Array.isArray(result.items)) {
+      return bad("result.items must be an array");
+    }
+    if (typeof result.summary !== "object" || result.summary == null) {
+      return bad("result.summary must be an object");
+    }
+    if (typeof result.dataset !== "string" || !result.dataset) {
+      return bad("result.dataset must be a non-empty string (required for compare)");
+    }
+    const summary = result.summary;
+    if (typeof summary.scorers !== "object" || summary.scorers == null) {
+      return bad("result.summary.scorers must be an object");
+    }
+    const summaryScorerNames = Object.keys(summary.scorers);
+    const items = result.items;
+    const summaryScorerSet = new Set(summaryScorerNames);
+    const uncoveredAcrossItems = /* @__PURE__ */ new Set();
+    for (const item of items) {
+      const itemScores = item?.scores;
+      if (itemScores && typeof itemScores === "object") {
+        for (const name of Object.keys(itemScores)) {
+          if (!summaryScorerSet.has(name)) uncoveredAcrossItems.add(name);
+        }
+      }
+    }
+    if (uncoveredAcrossItems.size > 0) {
+      return bad(
+        `item scores reference scorer(s) not in summary.scorers: ${[...uncoveredAcrossItems].join(", ")}`
+      );
+    }
+    const trim = (v) => typeof v === "string" && v.trim() !== "" ? v.trim() : void 0;
+    const metadataObj = typeof result.metadata === "object" && result.metadata != null ? result.metadata : {};
+    const workflowsFromMeta = Array.isArray(metadataObj.workflows) ? metadataObj.workflows : [];
+    const primaryWorkflow = workflowsFromMeta.find((w) => typeof w === "string");
+    const evalName = trim(body.eval) ?? trim(primaryWorkflow) ?? // Legacy fallback: pre-0.14 CLI artifacts had workflow at the top level.
+    trim(result.workflow) ?? "imported";
+    const id = randomUUID();
+    const timestamp = Date.now();
+    const imported = {
+      ...result,
+      id,
+      metadata: typeof result.metadata === "object" && result.metadata != null ? result.metadata : {}
+    };
+    await runtime.saveEvalResult({
+      id,
+      eval: evalName,
+      timestamp,
+      data: imported
+    });
+    return c.json({ ok: true, data: { id, eval: evalName, timestamp } });
+  });
+  function closeActiveRuns() {
+    for (const ac of activeRuns.values()) ac.abort();
+    activeRuns.clear();
+  }
+  return { app: app6, closeActiveRuns };
+}
+
+// src/server/routes/playground.ts
+import { Hono as Hono11 } from "hono";
+function createPlaygroundRoutes(connMgr) {
+  const app6 = new Hono11();
+  app6.post("/playground/chat", async (c) => {
+    const runtime = c.get("runtime");
+    const body = await c.req.json();
+    if (!body.message || typeof body.message !== "string" || !body.message.trim()) {
+      return c.json(
+        {
+          ok: false,
+          error: {
+            code: "INVALID_INPUT",
+            message: "message is required and must be a non-empty string"
+          }
+        },
+        400
+      );
+    }
+    const agents = runtime.getAgents();
+    const agent = body.agent ? agents.find((a) => a._name === body.agent) : agents[0];
+    if (!agent) {
+      return c.json(
+        {
+          ok: false,
+          error: { code: "NO_AGENT", message: `Agent "${body.agent ?? ""}" not found` }
+        },
+        400
+      );
+    }
+    const sessionId = body.sessionId ?? `playground-${Date.now()}`;
+    const executionId = `playground-${sessionId}-${Date.now()}`;
+    const store = runtime.getStateStore();
+    const history = await store.getSession(sessionId);
+    history.push({ role: "user", content: body.message });
+    const redactOn = runtime.isRedactEnabled();
+    const broadcast = (event) => {
+      connMgr.broadcastWithWildcard(`execution:${executionId}`, redactStreamEvent(event, redactOn));
+    };
+    const ctx = runtime.createContext({
+      sessionHistory: history,
+      onToken: (token) => {
+        broadcast({ type: "token", data: token });
+      }
+    });
+    (async () => {
+      try {
+        const result = await ctx.ask(agent, body.message);
+        const resultText = typeof result === "string" ? result : JSON.stringify(result);
+        history.push({ role: "assistant", content: resultText });
+        await store.saveSession(sessionId, history);
+        broadcast({ type: "done", data: resultText });
+      } catch (err) {
+        broadcast({
+          type: "error",
+          message: err instanceof Error ? err.message : String(err)
+        });
+      }
+    })();
+    return c.json({
+      ok: true,
+      data: { sessionId, executionId, streaming: true }
+    });
+  });
+  return app6;
+}
+
+// src/server/routes/eval-trends.ts
+import { Hono as Hono12 } from "hono";
+function createEvalTrendsRoutes(aggregator) {
+  const app6 = new Hono12();
+  app6.get("/eval-trends", (c) => {
+    const window = parseWindowParam(c.req.query("window"));
+    return c.json({ ok: true, data: aggregator.getSnapshot(window) });
+  });
+  return app6;
+}
+
+// src/server/routes/workflow-stats.ts
+import { Hono as Hono13 } from "hono";
+function createWorkflowStatsRoutes(aggregator) {
+  const app6 = new Hono13();
+  app6.get("/workflow-stats", (c) => {
+    const window = parseWindowParam(c.req.query("window"));
+    return c.json({ ok: true, data: enrichWorkflowStats(aggregator.getSnapshot(window)) });
+  });
+  return app6;
+}
+
+// src/server/routes/trace-stats.ts
+import { Hono as Hono14 } from "hono";
+function createTraceStatsRoutes(aggregator) {
+  const app6 = new Hono14();
+  app6.get("/trace-stats", (c) => {
+    const window = parseWindowParam(c.req.query("window"));
+    return c.json({ ok: true, data: aggregator.getSnapshot(window) });
+  });
+  return app6;
+}
+
+// src/server/index.ts
+function createServer(options) {
+  const { runtime, staticRoot, basePath = "", readOnly = false } = options;
+  const app6 = new Hono15();
+  const connMgr = new ConnectionManager();
+  const windows = ["24h", "7d", "30d", "all"];
+  const costAggregator = new TraceAggregator({
+    runtime,
+    connMgr,
+    channel: "costs",
+    reducer: reduceCost,
+    emptyState: emptyCostData,
+    windows
+  });
+  const workflowStatsAggregator = new ExecutionAggregator({
+    runtime,
+    connMgr,
+    channel: "workflow-stats",
+    reducer: reduceWorkflowStats,
+    emptyState: emptyWorkflowStatsData,
+    windows,
+    broadcastTransform: enrichWorkflowStats
+  });
+  const traceStatsAggregator = new TraceAggregator({
+    runtime,
+    connMgr,
+    channel: "trace-stats",
+    reducer: reduceTraceStats,
+    emptyState: emptyTraceStatsData,
+    windows
+  });
+  const evalTrendsAggregator = new EvalAggregator({
+    runtime,
+    connMgr,
+    channel: "eval-trends",
+    reducer: reduceEvalTrends,
+    emptyState: emptyEvalTrendData,
+    windows
+  });
+  if (options.cors !== false) {
+    app6.use("*", cors());
+  }
+  app6.use("*", errorHandler);
+  app6.use("*", async (c, next) => {
+    c.set("runtime", runtime);
+    await next();
+  });
+  if (readOnly) {
+    const blocked = [
+      /^POST \/api\/workflows(\/|$)/,
+      /^POST \/api\/executions(\/|$)/,
+      /^POST \/api\/sessions(\/|$)/,
+      /^DELETE \/api\/sessions(\/|$)/,
+      /^PUT \/api\/memory(\/|$)/,
+      /^DELETE \/api\/memory(\/|$)/,
+      /^POST \/api\/decisions(\/|$)/,
+      /^POST \/api\/tools(\/|$)/,
+      /^POST \/api\/evals\/import$/,
+      /^POST \/api\/evals\/[^/]+\/run$/,
+      /^POST \/api\/evals\/[^/]+\/rescore$/,
+      /^POST \/api\/evals\/runs\/[^/]+\/cancel$/,
+      /^DELETE \/api\/evals\/history\/[^/]+$/,
+      /^POST \/api\/playground(\/|$)/
+    ];
+    app6.use("/api/*", async (c, next) => {
+      const apiIdx = c.req.path.indexOf("/api/");
+      const apiPath = apiIdx >= 0 ? c.req.path.slice(apiIdx) : c.req.path;
+      const key = `${c.req.method} ${apiPath}`;
+      if (blocked.some((re) => re.test(key))) {
+        return c.json(
+          {
+            ok: false,
+            error: { code: "READ_ONLY", message: "Studio is mounted in read-only mode" }
+          },
+          405
+        );
+      }
+      await next();
+    });
+  }
+  const api = new Hono15();
+  api.route("/", createHealthRoutes(readOnly));
+  api.route("/", createWorkflowRoutes(connMgr));
+  api.route("/", executions_default);
+  api.route("/", createSessionRoutes(connMgr));
+  api.route("/", agents_default);
+  api.route("/", tools_default);
+  api.route("/", memory_default);
+  api.route("/", decisions_default);
+  api.route("/", createCostRoutes(costAggregator));
+  api.route("/", createEvalTrendsRoutes(evalTrendsAggregator));
+  api.route("/", createWorkflowStatsRoutes(workflowStatsAggregator));
+  api.route("/", createTraceStatsRoutes(traceStatsAggregator));
+  const { app: evalApp, closeActiveRuns } = createEvalRoutes(connMgr, options.evalLoader);
+  api.route("/", evalApp);
+  api.route("/", createPlaygroundRoutes(connMgr));
+  app6.route("/api", api);
+  const traceListener = (event) => {
+    const traceEvent = event;
+    if (traceEvent.executionId) {
+      connMgr.broadcastWithWildcard(`trace:${traceEvent.executionId}`, traceEvent);
+    }
+    if (traceEvent.type === "await_human") {
+      connMgr.broadcast("decisions", traceEvent);
+    }
+  };
+  runtime.on("trace", traceListener);
+  const aggregatorStartPromise = Promise.all([
+    costAggregator.start(),
+    workflowStatsAggregator.start(),
+    traceStatsAggregator.start(),
+    evalTrendsAggregator.start()
+  ]).catch((err) => console.error("[axl-studio] aggregator start failed:", err));
+  if (staticRoot) {
+    const indexPath = resolve(staticRoot, "index.html");
+    let spaHtml;
+    if (!existsSync(indexPath)) {
+      console.warn(`[axl-studio] index.html not found at ${indexPath}`);
+    } else {
+      const rawHtml = readFileSync(indexPath, "utf-8");
+      if (basePath) {
+        const safeBasePath = JSON.stringify(basePath).replace(/</g, "\\u003c");
+        const injected = rawHtml.replace(
+          "<head>",
+          `<head>
+<base href="${basePath}/">
+<script>window.__AXL_STUDIO_BASE__=${safeBasePath}</script>`
+        );
+        if (injected === rawHtml) {
+          console.warn(
+            "[axl-studio] Could not inject basePath into index.html \u2014 <head> tag not found. The SPA may not route correctly."
+          );
+        }
+        spaHtml = injected;
+      } else {
+        spaHtml = rawHtml;
+      }
+    }
+    const staticHandler = serveStatic({
+      root: staticRoot,
+      rewriteRequestPath: basePath ? (path) => path.startsWith(basePath) ? path.slice(basePath.length) || "/" : path : void 0
+    });
+    app6.use("/*", async (c, next) => {
+      const reqPath = c.req.path;
+      const resolved = basePath && reqPath.startsWith(basePath) ? reqPath.slice(basePath.length) || "/" : reqPath;
+      if (resolved === "/" || resolved === "/index.html" || resolved === "/ws") {
+        return next();
+      }
+      return staticHandler(c, next);
+    });
+    if (spaHtml) {
+      app6.get("*", async (c, next) => {
+        const resolved = basePath && c.req.path.startsWith(basePath) ? c.req.path.slice(basePath.length) || "/" : c.req.path;
+        if (resolved === "/ws") return next();
+        return c.html(spaHtml);
+      });
+    }
+  }
+  return {
+    app: app6,
+    connMgr,
+    costAggregator,
+    workflowStatsAggregator,
+    traceStatsAggregator,
+    evalTrendsAggregator,
+    aggregatorStartPromise,
+    /** Create WS handlers. Call before registering static/SPA routes are reached. */
+    createWsHandlers: () => createWsHandlers(connMgr),
+    traceListener,
+    /** Abort all active streaming eval runs. */
+    closeActiveRuns,
+    /** Close all aggregators (clear intervals and unsubscribe listeners). */
+    closeAggregators: () => {
+      costAggregator.close();
+      workflowStatsAggregator.close();
+      traceStatsAggregator.close();
+      evalTrendsAggregator.close();
+    }
+  };
+}
+
+export {
+  ConnectionManager,
+  handleWsMessage,
+  TraceAggregator,
+  ExecutionAggregator,
+  EvalAggregator,
+  createServer
+};
+//# sourceMappingURL=chunk-IPDMFFTQ.js.map