@jacexh/claude-web-console 0.12.4 → 0.13.0

package/server/src/session-manager.ts

@@ -159,7 +159,6 @@ export class SessionManager {
   private streamingSessionIds = new Set<string>()
   private sessionListeners = new Map<string, Set<SessionListener>>()
   private idleTimers = new Map<string, ReturnType<typeof setTimeout>>()
-  private pendingRemaps = new Map<string, { sessionIdRef: { current: string } }>()
   // Track cwd for each session so we can resume in the correct project
   private sessionCwds = new Map<string, string>()
   /** User-supplied creation options that must survive resume cycles */
@@ -350,18 +349,24 @@ export class SessionManager {
   }
 
   async createSession(
-    options?: { model?: string; cwd?: string; permissionMode?: string; executableArgs?: string[]; env?: Record<string, string> },
+    options: { message: string; cwd?: string; model?: string; permissionMode?: string; effortLevel?: EffortLevel; executableArgs?: string[]; env?: Record<string, string> },
   ): Promise<string> {
-    const cwd = options?.cwd ?? process.env.CC_WEB_CONSOLE_CWD ?? process.env.HOME ?? '/'
+    const cwd = options.cwd ?? process.env.CC_WEB_CONSOLE_CWD ?? process.env.HOME ?? '/'
     const sessionIdRef = { current: '' }
     const pluginArgs = getPluginDirArgs()
-    const userArgs = options?.executableArgs ?? []
+    const userArgs = options.executableArgs ?? []
+    const opts: SessionCreationOptions = {
+      model: options.model,
+      permissionMode: options.permissionMode,
+      executableArgs: options.executableArgs,
+      env: options.env,
+    }
     const sessionOptions = {
-      ...(options?.model ? { model: options.model } : {}),
-      permissionMode: options?.permissionMode ?? 'default',
+      ...(options.model ? { model: options.model } : {}),
+      permissionMode: options.permissionMode ?? 'default',
       canUseTool: this.buildCanUseTool(sessionIdRef),
       onElicitation: this.buildOnElicitation(sessionIdRef),
-      env: { ...cleanEnv(cwd), ...options?.env },
+      env: { ...cleanEnv(cwd), ...options.env },
       pathToClaudeCodeExecutable: CLAUDE_EXECUTABLE,
       executableArgs: [...pluginArgs, ...userArgs],
     } as SDKSessionOptions
@@ -371,28 +376,62 @@ export class SessionManager {
     const session = unstable_v2_createSession(sessionOptions)
     try { process.chdir(originalCwd) } catch { /* ignore */ }
 
-    // New sessions need send() before sessionId is available.
-    // Use a temporary ID, then remap when real sessionId arrives.
-    const tempId = `pending-${Date.now()}`
-    this.sessions.set(tempId, session)
-    this.sessionStatus.set(tempId, 'idle')
-    this.sessionCwds.set(tempId, cwd)
-    this.sessionCreationOptions.set(tempId, {
-      model: options?.model,
-      permissionMode: options?.permissionMode,
-      executableArgs: options?.executableArgs,
-      env: options?.env,
-    })
-
-    // Store tempId in pendingRemaps for remap inside consumeStream
-    this.pendingRemaps.set(tempId, { sessionIdRef })
-
-    // For new sessions, start stream immediately — SDK may emit init messages
-    this.startStreamConsumer(tempId, session)
+    // Send first message — SDK assigns sessionId asynchronously after send()
+    this.log.info({ cwd, model: options.model }, 'createSession: sending first message')
+    await session.send(options.message)
+
+    // SDK requires stream() to be consumed for the session to progress.
+    // Use a mutable ref so consumeStream picks up the real sessionId once resolved.
+    const streamIdRef = { current: `pending-${Date.now()}` }
+    this.log.info('createSession: starting stream + waiting for sessionId')
+    this.sessions.set(streamIdRef.current, session)
+    this.streamingSessionIds.add(streamIdRef.current)
+    this.consumeStream(streamIdRef, session)
+
+    const sessionId = await waitForSessionId(session, 30000)
+    this.log.info({ sessionId }, 'createSession: sessionId resolved')
+    sessionIdRef.current = sessionId
+
+    // Remap internal maps from tempKey → real sessionId
+    const tempKey = streamIdRef.current === sessionId ? null : streamIdRef.current
+    streamIdRef.current = sessionId
+    if (tempKey && tempKey !== sessionId) {
+      const s = this.sessions.get(tempKey)
+      if (s) { this.sessions.delete(tempKey); this.sessions.set(sessionId, s) }
+      this.streamingSessionIds.delete(tempKey)
+      this.streamingSessionIds.add(sessionId)
+      const listeners = this.sessionListeners.get(tempKey)
+      if (listeners) { this.sessionListeners.delete(tempKey); this.sessionListeners.set(sessionId, listeners) }
+      const q = this.activeQueries.get(tempKey)
+      if (q) { this.activeQueries.delete(tempKey); this.activeQueries.set(sessionId, q) }
+      const prevStatus = this.sessionStatus.get(tempKey)
+      this.sessionStatus.delete(tempKey)
+      if (prevStatus) this.sessionStatus.set(sessionId, prevStatus)
+    }
+
+    // Register session state under real sessionId
+    this.sessionStatus.set(sessionId, 'running')
+    this.sessionCwds.set(sessionId, cwd)
+    this.sessionCreationOptions.set(sessionId, opts)
+    saveSessionOptions(sessionId, opts)
+
+    // Pre-populate model/effort so getSessionState() returns them immediately
+    // when the client sends switch_session (before consumeStream's init message)
+    if (options.model) {
+      this.sessionModels.set(sessionId, options.model)
+    }
+    if (options.effortLevel) {
+      this.sessionEffortLevels.set(sessionId, options.effortLevel)
+    }
+
+    // Apply effort level after session is running (SDK doesn't accept it in SDKSessionOptions)
+    if (options.effortLevel) {
+      this.setEffortLevel(sessionId, options.effortLevel).catch((err) => {
+        this.log.error({ err, sessionId }, 'Failed to set initial effort level')
+      })
+    }
 
-    // SDK requires send() before sessionId is available.
-    // Return tempId now; real sessionId arrives via session_id_resolved WS event after first send().
-    return tempId
+    return sessionId
   }
 
   private fetchAndBroadcastModels(sessionId: string, session: SDKSession, currentModel?: string): void {
@@ -418,81 +457,68 @@ export class SessionManager {
   ): void {
     if (this.streamingSessionIds.has(sessionId)) return
     this.streamingSessionIds.add(sessionId)
-    this.consumeStream(sessionId, session)
+    this.consumeStream({ current: sessionId }, session)
   }
 
   private async consumeStream(
-    initialSessionId: string,
+    idRef: { current: string },
     session: SDKSession,
   ): Promise<void> {
-    // Track the current sessionId — may change from tempId to real sessionId
-    let currentSessionId = initialSessionId
+    // sessionId is read from ref — may change from tempKey to real ID during initial creation
+    const getId = () => idRef.current
     let modelsFetched = false
 
     try {
       // SDK's stream() ends after each turn (on "result" message).
       // Loop to re-enter stream() for subsequent turns.
       while (true) {
-        this.log.info({ sessionId: currentSessionId }, 'consumeStream: entering stream()')
+        this.log.info({ sessionId: getId() }, 'consumeStream: entering stream()')
         const query = session.stream()
         const turnState: TurnState = { turnStarted: false }
-        // Store query reference so control requests (setModel etc.) can use it
-        try {
-          const sid = session.sessionId
-          this.activeQueries.set(sid, query)
-        } catch { /* sessionId not yet available, will set after remap */ }
+        this.activeQueries.set(getId(), query)
 
         for await (const msg of query) {
+          const sid = getId()
           const msgAny = msg as Record<string, unknown>
           this.log.info({
             type: msgAny.type,
             subtype: msgAny.subtype,
             parentToolUseId: msgAny.parent_tool_use_id,
-            sessionId: currentSessionId,
+            sessionId: sid,
             message: JSON.stringify(msg).slice(0, 50),
           }, 'Stream message received')
 
           // Fetch models once after stream is active (works for both new and resumed sessions)
           if (!modelsFetched) {
             modelsFetched = true
-            try {
-              const sid = session.sessionId
-              // Update query ref now that sessionId is available
-              this.activeQueries.set(sid, query)
-              this.fetchAndBroadcastModels(sid, session, (msgAny.type === 'system' && msgAny.subtype === 'init') ? (msgAny.model as string) : undefined)
-            } catch { /* session not yet initialized */ }
+            this.activeQueries.set(sid, query)
+            this.fetchAndBroadcastModels(sid, session, (msgAny.type === 'system' && msgAny.subtype === 'init') ? (msgAny.model as string) : undefined)
           }
 
           // Extract commands from init message, then enrich with full descriptions
           if (msgAny.type === 'system' && msgAny.subtype === 'init') {
-            try {
-              const sid = session.sessionId
-              const slashCmds = (msgAny.slash_commands as string[]) ?? []
-              const skills = (msgAny.skills as string[]) ?? []
-              const allNames = new Set([...slashCmds, ...skills])
-              // Set basic cache immediately so getCommands() doesn't return empty
-              this.sessionCommands.set(sid, Array.from(allNames).map((name) => ({
-                name,
-                description: skills.includes(name) ? 'skill' : '',
-              })))
-              // Async: fetch full descriptions from supportedCommands()
-              const q = (session as unknown as { query: { supportedCommands(): Promise<{ name: string; description: string }[]> } }).query
-              q?.supportedCommands()?.then((cmds: { name: string; description: string }[]) => {
-                if (cmds.length > 0) {
-                  // Merge: use supportedCommands descriptions, but keep init-only skills that supportedCommands missed
-                  const cmdMap = new Map(cmds.map((c) => [c.name, c]))
-                  const existing = this.sessionCommands.get(sid) ?? []
-                  for (const prev of existing) {
-                    if (!cmdMap.has(prev.name)) {
-                      cmdMap.set(prev.name, prev)
-                    }
+            const slashCmds = (msgAny.slash_commands as string[]) ?? []
+            const skills = (msgAny.skills as string[]) ?? []
+            const allNames = new Set([...slashCmds, ...skills])
+            this.sessionCommands.set(sid, Array.from(allNames).map((name) => ({
+              name,
+              description: skills.includes(name) ? 'skill' : '',
+            })))
+            const q = (session as unknown as { query: { supportedCommands(): Promise<{ name: string; description: string }[]> } }).query
+            q?.supportedCommands()?.then((cmds: { name: string; description: string }[]) => {
+              if (cmds.length > 0) {
+                const currentSid = getId()
+                const cmdMap = new Map(cmds.map((c) => [c.name, c]))
+                const existing = this.sessionCommands.get(currentSid) ?? []
+                for (const prev of existing) {
+                  if (!cmdMap.has(prev.name)) {
+                    cmdMap.set(prev.name, prev)
                   }
-                  this.sessionCommands.set(sid, Array.from(cmdMap.values()))
-                  // Notify via broadcast so ws-handler can push updated list
-                  this.broadcast(sid, (l) => l.onMessage(sid, { type: 'commands_updated' } as unknown as SDKMessage))
                 }
-              }).catch(() => {})
-            } catch { /* session not yet initialized */ }
+                this.sessionCommands.set(currentSid, Array.from(cmdMap.values()))
+                this.broadcast(currentSid, (l) => l.onMessage(currentSid, { type: 'commands_updated' } as unknown as SDKMessage))
+              }
+            }).catch(() => {})
           }
           if (msgAny.type === 'result') {
             if (msgAny.is_error) {
@@ -500,96 +526,40 @@ export class SessionManager {
             } else {
               this.log.info({ cost: (msgAny as Record<string, unknown>).total_cost_usd }, 'Turn complete')
             }
-            this.sessionStatus.set(currentSessionId, 'idle')
-          }
-
-          let sessionId: string
-          try {
-            sessionId = session.sessionId
-          } catch {
-            continue
+            this.sessionStatus.set(sid, 'idle')
           }
 
-          // Remap tempId → real sessionId (O(1) lookup)
-          const remap = this.pendingRemaps.get(initialSessionId)
-          if (remap && remap.sessionIdRef.current === '' && sessionId && !sessionId.startsWith('pending-')) {
-            remap.sessionIdRef.current = sessionId
-            const tempId = initialSessionId
-            // Move session, cwd, listeners, streaming from tempId to real sessionId
-            const s = this.sessions.get(tempId)
-            if (s) { this.sessions.delete(tempId); this.sessions.set(sessionId, s) }
-            const c = this.sessionCwds.get(tempId)
-            if (c) { this.sessionCwds.delete(tempId); this.sessionCwds.set(sessionId, c) }
-            const opts = this.sessionCreationOptions.get(tempId)
-            if (opts) { this.sessionCreationOptions.delete(tempId); this.sessionCreationOptions.set(sessionId, opts); saveSessionOptions(sessionId, opts) }
-            const listeners = this.sessionListeners.get(tempId)
-            if (listeners) { this.sessionListeners.delete(tempId); this.sessionListeners.set(sessionId, listeners) }
-            this.streamingSessionIds.delete(tempId)
-            this.streamingSessionIds.add(sessionId)
-            const prevStatus = this.sessionStatus.get(tempId)
-            this.sessionStatus.delete(tempId)
-            if (prevStatus) this.sessionStatus.set(sessionId, prevStatus)
-            const q = this.activeQueries.get(tempId)
-            if (q) { this.activeQueries.delete(tempId); this.activeQueries.set(sessionId, q) }
-            this.pendingRemaps.delete(tempId)
-            // Update our tracking variable
-            currentSessionId = sessionId
-            // Notify listeners of the remap
-            this.broadcast(sessionId, (l) => l.onMessage(sessionId, {
-              type: 'session_id_resolved', tempId, sessionId,
-            } as unknown as SDKMessage))
-          }
-
-          // Set session status to running on first turn message (skip system/init)
           if (isTurnMessage(msgAny) && shouldBroadcastTurnStarted(turnState)) {
-            this.sessionStatus.set(sessionId, 'running')
+            this.sessionStatus.set(sid, 'running')
           }
-          this.broadcast(sessionId, (l) => l.onMessage(sessionId, msg))
+          this.broadcast(sid, (l) => l.onMessage(sid, msg))
         }
-        this.log.info({ sessionId: currentSessionId }, 'consumeStream: stream() ended (turn complete)')
-        // Check if session was closed while we were streaming
-        let sessionId: string
-        try { sessionId = session.sessionId } catch { break }
-        if (this.closedSessionIds.has(sessionId)) break
-        // Reset to idle if stream ended without a result (e.g. init-only stream)
-        if (shouldResetToIdleOnStreamEnd(this.sessionStatus.get(sessionId))) {
-          this.sessionStatus.set(sessionId, 'idle')
+        const sid = getId()
+        this.log.info({ sessionId: sid }, 'consumeStream: stream() ended (turn complete)')
+        if (this.closedSessionIds.has(sid)) break
+        // If stream ended without a result (e.g. control message like setModel response),
+        // reset status back to idle so the client isn't stuck in 'running'
+        if (shouldResetToIdleOnStreamEnd(this.sessionStatus.get(sid))) {
+          this.sessionStatus.set(sid, 'idle')
         }
         // Wait briefly before re-entering stream() for next turn
         await new Promise((r) => setTimeout(r, 50))
       }
     } catch (err) {
-      // AbortError is expected when session is closed
       if (!(err instanceof Error && err.name === 'AbortError')) {
         this.log.error({ err }, 'Stream error')
       }
     } finally {
-      try {
-        const sessionId = session.sessionId
-        this.sessionStatus.set(sessionId, 'stopped')
-        this.streamingSessionIds.delete(sessionId)
-        this.activeQueries.delete(sessionId)
-        // Clean up stale session object if stream ended unexpectedly (not via explicit closeSession).
-        // Without this, the session stays in this.sessions (appears "already running")
-        // while sessionStatus shows it as idle — making resume impossible.
-        if (this.sessions.has(sessionId) && !this.closedSessionIds.has(sessionId)) {
-          const s = this.sessions.get(sessionId)
-          this.sessions.delete(sessionId)
-          try { s?.close() } catch { /* already closed */ }
-        }
-        this.broadcast(sessionId, (l) => l.onEnd(sessionId))
-      } catch {
-        // Session never initialized — try with our tracked id
-        this.sessionStatus.set(currentSessionId, 'stopped')
-        this.streamingSessionIds.delete(currentSessionId)
-        this.activeQueries.delete(currentSessionId)
-        if (this.sessions.has(currentSessionId) && !this.closedSessionIds.has(currentSessionId)) {
-          const s = this.sessions.get(currentSessionId)
-          this.sessions.delete(currentSessionId)
-          try { s?.close() } catch { /* already closed */ }
-        }
-        this.broadcast(currentSessionId, (l) => l.onEnd(currentSessionId))
+      const sid = getId()
+      this.sessionStatus.set(sid, 'stopped')
+      this.streamingSessionIds.delete(sid)
+      this.activeQueries.delete(sid)
+      if (this.sessions.has(sid) && !this.closedSessionIds.has(sid)) {
+        const s = this.sessions.get(sid)
+        this.sessions.delete(sid)
+        try { s?.close() } catch { /* already closed */ }
       }
+      this.broadcast(sid, (l) => l.onEnd(sid))
     }
   }
 
@@ -664,6 +634,45 @@ export class SessionManager {
     } as unknown as SDKMessage))
   }
 
+  async setPermissionMode(sessionId: string, mode: string): Promise<void> {
+    const session = this.sessions.get(sessionId)
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`)
+    }
+    const query = (session as unknown as { query: { setPermissionMode(mode: string): Promise<void> } }).query
+    if (!query?.setPermissionMode) {
+      throw new Error(`Session ${sessionId} does not support setPermissionMode`)
+    }
+    await query.setPermissionMode(mode)
+    // Persist so resume uses the updated permission mode
+    const opts = this.sessionCreationOptions.get(sessionId)
+    if (opts) {
+      opts.permissionMode = mode
+      saveSessionOptions(sessionId, opts)
+    }
+    this.broadcast(sessionId, (l) => l.onMessage(sessionId, {
+      type: 'permission_mode_changed', sessionId, mode,
+    } as unknown as SDKMessage))
+  }
+
+  async setEnv(sessionId: string, env: Record<string, string>): Promise<void> {
+    const session = this.sessions.get(sessionId)
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`)
+    }
+    const query = (session as unknown as { query: { applyFlagSettings(settings: { env?: Record<string, string> }): Promise<void> } }).query
+    if (!query?.applyFlagSettings) {
+      throw new Error(`Session ${sessionId} does not support applyFlagSettings`)
+    }
+    await query.applyFlagSettings({ env })
+    // Persist so resume uses the updated env
+    const opts = this.sessionCreationOptions.get(sessionId)
+    if (opts) {
+      opts.env = env
+      saveSessionOptions(sessionId, opts)
+    }
+  }
+
   getSessionState(sessionId: string): { model?: string; effortLevel?: EffortLevel; status: 'idle' | 'running' | 'stopped' } {
     return {
       model: this.sessionModels.get(sessionId),
@@ -875,7 +884,6 @@ export class SessionManager {
 
       // Keep sessionCwds and sessionCommands — they're metadata needed for re-resume.
       // Only clean up runtime state.
-      this.pendingRemaps.delete(sessionId)
       // Deny pending permissions only for this session
       for (const [id, entry] of this.pendingPermissions) {
         if (entry.sessionId === sessionId) {

package/server/src/turn-lifecycle.ts

@@ -14,7 +14,10 @@ export function shouldResetToIdleOnStreamEnd(currentStatus: string): boolean {
   return currentStatus === 'running'
 }
 
-/** Returns true if this SDK message is part of an active turn (not session init). */
+/**
+ * Returns true if this SDK message is part of an active turn (not session init
+ * or a control response like setModel/applyFlagSettings).
+ */
 export function isTurnMessage(msg: Record<string, unknown>): boolean {
   if (msg.type === 'system' && msg.subtype === 'init') return false
   return true

package/server/src/types.ts

@@ -99,6 +99,18 @@ export interface ElicitationResponseMessage {
   content?: Record<string, unknown>
 }
 
+export interface SetPermissionModeMessage {
+  type: 'set_permission_mode'
+  sessionId: string
+  mode: string
+}
+
+export interface SetEnvMessage {
+  type: 'set_env'
+  sessionId: string
+  env: Record<string, string>
+}
+
 export interface GetSessionSettingsMessage {
   type: 'get_session_settings'
   sessionId: string
@@ -122,6 +134,8 @@ export type ClientMessage =
   | SetEffortLevelMessage
   | GetSubagentMessagesMessage
   | ElicitationResponseMessage
+  | SetPermissionModeMessage
+  | SetEnvMessage
   | GetSessionSettingsMessage
 
 // === Server → Client Messages ===
@@ -173,12 +187,6 @@ export interface SessionHistoryMessage {
   messages: unknown[]
 }
 
-export interface SessionIdResolvedMessage {
-  type: 'session_id_resolved'
-  tempId: string
-  sessionId: string
-}
-
 export interface FileListMessage {
   type: 'file_list'
   files: FileEntry[]
@@ -293,7 +301,6 @@ export type ServerMessage =
   | ErrorMessage
   | SessionEndMessage
   | SessionHistoryMessage
-  | SessionIdResolvedMessage
   | FileListMessage
   | DefaultCwdMessage
   | CommandListMessage

package/server/src/ws-handler.ts

@@ -47,15 +47,6 @@ export function createWsHandler(sessionManager: SessionManager, log: FastifyBase
             return
           }
 
-          if (msg.type === 'session_id_resolved') {
-            send({
-              type: 'session_id_resolved',
-              tempId: msg.tempId as string,
-              sessionId: msg.sessionId as string,
-            })
-            return
-          }
-
           if (msg.type === 'session_resumed') {
             send({
               type: 'session_resumed',
@@ -185,6 +176,10 @@ export function createWsHandler(sessionManager: SessionManager, log: FastifyBase
           }
 
           case 'switch_session': {
+            // Subscribe FIRST so live stream messages are not lost while loading history.
+            // For new sessions, consumeStream is already running — registering early
+            // ensures we catch assistant response chunks during the getHistory() await.
+            sessionManager.subscribe(msg.sessionId, makeListener(msg.sessionId))
             // Load historical messages
             const history = await sessionManager.getHistory(msg.sessionId)
             send({ type: 'session_history', sessionId: msg.sessionId, messages: history })
@@ -193,8 +188,6 @@ export function createWsHandler(sessionManager: SessionManager, log: FastifyBase
             if (state.model || state.effortLevel) {
               send({ type: 'session_state', sessionId: msg.sessionId, ...state })
             }
-            // Subscribe for live updates if session is running
-            sessionManager.subscribe(msg.sessionId, makeListener(msg.sessionId))
             break
           }
 
@@ -292,6 +285,16 @@ export function createWsHandler(sessionManager: SessionManager, log: FastifyBase
             break
           }
 
+          case 'set_permission_mode': {
+            await sessionManager.setPermissionMode(msg.sessionId, msg.mode)
+            break
+          }
+
+          case 'set_env': {
+            await sessionManager.setEnv(msg.sessionId, msg.env)
+            break
+          }
+
           case 'get_subagent_messages': {
             const messages = await sessionManager.getSubagentMessages(msg.sessionId, msg.agentId)
             send({ type: 'subagent_messages', sessionId: msg.sessionId, agentId: msg.agentId, messages })

package/client/dist/assets/channel-DETbjbce.js

@@ -1 +0,0 @@
-import{aq as o,ar as n}from"./mermaid.core-D970jp78.js";const t=(r,a)=>o.lang.round(n.parse(r)[a]);export{t as c};

package/client/dist/assets/classDiagram-6PBFFD2Q-BcM7pkgM.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-4TB4RGXK-dGyuU23q.js";import{_ as i}from"./mermaid.core-D970jp78.js";import"./chunk-FMBD7UC4-O6auhXOZ.js";import"./chunk-YZCP3GAM-CSmbvz_K.js";import"./chunk-55IACEB6-DDiu2l5t.js";import"./chunk-EDXVE4YY-B_5Djzmq.js";import"./index-CQyb-QJw.js";var n={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{n as diagram};

package/client/dist/assets/classDiagram-v2-HSJHXN6E-BcM7pkgM.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-4TB4RGXK-dGyuU23q.js";import{_ as i}from"./mermaid.core-D970jp78.js";import"./chunk-FMBD7UC4-O6auhXOZ.js";import"./chunk-YZCP3GAM-CSmbvz_K.js";import"./chunk-55IACEB6-DDiu2l5t.js";import"./chunk-EDXVE4YY-B_5Djzmq.js";import"./index-CQyb-QJw.js";var n={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{n as diagram};

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

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