openfox 0.2.4 → 1.0.0

package/dist/cli/dev.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import {
   runCli
-} from "../chunk-S5NRIWEU.js";
+} from "../chunk-2TBNG7CS.js";
 import {
   logger
-} from "../chunk-U62ZECSQ.js";
+} from "../chunk-PNBH3RAX.js";
 
 // src/cli/dev.ts
-runCli({ mode: "development" }).catch((error) => {
+var mode = process.env["OPENFOX_MODE"] ?? "development";
+runCli({ mode }).catch((error) => {
   logger.error("CLI fatal error", { error: error instanceof Error ? error.message : String(error) });
   process.exit(1);
 });

package/dist/cli/index.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import {
   runCli
-} from "../chunk-S5NRIWEU.js";
+} from "../chunk-2TBNG7CS.js";
 import {
   logger
-} from "../chunk-U62ZECSQ.js";
+} from "../chunk-PNBH3RAX.js";
 
 // src/cli/index.ts
-runCli({ mode: "production" }).catch((error) => {
+var mode = process.env["OPENFOX_MODE"] ?? "production";
+runCli({ mode }).catch((error) => {
   logger.error("CLI fatal error", { error: error instanceof Error ? error.message : String(error) });
   process.exit(1);
 });

package/dist/{config-GIXXE4VK.js → config-GIFCEJDU.js}

@@ -4,6 +4,8 @@ import {
   configFileExists,
   getActiveProvider,
   getDefaultModel,
+  getDefaultVisionFallback,
+  getVisionFallback,
   loadGlobalConfig,
   mergeConfigs,
   migrateConfig,
@@ -11,17 +13,20 @@ import {
   saveGlobalConfig,
   setDefaultModelSelection,
   trySmartDefaults
-} from "./chunk-GZ7ZVJIW.js";
-import "./chunk-5ZUU23XF.js";
-import "./chunk-26NRL3HX.js";
-import "./chunk-U62ZECSQ.js";
-import "./chunk-AF7XS4OI.js";
+} from "./chunk-3UQACISJ.js";
+import "./chunk-U6BUT37A.js";
+import "./chunk-XFXOSPYH.js";
+import "./chunk-5YQAXUKO.js";
+import "./chunk-M2C5GEQR.js";
+import "./chunk-PNBH3RAX.js";
 export {
   activateProvider,
   addProvider,
   configFileExists,
   getActiveProvider,
   getDefaultModel,
+  getDefaultVisionFallback,
+  getVisionFallback,
   loadGlobalConfig,
   mergeConfigs,
   migrateConfig,
@@ -30,4 +35,4 @@ export {
   setDefaultModelSelection,
   trySmartDefaults
 };
-//# sourceMappingURL=config-GIXXE4VK.js.map
+//# sourceMappingURL=config-GIFCEJDU.js.map

package/dist/events-G6CKHDNZ.js

@@ -0,0 +1,114 @@
+import {
+  EventStore,
+  compactContext,
+  createEvent,
+  emitAssistantMessageStart,
+  emitChatDone,
+  emitChatError,
+  emitContextCompacted,
+  emitContextState,
+  emitCriteriaSet,
+  emitCriterionUpdated,
+  emitFileRead,
+  emitFormatRetry,
+  emitMessageDelta,
+  emitMessageDone,
+  emitMessageThinking,
+  emitModeChanged,
+  emitPhaseChanged,
+  emitRunningChanged,
+  emitSessionInitialized,
+  emitTodosUpdated,
+  emitToolCall,
+  emitToolOutput,
+  emitToolPreparing,
+  emitToolResult,
+  emitTurnSnapshot,
+  emitUserMessage,
+  getContextMessages,
+  getCurrentContextWindowId,
+  getCurrentWindowMessages,
+  getEventStore,
+  getReadFilesCache,
+  getRecentUserPromptsForSession,
+  getSessionState,
+  initEventStore,
+  isFileInCache,
+  isStoredEvent,
+  isTurnEvent
+} from "./chunk-BU2ZYOEA.js";
+import {
+  buildContextMessagesFromEventHistory,
+  buildContextMessagesFromMessages,
+  buildContextMessagesFromStoredEvents,
+  buildMessagesFromStoredEvents,
+  buildSnapshot,
+  buildSnapshotFromSessionState,
+  foldContextState,
+  foldCriteria,
+  foldIsRunning,
+  foldMode,
+  foldPhase,
+  foldSessionState,
+  foldTodos,
+  foldTurnEventsToSnapshotMessages,
+  getMessagesForWindow
+} from "./chunk-2KSCZSXQ.js";
+import "./chunk-3EHGGBWE.js";
+import "./chunk-TVQOONDR.js";
+import "./chunk-PNBH3RAX.js";
+export {
+  EventStore,
+  buildContextMessagesFromEventHistory,
+  buildContextMessagesFromMessages,
+  buildContextMessagesFromStoredEvents,
+  buildMessagesFromStoredEvents,
+  buildSnapshot,
+  buildSnapshotFromSessionState,
+  compactContext,
+  createEvent,
+  emitAssistantMessageStart,
+  emitChatDone,
+  emitChatError,
+  emitContextCompacted,
+  emitContextState,
+  emitCriteriaSet,
+  emitCriterionUpdated,
+  emitFileRead,
+  emitFormatRetry,
+  emitMessageDelta,
+  emitMessageDone,
+  emitMessageThinking,
+  emitModeChanged,
+  emitPhaseChanged,
+  emitRunningChanged,
+  emitSessionInitialized,
+  emitTodosUpdated,
+  emitToolCall,
+  emitToolOutput,
+  emitToolPreparing,
+  emitToolResult,
+  emitTurnSnapshot,
+  emitUserMessage,
+  foldContextState,
+  foldCriteria,
+  foldIsRunning,
+  foldMode,
+  foldPhase,
+  foldSessionState,
+  foldTodos,
+  foldTurnEventsToSnapshotMessages,
+  getContextMessages,
+  getCurrentContextWindowId,
+  getCurrentWindowMessages,
+  getEventStore,
+  getMessagesForWindow,
+  getReadFilesCache,
+  getRecentUserPromptsForSession,
+  getSessionState,
+  initEventStore,
+  isFileInCache,
+  isStoredEvent,
+  isTurnEvent
+};
+//# sourceMappingURL=events-G6CKHDNZ.js.map

package/dist/folding-O52L65VN.js

@@ -0,0 +1,37 @@
+import {
+  buildContextMessagesFromEventHistory,
+  buildContextMessagesFromMessages,
+  buildContextMessagesFromStoredEvents,
+  buildMessagesFromStoredEvents,
+  buildSnapshot,
+  buildSnapshotFromSessionState,
+  foldContextState,
+  foldCriteria,
+  foldIsRunning,
+  foldMode,
+  foldPendingConfirmations,
+  foldPhase,
+  foldSessionState,
+  foldTodos,
+  foldTurnEventsToSnapshotMessages,
+  getMessagesForWindow
+} from "./chunk-2KSCZSXQ.js";
+export {
+  buildContextMessagesFromEventHistory,
+  buildContextMessagesFromMessages,
+  buildContextMessagesFromStoredEvents,
+  buildMessagesFromStoredEvents,
+  buildSnapshot,
+  buildSnapshotFromSessionState,
+  foldContextState,
+  foldCriteria,
+  foldIsRunning,
+  foldMode,
+  foldPendingConfirmations,
+  foldPhase,
+  foldSessionState,
+  foldTodos,
+  foldTurnEventsToSnapshotMessages,
+  getMessagesForWindow
+};
+//# sourceMappingURL=folding-O52L65VN.js.map

package/dist/{init-2EJ5AC7Z.js → init-MKTUIGZU.js}

@@ -1,14 +1,15 @@
 import {
   addProvider,
   saveGlobalConfig
-} from "./chunk-GZ7ZVJIW.js";
+} from "./chunk-3UQACISJ.js";
 import {
   detectBackend,
   detectModel
-} from "./chunk-5ZUU23XF.js";
-import "./chunk-26NRL3HX.js";
-import "./chunk-U62ZECSQ.js";
-import "./chunk-AF7XS4OI.js";
+} from "./chunk-U6BUT37A.js";
+import "./chunk-XFXOSPYH.js";
+import "./chunk-5YQAXUKO.js";
+import "./chunk-M2C5GEQR.js";
+import "./chunk-PNBH3RAX.js";
 
 // src/cli/init.ts
 import { select, text, spinner, outro, confirm } from "@clack/prompts";
@@ -21,11 +22,14 @@ var LLM_OPTIONS = [
 function createBaseConfig() {
   return {
     providers: [],
+    defaultModelSelection: void 0,
     activeProviderId: void 0,
+    activeWorkflowId: void 0,
     server: { port: 10369, host: "127.0.0.1", openBrowser: true },
     logging: { level: "info" },
     database: { path: "" },
-    workspace: { workdir: process.cwd() }
+    workspace: { workdir: process.cwd() },
+    visionFallback: { enabled: false, url: "http://localhost:11434", model: "qwen3-vl:2b", timeout: 120 }
   };
 }
 async function promptNetworkAccessibility() {
@@ -95,7 +99,7 @@ async function runInitWithSelect(mode, existingConfig) {
         name: "Default",
         url: found.url,
         backend: found.backend,
-        maxContext: 2e5,
+        models: [],
         isActive: true
       });
     } else {
@@ -129,10 +133,10 @@ async function runInitWithSelect(mode, existingConfig) {
           name: "Default",
           url,
           backend,
-          maxContext: 2e5,
+          models: [],
           isActive: true
         });
-        const { setDefaultModelSelection } = await import("./config-GIXXE4VK.js");
+        const { setDefaultModelSelection } = await import("./config-GIFCEJDU.js");
         config = setDefaultModelSelection(config, config.providers[config.providers.length - 1].id, model ?? "auto");
       } catch {
         s2.stop("Server isn't available");
@@ -153,10 +157,10 @@ async function runInitWithSelect(mode, existingConfig) {
           name: "Default",
           url,
           backend: "auto",
-          maxContext: 2e5,
+          models: [],
           isActive: true
         });
