@ai-setting/roy-agent-core 1.4.12 → 1.4.14

package/dist/env/debug/index.js

@@ -1,2300 +0,0 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __legacyDecorateClassTS = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1;i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// packages/core/src/env/log-trace/span-storage.ts
-var exports_span_storage = {};
-__export(exports_span_storage, {
-  SQLiteSpanStorage: () => SQLiteSpanStorage
-});
-
-class SQLiteSpanStorage {
-  db = null;
-  dbPath;
-  initialized = false;
-  constructor(dbPath) {
-    if (!dbPath) {
-      throw new Error("SQLiteSpanStorage requires a valid dbPath parameter");
-    }
-    if (dbPath === ":memory:") {
-      throw new Error("SQLiteSpanStorage does not support :memory: mode. Use a file path instead.");
-    }
-    this.dbPath = dbPath;
-  }
-  async initialize() {
-    if (this.initialized)
-      return;
-    const { Database } = __require("bun:sqlite");
-    const fs2 = __require("fs");
-    const path2 = __require("path");
-    const dir = path2.dirname(this.dbPath);
-    if (!fs2.existsSync(dir)) {
-      fs2.mkdirSync(dir, { recursive: true });
-    }
-    this.db = new Database(this.dbPath);
-    this.db.run("PRAGMA journal_mode=WAL");
-    this.db.run("PRAGMA busy_timeout=5000");
-    this.db.run("PRAGMA synchronous=NORMAL");
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS span (
-        span_id TEXT PRIMARY KEY,
-        trace_id TEXT NOT NULL,
-        parent_span_id TEXT,
-        name TEXT NOT NULL,
-        kind TEXT NOT NULL,
-        status TEXT NOT NULL,
-        start_time INTEGER NOT NULL,
-        end_time INTEGER,
-        attributes TEXT,
-        result TEXT,
-        error TEXT,
-        time_created INTEGER NOT NULL
-      )
-    `);
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_trace ON span(trace_id)");
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_parent ON span(parent_span_id)");
-    this.initialized = true;
-  }
-  save(span) {
-    if (!this.db)
-      return;
-    const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO span 
-      (span_id, trace_id, parent_span_id, name, kind, status, start_time, end_time, attributes, result, error, time_created)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-    const resultValue = span.result !== undefined && span.result !== null ? typeof span.result === "string" ? span.result : JSON.stringify(span.result) : null;
-    stmt.run(span.spanId, span.traceId, span.parentSpanId || null, span.name, span.kind, span.status, span.startTime, span.endTime || null, JSON.stringify(span.attributes), resultValue, span.error || null, Date.now());
-  }
-  saveBatch(spans) {
-    for (const span of spans) {
-      this.save(span);
-    }
-  }
-  findByTraceId(traceId) {
-    if (!this.db)
-      return [];
-    const rows = this.db.prepare("SELECT * FROM span WHERE trace_id = ?").all(traceId);
-    return this.buildTree(rows.map(this.rowToSpan));
-  }
-  findBySpanId(spanId) {
-    if (!this.db)
-      return;
-    const row = this.db.prepare("SELECT * FROM span WHERE span_id = ?").get(spanId);
-    return row ? this.rowToSpan(row) : undefined;
-  }
-  listTraces(limit = 10) {
-    if (!this.db)
-      return [];
-    const rows = this.db.prepare(`
-      SELECT trace_id, 
-             MIN(start_time) as start_time,
-             MAX(end_time) as end_time,
-             COUNT(*) as span_count
-      FROM span 
-      GROUP BY trace_id 
-      ORDER BY start_time DESC 
-      LIMIT ?
-    `).all(limit);
-    return rows.map((row) => ({
-      traceId: row.trace_id,
-      rootSpanName: "unknown",
-      startTime: row.start_time,
-      endTime: row.end_time,
-      duration: row.end_time - row.start_time,
-      spanCount: row.span_count,
-      status: "ok"
-    }));
-  }
-  deleteByTraceId(traceId) {
-    if (this.db) {
-      this.db.prepare("DELETE FROM span WHERE trace_id = ?").run(traceId);
-    }
-  }
-  close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-  }
-  rowToSpan(row) {
-    return {
-      traceId: row.trace_id,
-      spanId: row.span_id,
-      parentSpanId: row.parent_span_id,
-      name: row.name,
-      kind: row.kind,
-      status: row.status,
-      startTime: row.start_time,
-      endTime: row.end_time,
-      attributes: row.attributes ? JSON.parse(row.attributes) : {},
-      result: row.result || undefined,
-      error: row.error || undefined
-    };
-  }
-  buildTree(spans) {
-    const spanMap = new Map;
-    const roots = [];
-    for (const span of spans) {
-      spanMap.set(span.spanId, { ...span, children: [] });
-    }
-    for (const span of spanMap.values()) {
-      if (span.parentSpanId) {
-        const parent = spanMap.get(span.parentSpanId);
-        if (parent) {
-          parent.children.push(span);
-        } else {
-          roots.push(span);
-        }
-      } else {
-        roots.push(span);
-      }
-    }
-    return roots;
-  }
-}
-
-// packages/core/src/env/log-trace/opentelemetry/propagation.ts
-function padLeft(str, length) {
-  return str.padStart(length, "0");
-}
-function isValidHex(str) {
-  return /^[0-9a-f]+$/i.test(str);
-}
-function serialize(context) {
-  const traceId = padLeft(context.traceId.toLowerCase(), TRACE_ID_LENGTH);
-  const spanId = padLeft(context.spanId.toLowerCase(), PARENT_SPAN_ID_LENGTH);
-  const parts = [
-    TRACE_CONTEXT_VERSION,
-    traceId,
-    spanId,
-    TRACE_FLAGS_SAMPLED
-  ];
-  return parts.join("-");
-}
-function parse(traceparent) {
-  if (!traceparent || typeof traceparent !== "string") {
-    return;
-  }
-  const trimmed = traceparent.trim();
-  const parts = trimmed.split("-");
-  if (parts.length !== 4) {
-    return;
-  }
-  const [version, traceId, senderSpanId, flags] = parts;
-  if (version !== TRACE_CONTEXT_VERSION) {
-    if (version > TRACE_CONTEXT_VERSION) {
-      return;
-    }
-  }
-  if (traceId.length !== TRACE_ID_LENGTH || !isValidHex(traceId)) {
-    return;
-  }
-  if (senderSpanId.length !== PARENT_SPAN_ID_LENGTH || !isValidHex(senderSpanId)) {
-    return;
-  }
-  if (flags.length !== FLAGS_LENGTH || !isValidHex(flags)) {
-    return;
-  }
-  return {
-    traceId: traceId.toLowerCase(),
-    spanId: senderSpanId.toLowerCase()
-  };
-}
-var TRACE_CONTEXT_VERSION = "00", TRACE_FLAGS_SAMPLED = "01", TRACEPARENT_HEADER = "TRACEPARENT", TRACE_ID_LENGTH = 32, PARENT_SPAN_ID_LENGTH = 16, FLAGS_LENGTH = 2, propagation;
-var init_propagation = __esm(() => {
-  propagation = {
-    inject(carrier, context) {
-      carrier[TRACEPARENT_HEADER] = serialize(context);
-    },
-    extract(carrier) {
-      const traceparent = carrier[TRACEPARENT_HEADER];
-      if (!traceparent) {
-        return;
-      }
-      return parse(traceparent);
-    },
-    getTraceparentHeader() {
-      return TRACEPARENT_HEADER;
-    }
-  };
-});
-
-// packages/core/src/env/log-trace/types.ts
-var SpanKind, SpanStatus;
-var init_types = __esm(() => {
-  ((SpanKind2) => {
-    SpanKind2["CLIENT"] = "client";
-    SpanKind2["SERVER"] = "server";
-    SpanKind2["INTERNAL"] = "internal";
-  })(SpanKind ||= {});
-  ((SpanStatus2) => {
-    SpanStatus2["OK"] = "ok";
-    SpanStatus2["ERROR"] = "error";
-  })(SpanStatus ||= {});
-});
-
-// packages/core/src/env/log-trace/opentelemetry/tracer-provider.ts
-var exports_tracer_provider = {};
-__export(exports_tracer_provider, {
-  resetTracerProvider: () => resetTracerProvider,
-  getTracerProvider: () => getTracerProvider,
-  OTelTracerProvider: () => OTelTracerProvider
-});
-
-class OTelSpanImpl {
-  name;
-  kind;
-  spanContext;
-  attributes = {};
-  startTime;
-  endTime;
-  error;
-  storage;
-  parentSpanContext;
-  onEnd;
-  constructor(name, spanContext, storage, parentSpanContext, onEnd) {
-    this.name = name;
-    this.kind = "internal";
-    this.spanContext = spanContext;
-    this.parentSpanContext = parentSpanContext;
-    this.startTime = Date.now();
-    this.storage = storage;
-    this.onEnd = onEnd;
-  }
-  setAttribute(key, value) {
-    this.attributes[key] = value;
-  }
-  addEvent(name, attributes) {
-    const events = this.attributes._events || [];
-    events.push({ name, attributes });
-    this.attributes._events = events;
-  }
-  end(result, error) {
-    this.endTime = Date.now();
-    if (error) {
-      this.error = error.message;
-    }
-    this.storage.save({
-      traceId: this.spanContext.traceId,
-      spanId: this.spanContext.spanId,
-      parentSpanId: this.spanContext.parentSpanId,
-      name: this.name,
-      kind: this.kind,
-      status: error ? "error" /* ERROR */ : "ok" /* OK */,
-      startTime: this.startTime,
-      endTime: this.endTime,
-      attributes: this.attributes,
-      result,
-      error: this.error
-    });
-    this.onEnd?.();
-  }
-}
-
-class OTelTracerImpl {
-  name;
-  version;
-  storage;
-  currentContext;
-  activeSpans = new Map;
-  onSpanEndCallback;
-  provider;
-  constructor(name, version, storage, provider) {
-    this.name = name;
-    this.version = version;
-    this.storage = storage;
-    this.provider = provider;
-  }
-  setOnSpanEndCallback(callback) {
-    this.onSpanEndCallback = callback;
-  }
-  getActiveSpanCount() {
-    return this.activeSpans.size;
-  }
-  startSpan(name, options) {
-    const parentFromOptions = options?.parent;
-    const hasExplicitParent = options && "parent" in options;
-    const globalContext = this.provider.getGlobalContext();
-    let effectiveParentContext;
-    if (hasExplicitParent) {
-      effectiveParentContext = parentFromOptions;
-    } else if (this.currentContext) {
-      effectiveParentContext = this.currentContext;
-    } else if (globalContext) {
-      effectiveParentContext = globalContext;
-    }
-    const traceId = effectiveParentContext?.traceId || this.generateTraceId();
-    const spanId = this.generateSpanId();
-    let parentSpanId;
-    if (hasExplicitParent && parentFromOptions) {
-      parentSpanId = parentFromOptions.parentSpanId || parentFromOptions.spanId;
-    } else if (this.currentContext) {
-      parentSpanId = this.currentContext.spanId;
-    } else if (globalContext) {
-      parentSpanId = globalContext.spanId;
-    }
-    const spanContext = {
-      traceId,
-      spanId,
-      parentSpanId
-    };
-    this.currentContext = {
-      traceId,
-      spanId,
-      parentSpanId
-    };
-    const span = new OTelSpanImpl(name, spanContext, this.storage, effectiveParentContext, () => this.handleSpanEnd(spanContext.spanId, effectiveParentContext?.spanId));
-    if (options?.attributes) {
-      for (const [key, value] of Object.entries(options.attributes)) {
-        span.setAttribute(key, value);
-      }
-    }
-    this.activeSpans.set(spanId, span);
-    return span;
-  }
-  injectToEnv(env) {
-    if (this.currentContext) {
-      propagation.inject(env, this.currentContext);
-    }
-  }
-  getCurrentContext() {
-    return this.currentContext;
-  }
-  setCurrentContext(context) {
-    this.currentContext = context;
-  }
-  endSpan(span) {
-    const spanContext = span.spanContext;
-    this.activeSpans.delete(spanContext.spanId);
-    const currentTraceId = this.currentContext?.traceId;
-    if (spanContext.parentSpanId) {
-      const parentSpan = this.activeSpans.get(spanContext.parentSpanId);
-      if (parentSpan) {
-        const parentContext = {
-          traceId: spanContext.traceId,
-          spanId: parentSpan.spanContext.spanId,
-          parentSpanId: parentSpan.spanContext.parentSpanId
-        };
-        this.currentContext = parentContext;
-        return parentContext;
-      }
-      if (currentTraceId) {
-        const parentContext = {
-          traceId: currentTraceId,
-          spanId: spanContext.parentSpanId,
-          parentSpanId: undefined
-        };
-        this.currentContext = parentContext;
-        return parentContext;
-      }
-    }
-    this.currentContext = undefined;
-    return;
-  }
-  generateTraceId() {
-    const timestamp = Date.now().toString(16).padStart(12, "0");
-    const random = Array.from({ length: 5 }, () => Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0")).join("");
-    return (timestamp + random).slice(0, 32).padStart(32, "0");
-  }
-  generateSpanId() {
-    return Math.floor(Math.random() * 18446744073709552000).toString(16).padStart(16, "0");
-  }
-  handleSpanEnd(spanId, parentSpanId) {
-    this.activeSpans.delete(spanId);
-    const currentTraceId = this.currentContext?.traceId;
-    if (parentSpanId) {
-      const parentSpan = this.activeSpans.get(parentSpanId);
-      if (parentSpan) {
-        this.currentContext = {
-          traceId: parentSpan.spanContext.traceId,
-          spanId: parentSpan.spanContext.spanId,
-          parentSpanId: parentSpan.spanContext.parentSpanId
-        };
-        return;
-      }
-      if (currentTraceId) {
-        this.currentContext = {
-          traceId: currentTraceId,
-          spanId: parentSpanId,
-          parentSpanId: undefined
-        };
-        return;
-      }
-    }
-    this.currentContext = undefined;
-  }
-}
-
-class OTelTracerProvider {
-  tracers = new Map;
-  storage;
-  initialized = false;
-  globalContext;
-  constructor(storage, dbPath) {
-    this.storage = storage || new SQLiteSpanStorage(dbPath || getDefaultDbPath());
-  }
-  async initialize() {
-    if (this.initialized)
-      return;
-    await this.storage.initialize();
-    this.initialized = true;
-  }
-  isInitialized() {
-    return this.initialized;
-  }
-  getGlobalContext() {
-    return this.globalContext;
-  }
-  setGlobalContext(context) {
-    this.globalContext = context;
-  }
-  getTracer(name, version) {
-    const key = `${name}@${version || "0.0.0"}`;
-    let tracer = this.tracers.get(key);
-    if (!tracer) {
-      tracer = new OTelTracerImpl(name, version, this.storage, this);
-      this.tracers.set(key, tracer);
-      if (this.initialized) {
-        this.restoreFromEnv(tracer);
-      }
-    }
-    return tracer;
-  }
-  restoreFromEnv(tracer) {
-    const extracted = propagation.extract(process.env);
-    if (extracted) {
-      tracer.setCurrentContext({
-        traceId: extracted.traceId,
-        spanId: extracted.spanId,
-        parentSpanId: undefined
-      });
-    }
-  }
-  shutdown() {
-    for (const tracer of this.tracers.values()) {}
-    this.tracers.clear();
-    this.storage.close();
-    this.initialized = false;
-    this.globalContext = undefined;
-    delete process.env["TRACEPARENT"];
-    delete process.env["TRACE_ID"];
-    delete process.env["LOG_TRACE_REQUEST_ID"];
-  }
-  getStorage() {
-    return this.storage;
-  }
-}
-function getTracerProvider() {
-  if (!providerInstance) {
-    providerInstance = new OTelTracerProvider;
-  }
-  return providerInstance;
-}
-function resetTracerProvider() {
-  if (providerInstance) {
-    providerInstance.shutdown();
-    providerInstance = null;
-  }
-}
-function getDefaultDbPath() {
-  const os = __require("os");
-  const path2 = __require("path");
-  const home = os.homedir();
-  const dataHome = process.env.XDG_DATA_HOME || path2.join(home, ".local", "share");
-  return path2.join(dataHome, "roy-agent", "traces.db");
-}
-var providerInstance = null;
-var init_tracer_provider = __esm(() => {
-  init_propagation();
-  init_types();
-});
-
-// packages/core/src/env/hook/types.ts
-function createHook(meta, fn) {
-  return {
-    ...meta,
-    execute: fn
-  };
-}
-function createPriorityHook(name, fn, priority) {
-  return createHook({ name, priority }, fn);
-}
-// packages/core/src/env/hook/hook-manager.ts
-class HookManager {
-  _hooks = new Map;
-  componentName;
-  componentVersion;
-  defaultPriority;
-  constructor(options = {}) {
-    this.componentName = options.componentName ?? "unknown";
-    this.componentVersion = options.componentVersion ?? "0.0.0";
-    this.defaultPriority = options.defaultPriority ?? 0;
-  }
-  register(hookPoint, hook) {
-    const hooks = this.getOrCreateHooks(hookPoint);
-    hooks.push(hook);
-  }
-  registerMany(hookPoint, hooks) {
-    const hookList = this.getOrCreateHooks(hookPoint);
-    hookList.push(...hooks);
-  }
-  unregister(hookPoint, name) {
-    const hooks = this._hooks.get(hookPoint);
-    if (!hooks)
-      return false;
-    const index = hooks.findIndex((h) => h.name === name);
-    if (index === -1)
-      return false;
-    hooks.splice(index, 1);
-    return true;
-  }
-  unregisterAll(hookPoint) {
-    this._hooks.delete(hookPoint);
-  }
-  async execute(hookPoint, data, metadata = {}) {
-    const hooks = this._hooks.get(hookPoint);
-    if (!hooks || hooks.length === 0)
-      return;
-    const sortedHooks = this.sortHooks(hooks);
-    const ctx = this.createContext(hookPoint, data, metadata, "before");
-    for (const hook of sortedHooks) {
-      await this.safeExecute(hook, ctx);
-    }
-  }
-  async executeAndCollect(hookPoint, data, metadata = {}) {
-    const hooks = this._hooks.get(hookPoint);
-    if (!hooks || hooks.length === 0)
-      return [];
-    const sortedHooks = this.sortHooks(hooks);
-    const ctx = this.createContext(hookPoint, data, metadata, "before");
-    const results = [];
-    for (const hook of sortedHooks) {
-      const result = await this.safeExecuteAndReturn(hook, ctx);
-      if (result !== undefined) {
-        results.push(result);
-      }
-    }
-    return results;
-  }
-  count(hookPoint) {
-    return this._hooks.get(hookPoint)?.length ?? 0;
-  }
-  clear() {
-    this._hooks.clear();
-  }
-  getHookPoints() {
-    return Array.from(this._hooks.keys());
-  }
-  hasHooks(hookPoint) {
-    return this.count(hookPoint) > 0;
-  }
-  setComponentInfo(name, version) {
-    this.componentName = name;
-    this.componentVersion = version;
-  }
-  get hooks() {
-    return this._hooks;
-  }
-  async executeWithIntervention(hookPoint, data, metadata = {}) {
-    const hooks = this._hooks.get(hookPoint);
-    if (!hooks || hooks.length === 0) {
-      return { stopped: false, results: [] };
-    }
-    const sortedHooks = this.sortHooks(hooks);
-    const ctx = this.createContext(hookPoint, data, metadata, "before");
-    const results = [];
-    let stopped = false;
-    let action;
-    for (const hook of sortedHooks) {
-      if (stopped)
-        break;
-      const result = await this.safeExecuteAndReturn(hook, ctx);
-      results.push(result);
-      if (result && typeof result === "object" && "stopped" in result) {
-        const hookResult = result;
-        if (hookResult.stopped) {
-          stopped = true;
-          action = hookResult.action;
-        }
-      }
-    }
-    return { stopped, action, results };
-  }
-  getOrCreateHooks(hookPoint) {
-    let hooks = this._hooks.get(hookPoint);
-    if (!hooks) {
-      hooks = [];
-      this._hooks.set(hookPoint, hooks);
-    }
-    return hooks;
-  }
-  sortHooks(hooks) {
-    return [...hooks].sort((a, b) => {
-      const priorityA = a.priority ?? this.defaultPriority;
-      const priorityB = b.priority ?? this.defaultPriority;
-      return priorityA - priorityB;
-    });
-  }
-  createContext(hookPoint, data, metadata, phase) {
-    return {
-      component: {
-        name: this.componentName,
-        version: this.componentVersion
-      },
-      data,
-      metadata,
-      phase,
-      hookPoint
-    };
-  }
-  async safeExecute(hook, ctx) {
-    try {
-      await hook.execute(ctx);
-    } catch (error) {
-      console.error(`Hook "${hook.name}" failed:`, error);
-    }
-  }
-  async safeExecuteAndReturn(hook, ctx) {
-    try {
-      return await hook.execute(ctx);
-    } catch (error) {
-      console.error(`Hook "${hook.name}" failed:`, error);
-      return;
-    }
-  }
-}
-// packages/core/src/env/hook/global-hook-manager.ts
-var globalHookManager = new HookManager;
-var AgentHookPoints = {
-  BEFORE_START: "agent:before.start",
-  BEFORE_LLM: "agent:before.llm",
-  AFTER_LLM: "agent:after.llm",
-  BEFORE_TOOL: "agent:before.tool",
-  AFTER_TOOL: "agent:after.tool",
-  ON_ITERATION: "agent:on.iteration",
-  ON_THRESHOLD: "agent:on.threshold",
-  AFTER_COMPLETE: "agent:after.complete",
-  ON_ERROR: "agent:on.error"
-};
-var LLMHookPoints = {
-  BEFORE_INVOKE: "llm:before.invoke",
-  AFTER_INVOKE: "llm:after.invoke",
-  ON_STREAM: "llm:on.stream"
-};
-var ToolHookPoints = {
-  BEFORE_EXECUTE: "tool:before.execute",
-  AFTER_EXECUTE: "tool:after.execute",
-  BEFORE_REGISTER: "tool:before.register",
-  AFTER_REGISTER: "tool:after.register",
-  ON_ERROR: "tool:on.error"
-};
-var hookPointAliases = {
-  "before.tool": "tool:before.execute",
-  "after.tool": "tool:after.execute",
-  "llm.before-invoke": "llm:before.invoke",
-  "llm.after-invoke": "llm:after.invoke",
-  "llm.stream": "llm:on.stream"
-};
-function setupAliasHooks() {
-  const originalRegister = globalHookManager.register.bind(globalHookManager);
-  globalHookManager.register = function(hookPoint, hook) {
-    originalRegister(hookPoint, hook);
-    const alias = hookPointAliases[hookPoint];
-    if (alias) {
-      originalRegister(alias, hook);
-    }
-  };
-}
-setupAliasHooks();
-async function executeAgentHook(hookPoint, data, metadata = {}) {
-  await globalHookManager.execute(hookPoint, data, metadata);
-}
-async function executeAgentHookWithIntervention(hookPoint, data, metadata = {}) {
-  return globalHookManager.executeWithIntervention(hookPoint, data, metadata);
-}
-async function executeLLMHook(hookPoint, data, metadata = {}) {
-  await globalHookManager.execute(hookPoint, data, metadata);
-}
-async function executeToolHook(hookPoint, data, metadata = {}) {
-  await globalHookManager.execute(hookPoint, data, metadata);
-}
-// packages/core/src/env/debug/formatters/trace-formatter.ts
-class TraceFormatter {
-  formatEntry(entry, options = {}) {
-    const { pretty = false } = options;
-    const actionSymbol = entry.action === "enter" ? ">>>" : entry.action === "error" ? "!!!" : "<<<";
-    let output = `${actionSymbol} ${entry.function} ${entry.action}`;
-    if (entry.action === "enter" && entry.params) {
-      output += `
-` + this.formatData(entry.params, options);
-    } else if (entry.action === "quit") {
-      if (entry.durationMs !== undefined) {
-        output += ` (${entry.durationMs}ms)`;
-      }
-      if (entry.result) {
-        output += `
-` + this.formatData(entry.result, options);
-      }
-    } else if (entry.action === "error" && entry.error) {
-      output += `: ${entry.error}`;
-    }
-    if (pretty) {
-      output = this.indentMultilineContent(output);
-    }
-    return output;
-  }
-  indentMultilineContent(text, indent = "  ") {
-    const lines = text.split(`
-`);
-    if (lines.length <= 1)
-      return text;
-    return lines.map((line, i) => i === 0 ? line : `${indent}${line}`).join(`
-`);
-  }
-  formatEntries(entries, options = {}) {
-    if (entries.length === 0) {
-      return "No trace entries";
-    }
-    const formatted = entries.map((entry) => this.formatEntry(entry, options));
-    if (options.pretty) {
-      return formatted.join(`
-` + "-".repeat(80) + `
-`);
-    }
-    return formatted.join(`
-`);
-  }
-  formatData(data, options = {}) {
-    const { pretty = false, maxDepth = 10 } = options;
-    if (pretty) {
-      return this.formatPretty(data, 0, maxDepth);
-    }
-    return JSON.stringify(data);
-  }
-  formatPretty(data, indent = 0, maxDepth) {
-    const baseIndent = "  ".repeat(indent);
-    const nextIndent = "  ".repeat(indent + 1);
-    if (data === null || data === undefined) {
-      return String(data);
-    }
-    if (typeof data === "string") {
-      if (data.includes(`
-`)) {
-        return data.split(`
-`).map((line, i) => i === 0 ? line : `${nextIndent}${line}`).join(`
-`);
-      }
-      return data;
-    }
-    if (typeof data === "number" || typeof data === "boolean") {
-      return String(data);
-    }
-    if (Array.isArray(data)) {
-      if (data.length === 0)
-        return "[]";
-      const items = data.map((item) => {
-        const formatted = this.formatPretty(item, indent + 1, maxDepth);
-        return formatted.split(`
-`).map((line) => `  ${line}`).join(`
-`);
-      });
-      return `[
-` + items.join(`,
-`) + `
-` + baseIndent + "]";
-    }
-    if (typeof data === "object") {
-      const obj = data;
-      const keys = Object.keys(obj);
-      if (keys.length === 0)
-        return "{}";
-      if (indent >= maxDepth) {
-        return "{...}";
-      }
-      const entries = keys.map((key) => {
-        const value = obj[key];
-        let formatted;
-        if (typeof value === "object" && value !== null) {
-          formatted = this.formatPretty(value, indent + 1, maxDepth);
-        } else if (typeof value === "string" && value.includes(`
-`)) {
-          formatted = value.split(`
-`).map((line, i) => i === 0 ? line : `${nextIndent}${line}`).join(`
-`);
-        } else {
-          formatted = JSON.stringify(value);
-        }
-        return `  ${key}: ` + formatted.split(`
-`).map((line, i) => i === 0 ? line : nextIndent + line).join(`
-`);
-      });
-      return `{
-` + entries.join(`,
-`) + `
-` + baseIndent + "}";
-    }
-    return JSON.stringify(data);
-  }
-  toJSON(entries) {
-    return JSON.stringify(entries, null, 2);
-  }
-  toSummary(entries) {
-    if (entries.length === 0) {
-      return "No trace entries";
-    }
-    const functions = new Set(entries.map((e) => e.function));
-    const actions = entries.reduce((acc, e) => {
-      acc[e.action] = (acc[e.action] || 0) + 1;
-      return acc;
-    }, {});
-    let summary = `Trace Summary (${entries.length} entries)
-`;
-    summary += `Functions: ${[...functions].join(", ")}
-`;
-    summary += `Actions: ${Object.entries(actions).map(([k, v]) => `${k}=${v}`).join(", ")}`;
-    return summary;
-  }
-}
-// packages/core/src/env/debug/formatters/tree-formatter.ts
-var Colors = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  cyan: "\x1B[36m",
-  white: "\x1B[37m"
-};
-function color(text, colorCode) {
-  return `${colorCode}${text}${Colors.reset}`;
-}
-var CHARS = {
-  VERTICAL: "\u2502",
-  VERTICAL_CONNECTOR: "\u251C\u2500\u2500",
-  LAST_CONNECTOR: "\u2514\u2500\u2500",
-  SPACE: " ",
-  BAR: "\u2588",
-  EMPTY: "\u2591",
-  DASH: "\u2500"
-};
-
-class TreeFormatter {
-  options;
-  constructor(options = {}) {
-    this.options = {
-      showPercent: true,
-      showTimeBar: false,
-      barWidth: 10,
-      ...options
-    };
-  }
-  colorByPercent(percent) {
-    if (percent >= 80)
-      return Colors.red;
-    if (percent >= 50)
-      return Colors.yellow;
-    if (percent >= 20)
-      return Colors.cyan;
-    return Colors.dim;
-  }
-  formatTree(node) {
-    const lines = [];
-    const totalDuration = node.durationMs || 0;
-    const percentBase = node.children.reduce((sum, c) => sum + (c.durationMs || 0), 0) || totalDuration;
-    lines.push(this.formatNode(node, totalDuration, percentBase, "", true, true));
-    this.formatChildren(node.children, "", lines, totalDuration, percentBase);
-    return lines.join(`
-`);
-  }
-  formatNode(node, totalDuration, percentBase, prefix, isLast, isRoot) {
-    const connector = isRoot ? "" : isLast ? CHARS.LAST_CONNECTOR : CHARS.VERTICAL_CONNECTOR;
-    const prefixStr = isRoot ? "" : prefix;
-    let line = `${prefixStr}${connector} ${node.function}`;
-    if (node.durationMs !== undefined) {
-      line += color(` (${this.formatDuration(node.durationMs)})`, Colors.dim);
-    }
-    if (this.options.showPercent && percentBase > 0 && node.durationMs !== undefined && node.function !== "(root)" && !isRoot) {
-      const percent = Math.round(node.durationMs / percentBase * 100);
-      const percentStr = ` [${percent}%]`;
-      line += color(percentStr, this.colorByPercent(percent));
-    }
-    if (this.options.showTimeBar && node.durationMs !== undefined && totalDuration > 0 && !isRoot) {
-      line += " " + this.renderTimeBar(node.durationMs, totalDuration);
-    }
-    return isRoot ? color(line, Colors.bold) : line;
-  }
-  formatChildren(children, prefix, lines, totalDuration, percentBase) {
-    children.forEach((child, index) => {
-      const isLast = index === children.length - 1;
-      const newPrefix = prefix + (isLast ? "    " : `${CHARS.VERTICAL}   `);
-      lines.push(this.formatNode(child, totalDuration, percentBase, prefix, isLast, false));
-      if (child.children.length > 0) {
-        this.formatChildren(child.children, newPrefix, lines, totalDuration, percentBase);
-      }
-    });
-  }
-  renderTimeBar(duration, total) {
-    const width = this.options.barWidth || 10;
-    const filledWidth = Math.round(duration / total * width);
-    const emptyWidth = width - filledWidth;
-    const bar = CHARS.BAR.repeat(filledWidth) + CHARS.EMPTY.repeat(emptyWidth);
-    return color(`[${bar}]`, Colors.dim);
-  }
-  formatDuration(ms) {
-    if (ms < 1000) {
-      return `${ms}ms`;
-    } else if (ms < 60000) {
-      return `${(ms / 1000).toFixed(2)}s`;
-    } else if (ms < 3600000) {
-      const mins = Math.floor(ms / 60000);
-      const secs = Math.round(ms % 60000 / 1000);
-      return `${mins}m ${secs}s`;
-    } else {
-      const hours = Math.floor(ms / 3600000);
-      const mins = Math.floor(ms % 3600000 / 60000);
-      return `${hours}h ${mins}m`;
-    }
-  }
-  formatTrees(trees) {
-    if (trees.length === 0) {
-      return "No trace trees";
-    }
-    return trees.map((tree) => this.formatTree(tree)).join(`
-
-`);
-  }
-  toJSON(trees) {
-    return JSON.stringify(trees, null, 2);
-  }
-  formatSummary(node) {
-    const rows = [];
-    const total = node.durationMs || 0;
-    const childrenTotal = node.children.reduce((sum, c) => sum + (c.durationMs || 0), 0);
-    const percentBase = total > 0 ? total : childrenTotal;
-    const collect = (n, depth) => {
-      if (n.durationMs !== undefined) {
-        rows.push({
-          func: n.function,
-          duration: n.durationMs,
-          percent: percentBase > 0 ? Math.round(n.durationMs / percentBase * 100) : 0,
-          depth
-        });
-      }
-      n.children.forEach((child) => collect(child, depth + 1));
-    };
-    collect(node, 0);
-    rows.sort((a, b) => b.duration - a.duration);
-    const lines = [];
-    lines.push(color(`
-=== Duration Summary ===`, Colors.bold));
-    lines.push(color(`(sorted by time consumption)
-`, Colors.dim));
-    lines.push(color(`  ${"\u2500".repeat(65)}`, Colors.dim));
-    lines.push(color(`  ${"FUNCTION".padEnd(35)} ${"TIME".padEnd(12)} %`, Colors.dim));
-    lines.push(color(`  ${"\u2500".repeat(65)}`, Colors.dim));
-    for (const row of rows) {
-      const indent = "  ".repeat(row.depth);
-      const funcDisplay = row.depth > 0 ? "\u2514\u2500 ".repeat(row.depth) + row.func : row.func;
-      const percentStr = String(row.percent).padStart(3) + "%";
-      const percentColor = row.percent >= 50 ? Colors.red : row.percent >= 20 ? Colors.yellow : Colors.dim;
-      lines.push(`  ${indent}${funcDisplay.substring(0, 35).padEnd(35)}${this.formatDuration(row.duration).padEnd(12)} ${color(percentStr, percentColor)}`);
-    }
-    return lines.join(`
-`);
-  }
-  formatTimeline(node) {
-    const lines = [];
-    const totalDuration = node.durationMs || 0;
-    lines.push(color(`
-=== Timeline: ${node.function} ===`, Colors.bold));
-    lines.push(color(`Total: ${this.formatDuration(totalDuration)}
-`, Colors.dim));
-    const timeline = this.buildTimeline(node, totalDuration, 0, 0);
-    lines.push(...timeline);
-    return lines.join(`
-`);
-  }
-  buildTimeline(node, totalDuration, absoluteOffset, depth) {
-    const lines = [];
-    const width = 40;
-    const startPos = Math.round(absoluteOffset / totalDuration * width);
-    const durationWidth = node.durationMs !== undefined ? Math.max(2, Math.round(node.durationMs / totalDuration * width)) : 2;
-    const bar = " ".repeat(Math.max(0, startPos)) + CHARS.BAR.repeat(durationWidth);
-    const indent = "  ".repeat(depth);
-    const funcName = node.function.length > 25 ? "..." + node.function.slice(-22) : node.function;
-    const time = node.durationMs !== undefined ? this.formatDuration(node.durationMs) : "-";
-    const percent = node.durationMs !== undefined ? ` [${Math.round(node.durationMs / totalDuration * 100)}%]` : "";
-    lines.push(`${indent}${funcName.padEnd(25)} ${bar} ${color(time + percent, Colors.dim)}`);
-    let childOffset = absoluteOffset;
-    for (const child of node.children) {
-      lines.push(...this.buildTimeline(child, totalDuration, childOffset, depth + 1));
-      childOffset += child.durationMs || 0;
-    }
-    return lines;
-  }
-}
-// packages/core/src/env/debug/formatters/repl-formatter.ts
-class ReplFormatter {
-  context = {};
-  history = [];
-  getWelcomeMessage() {
-    return `========================================
-  Debug REPL - Interactive Debugger
-========================================
-
-Commands:
-  list [limit]     - List trace IDs
-  trace [options]  - Show trace details
-  tree [options]   - Show call tree
-  help             - Show this help
-  exit             - Exit REPL
-
-Examples:
-  list 10
-  trace --func llm.invoke
-  tree --trace trace-001
-
-========================================
-`;
-  }
-  formatPrompt(context) {
-    const ctx = { ...this.context, ...context };
-    let prompt = "debug";
-    if (ctx.traceId) {
-      prompt += `:${ctx.traceId}`;
-    } else if (ctx.function) {
-      prompt += `:${ctx.function}`;
-    }
-    return `${prompt}> `;
-  }
-  getHelpText() {
-    return `
-Available Commands:
-==================
-list [n]              - List recent trace IDs (default: 10)
-trace [options]       - Show trace details
-  --func <name>       - Filter by function name
-  --trace <id>        - Show specific trace
-  --pretty            - Pretty print output
-  --limit <n>         - Limit results
-tree [options]        - Show call tree
-  --func <name>       - Show tree for function
-  --trace <id>        - Show tree for trace
-clear                 - Clear screen
-help                  - Show this help
-exit                  - Exit REPL
-`;
-  }
-  formatCommandResult(command, data) {
-    switch (command) {
-      case "list":
-        return this.formatListResult(data);
-      case "trace":
-        return this.formatTraceResult(data);
-      case "tree":
-        return this.formatTreeResult(data);
-      default:
-        return `Unknown command: ${command}`;
-    }
-  }
-  formatListResult(data) {
-    const { traceIds, count } = data;
-    if (traceIds.length === 0) {
-      return "No traces found.";
-    }
-    let output = `
-`;
-    output += `  TraceId            First Time              Count
-`;
-    output += "  " + "-".repeat(70) + `
-`;
-    for (const trace of traceIds) {
-      const time = trace.firstTime.replace("T", " ").substring(0, 19);
-      output += `  ${trace.traceId.padEnd(18)} ${time.padEnd(22)} ${trace.count}
-`;
-    }
-    output += `
-  Total: ${count} traces
-`;
-    return output;
-  }
-  formatTraceResult(entries) {
-    if (entries.length === 0) {
-      return "No traces found.";
-    }
-    let output = "";
-    let currentTraceId = null;
-    for (const entry of entries) {
-      if (entry.traceId !== currentTraceId) {
-        currentTraceId = entry.traceId;
-        output += `
-=== Trace: ${entry.traceId} ===
-
-`;
-      }
-      if (entry.action === "enter") {
-        output += `>>> ${entry.function} enter:`;
-        if (entry.params) {
-          output += `
-` + this.formatJsonCompact(entry.params);
-        }
-        output += `
-`;
-      } else if (entry.action === "quit") {
-        output += `<<< ${entry.function} quit`;
-        if (entry.durationMs !== undefined) {
-          output += ` (${entry.durationMs}ms)`;
-        }
-        if (entry.result) {
-          output += `:
-` + this.formatJsonCompact(entry.result);
-        }
-        output += `
-`;
-      } else if (entry.action === "error") {
-        output += `!!! ${entry.function} error: ${entry.error}
-`;
-      }
-    }
-    return output;
-  }
-  formatTreeResult(trees) {
-    if (trees.length === 0) {
-      return "No trees found.";
-    }
-    let output = "";
-    for (const tree of trees) {
-      output += this.formatTreeNode(tree, "");
-    }
-    return output;
-  }
-  formatTreeNode(node, prefix) {
-    const duration = node.durationMs !== undefined ? ` (${node.durationMs}ms)` : "";
-    let output = `${prefix}${node.function}${duration}
-`;
-    const childPrefix = prefix + "  ";
-    for (let i = 0;i < node.children.length; i++) {
-      const isLast = i === node.children.length - 1;
-      const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-      output += this.formatTreeNode(node.children[i], childPrefix + connector);
-    }
-    return output;
-  }
-  formatJsonCompact(data, indent = 2) {
-    const spaces = "  ".repeat(indent);
-    if (data === null || data === undefined) {
-      return `${spaces}null
-`;
-    }
-    if (typeof data === "string") {
-      if (data.length > 200) {
-        return `${spaces}"${data.substring(0, 200)}..."
-`;
-      }
-      return `${spaces}"${data}"
-`;
-    }
-    if (typeof data === "number" || typeof data === "boolean") {
-      return `${spaces}${data}
-`;
-    }
-    if (Array.isArray(data)) {
-      if (data.length === 0)
-        return `${spaces}[]
-`;
-      let output = `${spaces}[
-`;
-      for (const item of data) {
-        output += this.formatJsonCompact(item, indent + 1);
-      }
-      output += `${spaces}]
-`;
-      return output;
-    }
-    if (typeof data === "object") {
-      const entries = Object.entries(data);
-      if (entries.length === 0)
-        return `${spaces}{}
-`;
-      let output = `${spaces}{
-`;
-      for (const [key, val] of entries) {
-        output += `${spaces}  ${key}: ${JSON.stringify(val).substring(0, 50)}`;
-        if (JSON.stringify(val).length > 50) {
-          output += "...";
-        }
-        output += `
-`;
-      }
-      output += `${spaces}}
-`;
-      return output;
-    }
-    return `${spaces}${String(data)}
-`;
-  }
-  parseCommand(input) {
-    const trimmed = input.trim();
-    if (!trimmed) {
-      return { command: "help", args: {} };
-    }
-    if (["exit", "quit", "q"].includes(trimmed.toLowerCase())) {
-      return { command: "exit", args: {} };
-    }
-    if (trimmed.toLowerCase() === "clear") {
-      return { command: "clear", args: {} };
-    }
-    if (["help", "?", "h"].includes(trimmed.toLowerCase())) {
-      return { command: "help", args: {} };
-    }
-    const parts = trimmed.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
-    if (parts.length === 0) {
-      return { command: "help", args: {} };
-    }
-    const command = parts[0]?.toLowerCase() ?? "";
-    const args = {};
-    for (let i = 1;i < parts.length; i++) {
-      const part = parts[i];
-      if (part.startsWith("--")) {
-        const key = part.substring(2);
-        const next = parts[i + 1];
-        if (next && !next.startsWith("--")) {
-          args[key] = next;
-          i++;
-        } else {
-          args[key] = "true";
-        }
-      } else if (part.startsWith("-")) {
-        const key = part.substring(1);
-        const next = parts[i + 1];
-        if (next && !next.startsWith("-")) {
-          args[key] = next;
-          i++;
-        } else {
-          args[key] = "true";
-        }
-      } else {
-        if (command === "list" && !args.limit) {
-          args.limit = part;
-        } else if (command === "trace" && !args.func) {
-          args.func = part;
-        } else if (command === "tree" && !args.func) {
-          args.func = part;
-        }
-      }
-    }
-    return { command, args };
-  }
-  setContext(context) {
-    this.context = { ...this.context, ...context };
-  }
-  getContext() {
-    return { ...this.context };
-  }
-  addToHistory(command) {
-    if (command.trim() && this.history[this.history.length - 1] !== command) {
-      this.history.push(command);
-    }
-  }
-  getHistory() {
-    return [...this.history];
-  }
-}
-// packages/core/src/env/component.ts
-class BaseComponent {
-  _status = "created";
-  _enabled = true;
-  env;
-  hookManager;
-  constructor() {
-    this.hookManager = new HookManager;
-  }
-  getStatus() {
-    return this._status;
-  }
-  getConfig() {
-    return {
-      name: this.name,
-      version: this.version,
-      enabled: this._enabled,
-      env: this.env
-    };
-  }
-  isEnvInitialized() {
-    return this._status !== "created";
-  }
-  setStatus(status) {
-    this._status = status;
-  }
-  getEnv() {
-    return this.env;
-  }
-  async init(config) {
-    if (config?.env) {
-      this.env = config.env;
-    }
-    this.setStatus("initializing");
-    try {
-      if (config?.name)
-        Object.defineProperty(this, "name", { value: config.name, writable: false });
-      if (config?.version)
-        Object.defineProperty(this, "version", { value: config.version, writable: false });
-    } catch {}
-    if (config?.enabled !== undefined)
-      this._enabled = config.enabled;
-    this.hookManager.setComponentInfo(this.name, this.version);
-    await this.onInit();
-    this.setStatus("running");
-  }
-  async start() {
-    if (this._started)
-      return;
-    this._started = true;
-    await this.onStart();
-    this.setStatus("running");
-  }
-  async stop() {
-    this.setStatus("stopping");
-    this.hookManager.clear();
-    await this.onStop();
-    this.setStatus("stopped");
-  }
-  async onInit() {}
-  async onStart() {}
-  async onStop() {}
-  registerHook(hookPoint, hook) {
-    this.hookManager.register(hookPoint, hook);
-  }
-  addHook(hookPoint, name, fn, priority) {
-    this.hookManager.register(hookPoint, createHook({ name, priority }, fn));
-  }
-  removeHook(hookPoint, name) {
-    return this.hookManager.unregister(hookPoint, name);
-  }
-  async executeHooks(hookPoint, data, metadata) {
-    await this.hookManager.execute(hookPoint, data, metadata);
-  }
-  getConfigComponent() {
-    return this.env?.getComponent("config");
-  }
-  getRuntimeConfig(key, defaultValue) {
-    const configComponent = this.getConfigComponent();
-    if (configComponent) {
-      const value = configComponent.get(key);
-      if (value !== undefined) {
-        return value;
-      }
-    }
-    return defaultValue;
-  }
-}
-
-// packages/core/src/env/debug/reader/log-reader.ts
-import * as fs from "fs";
-import * as readline from "readline";
-import * as path from "path";
-import { glob } from "glob";
-function getXDGDataHome() {
-  return process.env.XDG_DATA_HOME || path.join(process.env.HOME || "/home/" + (process.env.USER || "user"), ".local", "share");
-}
-
-class LogReader {
-  logDir;
-  constructor(options) {
-    this.logDir = options?.logDir || path.join(getXDGDataHome(), "roy-agent", "logs");
-  }
-  getLogPath(filename) {
-    if (!filename) {
-      return path.join(this.logDir, "app.log");
-    }
-    if (path.isAbsolute(filename)) {
-      return filename;
-    }
-    return path.join(this.logDir, filename);
-  }
-  async findLogFiles(pattern = "*.log") {
-    try {
-      const normalizedDir = this.logDir.replace(/\\/g, "/");
-      const fullPattern = `${normalizedDir}/${pattern}`;
-      const files = await glob(fullPattern);
-      return files.sort();
-    } catch {
-      return [];
-    }
-  }
-  getDefaultLogDir() {
-    return this.logDir;
-  }
-  async* readLines(filepath, options) {
-    const sinceTime = options?.since ? this.parseTime(options.since) : null;
-    const untilTime = options?.until ? this.parseTime(options.until) : null;
-    if (!fs.existsSync(filepath)) {
-      return;
-    }
-    const fileStream = fs.createReadStream(filepath, { encoding: "utf-8" });
-    const rl = readline.createInterface({
-      input: fileStream,
-      crlfDelay: Infinity
-    });
-    try {
-      for await (const line of rl) {
-        if (!line.trim())
-          continue;
-        if (sinceTime || untilTime) {
-          const lineTime = this.extractTimestamp(line);
-          if (lineTime) {
-            if (sinceTime && lineTime < sinceTime)
-              continue;
-            if (untilTime && lineTime > untilTime)
-              continue;
-          }
-        }
-        yield line;
-      }
-    } finally {
-      rl.close();
-      fileStream.destroy();
-    }
-  }
-  extractTimestamp(line) {
-    const match = line.match(/^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}:\d{2})/);
-    if (!match)
-      return null;
-    const datePart = match[1];
-    const timePart = match[2];
-    const isoString = `${datePart}T${timePart}`;
-    const timestamp = new Date(isoString).getTime();
-    return isNaN(timestamp) ? null : timestamp;
-  }
-  parseTime(timeStr) {
-    const now = Date.now();
-    const normalizedStr = timeStr.replace("T", " ");
-    const absoluteTime = new Date(normalizedStr).getTime();
-    if (!isNaN(absoluteTime) && absoluteTime > 0) {
-      return absoluteTime;
-    }
-    const originalTime = new Date(timeStr).getTime();
-    if (!isNaN(originalTime) && originalTime > 0) {
-      return originalTime;
-    }
-    const relativeMatch = timeStr.match(/^(\d+)([hms])$/);
-    if (relativeMatch) {
-      const value = parseInt(relativeMatch[1], 10);
-      const unit = relativeMatch[2];
-      switch (unit) {
-        case "h":
-          return now - value * 60 * 60 * 1000;
-        case "m":
-          return now - value * 60 * 1000;
-        case "s":
-          return now - value * 1000;
-      }
-    }
-    return now;
-  }
-  async readFile(filepath) {
-    return fs.promises.readFile(filepath, "utf-8");
-  }
-  exists(filepath) {
-    return fs.existsSync(filepath);
-  }
-}
-
-// packages/core/src/env/debug/reader/span-db-reader.ts
-class SpanDbReader {
-  storage = null;
-  dbPath = null;
-  sqliteDb = null;
-  constructor(options) {
-    if (options?.storage) {
-      this.storage = options.storage;
-    } else if (options?.dbPath) {
-      this.dbPath = options.dbPath;
-    }
-  }
-  async initialize() {
-    if (this.storage) {
-      await this.storage.initialize();
-    } else if (this.dbPath) {
-      await this.initSqliteStorage();
-    }
-  }
-  async initSqliteStorage() {
-    try {
-      const { SQLiteSpanStorage: SQLiteSpanStorage2 } = await Promise.resolve().then(() => exports_span_storage);
-      this.storage = new SQLiteSpanStorage2(this.dbPath);
-      await this.storage.initialize();
-    } catch (error) {
-      throw new Error(`Failed to initialize SQLite storage: ${error}`);
-    }
-  }
-  async getTraceEntries(traceId) {
-    if (!this.storage) {
-      throw new Error("Storage not initialized. Call initialize() first.");
-    }
-    const spans = this.storage.findByTraceId(traceId);
-    if (spans.length === 0) {
-      return [];
-    }
-    return this.spansToEntries(spans);
-  }
-  async listTraceIds(limit = 20) {
-    if (!this.storage) {
-      throw new Error("Storage not initialized. Call initialize() first.");
-    }
-    const traceInfos = this.storage.listTraces(limit);
-    const traceIds = traceInfos.map((info) => ({
-      traceId: info.traceId,
-      firstTime: new Date(info.startTime).toISOString(),
-      lastTime: info.endTime ? new Date(info.endTime).toISOString() : undefined,
-      count: info.spanCount
-    }));
-    return {
-      traceIds,
-      count: traceInfos.length
-    };
-  }
-  spansToEntries(spans) {
-    const entries = [];
-    for (const span of spans) {
-      entries.push({
-        traceId: span.traceId,
-        timestamp: new Date(span.startTime).toISOString(),
-        function: span.name,
-        action: "enter",
-        params: this.attributesToParams(span.attributes),
-        spanId: span.spanId,
-        parentSpanId: span.parentSpanId
-      });
-      if (span.endTime) {
-        entries.push({
-          traceId: span.traceId,
-          timestamp: new Date(span.endTime).toISOString(),
-          function: span.name,
-          action: "quit",
-          result: span.result,
-          error: span.error,
-          durationMs: span.endTime - span.startTime,
-          spanId: span.spanId,
-          parentSpanId: span.parentSpanId
-        });
-      }
-    }
-    entries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-    return entries;
-  }
-  attributesToParams(attributes) {
-    if (!attributes)
-      return [];
-    return Object.entries(attributes).map(([key, value]) => ({
-      key,
-      value
-    }));
-  }
-  getStorage() {
-    return this.storage;
-  }
-  close() {
-    if (this.storage) {
-      this.storage.close();
-      this.storage = null;
-    }
-    if (this.sqliteDb) {
-      this.sqliteDb.close();
-      this.sqliteDb = null;
-    }
-  }
-}
-
-// packages/core/src/env/debug/parser/regex-parser.ts
-var TRACE_LINE_REGEX = /^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\.\d{3})\s+\[(\w+)\]\s+\[([^\]]*)\]\[([^\]]*)\]\s+\[TRACE\]\s+(>>>|<<<|!!!)\s+(.+?)(?:\s+\[requestId=([^\]]+)\])?\s+(enter|quit|error):\s+(.*)$/;
-var REQUEST_ID_IN_CATEGORY_REGEX = /\[requestId=([^\]]+)\]/;
-
-class RegexParser {
-  parseLogLine(line) {
-    const trimmedLine = line.trim();
-    if (!trimmedLine) {
-      return null;
-    }
-    const match = trimmedLine.match(TRACE_LINE_REGEX);
-    if (!match) {
-      return null;
-    }
-    const [, timestamp, level, source, category, action, method, requestId, actionType, rawArgs] = match;
-    return {
-      raw: trimmedLine,
-      timestamp: timestamp.replace(" ", "T"),
-      level,
-      source,
-      category,
-      action,
-      method,
-      actionType,
-      rawArgs,
-      requestId: requestId || null
-    };
-  }
-  parseArgs(raw) {
-    if (!raw || !raw.trim()) {
-      return null;
-    }
-    const trimmed = raw.trim();
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (Array.isArray(parsed)) {
-        return parsed;
-      }
-      return parsed;
-    } catch {
-      return trimmed;
-    }
-  }
-  isTraceLine(line) {
-    return line.includes("[TRACE]") && (line.includes(">>>") || line.includes("<<<") || line.includes("!!!"));
-  }
-  filterByLevel(lines, level) {
-    if (!level) {
-      return lines;
-    }
-    const levelPattern = `[${level.toUpperCase()}]`;
-    return lines.filter((line) => {
-      if (!this.isTraceLine(line)) {
-        return false;
-      }
-      return line.includes(levelPattern);
-    });
-  }
-  filterByFunction(lines, functionName) {
-    if (!functionName) {
-      return lines;
-    }
-    return lines.filter((line) => {
-      return line.includes(functionName);
-    });
-  }
-  extractTraceId(line) {
-    const categoryMatch = line.match(REQUEST_ID_IN_CATEGORY_REGEX);
-    if (categoryMatch) {
-      return categoryMatch[1];
-    }
-    const match = line.match(TRACE_LINE_REGEX);
-    if (match && match[7]) {
-      return match[7];
-    }
-    return null;
-  }
-  extractTraceIds(lines) {
-    const traceIdMap = new Map;
-    for (const line of lines) {
-      if (!this.isTraceLine(line))
-        continue;
-      const traceId = this.extractTraceId(line);
-      const parsed = this.parseLogLine(line);
-      if (traceId && parsed) {
-        const existing = traceIdMap.get(traceId) || [];
-        existing.push(line);
-        traceIdMap.set(traceId, existing);
-      }
-    }
-    return traceIdMap;
-  }
-  parseLines(lines) {
-    const results = [];
-    for (const line of lines) {
-      const parsed = this.parseLogLine(line);
-      if (parsed) {
-        results.push(parsed);
-      }
-    }
-    return results;
-  }
-}
-
-// packages/core/src/env/debug/parser/span-builder.ts
-class SpanBuilder {
-  parser;
-  constructor() {
-    this.parser = new RegexParser;
-  }
-  buildTraceEntries(lines) {
-    const entries = [];
-    for (const line of lines) {
-      const entry = this.buildTraceEntry(line);
-      if (entry) {
-        entries.push(entry);
-      }
-    }
-    entries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-    return entries;
-  }
-  buildTraceEntry(line) {
-    const traceId = line.requestId || this.extractTraceId(line.raw);
-    const entry = {
-      traceId: traceId || this.generateVirtualTraceId(line.method, line.timestamp),
-      timestamp: line.timestamp,
-      function: line.method,
-      action: line.actionType
-    };
-    switch (line.actionType) {
-      case "enter":
-        entry.params = this.parser.parseArgs(line.rawArgs);
-        break;
-      case "quit":
-        entry.result = this.parser.parseArgs(line.rawArgs);
-        break;
-      case "error":
-        entry.error = line.rawArgs;
-        break;
-    }
-    return entry;
-  }
-  generateVirtualTraceId(functionName, timestamp) {
-    const base = `${functionName}:${timestamp}`;
-    let hash = 0;
-    for (let i = 0;i < base.length; i++) {
-      const char = base.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
-    }
-    return `vtrace_${Math.abs(hash).toString(36)}`;
-  }
-  extractTraceId(line) {
-    return this.parser.extractTraceId(line);
-  }
-  calculateDuration(enter, quit) {
-    try {
-      const enterTime = new Date(enter.timestamp).getTime();
-      const quitTime = new Date(quit.timestamp).getTime();
-      if (isNaN(enterTime) || isNaN(quitTime)) {
-        return 0;
-      }
-      return quitTime - enterTime;
-    } catch {
-      return 0;
-    }
-  }
-  pairEnterQuit(entries) {
-    const paired = [];
-    const enterStack = [];
-    for (const entry of entries) {
-      if (entry.action === "enter") {
-        enterStack.push(entry);
-      } else if (entry.action === "quit" && enterStack.length > 0) {
-        const enter = enterStack.pop();
-        const duration = this.calculateDuration(enter, entry);
-        paired.push({
-          enter,
-          quit: entry,
-          durationMs: duration
-        });
-      }
-    }
-    return paired;
-  }
-  buildCallTree(entries) {
-    if (entries.length === 0) {
-      return null;
-    }
-    const hasSpanHierarchy = entries.some((e) => e.spanId !== undefined || e.parentSpanId !== undefined);
-    if (hasSpanHierarchy) {
-      return this.buildCallTreeFromHierarchy(entries);
-    }
-    return this.buildCallTreeFromPairs(entries);
-  }
-  buildCallTreeFromHierarchy(entries) {
-    const nodeMap = new Map;
-    const rootNodes = [];
-    const addedToRoots = new Set;
-    const enterEntries = entries.filter((e) => e.action === "enter");
-    for (const entry of enterEntries) {
-      const spanId = entry.spanId;
-      const parentSpanId = entry.parentSpanId;
-      if (spanId && nodeMap.has(spanId)) {
-        continue;
-      }
-      const node = {
-        traceId: entry.traceId,
-        function: entry.function,
-        startTime: entry.timestamp,
-        endTime: undefined,
-        durationMs: entry.durationMs,
-        children: [],
-        entry,
-        spanId,
-        parentSpanId
-      };
-      if (spanId) {
-        nodeMap.set(spanId, node);
-      }
-      if (!parentSpanId || !nodeMap.has(parentSpanId)) {
-        rootNodes.push(node);
-        if (spanId)
-          addedToRoots.add(spanId);
-      }
-    }
-    const quitEntries = entries.filter((e) => e.action === "quit");
-    for (const quit of quitEntries) {
-      if (quit.spanId) {
-        const node = nodeMap.get(quit.spanId);
-        if (node) {
-          node.endTime = quit.timestamp;
-          node.durationMs = quit.durationMs || (node.endTime && node.startTime ? new Date(node.endTime).getTime() - new Date(node.startTime).getTime() : undefined);
-        }
-      }
-    }
-    for (const node of nodeMap.values()) {
-      if (node.parentSpanId && nodeMap.has(node.parentSpanId)) {
-        const parent = nodeMap.get(node.parentSpanId);
-        if (parent.traceId === node.traceId) {
-          parent.children.push(node);
-          rootNodes.splice(rootNodes.indexOf(node), 1);
-        }
-      }
-    }
-    if (rootNodes.length === 0) {
-      for (const entry of enterEntries) {
-        if (!entry.parentSpanId) {
-          const spanId = entry.spanId;
-          if (spanId && nodeMap.has(spanId) && !addedToRoots.has(spanId)) {
-            rootNodes.push(nodeMap.get(spanId));
-          }
-        }
-      }
-    }
-    rootNodes.sort((a, b) => a.startTime.localeCompare(b.startTime));
-    if (rootNodes.length === 0) {
-      return null;
-    }
-    if (rootNodes.length === 1) {
-      return rootNodes[0];
-    }
-    const allStartTimes = rootNodes.map((n) => new Date(n.startTime).getTime());
-    const allEndTimes = rootNodes.map((n) => n.endTime ? new Date(n.endTime).getTime() : 0).filter((t) => t > 0);
-    return {
-      traceId: entries[0]?.traceId || "merged",
-      function: "(root)",
-      children: rootNodes,
-      startTime: new Date(Math.min(...allStartTimes)).toISOString(),
-      endTime: allEndTimes.length > 0 ? new Date(Math.max(...allEndTimes)).toISOString() : undefined,
-      durationMs: allEndTimes.length > 0 && allStartTimes.length > 0 ? Math.max(...allEndTimes) - Math.min(...allStartTimes) : undefined
-    };
-  }
-  buildCallTreeFromPairs(entries) {
-    const sortedEntries = [...entries].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-    const paired = this.pairEnterQuit(sortedEntries);
-    if (paired.length === 0) {
-      return null;
-    }
-    const stack = [];
-    let root = null;
-    for (const entry of sortedEntries) {
-      if (entry.action === "enter") {
-        const span = paired.find((p) => p.enter === entry);
-        if (!span)
-          continue;
-        const node = this.buildNodeFromPaired(span);
-        if (stack.length === 0) {
-          root = node;
-        } else {
-          stack[stack.length - 1].node.children.push(node);
-        }
-        stack.push({ node, paired: span });
-      } else if (entry.action === "quit" && stack.length > 0) {
-        stack.pop();
-      }
-    }
-    return root;
-  }
-  buildNodeFromPaired(span) {
-    return {
-      traceId: span.enter.traceId,
-      function: span.enter.function,
-      startTime: span.enter.timestamp,
-      endTime: span.quit.timestamp,
-      durationMs: span.durationMs,
-      children: [],
-      entry: span.enter
-    };
-  }
-  buildMergedTree(entriesByFunction) {
-    const allEntries = [];
-    for (const entries of entriesByFunction.values()) {
-      allEntries.push(...entries);
-    }
-    allEntries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
-    return this.buildCallTree(allEntries);
-  }
-  getDurationSummary(entries) {
-    const summary = new Map;
-    const paired = this.pairEnterQuit(entries);
-    for (const span of paired) {
-      const func = span.enter.function;
-      const existing = summary.get(func) || { count: 0, totalMs: 0, avgMs: 0 };
-      existing.count++;
-      existing.totalMs += span.durationMs;
-      existing.avgMs = Math.round(existing.totalMs / existing.count);
-      summary.set(func, existing);
-    }
-    return summary;
-  }
-}
-
-// packages/core/src/env/debug/debug-component.ts
-class DebugComponent extends BaseComponent {
-  name = "debug";
-  version = "1.0.0";
-  reader;
-  spanDbReader = null;
-  parser;
-  spanBuilder;
-  traceFormatter;
-  treeFormatter;
-  options;
-  constructor(options) {
-    super();
-    this.options = options || {};
-    this.reader = new LogReader({ logDir: this.options.logDir });
-    this.parser = new RegexParser;
-    this.spanBuilder = new SpanBuilder;
-    this.traceFormatter = new TraceFormatter;
-    this.treeFormatter = new TreeFormatter;
-  }
-  async initSpanDbReader(dbPath) {
-    if (!this.spanDbReader) {
-      this.spanDbReader = new SpanDbReader({ dbPath });
-      await this.spanDbReader.initialize();
-    }
-  }
-  getSpanDbReader() {
-    return this.spanDbReader;
-  }
-  async getLiveTrace(traceId) {
-    try {
-      const { getTracerProvider: getTracerProvider2 } = await Promise.resolve().then(() => (init_tracer_provider(), exports_tracer_provider));
-      const provider = getTracerProvider2();
-      if (!provider.isInitialized()) {
-        await provider.initialize();
-      }
-      const storage = provider.getStorage();
-      const spans = storage.findByTraceId(traceId);
-      if (spans.length === 0) {
-        return null;
-      }
-      const flattenSpans = (spanList) => {
-        const result = [];
-        for (const span of spanList) {
-          result.push({
-            traceId: span.traceId,
-            spanId: span.spanId,
-            parentSpanId: span.parentSpanId,
-            function: span.name,
-            action: "enter",
-            timestamp: new Date(span.startTime).toISOString(),
-            params: Object.entries(span.attributes || {}).map(([k, v]) => ({ key: k, value: v }))
-          });
-          if (span.children && span.children.length > 0) {
-            result.push(...flattenSpans(span.children));
-          }
-        }
-        return result;
-      };
-      const flatSpans = flattenSpans(spans);
-      const tree = this.spanBuilder.buildCallTree(flatSpans);
-      const rootSpans = spans.filter((s) => !s.parentSpanId);
-      return {
-        traceId,
-        spans,
-        callTree: tree,
-        spanCount: flatSpans.length,
-        rootSpans
-      };
-    } catch (error) {
-      console.error("Failed to get trace from live storage:", error);
-      return null;
-    }
-  }
-  async listLiveTraces(limit = 20) {
-    try {
-      const { getTracerProvider: getTracerProvider2 } = await Promise.resolve().then(() => (init_tracer_provider(), exports_tracer_provider));
-      const provider = getTracerProvider2();
-      if (!provider.isInitialized()) {
-        await provider.initialize();
-      }
-      const storage = provider.getStorage();
-      const traces = storage.listTraces(limit);
-      return {
-        traces,
-        count: traces.length
-      };
-    } catch (error) {
-      console.error("Failed to list live traces:", error);
-      return { traces: [], count: 0 };
-    }
-  }
-  async formatLiveTrace(traceId) {
-    try {
-      const { getTracerProvider: getTracerProvider2 } = await Promise.resolve().then(() => (init_tracer_provider(), exports_tracer_provider));
-      const provider = getTracerProvider2();
-      if (!provider.isInitialized()) {
-        await provider.initialize();
-      }
-      const storage = provider.getStorage();
-      const spans = storage.findByTraceId(traceId);
-      if (spans.length === 0) {
-        return `No trace found for traceId: ${traceId}`;
-      }
-      const flattenSpans = (spanList) => {
-        const result = [];
-        for (const span of spanList) {
-          result.push({
-            traceId: span.traceId,
-            spanId: span.spanId,
-            parentSpanId: span.parentSpanId,
-            function: span.name,
-            action: "enter",
-            timestamp: new Date(span.startTime).toISOString(),
-            params: Object.entries(span.attributes || {}).map(([k, v]) => ({ key: k, value: v }))
-          });
-          if (span.children && span.children.length > 0) {
-            result.push(...flattenSpans(span.children));
-          }
-        }
-        return result;
-      };
-      const flatSpans = flattenSpans(spans);
-      const tree = this.spanBuilder.buildCallTree(flatSpans);
-      if (!tree) {
-        return "No trace structure found";
-      }
-      return this.treeFormatter.formatTree(tree);
-    } catch (error) {
-      return `Failed to format trace: ${error}`;
-    }
-  }
-  async init(config) {
-    await super.init(config);
-    this.setStatus("running");
-  }
-  async stop() {
-    this.setStatus("stopping");
-    this.setStatus("stopped");
-  }
-  async getTraces(options) {
-    if (options?.source === "sqlite") {
-      return this.getTracesFromSqlite(options);
-    }
-    const logFile = options?.logFile || this.reader.getLogPath();
-    const lines = [];
-    for await (const line of this.reader.readLines(logFile, options)) {
-      if (options?.function && !line.includes(options.function)) {
-        continue;
-      }
-      if (options?.traceId && !line.includes(`requestId=${options.traceId}`)) {
-        continue;
-      }
-      if (this.parser.isTraceLine(line)) {
-        lines.push(line);
-      }
-    }
-    const parsedLines = this.parser.parseLines(lines);
-    const entries = this.spanBuilder.buildTraceEntries(parsedLines);
-    let filteredEntries = entries;
-    if (options?.function) {
-      filteredEntries = entries.filter((e) => e.function.includes(options.function));
-    }
-    const paired = this.spanBuilder.pairEnterQuit(filteredEntries);
-    const result = [];
-    for (const span of paired) {
-      result.push({
-        ...span.enter,
-        durationMs: span.durationMs
-      });
-      if (span.quit) {
-        result.push({
-          ...span.quit,
-          durationMs: span.durationMs
-        });
-      }
-    }
-    return result;
-  }
-  async getTracesFromSqlite(options) {
-    if (!options?.traceId) {
-      return [];
-    }
-    await this.initSpanDbReader(options.dbPath);
-    const reader = this.getSpanDbReader();
-    if (!reader) {
-      throw new Error("Failed to initialize span database reader");
-    }
-    const entries = await reader.getTraceEntries(options.traceId);
-    if (options?.function) {
-      return entries.filter((e) => e.function.includes(options.function));
-    }
-    return entries;
-  }
-  async listTraceIds(options) {
-    if (options?.source === "sqlite") {
-      return this.listTraceIdsFromSqlite(options);
-    }
-    const logFile = options?.logFile || this.reader.getLogPath();
-    const limit = options?.limit || 20;
-    const traceMap = new Map;
-    for await (const line of this.reader.readLines(logFile, options)) {
-      if (!this.parser.isTraceLine(line))
-        continue;
-      const parsed = this.parser.parseLogLine(line);
-      if (!parsed)
-        continue;
-      const traceId = this.parser.extractTraceId(line) || this.spanBuilder.generateVirtualTraceId(parsed.method, parsed.timestamp);
-      const existing = traceMap.get(traceId);
-      if (existing) {
-        existing.lastTime = parsed.timestamp;
-        existing.count++;
-      } else {
-        traceMap.set(traceId, {
-          firstTime: parsed.timestamp,
-          lastTime: parsed.timestamp,
-          count: 1
-        });
-      }
-    }
-    const traceIds = [];
-    for (const [traceId, info] of traceMap.entries()) {
-      traceIds.push({
-        traceId,
-        firstTime: info.firstTime,
-        lastTime: info.lastTime,
-        count: info.count
-      });
-    }
-    traceIds.sort((a, b) => b.firstTime.localeCompare(a.firstTime));
-    return {
-      traceIds: traceIds.slice(0, limit),
-      count: traceIds.length
-    };
-  }
-  async listTraceIdsFromSqlite(options) {
-    const limit = options?.limit || 20;
-    await this.initSpanDbReader(options?.dbPath);
-    const reader = this.getSpanDbReader();
-    if (!reader) {
-      throw new Error("Failed to initialize span database reader");
-    }
-    return reader.listTraceIds(limit);
-  }
-  async getCallTree(options) {
-    if (!options?.traceId) {
-      return null;
-    }
-    const traces = await this.getTraces({
-      ...options,
-      traceId: options.traceId
-    });
-    if (traces.length === 0) {
-      return null;
-    }
-    return this.spanBuilder.buildCallTree(traces);
-  }
-  getReader() {
-    return this.reader;
-  }
-  getParser() {
-    return this.parser;
-  }
-  getSpanBuilder() {
-    return this.spanBuilder;
-  }
-  getTraceFormatter() {
-    return this.traceFormatter;
-  }
-  getTreeFormatter() {
-    return this.treeFormatter;
-  }
-  formatTraces(entries, options) {
-    return this.traceFormatter.formatEntries(entries, options);
-  }
-  formatTraceEntry(entry, options) {
-    return this.traceFormatter.formatEntry(entry, options);
-  }
-  tracesToJSON(entries) {
-    return this.traceFormatter.toJSON(entries);
-  }
-  tracesToSummary(entries) {
-    return this.traceFormatter.toSummary(entries);
-  }
-  formatTree(node) {
-    return this.treeFormatter.formatTree(node);
-  }
-  formatTrees(trees) {
-    return this.treeFormatter.formatTrees(trees);
-  }
-  treesToJSON(trees) {
-    return this.treeFormatter.toJSON(trees);
-  }
-  formatTreeSummary(node) {
-    return this.treeFormatter.formatSummary(node);
-  }
-  formatTreeTimeline(node) {
-    return this.treeFormatter.formatTimeline(node);
-  }
-}
-export {
-  TreeFormatter,
-  TraceFormatter,
-  SpanDbReader,
-  SpanBuilder,
-  ReplFormatter,
-  RegexParser,
-  LogReader,
-  DebugComponent
-};