@band-app/server 0.37.0 → 0.38.0

package/dist/start-server.mjs

@@ -92313,11 +92313,17 @@ function notify(chatId) {
 }
 function cloneMessage(msg) {
   return {
-    id: msg.id,
-    text: msg.text,
+    ...msg,
     files: msg.files ? msg.files.map((f2) => ({ ...f2 })) : void 0
   };
 }
+function turnOptions(input) {
+  return {
+    ...input.mode !== void 0 && { mode: input.mode },
+    ...input.model !== void 0 && { model: input.model },
+    ...input.codingAgentId !== void 0 && { codingAgentId: input.codingAgentId }
+  };
+}
 function subscribeQueue(listener) {
   queueListeners.add(listener);
   return () => {
@@ -92328,7 +92334,8 @@ function pushQueuedMessage(chatId, input) {
   const message = {
     id: randomUUID(),
     text: input.text,
-    files: input.files && input.files.length > 0 ? input.files.map((f2) => ({ ...f2 })) : void 0
+    files: input.files && input.files.length > 0 ? input.files.map((f2) => ({ ...f2 })) : void 0,
+    ...turnOptions(input)
   };
   const msgs = store.get(chatId);
   if (msgs) {
@@ -92343,11 +92350,17 @@ function setQueuedMessages(chatId, messages) {
   if (messages.length === 0) {
     store.delete(chatId);
   } else {
-    const stored = messages.map((m3) => ({
-      id: m3.id ?? randomUUID(),
-      text: m3.text,
-      files: m3.files && m3.files.length > 0 ? m3.files.map((f2) => ({ ...f2 })) : void 0
-    }));
+    const previous = new Map((store.get(chatId) ?? []).map((m3) => [m3.id, m3]));
+    const stored = messages.map((m3) => {
+      const kept = m3.id !== void 0 ? previous.get(m3.id) : void 0;
+      return {
+        id: m3.id ?? randomUUID(),
+        text: m3.text,
+        files: m3.files && m3.files.length > 0 ? m3.files.map((f2) => ({ ...f2 })) : void 0,
+        ...kept && turnOptions(kept),
+        ...turnOptions(m3)
+      };
+    });
     store.set(chatId, stored);
   }
   notify(chatId);
@@ -92355,6 +92368,13 @@ function setQueuedMessages(chatId, messages) {
 function getQueuedMessages(chatId) {
   return (store.get(chatId) ?? []).map(cloneMessage);
 }
+function hasQueuedMessages(chatId) {
+  return (store.get(chatId)?.length ?? 0) > 0;
+}
+function peekQueuedMessage(chatId) {
+  const first = store.get(chatId)?.[0];
+  return first ? cloneMessage(first) : null;
+}
 function shiftQueuedMessage(chatId) {
   const msgs = store.get(chatId);
   if (!msgs || msgs.length === 0) return null;
@@ -107359,8 +107379,42 @@ var CLIENT_CAPABILITIES = {
   // Claude Code's AskUserQuestion arrives as a form elicitation, and is
   // disabled when the client can't render one.
   elicitation: { form: {} },
-  session: { notices: {} }
-};
+  session: { notices: {} },
+  // JetBrains AIR extension: the Claude adapter reports background work
+  // (background Bash, Monitor, workflows) as `async_task_*` updates only to
+  // a client that lists `asyncTasks`. Band uses them to keep the process
+  // alive while that work runs.
+  _meta: { jetbrains: { air: { version: 1, capabilities: ["asyncTasks"] } } }
+};
+function asAsyncTaskNotification(message) {
+  if (!message || typeof message !== "object") return null;
+  const m3 = message;
+  if (m3.method !== methods.client.session.update) return null;
+  const params = m3.params;
+  const update = params?.update;
+  if (typeof params?.sessionId !== "string" || typeof update?.sessionUpdate !== "string" || !update.sessionUpdate.startsWith("async_task_") || typeof update.asyncTaskId !== "string") {
+    return null;
+  }
+  return params;
+}
+function splitAsyncTasks(readable, onAsyncTask) {
+  return readable.pipeThrough(
+    new TransformStream({
+      transform(message, controller) {
+        const task = asAsyncTaskNotification(message);
+        if (!task) {
+          controller.enqueue(message);
+          return;
+        }
+        try {
+          onAsyncTask(task);
+        } catch (err) {
+          log.warn({ err }, "async task handler threw");
+        }
+      }
+    })
+  );
+}
 function stderrTail() {
   let buf = "";
   return {
@@ -107426,10 +107480,14 @@ var AcpAgentProcess = class _AcpAgentProcess {
     } catch (err) {
       throw new Error(`Could not start ${label}: ${err.message}`);
     }
-    const stream = ndJsonStream2(
+    const wire = ndJsonStream2(
       Writable.toWeb(child.stdin),
       Readable.toWeb(child.stdout)
     );
+    const stream = {
+      writable: wire.writable,
+      readable: splitAsyncTasks(wire.readable, (n) => handlers3.onAsyncTask?.(n))
+    };
     const connection = client({ name: "band" }).onNotification(methods.client.session.update, (ctx) => {
       handlers3.onUpdate(ctx.params);
     }).onRequest(methods.client.session.requestPermission, async (ctx) => ({
@@ -107801,11 +107859,11 @@ function resumeCliInvocation(agentType, sessionId, opts) {
 var CLAUDE_CODE_INTERACTIVE_TOOLS = /* @__PURE__ */ new Set(["AskUserQuestion", "ExitPlanMode"]);
 function mapClaudeCodeHookStatus(payload) {
   const hookEvent = typeof payload.hook_event_name === "string" ? payload.hook_event_name : "";
-  const toolName = typeof payload.tool_name === "string" ? payload.tool_name : "";
+  const toolName2 = typeof payload.tool_name === "string" ? payload.tool_name : "";
   if (hookEvent === "Stop") {
     return "needs_attention";
   }
-  if ((hookEvent === "PreToolUse" || hookEvent === "PermissionRequest") && CLAUDE_CODE_INTERACTIVE_TOOLS.has(toolName)) {
+  if ((hookEvent === "PreToolUse" || hookEvent === "PermissionRequest") && CLAUDE_CODE_INTERACTIVE_TOOLS.has(toolName2)) {
     return "needs_attention";
   }
   return "working";
@@ -116936,6 +116994,101 @@ var ChatEventQueries = class {
   }
 };
 
+// src/server/services/_utils/agent-pending-work.ts
+var MAX_HOLD_MS = 8 * 60 * 6e4;
+var MONITOR_DEFAULT_TIMEOUT_MS = 5 * 6e4;
+function toolName(update) {
+  const meta2 = update._meta;
+  const name3 = meta2?.claudeCode?.toolName ?? update.name;
+  return typeof name3 === "string" ? name3 : void 0;
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+var PendingWork = class {
+  holds = /* @__PURE__ */ new Map();
+  /** Tool calls an async task was announced for. */
+  taskToolCalls = /* @__PURE__ */ new Set();
+  /** Notes what a `session/update` starts or ends. `inTurn` is whether a
+   *  Band-started turn is running. */
+  observeUpdate(update, inTurn, now = Date.now()) {
+    if (update.sessionUpdate !== "tool_call" && update.sessionUpdate !== "tool_call_update") return;
+    const key2 = `tool:${update.toolCallId}`;
+    if (this.taskToolCalls.has(update.toolCallId)) return;
+    if (update.status === "failed") {
+      this.holds.delete(key2);
+      return;
+    }
+    const held = this.holds.get(key2);
+    if (update.status === "completed") {
+      if (held?.untilCompleted) this.holds.delete(key2);
+      return;
+    }
+    if (held) return;
+    const hold = this.toolHold(update, now);
+    if (hold) {
+      this.set(key2, hold, now);
+      return;
+    }
+    if (!inTurn && update.sessionUpdate === "tool_call") {
+      this.set(key2, { reason: "tool call", until: now + MAX_HOLD_MS, untilCompleted: true }, now);
+    }
+  }
+  /** Notes an AIR async task starting or ending. */
+  observeAsyncTask(update, now = Date.now()) {
+    const key2 = `task:${update.asyncTaskId}`;
+    if (update.sessionUpdate === "async_task_spawned") {
+      if (update.toolCallId) {
+        this.taskToolCalls.add(update.toolCallId);
+        this.holds.delete(`tool:${update.toolCallId}`);
+      }
+      this.set(
+        key2,
+        { reason: `${update.taskType ?? "background"} task`, until: now + MAX_HOLD_MS },
+        now
+      );
+    } else if (update.sessionUpdate === "async_task_state_update" && (update.state === "completed" || update.state === "failed" || update.state === "stopped")) {
+      this.holds.delete(key2);
+      if (update.toolCallId) this.holds.delete(`tool:${update.toolCallId}`);
+    }
+  }
+  /** The holds still in force, dropping the ones that lapsed. */
+  outstanding(now = Date.now()) {
+    for (const [key2, hold] of this.holds) {
+      if (hold.until <= now) this.holds.delete(key2);
+    }
+    return [...this.holds.values()];
+  }
+  clear() {
+    this.holds.clear();
+    this.taskToolCalls.clear();
+  }
+  toolHold(update, now) {
+    const input = update.rawInput;
+    if (!input || typeof input !== "object") return null;
+    switch (toolName(update)) {
+      case "ScheduleWakeup": {
+        const delaySeconds = finiteNumber(input.delaySeconds);
+        return delaySeconds === void 0 ? null : { reason: "scheduled wakeup", until: now + delaySeconds * 1e3 };
+      }
+      case "CronCreate":
+        return { reason: "cron job", until: now + MAX_HOLD_MS };
+      case "Monitor": {
+        const timeout = finiteNumber(input.timeout_ms) ?? MONITOR_DEFAULT_TIMEOUT_MS;
+        return { reason: "monitor", until: now + timeout };
+      }
+      case "Bash":
+      case "PowerShell":
+        return input.run_in_background === true ? { reason: "background command", until: now + MAX_HOLD_MS, untilCompleted: true } : null;
+      default:
+        return null;
+    }
+  }
+  set(key2, hold, now) {
+    this.holds.set(key2, { ...hold, until: Math.min(hold.until, now + MAX_HOLD_MS) });
+  }
+};
+
 // src/server/services/_utils/chat-log-replay.ts
 function textChunk(row) {
   const event = row.event;
@@ -145503,6 +145656,25 @@ function submitTask(options2) {
   });
   return toTaskInfo(task);
 }
+function submitOrQueueTask(options2) {
+  const { workspaceId: workspaceId2, chatId } = options2;
+  if (!workspaceService.resolve(workspaceId2)) {
+    throw new WorkspaceNotFoundError(workspaceId2);
+  }
+  const running = tasks2.get(chatId)?.status === "running";
+  if (!running && !hasQueuedMessages(chatId)) {
+    return { queued: false, task: submitTask(options2) };
+  }
+  const queued = pushQueuedMessage(chatId, {
+    text: options2.prompt,
+    files: options2.attachments,
+    mode: options2.mode,
+    model: options2.model,
+    codingAgentId: options2.codingAgentId
+  });
+  if (!running) drainQueue(workspaceId2, chatId);
+  return { queued: true, queuedMessageId: queued.id };
+}
 async function runTask(task) {
   const { chatId } = task;
   chatService.updateStatus(chatId, "running");
@@ -145632,7 +145804,7 @@ function finishTask(task, outcome) {
   task.completedAt = Date.now();
   persistTask(task);
   if (tasks2.get(task.chatId) === task) tasks2.delete(task.chatId);
-  if (status === "completed" && drainQueue(task)) return;
+  if (status === "completed" && drainQueue(task.workspaceId, task.chatId)) return;
   chatService.updateStatus(task.chatId, status === "completed" ? "idle" : "error");
   const stopped = outcome === "cancelled" || task.cancelRequested === true;
   const updated = setWorkspaceSourceStatus(task.workspaceId, chatStatusSource(task.chatId), {
@@ -145640,20 +145812,24 @@ function finishTask(task, outcome) {
   });
   emit({ kind: "update", status: updated });
 }
-function drainQueue(task) {
-  const queued = shiftQueuedMessage(task.chatId);
+function drainQueue(workspaceId2, chatId) {
+  const queued = peekQueuedMessage(chatId);
   if (!queued) return false;
   try {
     const attachments = (queued.files ?? []).filter((f2) => f2.path).map((f2) => ({ path: f2.path, mediaType: f2.mediaType, url: f2.url, filename: f2.filename }));
     submitTask({
-      workspaceId: task.workspaceId,
-      chatId: task.chatId,
+      workspaceId: workspaceId2,
+      chatId,
       prompt: queued.text,
-      attachments
+      attachments,
+      mode: queued.mode,
+      model: queued.model,
+      codingAgentId: queued.codingAgentId
     });
+    removeQueuedMessage(chatId, queued.id);
     return true;
   } catch (err) {
-    log19.warn({ chatId: task.chatId, err }, "failed to auto-start queued task");
+    log19.warn({ chatId, err }, "failed to auto-start queued task");
     return false;
   }
 }
@@ -145700,6 +145876,9 @@ var TaskService = class {
   submitTask(options2) {
     return submitTask(options2);
   }
+  submitOrQueueTask(options2) {
+    return submitOrQueueTask(options2);
+  }
   abortTask(chatId) {
     return abortTask(chatId);
   }
@@ -149584,6 +149763,7 @@ var chatService = new ChatService();
 var log31 = createLogger("agent-sessions");
 var IDLE_TIMEOUT_MS = 15 * 6e4;
 var CANCEL_GRACE_MS = 15e3;
+var MAX_TIMER_MS = 2 ** 31 - 1;
 var PROBE_SETTLE_MS = 1500;
 var events = new ChatEventQueries();
 var settings = new SettingsQueries();
@@ -149662,6 +149842,7 @@ function runtimeFor(chat, def2) {
       turnSeq: 0,
       live: emptyLive(),
       pending: /* @__PURE__ */ new Map(),
+      work: new PendingWork(),
       idleTimer: null,
       claudeCli: null
     };
@@ -149677,19 +149858,41 @@ function stopRuntime(rt) {
   rt.sessionId = null;
   runtimes.delete(rt.chatId);
 }
-function scheduleIdle(rt) {
+function idleTimeoutMs() {
+  const override = Number(process.env.BAND_AGENT_IDLE_TIMEOUT_MS);
+  return Number.isFinite(override) && override > 0 ? override : IDLE_TIMEOUT_MS;
+}
+function scheduleIdle(rt, delayMs = idleTimeoutMs()) {
   if (rt.idleTimer) clearTimeout(rt.idleTimer);
+  const delay2 = Math.min(delayMs, MAX_TIMER_MS);
   rt.idleTimer = setTimeout(() => {
     rt.idleTimer = null;
     if (rt.inTurn || rt.pending.size > 0 || rt.attaching) return;
+    const now = Date.now();
+    const holds = rt.work.outstanding(now);
+    if (holds.length > 0) {
+      const until = Math.max(...holds.map((h) => h.until));
+      log31.info(
+        {
+          chatId: rt.chatId,
+          work: holds.map((h) => ({ reason: h.reason, until: new Date(h.until).toISOString() }))
+        },
+        "idle agent has pending work; not stopping it"
+      );
+      scheduleIdle(rt, until - now + idleTimeoutMs());
+      return;
+    }
     log31.info({ chatId: rt.chatId }, "stopping idle agent");
     rt.process?.close();
     rt.process = null;
     rt.sessionId = null;
     if (runtimes.get(rt.chatId) === rt) runtimes.delete(rt.chatId);
-  }, IDLE_TIMEOUT_MS);
+  }, delay2);
   rt.idleTimer.unref?.();
 }
+function agentActive(rt) {
+  if (!rt.inTurn && !rt.attaching && rt.process) scheduleIdle(rt);
+}
 function record2(rt, event, turnStart = false) {
   if (!rt.sessionId) {
     broadcastTransient(rt.chatId, event);
@@ -149805,6 +150008,10 @@ function routeUpdate(rt, notification) {
   }
   const update = notification.update;
   applyLive(rt, update);
+  if (!rt.attaching) {
+    rt.work.observeUpdate(update, rt.inTurn);
+    agentActive(rt);
+  }
   if (rt.routing === "drop") return;
   if (update.sessionUpdate === "user_message_chunk") {
     if (rt.inTurn) return;
@@ -149875,6 +150082,11 @@ function requestElicitation(rt, request, signal) {
 function handlersFor(rt, generation) {
   return {
     onUpdate: (n) => routeUpdate(rt, n),
+    onAsyncTask: (n) => {
+      if (n.sessionId !== rt.sessionId || rt.attaching) return;
+      rt.work.observeAsyncTask(n.update);
+      agentActive(rt);
+    },
     onPermission: (req, signal) => requestPermission(rt, req, signal),
     onElicitation: (req, signal) => requestElicitation(rt, req, signal),
     onExit: (code, stderr) => {
@@ -149882,6 +150094,7 @@ function handlersFor(rt, generation) {
       log31.info({ chatId: rt.chatId, code }, "agent exited");
       log31.debug({ chatId: rt.chatId, stderr: stderr.slice(-500) }, "agent stderr");
       for (const p3 of [...rt.pending.values()]) p3.cancel();
+      rt.work.clear();
       rt.process = null;
       rt.starting = null;
     }
@@ -150844,7 +151057,7 @@ async function handleChatSubmit(req, res, chatId) {
     }));
   }
   try {
-    taskService.submitTask({
+    const result = taskService.submitOrQueueTask({
       workspaceId: workspaceId2,
       chatId,
       prompt: text3,
@@ -150854,18 +151067,12 @@ async function handleChatSubmit(req, res, chatId) {
       model,
       codingAgentId
     });
-    log33.info({ chatId, workspaceId: workspaceId2 }, "chat-submit: task started");
-    sendJson2(res, 200, { ok: true, queued: false });
+    log33.info(
+      { chatId, workspaceId: workspaceId2 },
+      result.queued ? "chat-submit: chat busy, message queued" : "chat-submit: task started"
+    );
+    sendJson2(res, 200, { ok: true, queued: result.queued });
   } catch (err) {
-    if (err instanceof TaskConflictError) {
-      pushQueuedMessage(chatId, {
-        text: text3,
-        ...attachments.length > 0 && { files: attachments }
-      });
-      log33.info({ chatId, workspaceId: workspaceId2 }, "chat-submit: task busy, message queued");
-      sendJson2(res, 200, { ok: true, queued: true });
-      return;
-    }
     if (err instanceof WorkspaceNotFoundError) {
       sendJson2(res, 404, { error: err.message });
       return;
@@ -155807,7 +156014,7 @@ var McpServer = class {
   /**
    * Validates tool input arguments against the tool's input schema.
    */
-  async validateToolInput(tool, args, toolName) {
+  async validateToolInput(tool, args, toolName2) {
     if (!tool.inputSchema) {
       return void 0;
     }
@@ -155817,14 +156024,14 @@ var McpServer = class {
     if (!parseResult.success) {
       const error40 = "error" in parseResult ? parseResult.error : "Unknown error";
       const errorMessage = getParseErrorMessage(error40);
-      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage}`);
+      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName2}: ${errorMessage}`);
     }
     return parseResult.data;
   }
   /**
    * Validates tool output against the tool's output schema.
    */
-  async validateToolOutput(tool, result, toolName) {
+  async validateToolOutput(tool, result, toolName2) {
     if (!tool.outputSchema) {
       return;
     }
@@ -155835,14 +156042,14 @@ var McpServer = class {
       return;
     }
     if (!result.structuredContent) {
-      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
+      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${toolName2} has an output schema but no structured content was provided`);
     }
     const outputObj = normalizeObjectSchema(tool.outputSchema);
     const parseResult = await safeParseAsync3(outputObj, result.structuredContent);
     if (!parseResult.success) {
       const error40 = "error" in parseResult ? parseResult.error : "Unknown error";
       const errorMessage = getParseErrorMessage(error40);
-      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`);
+      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName2}: ${errorMessage}`);
     }
   }
   /**
@@ -158627,23 +158834,25 @@ var chatsRouter = t3.router({
     if (!chat) {
       chat = chatService.create(input.workspaceId, { id: input.chatId, name: "Chat" });
     }
-    try {
-      const task = taskService.submitTask({
-        workspaceId: chat.workspaceId,
-        chatId: chat.id,
-        prompt: input.message,
-        sessionId: input.sessionId
-      });
-      return { taskId: task.id, sessionId: task.sessionId };
-    } catch (err) {
-      if (err instanceof TaskConflictError) {
-        throw new TRPCError({
-          code: "CONFLICT",
-          message: "Task already running for this chat pane"
-        });
-      }
-      throw err;
+    const result = taskService.submitOrQueueTask({
+      workspaceId: chat.workspaceId,
+      chatId: chat.id,
+      prompt: input.message,
+      sessionId: input.sessionId
+    });
+    if (result.queued) {
+      return {
+        queued: true,
+        queuedMessageId: result.queuedMessageId,
+        taskId: null,
+        sessionId: null
+      };
     }
+    return {
+      queued: false,
+      taskId: result.task.id,
+      sessionId: result.task.sessionId
+    };
   }),
   stop: publicProcedure.input(external_exports2.object({ chatId: external_exports2.string() })).mutation(({ input }) => {
     taskService.abortTask(input.chatId);
@@ -162148,7 +162357,7 @@ var tasksRouter = t3.router({
       }));
     }
     try {
-      const task = taskService.submitTask({
+      const result = taskService.submitOrQueueTask({
         workspaceId: input.workspaceId,
         chatId,
         prompt: input.prompt,
@@ -162158,7 +162367,19 @@ var tasksRouter = t3.router({
         model: input.model,
         codingAgentId: input.codingAgentId
       });
+      if (result.queued) {
+        return {
+          queued: true,
+          id: null,
+          queuedMessageId: result.queuedMessageId,
+          workspaceId: input.workspaceId,
+          chatId,
+          sessionId: null
+        };
+      }
+      const { task } = result;
       return {
+        queued: false,
         id: task.id,
         workspaceId: task.workspaceId,
         chatId: task.chatId,
@@ -164993,10 +165214,10 @@ function discoverProcedures() {
   for (const [path, procedure] of Object.entries(procRecord)) {
     const type = procedure._def.type;
     if (type === "subscription") continue;
-    const toolName = `band_${path.replace(/\./g, "_")}`;
+    const toolName2 = `band_${path.replace(/\./g, "_")}`;
     const inputs = procedure._def.inputs;
     const inputSchema = inputs.length > 0 ? inputs[0] : void 0;
-    procedures.push({ path, toolName, type, inputSchema });
+    procedures.push({ path, toolName: toolName2, type, inputSchema });
   }
   return procedures;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@band-app/server",
-  "version": "0.37.0",
+  "version": "0.38.0",
   "type": "module",
   "bin": {
     "band-server": "./bin/band-server.mjs"
@@ -127,11 +127,11 @@
     "ws": "^8.18.0",
     "zod": "^3.25.67",
     "zustand": "^5.0.0",
-    "@band-app/coding-agent": "^0.37.0",
-    "@band-app/logger": "^0.37.0",
+    "@band-app/coding-agent": "^0.38.0",
+    "@band-app/logger": "^0.38.0",
     "@band-app/plugin-api": "^0.1.0",
     "@band-app/plugin-github": "^0.1.0",
-    "@band-app/ui": "^0.37.0"
+    "@band-app/ui": "^0.38.0"
   },
   "scripts": {
     "dev": "NODE_ENV=development tsx watch start-server.ts",

package/dist/client/assets/channel-30zU4uX-.js

@@ -1 +0,0 @@
-import{Y as a,Z as n}from"./main-D7maoxCk.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist/client/assets/classDiagram-2ON5EDUG-xMXNI9Qc.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-B4BG7PRW-Bd2C6K3g.js";import{_ as i}from"./main-D7maoxCk.js";import"./chunk-FMBD7UC4-CSFx-rdE.js";import"./chunk-55IACEB6-N8w7W4nW.js";import"./chunk-QN33PNHL-OZhPV9ZW.js";var p={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{p as diagram};

package/dist/client/assets/classDiagram-v2-WZHVMYZB-xMXNI9Qc.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-B4BG7PRW-Bd2C6K3g.js";import{_ as i}from"./main-D7maoxCk.js";import"./chunk-FMBD7UC4-CSFx-rdE.js";import"./chunk-55IACEB6-N8w7W4nW.js";import"./chunk-QN33PNHL-OZhPV9ZW.js";var p={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{p as diagram};

package/dist/client/assets/clone-D1RDOFVG.js

@@ -1 +0,0 @@
-import{b as r}from"./_baseUniq-D9VK2Z8h.js";var e=4;function a(o){return r(o,e)}export{a as c};