@dxos/plugin-assistant 0.9.0 → 0.9.1-staging.ee54ba693a

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

@@ -4,17 +4,21 @@ import "../chunk-J5LGTIGS.mjs";
 import * as Array from "effect/Array";
 import * as Either from "effect/Either";
 import { pipe } from "effect/Function";
+import * as Option from "effect/Option";
 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 { Annotation } from "@dxos/echo";
 import { AGENT_PROCESS_KEY } from "@dxos/functions-runtime";
+import { EID as EID2 } from "@dxos/keys";
 import { LogLevel, log } from "@dxos/log";
 
 // src/execution-graph/span-tree.ts
 import { AgentRequestBegin, AgentRequestEnd } from "@dxos/assistant";
 import { Trace } from "@dxos/compute";
+import { EID } from "@dxos/keys";
 var ROOT_SPAN_ID = "<main>";
 var BEGIN_EVENT_TYPES = /* @__PURE__ */ new Set([
   Trace.OperationStart.key,
@@ -30,8 +34,8 @@ var computeMeta = (rawMeta) => ({
   pid: rawMeta.pid,
   parentPid: rawMeta.parentPid,
   processName: rawMeta.processName,
-  conversationId: rawMeta.conversationId,
-  triggerId: rawMeta.triggerId,
+  conversationId: rawMeta.conversation ? EID.getEntityId(EID.parse(rawMeta.conversation.uri)) : void 0,
+  triggerId: rawMeta.trigger ? EID.getEntityId(EID.parse(rawMeta.trigger.uri)) : void 0,
   toolCallId: rawMeta.toolCallId,
   runtimeName: rawMeta.runtimeName
 });
@@ -159,6 +163,7 @@ var flattenSpanTree = (root) => {
 // 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 SHIMMER_EFFECT_TAG = "effect:shimmer";
 var ICONS = {
   agentRequestBegin: {
     icon: "ph--atom--regular",
@@ -217,18 +222,18 @@ var ICONS = {
     level: LogLevel.VERBOSE
   }
 };
-var buildExecutionGraph = ({ traceMessages, activeProcesses = [], eventLimit = 500 }) => {
+var buildExecutionGraph = ({ traceMessages, activeProcesses = [], collapseCompletedSpans = false, eventLimit = 500 }) => {
   const spanTree = buildSpanTree(traceMessages, {
     eventLimit
   });
   const toolCallContext = buildToolCallContext(traceMessages);
-  const built = spanTreeToCommits(spanTree, activeProcesses, toolCallContext);
+  const built = spanTreeToCommits(spanTree, activeProcesses, toolCallContext, collapseCompletedSpans);
   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 });
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 86, S: void 0 });
   return {
     ...built,
     spanTree
@@ -271,7 +276,7 @@ var parseAgentRequestEnd = (data) => {
   }
   log("invalid trace event", {
     type: AgentRequestEnd2.key
-  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 131, S: void 0 });
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 135, S: void 0 });
   return void 0;
 };
 var presentAgentRequestEnd = (data) => {
@@ -301,7 +306,7 @@ var presentEvent = (event, toolCallContext) => {
     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 });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 165, S: void 0 });
       return void 0;
     }
     return {
@@ -321,7 +326,7 @@ var presentEvent = (event, toolCallContext) => {
     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 });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 185, S: void 0 });
       return void 0;
     }
     switch (event.data.block._tag) {
@@ -361,7 +366,7 @@ var presentEvent = (event, toolCallContext) => {
         return {
           icon: success ? ICONS.toolResultSuccess.icon : ICONS.toolResultError.icon,
           level: success ? ICONS.toolResultSuccess.level : ICONS.toolResultError.level,
-          message: `${name} - ${success ? "Success" : "Error"}`,
+          message: `${name}${!success ? " - Error" : ""}`,
           idSuffix: `toolResult:${event.data.block.toolCallId}`
         };
       }
@@ -373,7 +378,7 @@ var presentEvent = (event, toolCallContext) => {
     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 });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 247, S: void 0 });
       return void 0;
     }
     return {
@@ -387,37 +392,153 @@ var presentEvent = (event, toolCallContext) => {
     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 });
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 261, 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"}`,
+      message: `${event.data.name ?? event.data.key}${!success ? " - Error" : ""}`,
       idSuffix: `${event.data.key}:end`
     };
   }
   return void 0;
 };
