@dxos/plugin-assistant 0.8.4-main.abd8ff62ef → 0.8.4-main.bc2380dfbc

package/dist/lib/neutral/TracePanel-C77SPEIS.mjs

@@ -0,0 +1,672 @@
+import "./chunk-J5LGTIGS.mjs";
+
+// src/containers/TracePanel/TracePanel.tsx
+import { Atom } from "@effect-atom/atom";
+import { useAtomValue } from "@effect-atom/atom-react";
+import { pipe as pipe2 } from "effect/Function";
+import React, { useCallback, useMemo, useState } from "react";
+import { useAtomCapability, useOperationInvoker } from "@dxos/app-framework/ui";
+import { LayoutOperation } from "@dxos/app-toolkit";
+import { Trace as Trace3 } from "@dxos/compute";
+import { Filter, Query } from "@dxos/echo";
+import { AtomQuery } from "@dxos/echo-atom";
+import { FeedTraceSink, Process as Process2 } from "@dxos/functions-runtime";
+import { DXN } from "@dxos/keys";
+import { log as log2 } from "@dxos/log";
+import { useComputeRuntimeService } from "@dxos/plugin-automation/hooks";
+import { ScrollContainer } from "@dxos/react-ui";
+import { useAttentionAttributes } from "@dxos/react-ui-attention";
+import { Timeline } from "@dxos/react-ui-components";
+import { Syntax } from "@dxos/react-ui-syntax-highlighter";
+import { composable, composableProps, mx } from "@dxos/ui-theme";
+import { ProcessTree } from "#components";
+import { AssistantCapabilities } from "#types";
+
+// src/containers/TracePanel/execution-graph.ts
+import * as Array from "effect/Array";
+import * as Either from "effect/Either";
+import { pipe } from "effect/Function";
+import * as Pipeable from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+import * as Struct from "effect/Struct";
+import { AgentRequestBegin as AgentRequestBegin2, AgentRequestEnd as AgentRequestEnd2, CompleteBlock } from "@dxos/assistant";
+import { Trace as Trace2 } from "@dxos/compute";
+import { AGENT_PROCESS_KEY, Process } from "@dxos/functions-runtime";
+import { LogLevel, log } from "@dxos/log";
+
+// src/containers/TracePanel/span-tree.ts
+import { AgentRequestBegin, AgentRequestEnd } from "@dxos/assistant";
+import { Trace } from "@dxos/compute";
+var ROOT_SPAN_ID = "<main>";
+var BEGIN_EVENT_TYPES = /* @__PURE__ */ new Set([
+  Trace.OperationStart.key,
+  AgentRequestBegin.key
+]);
+var END_EVENT_TYPES = /* @__PURE__ */ new Set([
+  Trace.OperationEnd.key,
+  AgentRequestEnd.key
+]);
+var isSpanBeginEvent = (event) => BEGIN_EVENT_TYPES.has(event.type);
+var isSpanEndEvent = (event) => END_EVENT_TYPES.has(event.type);
+var computeMeta = (rawMeta) => ({
+  pid: rawMeta.pid,
+  parentPid: rawMeta.parentPid,
+  processName: rawMeta.processName,
+  conversationId: rawMeta.conversationId,
+  triggerId: rawMeta.triggerId,
+  toolCallId: rawMeta.toolCallId,
+  runtimeName: rawMeta.runtimeName
+});
+var makeMutableSpan = (id, meta) => ({
+  id,
+  meta,
+  events: [],
+  children: [],
+  firstTimestamp: Number.POSITIVE_INFINITY
+});
+var freezeSpan = (span) => ({
+  id: span.id,
+  meta: span.meta,
+  events: span.events,
+  children: span.children.map(freezeSpan)
+});
+var buildSpanTree = (messages, options = {}) => {
+  const allEvents = messages.flatMap((message) => Trace.flatten(message));
+  allEvents.sort((a, b) => a.timestamp - b.timestamp);
+  const events = options.eventLimit !== void 0 && allEvents.length > options.eventLimit ? allEvents.slice(-options.eventLimit) : allEvents;
+  const root = makeMutableSpan(ROOT_SPAN_ID, {});
+  const openSpans = /* @__PURE__ */ new Map();
+  let spanCounter = 0;
+  const allocSpanId = (pid) => {
+    const id = `${pid}#${spanCounter}`;
+    spanCounter += 1;
+    return id;
+  };
+  const noteTimestamp = (span, timestamp) => {
+    if (timestamp < span.firstTimestamp) {
+      span.firstTimestamp = timestamp;
+    }
+  };
+  for (const event of events) {
+    const pid = event.meta.pid;
+    if (!pid) {
+      root.events.push(event);
+      noteTimestamp(root, event.timestamp);
+      continue;
+    }
+    if (BEGIN_EVENT_TYPES.has(event.type)) {
+      const parentPid = event.meta.parentPid;
+      const parent = parentPid && openSpans.get(parentPid) || root;
+      const span = makeMutableSpan(allocSpanId(pid), computeMeta(event.meta));
+      span.events.push(event);
+      noteTimestamp(span, event.timestamp);
+      parent.children.push(span);
+      openSpans.set(pid, span);
+      continue;
+    }
+    if (END_EVENT_TYPES.has(event.type)) {
+      const span = openSpans.get(pid);
+      if (span) {
+        span.events.push(event);
+        noteTimestamp(span, event.timestamp);
+        openSpans.delete(pid);
+      } else {
+        root.events.push(event);
+        noteTimestamp(root, event.timestamp);
+      }
+      continue;
+    }
+    const open = openSpans.get(pid);
+    if (open) {
+      open.events.push(event);
+      noteTimestamp(open, event.timestamp);
+    } else {
+      root.events.push(event);
+      noteTimestamp(root, event.timestamp);
+    }
+  }
+  const sortChildren = (span) => {
+    span.children.sort((a, b) => a.firstTimestamp - b.firstTimestamp);
+    for (const child of span.children) {
+      sortChildren(child);
+    }
+  };
+  sortChildren(root);
+  return freezeSpan(root);
+};
+var walkSpanTree = (root, visit, depth = 0) => {
+  visit(root, depth);
+  for (const child of root.children) {
+    walkSpanTree(child, visit, depth + 1);
+  }
+};
+
+// src/containers/TracePanel/execution-graph.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/containers/TracePanel/execution-graph.ts";
+var MAIN_BRANCH = "main";
+var ICONS = {
+  agentRequestBegin: {
+    icon: "ph--atom--regular",
+    level: LogLevel.VERBOSE
+  },
+  agentRequestEnd: {
+    icon: "ph--atom--regular",
+    level: LogLevel.INFO
+  },
+  userMessage: {
+    icon: "ph--user--regular",
+    level: LogLevel.VERBOSE
+  },
+  statusMessage: {
+    icon: "ph--info--regular",
+    level: LogLevel.VERBOSE
+  },
+  operationStart: {
+    icon: "ph--function--regular",
+    level: LogLevel.VERBOSE
+  },
+  operationEndSuccess: {
+    icon: "ph--function--regular",
+    level: LogLevel.INFO
+  },
+  operationEndError: {
+    icon: "ph--function--regular",
+    level: LogLevel.ERROR
+  },
+  agentRequestRunning: {
+    icon: "ph--spinner-gap--regular",
+    level: LogLevel.VERBOSE
+  },
+  processRunning: {
+    icon: "ph--spinner-gap--regular",
+    level: LogLevel.VERBOSE
+  }
+};
+var buildExecutionGraph = ({ traceMessages, activeProcesses = [], eventLimit = 500 }) => {
+  const spanTree = buildSpanTree(traceMessages, {
+    eventLimit
+  });
+  const built = spanTreeToCommits(spanTree, activeProcesses);
+  log("trace execution graph", {
+    traceMessages: traceMessages.length,
+    commits: built.commits.length,
+    branches: built.branches.length,
+    activeProcesses: activeProcesses.length
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 61, S: void 0 });
+  return {
+    ...built,
+    spanTree
+  };
+};
+var presentEvent = (event) => {
+  if (Trace2.isOfType(AgentRequestBegin2, event)) {
+    if (Either.isLeft(Schema.validateEither(AgentRequestBegin2.schema)(event.data))) {
+      log("invalid trace event", {
+        type: event.type
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 75, S: void 0 });
+      return void 0;
+    }
+    return {
+      icon: ICONS.agentRequestBegin.icon,
+      level: ICONS.agentRequestBegin.level,
+      message: "Agent processing request..."
+    };
+  }
+  if (Trace2.isOfType(AgentRequestEnd2, event)) {
+    if (Either.isLeft(Schema.validateEither(AgentRequestEnd2.schema)(event.data))) {
+      log("invalid trace event", {
+        type: event.type
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 88, S: void 0 });
+      return void 0;
+    }
+    return {
+      icon: ICONS.agentRequestEnd.icon,
+      level: ICONS.agentRequestEnd.level,
+      message: "Agent completed request"
+    };
+  }
+  if (Trace2.isOfType(CompleteBlock, event)) {
+    if (Either.isLeft(Schema.validateEither(CompleteBlock.schema)(event.data))) {
+      log("invalid trace event", {
+        type: event.type
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 101, S: void 0 });
+      return void 0;
+    }
+    switch (event.data.block._tag) {
+      case "text":
+        return event.data.role === "user" ? {
+          icon: ICONS.userMessage.icon,
+          level: ICONS.userMessage.level,
+          message: trimText(event.data.block.text)
+        } : void 0;
+      case "status":
+        return {
+          icon: ICONS.statusMessage.icon,
+          level: ICONS.statusMessage.level,
+          message: trimText(event.data.block.statusText)
+        };
+      default:
+        return void 0;
+    }
+  }
+  if (Trace2.isOfType(Trace2.OperationStart, event)) {
+    if (Either.isLeft(Schema.validateEither(Trace2.OperationStart.schema)(event.data))) {
+      log("invalid trace event", {
+        type: event.type
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 125, S: void 0 });
+      return void 0;
+    }
+    return {
+      icon: ICONS.operationStart.icon,
+      level: ICONS.operationStart.level,
+      message: event.data.name ?? event.data.key,
+      idSuffix: `${event.data.key}:start`
+    };
+  }
+  if (Trace2.isOfType(Trace2.OperationEnd, event)) {
+    if (Either.isLeft(Schema.validateEither(Trace2.OperationEnd.schema)(event.data))) {
+      log("invalid trace event", {
+        type: event.type
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 139, S: void 0 });
+      return void 0;
+    }
+    const success = event.data.outcome === "success";
+    return {
+      icon: success ? ICONS.operationEndSuccess.icon : ICONS.operationEndError.icon,
+      level: success ? ICONS.operationEndSuccess.level : ICONS.operationEndError.level,
+      message: `${event.data.name ?? event.data.key} - ${success ? "Success" : "Error"}`,
+      idSuffix: `${event.data.key}:end`
+    };
+  }
+  return void 0;
+};
+var isCollapsibleSpan = (span, parent) => {
+  if (span.id === ROOT_SPAN_ID) {
+    return false;
+  }
+  if (span.events.length !== 2) {
+    return false;
+  }
+  if (span.children.length > 0) {
+    return false;
+  }
+  const firstEvent = span.events[0];
+  const lastEvent = span.events[span.events.length - 1];
+  if (!isSpanBeginEvent(firstEvent) || !isSpanEndEvent(lastEvent)) {
+    return false;
+  }
+  return parent !== null;
+};
+var spanTreeToCommits = (root, activeProcesses) => {
+  const builder = new GraphBuilder();
+  builder.addBranch(MAIN_BRANCH);
+  const parentBySpan = /* @__PURE__ */ new Map();
+  parentBySpan.set(root, null);
+  const indexParents = (span) => {
+    for (const child of span.children) {
+      parentBySpan.set(child, span);
+      indexParents(child);
+    }
+  };
+  indexParents(root);
+  const findParentSpan = (span) => parentBySpan.get(span) ?? null;
+  const branchOf = (span) => {
+    if (!span || span.id === ROOT_SPAN_ID) {
+      return MAIN_BRANCH;
+    }
+    return span.meta.pid ?? span.id;
+  };
+  const lastInAncestorChain = (span) => {
+    const branches = [];
+    const seen = /* @__PURE__ */ new Set();
+    let current = span;
+    while (current) {
+      const branch = branchOf(current);
+      if (!seen.has(branch)) {
+        seen.add(branch);
+        branches.push(branch);
+      }
+      current = findParentSpan(current);
+    }
+    if (!seen.has(MAIN_BRANCH)) {
+      branches.push(MAIN_BRANCH);
+    }
+    return CommitSelector.firstOf(...branches.map((branch) => CommitSelector.branch(branch).pipe(CommitSelector.compose(CommitSelector.last()))));
+  };
+  const stream = [];
+  walkSpanTree(root, (span) => {
+    span.events.forEach((event, eventIndex) => {
+      stream.push({
+        span,
+        event,
+        eventIndex,
+        globalIndex: stream.length
+      });
+    });
+  });
+  stream.sort((a, b) => a.event.timestamp - b.event.timestamp || a.globalIndex - b.globalIndex);
+  const beginCommitIdBySpan = /* @__PURE__ */ new Map();
+  for (const { span, event, globalIndex } of stream) {
+    const presentation = presentEvent(event);
+    if (!presentation) {
+      continue;
+    }
+    const isBeginEvent = isSpanBeginEvent(event);
+    const isEndEvent = isSpanEndEvent(event);
+    const parentSpan = findParentSpan(span);
+    const collapsible = isCollapsibleSpan(span, parentSpan);
+    if (collapsible && isBeginEvent) {
+      continue;
+    }
+    const parentBranch = branchOf(parentSpan);
+    const ownBranch = branchOf(span);
+    let branch;
+    let parents;
+    if (span.id === ROOT_SPAN_ID) {
+      branch = MAIN_BRANCH;
+      parents = builder.computeParents(CommitSelector.branch(MAIN_BRANCH).pipe(CommitSelector.compose(CommitSelector.last())));
+    } else if (collapsible) {
+      branch = parentBranch;
+      parents = builder.computeParents(lastInAncestorChain(parentSpan));
+    } else if (isBeginEvent) {
+      branch = parentBranch;
+      parents = builder.computeParents(lastInAncestorChain(parentSpan));
+    } else if (isEndEvent) {
+      branch = parentBranch;
+      const beginId = beginCommitIdBySpan.get(span.id);
+      parents = builder.computeParents(CommitSelector.unionAll(beginId ? CommitSelector.id(beginId) : lastInAncestorChain(parentSpan), CommitSelector.branch(ownBranch).pipe(CommitSelector.compose(CommitSelector.last()))));
+    } else {
+      branch = ownBranch;
+      parents = builder.computeParents(CommitSelector.branch(ownBranch).pipe(CommitSelector.compose(CommitSelector.last()), CommitSelector.orElse(lastInAncestorChain(parentSpan))));
+    }
+    const commitId = formatCommitId(span, globalIndex, presentation.idSuffix);
+    const commit = {
+      id: commitId,
+      branch,
+      parents,
+      timestamp: new Date(event.timestamp),
+      icon: presentation.icon,
+      level: presentation.level,
+      message: presentation.message
+    };
+    builder.addCommit(commit);
+    if (isBeginEvent && !collapsible && span.id !== ROOT_SPAN_ID) {
+      beginCommitIdBySpan.set(span.id, commitId);
+    }
+  }
+  for (const process of activeProcesses) {
+    if (process.key === AGENT_PROCESS_KEY && process.params.target && (process.state === Process.State.RUNNING || process.state === Process.State.HYBERNATING)) {
+      builder.addCommit({
+        id: `running:${process.pid}`,
+        branch: process.pid,
+        parents: builder.computeParents(CommitSelector.branch(process.pid).pipe(CommitSelector.compose(CommitSelector.last()))),
+        icon: ICONS.agentRequestRunning.icon,
+        level: ICONS.agentRequestRunning.level,
+        message: "Generating...",
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    } else if (process.state === Process.State.RUNNING && builder.hasBranch(process.pid)) {
+      builder.addCommit({
+        id: `running:${process.pid}`,
+        branch: process.pid,
+        parents: builder.computeParents(CommitSelector.branch(process.pid).pipe(CommitSelector.compose(CommitSelector.last()))),
+        icon: ICONS.processRunning.icon,
+        level: ICONS.processRunning.level,
+        message: "Running...",
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }
+  }
+  return builder.build();
+};
+var formatCommitId = (span, globalIndex, suffix) => {
+  const base = `${span.id}:${globalIndex}`;
+  return suffix ? `${base}:${suffix}` : base;
+};
+var trimText = (text) => text.slice(0, 100).trim().split("\n")[0];
+var CommitSelector = {
+  make: (select) => ({
+    select,
+    pipe(...args) {
+      return Pipeable.pipeArguments(this, args);
+    }
+  }),
+  identity: () => CommitSelector.make((commits) => commits),
+  /**
+  * Selects commits that match the given predicate.
+  */
+  filter: (predicate) => CommitSelector.make((commits) => commits.filter(predicate)),
+  /**
+  * Selects commits by id.
+  */
+  id: (id) => CommitSelector.filter((commit) => commit.id === id),
+  /**
+  * Selects commits by tag.
+  */
+  tag: (tag) => CommitSelector.filter((commit) => tag && commit.tags?.includes(tag)),
+  /**
+  * Selects commits by if any of the given tags are present.
+  */
+  anyTags: (tags) => CommitSelector.filter((commit) => tags.some((tag) => tag && commit.tags?.includes(tag))),
+  /**
+  * Selects commits by branch.
+  */
+  branch: (branch) => CommitSelector.filter((commit) => branch && commit.branch === branch),
+  /**
+  * Chains two selectors together, applying the second selector to the result of the first.
+  *
+  * Example:
+  *
+  * ```
+  * CommitSelector.tag('tag').pipe(CommitSelector.compose(CommitSelector.branch('main')));
+  * ```
+  */
+  compose: (next) => (prev) => CommitSelector.make((commits) => next.select(prev.select(commits))),
+  /**
+  * If `prev` selector matches no commits, return `next` selector, otherwise return `prev` selector.
+  * Same as `CommitSelector.firstOf(prev, next)`.
+  *
+  * Example:
+  *
+  * ```
+  * CommitSelector.tag('tag').pipe(CommitSelector.orElse(CommitSelector.branch('main')));
+  * ```
+  */
+  orElse: (next) => (prev) => CommitSelector.make((commits) => {
+    const selected = prev.select(commits);
+    if (selected.length > 0) {
+      return selected;
+    }
+    return next.select(commits);
+  }),
+  /**
+  * Selects commits that match either of the given selectors.
+  */
+  andAlso: (next) => (prev) => CommitSelector.unionAll(prev, next),
+  /**
+  * Selects the first n commits.
+  */
+  first: (n = 1) => CommitSelector.make((commits) => commits.slice(0, n)),
+  /**
+  * Selects the last n commits (reverses the order of the commits).
+  */
+  last: (n = 1) => CommitSelector.make((commits) => commits.toReversed().slice(0, n)),
+  /**
+  * Selects commits that do not match the given selector.
+  */
+  not: (selector) => CommitSelector.make((commits) => {
+    const selected = selector.select(commits);
+    return commits.filter((commit) => !selected.includes(commit));
+  }),
+  /**
+  * Selects commits that match any of the given selectors.
+  */
+  unionAll: (...selectors) => CommitSelector.make((commits) => {
+    return Array.dedupeWith(selectors.flatMap((selector) => selector.select(commits)), (a, b) => a.id === b.id);
+  }),
+  /**
+  * Selects commits that match all of the given selectors.
+  */
+  intersectAll: (...selectors) => CommitSelector.make((commits) => {
+    const selected = selectors.map((selector) => selector.select(commits));
+    if (selected.length === 0) {
+      return [];
+    }
+    return selected[0].filter((commit) => selected.every((selected2) => selected2.some((c) => c.id === commit.id)));
+  }),
+  /**
+  * Returns the result of the first selector that matches any commits.
+  */
+  firstOf: (...selectors) => CommitSelector.make((commits) => {
+    for (const selector of selectors) {
+      const selected = selector.select(commits);
+      if (selected.length > 0) {
+        return selected;
+      }
+    }
+    return [];
+  })
+};
+var GraphBuilder = class {
+  #commits = [];
+  #branches = /* @__PURE__ */ new Set();
+  findCommits(selector) {
+    return selector.select(this.#commits);
+  }
+  hasBranch(branch) {
+    return this.#branches.has(branch);
+  }
+  addCommit(commit) {
+    this.addBranch(commit.branch);
+    this.#commits.push(commit);
+  }
+  /**
+  * Computes parents — picks first matching commit's id.
+  */
+  computeParents(selector) {
+    return Array.dedupe(selector.select(this.#commits).map((commit) => commit.id));
+  }
+  addBranch(branch) {
+    this.#branches.add(branch);
+  }
+  /**
+  * Removes duplicate commits and dangling parents.
+  */
+  doctor() {
+    this.#commits = pipe(this.#commits, Array.dedupeWith((a, b) => a.id === b.id), Array.map(Struct.evolve({
+      parents: (parents) => parents ? Array.filter(parents, (id) => this.#commits.some((commit) => commit.id === id)) : void 0
+    })));
+  }
+  build() {
+    this.doctor();
+    return {
+      commits: this.#commits,
+      branches: [
+        ...this.#branches
+      ]
+    };
+  }
+};
+
+// src/containers/TracePanel/TracePanel.tsx
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/containers/TracePanel/TracePanel.tsx";
+var TracePanel = composable(({ space, attendableId, onProcessTerminate, ...props }, forwardedRef) => {
+  const attentionAttrs = useAttentionAttributes(attendableId);
+  const { invokePromise } = useOperationInvoker();
+  const settings = useAtomCapability(AssistantCapabilities.Settings);
+  const tracePanelDebug = settings.tracePanelDebug ?? false;
+  const { branches, commits, spanTree } = useExecutionGraph(space);
+  const runtime = useComputeRuntimeService(Process2.ProcessMonitorService, space.id);
+  const processes = useAtomValue(runtime?.processTreeAtom ?? atomEmpty);
+  const [selectedCommit, setSelectedCommit] = useState();
+  const handleCommitSelect = useCallback((commit) => {
+    setSelectedCommit(commit);
+    if (commit?.link) {
+      const dxn = DXN.tryParse(commit.link)?.asEchoDXN();
+      if (dxn?.spaceId && dxn.echoId) {
+        void invokePromise(LayoutOperation.Open, {
+          subject: [
+            `${dxn.spaceId}:${dxn.echoId}`
+          ]
+        });
+      }
+    }
+  }, [
+    invokePromise,
+    setSelectedCommit
+  ]);
+  const [currentBranch, setCurrentBranch] = useState(null);
+  const handleProcessSelect = useCallback((process) => {
+    const branch = branches.find((branch2) => branch2 === process.pid.toString());
+    if (branch) {
+      setCurrentBranch(branch);
+    }
+  }, [
+    branches
+  ]);
+  return /* @__PURE__ */ React.createElement("div", {
+    ...composableProps(props, {
+      ...attentionAttrs,
+      classNames: mx("h-full grid divide-y divide-separator", !tracePanelDebug && selectedCommit ? "grid-rows-[minmax(0,4lh)_1fr_minmax(0,206px)]" : "grid-rows-[minmax(0,4lh)_1fr]")
+    }),
+    ref: forwardedRef
+  }, /* @__PURE__ */ React.createElement(ProcessTree, {
+    processes,
+    onProcessSelect: handleProcessSelect,
+    onProcessTerminate
+  }), /* @__PURE__ */ React.createElement(ScrollContainer.Root, {
+    pin: true
+  }, /* @__PURE__ */ React.createElement(ScrollContainer.Content, {
+    thin: true
+  }, /* @__PURE__ */ React.createElement(ScrollContainer.Fade, null), /* @__PURE__ */ React.createElement(ScrollContainer.Viewport, null, tracePanelDebug ? /* @__PURE__ */ React.createElement(Syntax.Root, {
+    data: spanTree
+  }, /* @__PURE__ */ React.createElement(Syntax.Content, null, /* @__PURE__ */ React.createElement(Syntax.Viewport, null, /* @__PURE__ */ React.createElement(Syntax.Code, {
+    className: "text-xs"
+  })))) : /* @__PURE__ */ React.createElement(Timeline, {
+    compact: true,
+    commits,
+    branches,
+    currentBranch,
+    onSelect: handleCommitSelect
+  })), /* @__PURE__ */ React.createElement(ScrollContainer.ScrollDownButton, null))), !tracePanelDebug && selectedCommit && /* @__PURE__ */ React.createElement(Syntax.Root, {
+    data: selectedCommit
+  }, /* @__PURE__ */ React.createElement(Syntax.Content, null, /* @__PURE__ */ React.createElement(Syntax.Viewport, null, /* @__PURE__ */ React.createElement(Syntax.Code, {
+    className: "text-xs"
+  })))));
+});
+var atomEmpty = Atom.make(() => []);
+var useExecutionGraph = (space, { eventLimit } = {}) => {
+  const runtime = useComputeRuntimeService(Process2.ProcessMonitorService, space.id);
+  const activeProcesses = useAtomValue(runtime?.processTreeAtom ?? atomEmpty);
+  const atom = useMemo(() => getExecutionGraph(space, activeProcesses, {
+    eventLimit
+  }), [
+    space,
+    activeProcesses,
+    eventLimit
+  ]);
+  return useAtomValue(atom);
+};
+var getExecutionGraph = (space, activeProcesses = [], { eventLimit = 300 } = {}) => {
+  return pipe2(AtomQuery.make(space.db, FeedTraceSink.query), Atom.map((feeds) => {
+    log2("trace panel query trace feeds", {
+      spaceId: space.id,
+      feedCount: feeds.length
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 107, S: void 0 });
+    return AtomQuery.make(space.db, feeds.length > 0 ? Query.type(Trace3.Message).from(feeds[0]) : Query.select(Filter.nothing()));
+  }), (_) => Atom.make((get) => get(get(_))), (_) => Atom.make((get) => buildExecutionGraph({
+    traceMessages: [
+      ...get(_)
+    ],
+    activeProcesses,
+    eventLimit
+  })));
+};
+
+// src/containers/TracePanel/index.ts
+var TracePanel_default = TracePanel;
+export {
+  TracePanel,
+  TracePanel_default as default
+};
+//# sourceMappingURL=TracePanel-C77SPEIS.mjs.map