-        const { setDefaultModelSelection } = await import("./config-GIXXE4VK.js");
+        const { setDefaultModelSelection } = await import("./config-GIFCEJDU.js");
         config = setDefaultModelSelection(config, config.providers[config.providers.length - 1].id, "auto");
       }
     }
@@ -172,8 +176,37 @@ async function runInitWithSelect(mode, existingConfig) {
     }
   });
   config.workspace = { workdir: String(workdirChoice).replace(/\/$/, "") };
+  const visionChoice = await confirm({
+    message: "Configure vision fallback for non-vision models?",
+    initialValue: false
+  });
+  if (visionChoice === true) {
+    const visionUrl = await text({
+      message: "Vision fallback server URL",
+      placeholder: "http://localhost:11434",
+      initialValue: config.visionFallback?.url || "http://localhost:11434",
+      validate: (value) => {
+        if (!value || value.length === 0) return "URL is required";
+        if (!value.startsWith("http")) return "Must start with http://";
+      }
+    });
+    const visionModel = await text({
+      message: "Vision fallback model name",
+      placeholder: "qwen3-vl:2b",
+      initialValue: config.visionFallback?.model || "qwen3-vl:2b",
+      validate: (value) => {
+        if (!value || value.length === 0) return "Model name is required";
+      }
+    });
+    config.visionFallback = {
+      enabled: true,
+      url: String(visionUrl),
+      model: String(visionModel),
+      timeout: 120
+    };
+  }
   if (config.providers.length > 0 && !config.defaultModelSelection) {
-    const { setDefaultModelSelection } = await import("./config-GIXXE4VK.js");
+    const { setDefaultModelSelection } = await import("./config-GIFCEJDU.js");
     config = setDefaultModelSelection(config, config.providers[0].id, "auto");
   }
   await saveGlobalConfig(mode, config);