-var isCollapsibleSpan = (span, parent) => {
-  if (span.id === ROOT_SPAN_ID) {
+var collectProcessActivityLines = (messages, rootPid, options = {}) => {
+  const { conversationId, eventLimit = 50 } = options;
+  const descendantPids = collectDescendantPids(messages, rootPid);
+  const filtered = messages.filter((message) => {
+    const pid = message.meta.pid;
+    if (!pid || !descendantPids.has(pid)) {
+      return false;
+    }
+    const metaConvId = message.meta.conversation ? EID2.getEntityId(EID2.parse(message.meta.conversation.uri)) : void 0;
+    if (conversationId && metaConvId !== void 0 && metaConvId !== conversationId) {
+      return false;
+    }
+    return true;
+  });
+  const events = filtered.flatMap((message) => Trace2.flatten(message)).sort((left, right) => left.timestamp - right.timestamp).slice(-eventLimit);
+  const toolCallContext = buildToolCallContext(filtered);
+  const lines = [];
+  for (const event of events) {
+    const presentation = presentEvent(event, toolCallContext);
+    if (presentation) {
+      lines.push(presentation.message);
+    }
+  }
+  return lines;
+};
+var deriveInFlightActivityLine = (messages, rootPid, options = {}) => {
+  const { conversationId, eventLimit = 50 } = options;
+  const descendantPids = collectDescendantPids(messages, rootPid);
+  const filtered = messages.filter((message) => {
+    const pid = message.meta.pid;
+    if (!pid || !descendantPids.has(pid)) {
+      return false;
+    }
+    const metaConvId = message.meta.conversation ? EID2.getEntityId(EID2.parse(message.meta.conversation.uri)) : void 0;
+    if (conversationId && metaConvId !== void 0 && metaConvId !== conversationId) {
+      return false;
+    }
+    return true;
+  });
+  const events = filtered.flatMap((message) => Trace2.flatten(message)).sort((left, right) => left.timestamp - right.timestamp).slice(-eventLimit);
+  const openOperations = /* @__PURE__ */ new Map();
+  let agentRequestOpen = false;
+  let lastLine;
+  for (const event of events) {
+    const pid = event.meta.pid ?? rootPid;
+    if (Trace2.isOfType(Trace2.OperationStart, event)) {
+      const key = `${pid}:${event.data.key}`;
+      const name = event.data.name ?? event.data.key;
+      openOperations.set(key, {
+        name,
+        timestamp: event.timestamp
+      });
+      lastLine = `${name}...`;
+      continue;
+    }
+    if (Trace2.isOfType(Trace2.OperationEnd, event)) {
+      openOperations.delete(`${pid}:${event.data.key}`);
+      continue;
+    }
+    if (Trace2.isOfType(AgentRequestBegin2, event)) {
+      agentRequestOpen = true;
+      lastLine = "Generating...";
+      continue;
+    }
+    if (Trace2.isOfType(AgentRequestEnd2, event)) {
+      agentRequestOpen = false;
+    }
+  }
+  if (agentRequestOpen) {
+    return "Generating...";
+  }
+  const latestOperation = [
+    ...openOperations.values()
+  ].sort((left, right) => right.timestamp - left.timestamp)[0];
+  if (latestOperation) {
+    return `${latestOperation.name}...`;
+  }
+  return lastLine;
+};
+var collectDescendantPids = (messages, rootPid) => {
+  const pids = /* @__PURE__ */ new Set([
+    rootPid
+  ]);
+  let expanded = true;
+  while (expanded) {
+    expanded = false;
+    for (const message of messages) {
+      const pid = message.meta.pid;
+      const parentPid = message.meta.parentPid;
+      if (pid && parentPid && pids.has(parentPid) && !pids.has(pid)) {
+        pids.add(pid);
+        expanded = true;
+      }
+    }
+  }
+  return pids;
+};
+var isPendingToolCallEvent = (event, toolCallContext) => {
+  if (!Trace2.isOfType(CompleteBlock, event)) {
     return false;
   }
-  if (span.events.length !== 2) {
+  if (event.data.block._tag !== "toolCall") {
     return false;
   }
-  if (span.children.length > 0) {
+  return !toolCallContext.resultByCallId.has(event.data.block.toolCallId);
+};
+var shouldShimmerInProgressCommit = (event, toolCallContext) => isPendingToolCallEvent(event, toolCallContext);
+var isCompletedSpan = (span) => {
+  if (span.id === ROOT_SPAN_ID) {
     return false;
   }
-  const firstEvent = span.events[0];
   const lastEvent = span.events[span.events.length - 1];
-  if (!isSpanBeginEvent(firstEvent) || !isSpanEndEvent(lastEvent)) {
+  return lastEvent !== void 0 && isSpanEndEvent(lastEvent);
+};
+var isCollapsibleSpan = (span, parent, collapseCompletedSpans) => {
+  if (span.id === ROOT_SPAN_ID) {
     return false;
   }
-  return parent !== null;
+  if (parent === null) {
+    return false;
+  }
+  if (span.events.length === 2 && span.children.length === 0) {
+    const firstEvent = span.events[0];
+    const lastEvent = span.events[span.events.length - 1];
+    if (isSpanBeginEvent(firstEvent) && isSpanEndEvent(lastEvent)) {
+      return true;
+    }
+  }
+  if (collapseCompletedSpans && isCompletedSpan(span)) {
+    return true;
+  }
+  return false;
 };
-var spanTreeToCommits = (root, activeProcesses, toolCallContext) => {
+var spanTreeToCommits = (root, activeProcesses, toolCallContext, collapseCompletedSpans) => {
   const builder = new GraphBuilder();
   const details = {};
   builder.addBranch(MAIN_BRANCH);
@@ -431,12 +552,29 @@ var spanTreeToCommits = (root, activeProcesses, toolCallContext) => {
   };
   indexParents(root);
   const findParentSpan = (span) => parentBySpan.get(span) ?? null;
+  const collapsedSpanIds = /* @__PURE__ */ new Set();
+  walkSpanTree(root, (span) => {
+    if (isCollapsibleSpan(span, findParentSpan(span), collapseCompletedSpans)) {
+      collapsedSpanIds.add(span.id);
+    }
+  });
+  const isUnderCollapsedAncestor = (span) => {
+    let ancestor = findParentSpan(span);
+    while (ancestor) {
+      if (collapsedSpanIds.has(ancestor.id)) {
+        return true;
+      }
+      ancestor = findParentSpan(ancestor);
+    }
+    return false;
+  };
   const branchOf = (span) => {
     if (!span || span.id === ROOT_SPAN_ID) {
       return MAIN_BRANCH;
     }
     return span.meta.pid ?? span.id;
   };
+  const beginCommitIdBySpan = /* @__PURE__ */ new Map();
   const lastInSpanContext = (span) => {
     if (!span || span.id === ROOT_SPAN_ID) {
       return CommitSelector.branch(MAIN_BRANCH).pipe(CommitSelector.compose(CommitSelector.last()));
@@ -445,36 +583,71 @@ var spanTreeToCommits = (root, activeProcesses, toolCallContext) => {
     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
+  const lastCommitIdBySpan = /* @__PURE__ */ new Map();
+  let globalIndex = 0;
+  const insertedRunningPids = /* @__PURE__ */ new Set();
+  const activeProcessByPid = new Map(activeProcesses.map((process) => [
+    process.pid,
+    process
+  ]));
+  const emitRunningIndicator = (pid) => {
+    if (insertedRunningPids.has(pid)) {
+      return;
+    }
+    const process = activeProcessByPid.get(pid);
+    if (!process) {
+      return;
+    }
+    if (process.key === AGENT_PROCESS_KEY && Option.isSome(Annotation.getDictionary(process.params.annotations, Process.TargetAnnotation)) && (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(),
+        tags: [
+          SHIMMER_EFFECT_TAG
+        ]
       });
-    });
-  });
-  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) {
+      insertedRunningPids.add(pid);
+    } 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(),
+        tags: [
+          SHIMMER_EFFECT_TAG
+        ]
+      });
+      insertedRunningPids.add(pid);
+    }
+  };
+  const emitEventCommit = (span, event, eventIndex) => {
     const presentation = presentEvent(event, toolCallContext);
     if (!presentation) {
-      continue;
+      return;
     }
     const isBeginEvent = isSpanBeginEvent(event);
     const isEndEvent = isSpanEndEvent(event);
     const parentSpan = findParentSpan(span);
-    const collapsible = isCollapsibleSpan(span, parentSpan);
-    if (collapsible && isBeginEvent) {
-      continue;
+    const collapsible = isCollapsibleSpan(span, parentSpan, collapseCompletedSpans);
+    if (isUnderCollapsedAncestor(span)) {
+      return;
+    }
+    if (collapsible && !isEndEvent) {
+      return;
     }
     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 spanHasMiddle = span.events.some((spanEvent) => !isSpanBeginEvent(spanEvent) && !isSpanEndEvent(spanEvent));
     const isProcessBoundary = ownPid != null && parentPid != null && ownPid !== parentPid && spanHasMiddle;
     let branch;
     let parents;
@@ -494,7 +667,9 @@ var spanTreeToCommits = (root, activeProcesses, toolCallContext) => {
       branch = ownBranch;
       parents = builder.computeParents(lastInSpanContext(span));
     }
-    const commitId = formatCommitId(span, globalIndex, presentation.idSuffix);
+    const commitIndex = globalIndex++;
+    const commitId = formatCommitId(span, commitIndex, presentation.idSuffix);
+    const shimmer = shouldShimmerInProgressCommit(event, toolCallContext);
     const commit = {
       id: commitId,
       branch,
@@ -502,36 +677,57 @@ var spanTreeToCommits = (root, activeProcesses, toolCallContext) => {
       timestamp: new Date(event.timestamp),
       icon: presentation.icon,
       level: presentation.level,
-      message: presentation.message
+      message: presentation.message,
+      ...shimmer && {
+        tags: [
+          SHIMMER_EFFECT_TAG
+        ]
+      }
     };
     builder.addCommit(commit);
     details[commitId] = event;
+    lastCommitIdBySpan.set(span.id, commitId);
     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 finishSpan = (span) => {
+    const pid = span.meta.pid;
+    if (pid) {
+      emitRunningIndicator(Process.ID.make(pid));
+    }
+    if (span.id === ROOT_SPAN_ID || isCompletedSpan(span)) {
+      return;
+    }
+    if (pid && insertedRunningPids.has(pid)) {
+      return;
+    }
+    const lastCommitId = lastCommitIdBySpan.get(span.id);
+    if (lastCommitId) {
+      builder.addTag(lastCommitId, SHIMMER_EFFECT_TAG);
+    }
+  };
+  const emitSpanCommits = (span) => {
+    for (let eventIndex = 0; eventIndex < span.events.length; eventIndex += 1) {
+      const event = span.events[eventIndex];
+      if (isSpanBeginEvent(event)) {
+        emitEventCommit(span, event, eventIndex);
+      }
     }
+    for (const child of span.children) {
+      emitSpanCommits(child);
+    }
+    for (let eventIndex = 0; eventIndex < span.events.length; eventIndex += 1) {
+      const event = span.events[eventIndex];
+      if (!isSpanBeginEvent(event)) {
+        emitEventCommit(span, event, eventIndex);
+      }
+    }
+    finishSpan(span);
+  };
+  emitSpanCommits(root);
+  for (const process of activeProcesses) {
+    emitRunningIndicator(process.pid);
   }
   const { commits, branches } = builder.build();
   return {
@@ -661,6 +857,23 @@ var GraphBuilder = class {
     this.addBranch(commit.branch);
     this.#commits.push(commit);
   }
+  addTag(commitId, tag) {
+    const index = this.#commits.findIndex((commit2) => commit2.id === commitId);
+    if (index < 0) {
+      return;
+    }
+    const commit = this.#commits[index];
+    if (commit.tags?.includes(tag)) {
+      return;
+    }
+    this.#commits[index] = {
+      ...commit,
+      tags: [
+        ...commit.tags ?? [],
+        tag
+      ]
+    };
+  }
   /**
   * Computes parents — picks first matching commit's id.
   */
@@ -688,6 +901,61 @@ var GraphBuilder = class {
     };
   }
 };
+
+// src/execution-graph/pending-block-status.ts
+import { PartialBlock } from "@dxos/assistant";
+import { Trace as Trace3 } from "@dxos/compute";
+var estimateTokenCount = (text) => Math.max(1, Math.ceil(new TextEncoder().encode(text).length / 4));
+var formatOperationInputStatus = (data) => {
+  const name = data.name ?? data.key;
+  const bytes = new TextEncoder().encode(JSON.stringify(data.input)).length;
+  return `Calling ${name} (${bytes} bytes)...`;
+};
+var ROUTINE_ULID_STATUS = /^Running [0-9A-HJKMNP-TV-Z]{26}$/i;
+var formatPendingBlockStatus = (block) => {
+  if (!block.pending) {
+    return void 0;
+  }
+  if (block._tag === "text") {
+    return `Generating ${estimateTokenCount(block.text)} tokens....`;
+  }
+  if (block._tag === "toolCall") {
+    const bytes = new TextEncoder().encode(block.input).length;
+    const name = block.operationName ?? block.name;
+    return `Calling ${name} (${bytes} bytes)...`;
+  }
+  return void 0;
+};
+var pendingStatusFromEphemeralMessage = (message) => {
+  for (const event of message.events) {
+    if (Trace3.isOfType(PartialBlock, event)) {
+      const status = formatPendingBlockStatus(event.data.block);
+      if (status) {
+        return status;
+      }
+      continue;
+    }
+    if (Trace3.isOfType(Trace3.OperationInput, event)) {
+      return formatOperationInputStatus(event.data);
+    }
+    if (Trace3.isOfType(Trace3.StatusUpdate, event)) {
+      if (ROUTINE_ULID_STATUS.test(event.data.message.trim())) {
+        continue;
+      }
+      return event.data.message;
+    }
+  }
+  return void 0;
+};
+var resolveEphemeralStatusUpdate = (message) => {
+  const line = pendingStatusFromEphemeralMessage(message);
+  if (line) {
+    return {
+      line
+    };
+  }
+  return "unchanged";
+};
 export {
   BEGIN_EVENT_TYPES,
   CommitSelector,
@@ -695,9 +963,15 @@ export {
   ROOT_SPAN_ID,
   buildExecutionGraph,
   buildSpanTree,
+  collectProcessActivityLines,
+  deriveInFlightActivityLine,
+  estimateTokenCount,
   flattenSpanTree,
+  formatPendingBlockStatus,
   isSpanBeginEvent,
   isSpanEndEvent,
+  pendingStatusFromEphemeralMessage,
+  resolveEphemeralStatusUpdate,
   walkSpanTree
 };
 //# sourceMappingURL=index.mjs.map