@dxos/plugin-assistant 0.8.4-main.fcfe5033a5 → 0.8.4-staging.60fe92afc8

package/dist/lib/neutral/execution-graph/index.mjs

@@ -0,0 +1,703 @@
+import "../chunk-J5LGTIGS.mjs";
+
+// src/execution-graph/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 { Process, Trace as Trace2 } from "@dxos/compute";
+import { AGENT_PROCESS_KEY } from "@dxos/functions-runtime";
+import { LogLevel, log } from "@dxos/log";
+
+// src/execution-graph/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 = applyEventLimit(allEvents, options.eventLimit);
+  const root = makeMutableSpan(ROOT_SPAN_ID, {});
+  const openSpans = /* @__PURE__ */ new Map();
+  const lastSpanByPid = /* @__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) ?? lastSpanByPid.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);
+      lastSpanByPid.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 applyEventLimit = (events, eventLimit) => {
+  if (eventLimit === void 0) {
+    return [
+      ...events
+    ];
+  }
+  let nonBoundaryCount = 0;
+  for (const event of events) {
+    if (!isBoundary(event)) {
+      nonBoundaryCount += 1;
+    }
+  }
+  if (nonBoundaryCount <= eventLimit) {
+    return [
+      ...events
+    ];
+  }
+  const dropCount = nonBoundaryCount - eventLimit;
+  let dropped = 0;
+  const result = [];
+  for (const event of events) {
+    if (!isBoundary(event) && dropped < dropCount) {
+      dropped += 1;
+      continue;
+    }
+    result.push(event);
+  }
+  return result;
+};
+var isBoundary = (event) => BEGIN_EVENT_TYPES.has(event.type) || END_EVENT_TYPES.has(event.type);
+var walkSpanTree = (root, visit, depth = 0) => {
+  visit(root, depth);
+  for (const child of root.children) {
+    walkSpanTree(child, visit, depth + 1);
+  }
+};
+var flattenSpanTree = (root) => {
+  const result = [];
+  walkSpanTree(root, (span) => result.push(span));
+  return result;
+};
+
+// src/execution-graph/execution-graph.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-assistant/src/execution-graph/execution-graph.ts";
+var MAIN_BRANCH = "main";
+var ICONS = {
+  agentRequestBegin: {
+    icon: "ph--atom--regular",
+    level: LogLevel.VERBOSE
+  },
+  agentRequestEndSuccess: {
+    icon: "ph--atom--regular",
+    level: LogLevel.INFO
+  },
+  agentRequestEndError: {
+    icon: "ph--atom--regular",
+    level: LogLevel.ERROR
+  },
+  agentRequestEndInterrupted: {
+    icon: "ph--atom--regular",
+    level: LogLevel.WARN
+  },
+  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
+  },
+  toolCall: {
+    icon: "ph--wrench--regular",
+    level: LogLevel.VERBOSE
+  },
+  toolResultSuccess: {
+    icon: "ph--wrench--regular",
+    level: LogLevel.INFO
+  },
+  toolResultError: {
+    icon: "ph--wrench--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 toolCallContext = buildToolCallContext(traceMessages);
+  const built = spanTreeToCommits(spanTree, activeProcesses, toolCallContext);
+  log("trace execution graph", {
+    traceMessages: traceMessages.length,
+    commits: built.commits.length,
+    branches: built.branches.length,
+    activeProcesses: activeProcesses.length
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 82, S: void 0 });
+  return {
+    ...built,
+    spanTree
+  };
+};
+var buildToolCallContext = (messages) => {
+  const callById = /* @__PURE__ */ new Map();
+  const resultByCallId = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    for (const event of message.events) {
+      if (event.type !== CompleteBlock.key) {
+        continue;
+      }
+      const data = event.data;
+      const block = data?.block;
+      if (!block) {
+        continue;
+      }
+      if (block._tag === "toolCall") {
+        callById.set(block.toolCallId, block);
+      } else if (block._tag === "toolResult") {
+        resultByCallId.set(block.toolCallId, block);
+      }
+    }
+  }
+  return {
+    callById,
+    resultByCallId
+  };
+};
+var parseAgentRequestEnd = (data) => {
+  const validated = Schema.validateEither(AgentRequestEnd2.schema)(data);
+  if (Either.isRight(validated)) {
+    return validated.right;
+  }
+  if (data != null && typeof data === "object" && Object.keys(data).length === 0) {
+    return {
+      status: "success"
+    };
+  }
+  log("invalid trace event", {
+    type: AgentRequestEnd2.key
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 131, S: void 0 });
+  return void 0;
+};
+var presentAgentRequestEnd = (data) => {
+  switch (data.status) {
+    case "error":
+      return {
+        icon: ICONS.agentRequestEndError.icon,
+        level: ICONS.agentRequestEndError.level,
+        message: data.error ? trimText(`Agent request failed: ${data.error}`) : "Agent request failed"
+      };
+    case "interrupted":
+      return {
+        icon: ICONS.agentRequestEndInterrupted.icon,
+        level: ICONS.agentRequestEndInterrupted.level,
+        message: "Agent request interrupted"
+      };
+    default:
+      return {
+        icon: ICONS.agentRequestEndSuccess.icon,
+        level: ICONS.agentRequestEndSuccess.level,
+        message: "Agent completed request"
+      };
+  }
+};
+var presentEvent = (event, toolCallContext) => {
+  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: 161, S: void 0 });
+      return void 0;
+    }
+    return {
+      icon: ICONS.agentRequestBegin.icon,
+      level: ICONS.agentRequestBegin.level,
+      message: "Agent processing request..."
+    };
+  }
+  if (Trace2.isOfType(AgentRequestEnd2, event)) {
+    const endData = parseAgentRequestEnd(event.data);
+    if (!endData) {
+      return void 0;
+    }
+    return presentAgentRequestEnd(endData);
+  }
+  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: 181, 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)
+        };
+      case "toolCall": {
+        if (event.data.block.operationKey) {
+          return void 0;
+        }
+        if (toolCallContext.resultByCallId.has(event.data.block.toolCallId)) {
+          return void 0;
+        }
+        return {
+          icon: ICONS.toolCall.icon,
+          level: ICONS.toolCall.level,
+          message: event.data.block.name,
+          idSuffix: `toolCall:${event.data.block.toolCallId}`
+        };
+      }
+      case "toolResult": {
+        const call = toolCallContext.callById.get(event.data.block.toolCallId);
+        if (call?.operationKey) {
+          return void 0;
+        }
+        const success = event.data.block.error === void 0;
+        const name = call?.name ?? event.data.block.name;
+        return {
+          icon: success ? ICONS.toolResultSuccess.icon : ICONS.toolResultError.icon,
+          level: success ? ICONS.toolResultSuccess.level : ICONS.toolResultError.level,
+          message: `${name} - ${success ? "Success" : "Error"}`,
+          idSuffix: `toolResult:${event.data.block.toolCallId}`
+        };
+      }
+      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: 243, S: void 0 });
+      return void 0;
+    }
+    return {
+      icon: event.data.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: 257, S: void 0 });
+      return void 0;
+    }
+    const success = event.data.outcome === "success";
+    return {
+      icon: event.data.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, toolCallContext) => {
+  const builder = new GraphBuilder();
+  const details = {};
+  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 lastInSpanContext = (span) => {
+    if (!span || span.id === ROOT_SPAN_ID) {
+      return CommitSelector.branch(MAIN_BRANCH).pipe(CommitSelector.compose(CommitSelector.last()));
+    }
+    const ownBranch = branchOf(span);
+    const beginId = beginCommitIdBySpan.get(span.id);
+    return CommitSelector.firstOf(CommitSelector.branch(ownBranch).pipe(CommitSelector.compose(CommitSelector.last())), beginId ? CommitSelector.id(beginId) : CommitSelector.filter(() => false), lastInSpanContext(findParentSpan(span)));
+  };
+  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, toolCallContext);
+    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);
+    const ownPid = span.meta.pid;
+    const parentPid = parentSpan?.meta.pid;
+    const spanHasMiddle = span.events.some((event2) => !isSpanBeginEvent(event2) && !isSpanEndEvent(event2));
+    const isProcessBoundary = ownPid != null && parentPid != null && ownPid !== parentPid && spanHasMiddle;
+    let branch;
+    let parents;
+    if (span.id === ROOT_SPAN_ID) {
+      branch = MAIN_BRANCH;
+      parents = builder.computeParents(lastInSpanContext(null));
+    } else if (collapsible) {
+      branch = parentBranch;
+      parents = builder.computeParents(lastInSpanContext(parentSpan));
+    } else if (isBeginEvent) {
+      branch = isProcessBoundary ? ownBranch : parentBranch;
+      parents = builder.computeParents(lastInSpanContext(parentSpan));
+    } else if (isEndEvent) {
+      branch = isProcessBoundary ? MAIN_BRANCH : parentBranch;
+      parents = builder.computeParents(CommitSelector.unionAll(CommitSelector.branch(branch).pipe(CommitSelector.compose(CommitSelector.last())), CommitSelector.branch(ownBranch).pipe(CommitSelector.compose(CommitSelector.last()))));
+    } else {
+      branch = ownBranch;
+      parents = builder.computeParents(lastInSpanContext(span));
+    }
+    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);
+    details[commitId] = event;
+    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()
+      });
+    }
+  }
+  const { commits, branches } = builder.build();
+  return {
+    commits,
+    branches,
+    details
+  };
+};
+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
+      ]
+    };
+  }
+};
+export {
+  BEGIN_EVENT_TYPES,
+  CommitSelector,
+  END_EVENT_TYPES,
+  ROOT_SPAN_ID,
+  buildExecutionGraph,
+  buildSpanTree,
+  flattenSpanTree,
+  isSpanBeginEvent,
+  isSpanEndEvent,
+  walkSpanTree
+};
+//# sourceMappingURL=index.mjs.map