@@ -182,4 +215,4 @@ async function runInitWithSelect(mode, existingConfig) {
 export {
   runInitWithSelect
 };
-//# sourceMappingURL=init-2EJ5AC7Z.js.map
+//# sourceMappingURL=init-MKTUIGZU.js.map

package/dist/orchestrator-UGXX7JRQ.js

@@ -0,0 +1,39 @@
+import {
+  filterToolRegistryForStepDone,
+  runBuilderTurn,
+  runChatTurn,
+  runVerifierTurn
+} from "./chunk-VZXXJKSQ.js";
+import {
+  TurnMetrics,
+  createChatDoneEvent,
+  createMessageDoneEvent,
+  createMessageStartEvent,
+  createToolCallEvent,
+  createToolResultEvent
+} from "./chunk-YB2574C6.js";
+import "./chunk-BU2ZYOEA.js";
+import "./chunk-2KSCZSXQ.js";
+import "./chunk-S4QKTRGJ.js";
+import "./chunk-22CTURMH.js";
+import "./chunk-7IOZFJBW.js";
+import "./chunk-XKFPU2FA.js";
+import "./chunk-3EHGGBWE.js";
+import "./chunk-TPT6HP4H.js";
+import "./chunk-TVQOONDR.js";
+import "./chunk-XFXOSPYH.js";
+import "./chunk-5YQAXUKO.js";
+import "./chunk-PNBH3RAX.js";
+export {
+  TurnMetrics,
+  createChatDoneEvent,
+  createMessageDoneEvent,
+  createMessageStartEvent,
+  createToolCallEvent,
+  createToolResultEvent,
+  filterToolRegistryForStepDone,
+  runBuilderTurn,
+  runChatTurn,
+  runVerifierTurn
+};
+//# sourceMappingURL=orchestrator-UGXX7JRQ.js.map

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openfox",
-  "version": "0.2.4",
+  "version": "1.0.0",
   "description": "Local-LLM-first agentic coding assistant",
   "type": "module",
   "bin": {
@@ -34,6 +34,9 @@
     "test": "vitest run --reporter=dot --silent=passed-only && vitest run --reporter=dot --silent=passed-only --config e2e/vitest.config.ts",
     "test:unit": "vitest run --reporter=dot --silent=passed-only",
     "test:e2e": "vitest run --reporter=dot --silent=passed-only --config e2e/vitest.config.ts",
+    "test:playwright": "playwright test --config=e2e-playwright/playwright.config.ts",
+    "test:playwright:ui": "playwright test --config=e2e-playwright/playwright.config.ts --ui",
+    "test:playwright:headed": "playwright test --config=e2e-playwright/playwright.config.ts --headed",
     "test:cov": "vitest run --reporter=dot --silent=passed-only --coverage && vitest run --reporter=dot --silent=passed-only --config e2e/vitest.config.ts --coverage",
     "test:cov:unit": "vitest run --reporter=dot --silent=passed-only --coverage",
     "test:cov:e2e": "vitest run --reporter=dot --silent=passed-only --config e2e/vitest.config.ts --coverage",
@@ -59,12 +62,12 @@
     "gray-matter": "^4.0.3",
     "html2canvas": "^1.4.1",
     "ignore": "^7.0.5",
+    "node-pty": "^1.1.0",
     "open": "^11.0.0",
     "openai": "^6.33.0",
     "pyright": "^1.1.408",
     "react-markdown": "^10.1.0",
     "react-syntax-highlighter": "^16.1.1",
-    "react-virtuoso": "4.18.3",
     "remark-gfm": "^4.0.1",
     "sql-language-server": "^1.7.1",
     "turndown": "^7.2.2",
@@ -82,6 +85,10 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@playwright/test": "^1.58.2",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.19.15",
     "@types/react": "^19.0.8",

package/dist/{paths-4BPXWB2W.js → paths-MM76AWYB.js}

@@ -5,7 +5,7 @@ import {
   getGlobalConfigPath,
   getGlobalDataDir,
   getSkillsDir
-} from "./chunk-AF7XS4OI.js";
+} from "./chunk-5YQAXUKO.js";
 export {
   ensureDataDirExists,
   getDatabasePath,
@@ -14,4 +14,4 @@ export {
   getGlobalDataDir,
   getSkillsDir
 };
-//# sourceMappingURL=paths-4BPXWB2W.js.map
+//# sourceMappingURL=paths-MM76AWYB.js.map

package/dist/processor-KLHKDILM.js

@@ -0,0 +1,236 @@
+import {
+  generateSessionName,
+  needsNameGeneration
+} from "./chunk-QDEKU5RL.js";
+import {
+  getEventStore,
+  updateSessionMetadata
+} from "./chunk-BU2ZYOEA.js";
+import {
+  buildMessagesFromStoredEvents,
+  foldPendingConfirmations
+} from "./chunk-2KSCZSXQ.js";
+import {
+  createChatMessageMessage,
+  createContextStateMessage,
+  createSessionRunningMessage,
+  createSessionStateMessage
+} from "./chunk-S4QKTRGJ.js";
+import "./chunk-3EHGGBWE.js";
+import "./chunk-TPT6HP4H.js";
+import "./chunk-TVQOONDR.js";
+import {
+  logger
+} from "./chunk-PNBH3RAX.js";
+
+// src/server/queue/processor.ts
+var QueueProcessor = class {
+  deps;
+  unsubscribe = null;
+  activeAgents = /* @__PURE__ */ new Map();
+  constructor(deps) {
+    this.deps = deps;
+  }
+  start() {
+    if (this.unsubscribe) {
+      logger.warn("QueueProcessor already started");
+      return;
+    }
+    this.unsubscribe = this.deps.sessionManager.subscribe((event) => {
+      if (event.type === "queue_added") {
+        this.handleQueueAdded(event.sessionId);
+      } else if (event.type === "running_changed" && !event.isRunning) {
+        this.handleTurnDone(event.sessionId);
+      }
+    });
+    logger.debug("QueueProcessor started");
+  }
+  stop() {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+    for (const controller of this.activeAgents.values()) {
+      controller.abort();
+    }
+    this.activeAgents.clear();
+    logger.debug("QueueProcessor stopped");
+  }
+  abortSession(sessionId) {
+    const controller = this.activeAgents.get(sessionId);
+    if (controller) {
+      controller.abort();
+      this.activeAgents.delete(sessionId);
+      return true;
+    }
+    return false;
+  }
+  handleQueueAdded(sessionId) {
+    const { sessionManager } = this.deps;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) return;
+    if (session.isRunning) {
+      logger.debug("Session is running, not starting new turn", { sessionId });
+      return;
+    }
+    if (!sessionManager.hasQueuedMessages(sessionId)) {
+      logger.debug("No queued messages", { sessionId });
+      return;
+    }
+    this.startTurn(sessionId);
+  }
+  handleTurnDone(sessionId) {
+    logger.debug("Turn done, checking for more queued messages", { sessionId });
+    const { sessionManager } = this.deps;
+    if (!sessionManager.hasQueuedMessages(sessionId)) {
+      logger.debug("No more queued messages", { sessionId });
+      return;
+    }
+    this.startTurn(sessionId);
+  }
+  startTurn(sessionId) {
+    const { sessionManager, broadcastForSession } = this.deps;
+    logger.info("Starting turn from queue processor", { sessionId });
+    const session = sessionManager.getSession(sessionId);
+    if (!session || session.isRunning) {
+      logger.warn("Cannot start turn: session not found or already running", { sessionId });
+      return;
+    }
+    const queue = sessionManager.getQueueState(sessionId);
+    if (queue.length === 0) {
+      logger.warn("Cannot start turn: queue is empty", { sessionId });
+      return;
+    }
+    const controller = new AbortController();
+    this.activeAgents.set(sessionId, controller);
+    sessionManager.setRunning(sessionId, true);
+    broadcastForSession(sessionId, createSessionRunningMessage(true));
+    const nextAsap = queue.find((m) => m.mode === "asap") ?? queue[0];
+    if (nextAsap) {
+      sessionManager.cancelQueuedMessage(sessionId, nextAsap.queueId);
+      const userMessage = sessionManager.addMessage(sessionId, {
+        role: "user",
+        content: nextAsap.content,
+        ...nextAsap.attachments ? { attachments: nextAsap.attachments } : {}
+      });
+      broadcastForSession(sessionId, createChatMessageMessage(userMessage));
+      logger.debug("Added queued message to session", { sessionId, queueId: nextAsap.queueId, messageId: userMessage.id });
+      const messageCount = this.getSessionMessageCount(sessionId);
+      const currentSession = sessionManager.getSession(sessionId);
+      logger.debug("Session name generation check (queue)", {
+        sessionId,
+        title: currentSession?.metadata.title,
+        messageCount,
+        needsGeneration: currentSession ? needsNameGeneration(currentSession.metadata.title, messageCount) : false
+      });
+      if (currentSession && needsNameGeneration(currentSession.metadata.title, messageCount)) {
+        const eventStore = getEventStore();
+        generateSessionName({
+          userMessage: nextAsap.content,
+          llmClient: this.deps.getLLMClient(),
+          signal: controller.signal
+        }).then((result) => {
+          logger.debug("Session name generation result (queue)", {
+            sessionId,
+            success: result.success,
+            name: result.name,
+            error: result.error
+          });
+          if (result.success && result.name) {
+            updateSessionMetadata(sessionId, { title: result.name });
+            eventStore.append(sessionId, {
+              type: "session.name_generated",
+              data: { name: result.name }
+            });
+            const updatedSession = sessionManager.getSession(sessionId);
+            if (updatedSession) {
+              const events = eventStore.getEvents(sessionId);
+              const messages = buildMessagesFromStoredEvents(events);
+              const pendingConfirmations = foldPendingConfirmations(events);
+              broadcastForSession(sessionId, createSessionStateMessage(updatedSession, messages, pendingConfirmations));
+            }
+          }
+        }).catch((error) => {
+          logger.error("Session name generation failed (queue)", {
+            sessionId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        });
+      }
+    }
+    this.runTurn(sessionId, controller);
+  }
+  async runTurn(sessionId, controller) {
+    const { sessionManager, getLLMClient, getActiveProvider, broadcastForSession, providerManager } = this.deps;
+    const session = sessionManager.getSession(sessionId);
+    if (session?.providerId && session.providerModel) {
+      const currentActiveProviderId = providerManager.getActiveProviderId();
+      const currentModel = providerManager.getCurrentModel();
+      if (currentActiveProviderId !== session.providerId || currentModel !== session.providerModel) {
+        logger.info("Switching to session provider", {
+          sessionId,
+          fromProvider: currentActiveProviderId,
+          fromModel: currentModel,
+          toProvider: session.providerId,
+          toModel: session.providerModel
+        });
+        const result = await providerManager.activateProvider(session.providerId, { model: session.providerModel });
+        if (!result.success) {
+          logger.error("Failed to activate session provider", { sessionId, error: result.error });
+        }
+      }
+    }
+    const llmClient = getLLMClient();
+    const provider = getActiveProvider?.();
+    const statsIdentity = {
+      providerId: provider?.id ?? `provider:${llmClient.getModel()}`,
+      providerName: provider?.name ?? "Unknown Provider",
+      backend: provider?.backend ?? llmClient.getBackend(),
+      model: llmClient.getModel()
+    };
+    const { runChatTurn } = await import("./orchestrator-UGXX7JRQ.js");
+    runChatTurn({
+      sessionManager,
+      sessionId,
+      llmClient,
+      statsIdentity,
+      signal: controller.signal,
+      onMessage: (msg) => broadcastForSession(sessionId, msg)
+    }).catch((error) => {
+      if (error instanceof Error && error.message === "Aborted") {
+        return;
+      }
+      logger.error("QueueProcessor turn error", { sessionId, error });
+    }).finally(() => {
+      this.activeAgents.delete(sessionId);
+      const session2 = this.deps.sessionManager.getSession(sessionId);
+      if (!session2) return;
+      const hasMore = sessionManager.hasQueuedMessages(sessionId);
+      if (!hasMore) {
+        sessionManager.setRunning(sessionId, false);
+        const contextState = sessionManager.getContextState(sessionId);
+        broadcastForSession(sessionId, createContextStateMessage(contextState));
+        return;
+      }
+      this.startTurn(sessionId);
+    });
+  }
+  getSessionMessageCount(sessionId) {
+    const eventStore = getEventStore();
+    const events = eventStore.getEvents(sessionId);
+    let count = 0;
+    for (const event of events) {
+      if (event.type === "message.start") {
+        const data = event.data;
+        if (data.role === "user") {
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+};
+export {
+  QueueProcessor
+};
+//# sourceMappingURL=processor-KLHKDILM.js.map