@maydotinc/q-studio 0.1.0 → 0.1.1

package/dist/{core/index.js → chunk-L36RXNVW.js}

@@ -1,2241 +1,2201 @@
-// src/core/queue-manager.ts
-import { FlowProducer } from "bullmq";
-import { LRUCache } from "lru-cache";
-var QueueManager = class {
-  queues = /* @__PURE__ */ new Map();
-  queueGroupByName = /* @__PURE__ */ new Map();
-  queueGroups = [];
-  tagFields = [];
-  flowProducer = null;
-  // LRU cache for expensive operations
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  cache = new LRUCache({
-    max: 100,
-    // Max 100 entries
-    ttl: 1e3 * 60,
-    // Default 1 minute TTL
-    allowStale: false,
-    // Don't return stale entries
-    updateAgeOnGet: true
-    // Reset TTL on access
-  });
-  CACHE_TTL = {
-    metrics: 5 * 60 * 1e3,
-    // 5 minutes - metrics are expensive
-    overview: 2 * 60 * 1e3,
-    // 2 minutes
-    queues: 2 * 60 * 1e3,
-    // 2 minutes
-    flows: 2 * 60 * 1e3,
-    // 2 minutes
-    activity: 5 * 60 * 1e3
-    // 5 minutes - activity timeline
+// ../core/src/api/handlers.ts
+function parseSort(sort) {
+  if (!sort) return void 0;
+  const [field, dir] = sort.split(":");
+  if (!field) return void 0;
+  return {
+    field,
+    direction: dir === "asc" ? "asc" : "desc"
   };
-  constructor(queues, tagFields = [], queueGroups = []) {
-    for (const queue of queues) {
-      this.queues.set(queue.name, queue);
-    }
-    this.queueGroups = queueGroups.map((group) => ({
-      name: group.name,
-      queues: group.queues.map((queue) => queue.name)
-    }));
-    for (const group of this.queueGroups) {
-      for (const queueName of group.queues) {
-        this.queueGroupByName.set(queueName, group.name);
+}
+var readonlyError = {
+  status: 403,
+  body: { error: "Dashboard is in readonly mode" }
+};
+function buildRouteTable(core) {
+  const qm = core.queueManager;
+  const isReadonly = () => !!core.options.readonly;
+  return [
+    {
+      method: "post",
+      path: "/refresh",
+      handler: async () => {
+        qm.clearCache();
+        return { status: 200, body: { success: true } };
       }
-    }
-    this.tagFields = tagFields;
-    const firstQueue = queues[0];
-    if (firstQueue) {
-      const connection = firstQueue.opts?.connection;
-      if (connection) {
-        this.flowProducer = new FlowProducer({ connection });
+    },
+    {
+      method: "get",
+      path: "/overview",
+      handler: async () => ({
+        status: 200,
+        body: await qm.getOverview()
+      })
+    },
+    {
+      method: "get",
+      path: "/counts",
+      handler: async () => ({
+        status: 200,
+        body: await qm.getQuickCounts()
+      })
+    },
+    {
+      method: "get",
+      path: "/runs",
+      handler: async ({ query }) => {
+        const limit = Number(query.limit) || 50;
+        const cursor = query.cursor;
+        const start = cursor ? Number(cursor) : 0;
+        const sort = parseSort(query.sort);
+        const status = query.status;
+        const q = query.q;
+        const from = query.from;
+        const to = query.to;
+        const tagsParam = query.tags;
+        let tags;
+        if (tagsParam) {
+          try {
+            tags = JSON.parse(tagsParam);
+          } catch {
+            const tagPairs = tagsParam.split(",");
+            tags = {};
+            for (const pair of tagPairs) {
+              const [key, value] = pair.split(":");
+              if (key && value) {
+                tags[key.trim()] = value.trim();
+              }
+            }
+          }
+        }
+        let timeRange;
+        if (from && to) {
+          timeRange = {
+            start: Number(from),
+            end: Number(to)
+          };
+        }
+        let text;
+        if (q) {
+          if (!q.includes(":")) {
+            text = q;
+          } else {
+            const parts = q.split(" ");
+            const textParts = parts.filter((p) => !p.includes(":"));
+            if (textParts.length > 0) {
+              text = textParts.join(" ");
+            }
+          }
+        }
+        const filters = status || tags || text || timeRange ? {
+          status,
+          tags,
+          text,
+          timeRange
+        } : void 0;
+        return {
+          status: 200,
+          body: await qm.getAllRuns(limit, start, sort, filters)
+        };
       }
-    }
-  }
-  /**
-   * Get cached value or compute and cache
-   */
-  async cached(key, ttl, compute) {
-    const cached = this.cache.get(key);
-    if (cached !== void 0) {
-      return cached;
-    }
-    const data = await compute();
-    this.cache.set(key, data, { ttl });
-    return data;
-  }
-  /**
-   * Execute a promise with a timeout
-   */
-  async withTimeout(promise, timeoutMs, errorMessage) {
-    let timeoutId;
-    const timeoutPromise = new Promise((_, reject) => {
-      timeoutId = setTimeout(() => reject(new Error(errorMessage)), timeoutMs);
-    });
-    try {
-      return await Promise.race([promise, timeoutPromise]);
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-  /**
-   * Get jobs by time range using Redis sorted sets (ZRANGEBYSCORE)
-   * This is more efficient than fetching all jobs and filtering in memory
-   */
-  async getJobsByTimeRange(queue, status, startTime, endTime, limit) {
-    try {
-      const client = queue.client;
-      if (!client) {
-        const jobs2 = await queue.getJobs([status], 0, limit * 2);
-        return jobs2.filter(
-          (job) => job.finishedOn && job.finishedOn >= startTime && job.finishedOn <= endTime
-        );
+    },
+    {
+      method: "get",
+      path: "/schedulers",
+      handler: async ({ query }) => {
+        const repeatableSort = parseSort(query.repeatableSort);
+        const delayedSort = parseSort(query.delayedSort);
+        return {
+          status: 200,
+          body: await qm.getSchedulers(repeatableSort, delayedSort)
+        };
       }
-      const queueKey = `bull:${queue.name}:${status}`;
-      const jobIds = await client.zrangebyscore(
-        queueKey,
-        startTime,
-        endTime,
-        "LIMIT",
-        0,
-        limit
-      );
-      if (!jobIds || jobIds.length === 0) {
-        return [];
+    },
+    {
+      method: "post",
+      path: "/test",
+      handler: async ({ body }) => {
+        if (isReadonly()) return readonlyError;
+        const req = body;
+        if (!req?.queueName || !req.jobName) {
+          return {
+            status: 400,
+            body: { error: "queueName and jobName are required" }
+          };
+        }
+        try {
+          const result = await qm.enqueueJob(req);
+          return { status: 200, body: result };
+        } catch (e) {
+          return { status: 400, body: { error: e.message } };
+        }
       }
-      const jobPromises = jobIds.map((jobId) => queue.getJob(jobId));
-      const jobs = await Promise.all(jobPromises);
-      return jobs.filter(
-        (job) => job !== null && job !== void 0
-      );
-    } catch (_error) {
-      const jobs = await queue.getJobs([status], 0, limit * 2);
-      return jobs.filter(
-        (job) => job.finishedOn && job.finishedOn >= startTime && job.finishedOn <= endTime
-      );
-    }
-  }
-  /**
-   * Cache for job state lookups to avoid repeated Redis calls
-   */
-  jobStateCache = new LRUCache({
-    max: 1e3,
-    ttl: 1e3 * 30
-    // 30 second TTL - job states don't change frequently
-  });
-  /**
-   * Cache for job counts to avoid repeated Redis calls
-   * Short TTL since counts change frequently but are expensive to fetch
-   */
-  countCache = new LRUCache({
-    max: 100,
-    // Cache counts for up to 100 queues
-    ttl: 1e3 * 5
-    // 5 second TTL - counts change but not instantly
-  });
-  /**
-   * Get job counts with caching
-   */
-  async getCachedJobCounts(queue) {
-    const cacheKey = queue.name;
-    const cached = this.countCache.get(cacheKey);
-    if (cached !== void 0) {
-      return cached;
-    }
-    const counts = await queue.getJobCounts();
-    this.countCache.set(cacheKey, counts);
-    return counts;
-  }
-  /**
-   * Invalidate caches related to a job or queue
-   */
-  invalidateJobCache(queueName, jobId) {
-    this.countCache.delete(queueName);
-    if (jobId) {
-      const stateCacheKey = `${queueName}:${jobId}`;
-      this.jobStateCache.delete(stateCacheKey);
-    }
-    this.cache.delete("metrics");
-    this.cache.delete("overview");
-    this.cache.delete("activity");
-  }
-  /**
-   * Clear cache (useful after mutations)
-   */
-  clearCache(prefix) {
-    if (prefix) {
-      for (const key of this.cache.keys()) {
-        if (key.startsWith(prefix)) {
-          this.cache.delete(key);
+    },
+    {
+      method: "get",
+      path: "/queue-names",
+      handler: async () => ({
+        status: 200,
+        body: qm.getQueueNames()
+      })
+    },
+    {
+      method: "get",
+      path: "/queues",
+      handler: async () => ({
+        status: 200,
+        body: await qm.getQueues()
+      })
+    },
+    {
+      method: "get",
+      path: "/metrics",
+      handler: async () => ({
+        status: 200,
+        body: await qm.getMetrics()
+      })
+    },
+    {
+      method: "get",
+      path: "/activity",
+      handler: async () => ({
+        status: 200,
+        body: await qm.getActivityStats()
+      })
+    },
+    {
+      method: "get",
+      path: "/queues/:name/jobs",
+      handler: async ({ params, query }) => {
+        const name = params.name;
+        const status = query.status;
+        const limit = Number(query.limit) || 50;
+        const cursor = query.cursor;
+        const start = cursor ? Number(cursor) : 0;
+        const sort = parseSort(query.sort);
+        return {
+          status: 200,
+          body: await qm.getJobs(name, status, limit, start, sort)
+        };
+      }
+    },
+    {
+      method: "get",
+      path: "/jobs/:queue/:id/logs",
+      handler: async ({ params, query }) => {
+        const start = query.start ? Number(query.start) : 0;
+        const end = query.end ? Number(query.end) : 999;
+        const asc = query.asc !== "false";
+        const logs = await qm.getJobLogs(
+          params.queue,
+          params.id,
+          start,
+          end,
+          asc
+        );
+        if (!logs) {
+          return { status: 404, body: { error: "Job not found" } };
         }
+        return { status: 200, body: logs };
       }
-    } else {
-      this.cache.clear();
-    }
-  }
-  /**
-   * Get quick job counts across all queues (lightweight, for smart polling)
-   * Returns total counts per status - cached and very fast
-   */
-  async getQuickCounts() {
-    return this.cached("quick-counts", 2e3, async () => {
-      const totals = {
-        waiting: 0,
-        active: 0,
-        completed: 0,
-        failed: 0,
-        delayed: 0,
-        total: 0,
-        timestamp: Date.now()
-      };
-      await Promise.all(
-        Array.from(this.queues.values()).map(async (queue) => {
-          const counts = await this.getCachedJobCounts(queue);
-          totals.waiting += counts.waiting || 0;
-          totals.active += counts.active || 0;
-          totals.completed += counts.completed || 0;
-          totals.failed += counts.failed || 0;
-          totals.delayed += counts.delayed || 0;
-        })
-      );
-      totals.total = totals.waiting + totals.active + totals.completed + totals.failed + totals.delayed;
-      return totals;
-    });
-  }
-  /**
-   * Get configured tag field names
-   */
-  getTagFields() {
-    return this.tagFields;
-  }
-  /**
-   * Get just queue names (very fast, no Redis calls)
-   * Used for sidebar initial render
-   */
-  getQueueNames() {
-    return Array.from(this.queues.keys());
-  }
-  /**
-   * Get configured queue groups (very fast, no Redis calls)
-   */
-  getQueueGroups() {
-    return this.queueGroups;
-  }
-  /**
-   * Get a queue by name
-   */
-  getQueue(name) {
-    return this.queues.get(name);
-  }
-  /**
-   * Get information for all queues (cached)
-   */
-  async getQueues() {
-    return this.cached("queues", this.CACHE_TTL.queues, async () => {
-      const queueEntries = Array.from(this.queues.entries());
-      const results = await Promise.all(
-        queueEntries.map(async ([name, queue]) => {
-          const [counts, isPaused] = await Promise.all([
-            this.getCachedJobCounts(queue),
-            queue.isPaused()
-          ]);
+    },
+    {
+      method: "get",
+      path: "/jobs/:queue/:id",
+      handler: async ({ params }) => {
+        const job = await qm.getJob(params.queue, params.id);
+        if (!job) {
+          return { status: 404, body: { error: "Job not found" } };
+        }
+        return { status: 200, body: job };
+      }
+    },
+    {
+      method: "post",
+      path: "/jobs/:queue/:id/retry",
+      handler: async ({ params }) => {
+        if (isReadonly()) return readonlyError;
+        const success = await qm.retryJob(params.queue, params.id);
+        if (!success) {
+          return { status: 400, body: { error: "Failed to retry job" } };
+        }
+        return { status: 200, body: { success: true } };
+      }
+    },
+    {
+      method: "post",
+      path: "/jobs/:queue/:id/remove",
+      handler: async ({ params }) => {
+        if (isReadonly()) return readonlyError;
+        const success = await qm.removeJob(params.queue, params.id);
+        if (!success) {
+          return { status: 400, body: { error: "Failed to remove job" } };
+        }
+        return { status: 200, body: { success: true } };
+      }
+    },
+    {
+      method: "post",
+      path: "/jobs/:queue/:id/promote",
+      handler: async ({ params }) => {
+        if (isReadonly()) return readonlyError;
+        const success = await qm.promoteJob(params.queue, params.id);
+        if (!success) {
+          return { status: 400, body: { error: "Failed to promote job" } };
+        }
+        return { status: 200, body: { success: true } };
+      }
+    },
+    {
+      method: "get",
+      path: "/search",
+      handler: async ({ query }) => {
+        const q = query.q || "";
+        const limit = Number(query.limit) || 20;
+        if (!q) return { status: 200, body: { results: [] } };
+        const results = await qm.search(q, limit);
+        return { status: 200, body: { results } };
+      }
+    },
+    {
+      method: "get",
+      path: "/tags/:field/values",
+      handler: async ({ params, query }) => {
+        const field = params.field;
+        const limit = Number(query.limit) || 50;
+        const tagFields = qm.getTagFields();
+        if (tagFields.length > 0 && !tagFields.includes(field)) {
           return {
-            name,
-            group: this.queueGroupByName.get(name),
-            counts: {
-              waiting: counts.waiting || 0,
-              active: counts.active || 0,
-              completed: counts.completed || 0,
-              failed: counts.failed || 0,
-              delayed: counts.delayed || 0,
-              paused: counts.paused || 0
-            },
-            isPaused
+            status: 400,
+            body: {
+              error: `Field "${field}" is not a configured tag field`
+            }
           };
-        })
-      );
-      return results;
-    });
-  }
-  /**
-   * Get overview statistics (cached)
-   */
-  async getOverview() {
-    return this.cached("overview", this.CACHE_TTL.overview, async () => {
-      const queues = await this.getQueues();
-      let totalJobs = 0;
-      let activeJobs = 0;
-      let failedJobs = 0;
-      for (const queue of queues) {
-        totalJobs += queue.counts.waiting + queue.counts.active + queue.counts.delayed;
-        activeJobs += queue.counts.active;
-        failedJobs += queue.counts.failed;
+        }
+        const values = await qm.getTagValues(field, limit);
+        return { status: 200, body: { field, values } };
       }
-      const completedToday = queues.reduce(
-        (sum, q) => sum + q.counts.completed,
-        0
-      );
-      return {
-        totalJobs,
-        activeJobs,
-        failedJobs,
-        completedToday,
-        avgDuration: 0,
-        // Would need metrics tracking
-        queues
-      };
-    });
-  }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Queue Control (Pause/Resume)
-  // ─────────────────────────────────────────────────────────────────────────────
-  /**
-   * Pause a queue - stops processing new jobs
-   */
-  async pauseQueue(queueName) {
-    const queue = this.queues.get(queueName);
-    if (!queue) {
-      throw new Error(`Queue "${queueName}" not found`);
-    }
-    await queue.pause();
-  }
-  /**
-   * Resume a paused queue
-   */
-  async resumeQueue(queueName) {
-    const queue = this.queues.get(queueName);
-    if (!queue) {
-      throw new Error(`Queue "${queueName}" not found`);
-    }
-    await queue.resume();
-  }
-  /**
-   * Check if a queue is paused
-   */
-  async isQueuePaused(queueName) {
-    const queue = this.queues.get(queueName);
-    if (!queue) {
-      throw new Error(`Queue "${queueName}" not found`);
-    }
-    return queue.isPaused();
-  }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Metrics
-  // ─────────────────────────────────────────────────────────────────────────────
-  /**
-   * Get metrics for the last 24 hours (cached - expensive operation)
-   */
-  async getMetrics() {
-    return this.cached("metrics", this.CACHE_TTL.metrics, async () => {
-      return this.withTimeout(
-        (async () => {
-          const now = Date.now();
-          const twentyFourHoursAgo = now - 24 * 60 * 60 * 1e3;
-          const createEmptyBuckets = () => {
-            const buckets = [];
-            const startHour = Math.floor(twentyFourHoursAgo / (60 * 60 * 1e3)) * (60 * 60 * 1e3);
-            for (let i = 0; i < 24; i++) {
-              buckets.push({
-                hour: startHour + i * 60 * 60 * 1e3,
-                completed: 0,
-                failed: 0,
-                avgDuration: 0,
-                avgWaitTime: 0
-              });
-            }
-            return buckets;
-          };
-          const queueMetricsMap = /* @__PURE__ */ new Map();
-          for (const queueName of this.queues.keys()) {
-            queueMetricsMap.set(queueName, {
-              buckets: createEmptyBuckets(),
-              durations: Array.from({ length: 24 }, () => []),
-              waitTimes: Array.from({ length: 24 }, () => [])
-            });
-          }
-          const allJobs = [];
-          const jobTypeStats = /* @__PURE__ */ new Map();
-          const queueEntries = Array.from(this.queues.entries());
-          const queueChecks = await Promise.all(
-            queueEntries.map(async ([queueName, queue]) => {
-              const counts = await this.getCachedJobCounts(queue);
-              return {
-                queueName,
-                queue,
-                hasRelevantJobs: (counts.completed || 0) > 0 || (counts.failed || 0) > 0
-              };
-            })
-          );
-          const relevantQueues = queueChecks.filter((q) => q.hasRelevantJobs);
-          const queueResults = await Promise.all(
-            relevantQueues.map(async ({ queueName, queue }) => {
-              const [completedJobs, failedJobs] = await Promise.all([
-                this.getJobsByTimeRange(
-                  queue,
-                  "completed",
-                  twentyFourHoursAgo,
-                  now,
-                  100
-                  // Reduced from 200 - only recent jobs needed
-                ),
-                this.getJobsByTimeRange(
-                  queue,
-                  "failed",
-                  twentyFourHoursAgo,
-                  now,
-                  100
-                  // Reduced from 200 - only recent jobs needed
-                )
-              ]);
-              return { queueName, completedJobs, failedJobs };
-            })
-          );
-          for (const { queueName, completedJobs, failedJobs } of queueResults) {
-            const metrics = queueMetricsMap.get(queueName);
-            for (const job of completedJobs) {
-              if (!job?.finishedOn || job.finishedOn < twentyFourHoursAgo)
-                continue;
-              const bucketIndex = Math.floor(
-                (job.finishedOn - (metrics.buckets[0]?.hour || 0)) / (60 * 60 * 1e3)
-              );
-              if (bucketIndex >= 0 && bucketIndex < 24) {
-                metrics.buckets[bucketIndex].completed++;
-                const duration = job.processedOn ? job.finishedOn - job.processedOn : 0;
-                const waitTime = job.processedOn ? job.processedOn - job.timestamp : 0;
-                if (duration > 0) {
-                  metrics.durations[bucketIndex].push(duration);
-                  allJobs.push({
-                    name: job.name,
-                    queueName,
-                    duration,
-                    jobId: job.id || ""
-                  });
-                }
-                if (waitTime > 0) {
-                  metrics.waitTimes[bucketIndex].push(waitTime);
-                }
-              }
-              const key = `${queueName}:${job.name}`;
-              const stats = jobTypeStats.get(key) || {
-                name: job.name,
-                queueName,
-                completed: 0,
-                failed: 0
-              };
-              stats.completed++;
-              jobTypeStats.set(key, stats);
-            }
-            for (const job of failedJobs) {
-              if (!job?.finishedOn || job.finishedOn < twentyFourHoursAgo)
-                continue;
-              const bucketIndex = Math.floor(
-                (job.finishedOn - (metrics.buckets[0]?.hour || 0)) / (60 * 60 * 1e3)
-              );
-              if (bucketIndex >= 0 && bucketIndex < 24) {
-                metrics.buckets[bucketIndex].failed++;
-              }
-              const key = `${queueName}:${job.name}`;
-              const stats = jobTypeStats.get(key) || {
-                name: job.name,
-                queueName,
-                completed: 0,
-                failed: 0
-              };
-              stats.failed++;
-              jobTypeStats.set(key, stats);
-            }
-          }
-          for (const metrics of queueMetricsMap.values()) {
-            for (let i = 0; i < 24; i++) {
-              const durations = metrics.durations[i];
-              const waitTimes = metrics.waitTimes[i];
-              if (durations.length > 0) {
-                metrics.buckets[i].avgDuration = Math.round(
-                  durations.reduce((a, b) => a + b, 0) / durations.length
-                );
-              }
-              if (waitTimes.length > 0) {
-                metrics.buckets[i].avgWaitTime = Math.round(
-                  waitTimes.reduce((a, b) => a + b, 0) / waitTimes.length
-                );
-              }
-            }
-          }
-          const aggregateBuckets = createEmptyBuckets();
-          const aggregateDurations = Array.from(
-            { length: 24 },
-            () => []
-          );
-          const aggregateWaitTimes = Array.from(
-            { length: 24 },
-            () => []
-          );
-          for (const metrics of queueMetricsMap.values()) {
-            for (let i = 0; i < 24; i++) {
-              aggregateBuckets[i].completed += metrics.buckets[i].completed;
-              aggregateBuckets[i].failed += metrics.buckets[i].failed;
-              aggregateDurations[i].push(...metrics.durations[i]);
-              aggregateWaitTimes[i].push(...metrics.waitTimes[i]);
-            }
-          }
-          for (let i = 0; i < 24; i++) {
-            if (aggregateDurations[i].length > 0) {
-              aggregateBuckets[i].avgDuration = Math.round(
-                aggregateDurations[i].reduce((a, b) => a + b, 0) / aggregateDurations[i].length
-              );
-            }
-            if (aggregateWaitTimes[i].length > 0) {
-              aggregateBuckets[i].avgWaitTime = Math.round(
-                aggregateWaitTimes[i].reduce((a, b) => a + b, 0) / aggregateWaitTimes[i].length
-              );
-            }
-          }
-          const totalCompleted = aggregateBuckets.reduce(
-            (sum, b) => sum + b.completed,
-            0
-          );
-          const totalFailed = aggregateBuckets.reduce(
-            (sum, b) => sum + b.failed,
-            0
-          );
-          const allDurations = aggregateDurations.flat();
-          const allWaitTimes = aggregateWaitTimes.flat();
-          const slowestJobs = allJobs.sort((a, b) => b.duration - a.duration).slice(0, 10);
-          const mostFailingTypes = Array.from(jobTypeStats.values()).filter((s) => s.failed > 0).map((s) => ({
-            name: s.name,
-            queueName: s.queueName,
-            failCount: s.failed,
-            totalCount: s.completed + s.failed,
-            errorRate: s.failed / (s.completed + s.failed)
-          })).sort((a, b) => b.failCount - a.failCount).slice(0, 10);
+    },
+    {
+      method: "post",
+      path: "/queues/:name/clean",
+      handler: async ({ params, body }) => {
+        if (isReadonly()) return readonlyError;
+        const req = body;
+        if (!req) {
+          return { status: 400, body: { error: "Body required" } };
+        }
+        const count = await qm.cleanJobs(
+          params.name,
+          req.status,
+          req.grace || 0
+        );
+        return { status: 200, body: { removed: count } };
+      }
+    },
+    {
+      method: "post",
+      path: "/bulk/retry",
+      handler: async ({ body }) => {
+        if (isReadonly()) return readonlyError;
+        const req = body;
+        if (!req?.jobs) {
+          return { status: 400, body: { error: "jobs is required" } };
+        }
+        return { status: 200, body: await qm.bulkRetry(req.jobs) };
+      }
+    },
+    {
+      method: "post",
+      path: "/bulk/delete",
+      handler: async ({ body }) => {
+        if (isReadonly()) return readonlyError;
+        const req = body;
+        if (!req?.jobs) {
+          return { status: 400, body: { error: "jobs is required" } };
+        }
+        return { status: 200, body: await qm.bulkDelete(req.jobs) };
+      }
+    },
+    {
+      method: "post",
+      path: "/bulk/promote",
+      handler: async ({ body }) => {
+        if (isReadonly()) return readonlyError;
+        const req = body;
+        if (!req?.jobs) {
+          return { status: 400, body: { error: "jobs is required" } };
+        }
+        return { status: 200, body: await qm.bulkPromote(req.jobs) };
+      }
+    },
+    {
+      method: "post",
+      path: "/queues/:name/pause",
+      handler: async ({ params }) => {
+        if (isReadonly()) return readonlyError;
+        try {
+          await qm.pauseQueue(params.name);
+          return { status: 200, body: { success: true, paused: true } };
+        } catch (error) {
           return {
-            queues: [],
-            // Empty - per-queue metrics not used by frontend
-            aggregate: {
-              queueName: "all",
-              buckets: aggregateBuckets,
-              summary: {
-                totalCompleted,
-                totalFailed,
-                errorRate: totalCompleted + totalFailed > 0 ? totalFailed / (totalCompleted + totalFailed) : 0,
-                avgDuration: allDurations.length > 0 ? Math.round(
-                  allDurations.reduce((a, b) => a + b, 0) / allDurations.length
-                ) : 0,
-                avgWaitTime: allWaitTimes.length > 0 ? Math.round(
-                  allWaitTimes.reduce((a, b) => a + b, 0) / allWaitTimes.length
-                ) : 0,
-                throughputPerHour: Math.round(
-                  (totalCompleted + totalFailed) / 24
-                )
-              }
-            },
-            slowestJobs,
-            mostFailingTypes,
-            computedAt: now
+            status: 404,
+            body: {
+              error: error instanceof Error ? error.message : "Failed to pause queue"
+            }
           };
-        })(),
-        45e3,
-        // 45 second timeout (before proxy timeout)
-        "Metrics computation timed out after 45 seconds"
-      );
-    });
-  }
-  /**
-   * Get activity stats for the last 7 days (cached)
-   * Returns 4-hour buckets for the activity timeline
-   */
-  async getActivityStats() {
-    return this.cached("activity", this.CACHE_TTL.activity, async () => {
-      const now = Date.now();
-      const bucketSize = 4 * 60 * 60 * 1e3;
-      const bucketCount = 42;
-      const startDate = new Date(now);
-      startDate.setHours(0, 0, 0, 0);
-      startDate.setDate(startDate.getDate() - 6);
-      const startTime = startDate.getTime();
-      const buckets = [];
-      for (let i = 0; i < bucketCount; i++) {
-        buckets.push({
-          time: startTime + i * bucketSize,
-          completed: 0,
-          failed: 0
-        });
+        }
       }
-      const queueEntries = Array.from(this.queues.entries());
-      const queueChecks = await Promise.all(
-        queueEntries.map(async ([, queue]) => {
-          const counts = await this.getCachedJobCounts(queue);
+    },
+    {
+      method: "post",
+      path: "/queues/:name/resume",
+      handler: async ({ params }) => {
+        if (isReadonly()) return readonlyError;
+        try {
+          await qm.resumeQueue(params.name);
+          return { status: 200, body: { success: true, paused: false } };
+        } catch (error) {
           return {
-            queue,
-            hasRelevantJobs: (counts.completed || 0) > 0 || (counts.failed || 0) > 0
+            status: 404,
+            body: {
+              error: error instanceof Error ? error.message : "Failed to resume queue"
+            }
           };
-        })
-      );
-      const relevantQueues = queueChecks.filter((q) => q.hasRelevantJobs);
-      const queueResults = await Promise.all(
-        relevantQueues.map(async ({ queue }) => {
-          const [completedJobs, failedJobs] = await Promise.all([
-            this.getJobsByTimeRange(
-              queue,
-              "completed",
-              startTime,
-              now,
-              200
-              // Reduced from 500 - only jobs in time range needed
-            ),
-            this.getJobsByTimeRange(
-              queue,
-              "failed",
-              startTime,
-              now,
-              200
-              // Reduced from 500 - only jobs in time range needed
-            )
-          ]);
-          return { completedJobs, failedJobs };
-        })
-      );
-      for (const { completedJobs, failedJobs } of queueResults) {
-        for (const job of completedJobs) {
-          if (!job?.finishedOn || job.finishedOn < startTime) continue;
-          const bucketIndex = Math.floor(
-            (job.finishedOn - startTime) / bucketSize
-          );
-          if (bucketIndex >= 0 && bucketIndex < bucketCount) {
-            buckets[bucketIndex].completed++;
-          }
         }
-        for (const job of failedJobs) {
-          if (!job?.finishedOn || job.finishedOn < startTime) continue;
-          const bucketIndex = Math.floor(
-            (job.finishedOn - startTime) / bucketSize
-          );
-          if (bucketIndex >= 0 && bucketIndex < bucketCount) {
-            buckets[bucketIndex].failed++;
-          }
+      }
+    },
+    {
+      method: "get",
+      path: "/flows",
+      handler: async ({ query }) => {
+        const limit = Number(query.limit) || 50;
+        const flows = await qm.getFlows(limit);
+        return { status: 200, body: { flows } };
+      }
+    },
+    {
+      method: "get",
+      path: "/flows/:queueName/:jobId",
+      handler: async ({ params }) => {
+        const flow = await qm.getFlow(params.queueName, params.jobId);
+        if (!flow) {
+          return { status: 404, body: { error: "Flow not found" } };
+        }
+        return { status: 200, body: flow };
+      }
+    },
+    {
+      method: "post",
+      path: "/flows",
+      handler: async ({ body }) => {
+        if (isReadonly()) return readonlyError;
+        const req = body;
+        if (!req?.name || !req.queueName || !req.children?.length) {
+          return {
+            status: 400,
+            body: { error: "name, queueName, and children are required" }
+          };
+        }
+        try {
+          const result = await qm.createFlow(req);
+          return { status: 200, body: result };
+        } catch (e) {
+          return { status: 400, body: { error: e.message } };
         }
       }
-      const totalCompleted = buckets.reduce((sum, b) => sum + b.completed, 0);
-      const totalFailed = buckets.reduce((sum, b) => sum + b.failed, 0);
-      return {
-        buckets,
-        startTime,
-        endTime: now,
-        bucketSize,
-        totalCompleted,
-        totalFailed,
-        computedAt: now
-      };
-    });
-  }
-  /**
-   * Get jobs for a specific queue with pagination and sorting
-   */
-  async getJobs(queueName, status, limit = 50, start = 0, sort) {
-    const queue = this.queues.get(queueName);
-    if (!queue) {
-      return { data: [], total: 0, hasMore: false };
     }
-    const types = status ? [status] : ["waiting", "active", "completed", "failed", "delayed"];
-    const counts = await this.getCachedJobCounts(queue);
-    const jobsWithState = [];
-    let total = 0;
-    for (const type of types) {
-      const typeJobs = await queue.getJobs(type, start, start + limit);
-      jobsWithState.push(
-        ...typeJobs.map((job) => ({ job, state: type }))
-      );
-      const typeCount = counts[type] || 0;
-      total += typeCount;
+  ];
+}
+
+// ../core/src/core/queue-manager.ts
+import { FlowProducer } from "bullmq";
+import { LRUCache } from "lru-cache";
+var QueueManager = class {
+  queues = /* @__PURE__ */ new Map();
+  queueGroupByName = /* @__PURE__ */ new Map();
+  queueGroups = [];
+  tagFields = [];
+  flowProducer = null;
+  // LRU cache for expensive operations
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  cache = new LRUCache({
+    max: 100,
+    // Max 100 entries
+    ttl: 1e3 * 60,
+    // Default 1 minute TTL
+    allowStale: false,
+    // Don't return stale entries
+    updateAgeOnGet: true
+    // Reset TTL on access
+  });
+  CACHE_TTL = {
+    metrics: 5 * 60 * 1e3,
+    // 5 minutes - metrics are expensive
+    overview: 2 * 60 * 1e3,
+    // 2 minutes
+    queues: 2 * 60 * 1e3,
+    // 2 minutes
+    flows: 2 * 60 * 1e3,
+    // 2 minutes
+    activity: 5 * 60 * 1e3
+    // 5 minutes - activity timeline
+  };
+  constructor(queues, tagFields = [], queueGroups = []) {
+    for (const queue of queues) {
+      this.queues.set(queue.name, queue);
+    }
+    this.queueGroups = queueGroups.map((group) => ({
+      name: group.name,
+      queues: group.queues.map((queue) => queue.name)
+    }));
+    for (const group of this.queueGroups) {
+      for (const queueName of group.queues) {
+        this.queueGroupByName.set(queueName, group.name);
+      }
+    }
+    this.tagFields = tagFields;
+    const firstQueue = queues[0];
+    if (firstQueue) {
+      const connection = firstQueue.opts?.connection;
+      if (connection) {
+        this.flowProducer = new FlowProducer({ connection });
+      }
     }
-    const jobInfos = await Promise.all(
-      jobsWithState.map(({ job, state }) => this.jobToInfo(job, "full", state))
-    );
-    const sortField = sort?.field ?? "timestamp";
-    const sortDir = sort?.direction === "asc" ? 1 : -1;
-    jobInfos.sort((a, b) => {
-      const aVal = this.getSortValue(a, sortField);
-      const bVal = this.getSortValue(b, sortField);
-      if (aVal < bVal) return -1 * sortDir;
-      if (aVal > bVal) return 1 * sortDir;
-      return 0;
-    });
-    const data = jobInfos.slice(0, limit);
-    return {
-      data,
-      total,
-      hasMore: start + limit < total,
-      cursor: start + limit < total ? String(start + limit) : void 0
-    };
   }
   /**
-   * Get a single job by ID
+   * Get cached value or compute and cache
    */
-  async getJob(queueName, jobId) {
-    const queue = this.queues.get(queueName);
-    if (!queue) return null;
-    const job = await queue.getJob(jobId);
-    if (!job) return null;
-    return this.jobToInfo(job, "full");
+  async cached(key, ttl, compute) {
+    const cached = this.cache.get(key);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const data = await compute();
+    this.cache.set(key, data, { ttl });
+    return data;
   }
   /**
-   * Get BullMQ log lines for a job.
+   * Execute a promise with a timeout
    */
-  async getJobLogs(queueName, jobId, start = 0, end = 999, asc = true) {
-    const queue = this.queues.get(queueName);
-    if (!queue) return null;
-    const job = await queue.getJob(jobId);
-    if (!job) return null;
-    const result = await queue.getJobLogs(jobId, start, end, asc);
-    return {
-      logs: result.logs,
-      count: result.count,
-      start,
-      end
-    };
+  async withTimeout(promise, timeoutMs, errorMessage) {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => reject(new Error(errorMessage)), timeoutMs);
+    });
+    try {
+      return await Promise.race([promise, timeoutPromise]);
+    } finally {
+      clearTimeout(timeoutId);
+    }
   }
   /**
-   * Retry a failed job
+   * Get jobs by time range using Redis sorted sets (ZRANGEBYSCORE)
+   * This is more efficient than fetching all jobs and filtering in memory
    */
-  async retryJob(queueName, jobId) {
-    const queue = this.queues.get(queueName);
-    if (!queue) return false;
-    const job = await queue.getJob(jobId);
-    if (!job) return false;
-    await job.retry();
-    this.invalidateJobCache(queueName, jobId);
-    return true;
+  async getJobsByTimeRange(queue, status, startTime, endTime, limit) {
+    try {
+      const client = queue.client;
+      if (!client) {
+        const jobs2 = await queue.getJobs([status], 0, limit * 2);
+        return jobs2.filter(
+          (job) => job.finishedOn && job.finishedOn >= startTime && job.finishedOn <= endTime
+        );
+      }
+      const queueKey = `bull:${queue.name}:${status}`;
+      const jobIds = await client.zrangebyscore(
+        queueKey,
+        startTime,
+        endTime,
+        "LIMIT",
+        0,
+        limit
+      );
+      if (!jobIds || jobIds.length === 0) {
+        return [];
+      }
+      const jobPromises = jobIds.map((jobId) => queue.getJob(jobId));
+      const jobs = await Promise.all(jobPromises);
+      return jobs.filter(
+        (job) => job !== null && job !== void 0
+      );
+    } catch (_error) {
+      const jobs = await queue.getJobs([status], 0, limit * 2);
+      return jobs.filter(
+        (job) => job.finishedOn && job.finishedOn >= startTime && job.finishedOn <= endTime
+      );
+    }
   }
   /**
-   * Remove a job
+   * Cache for job state lookups to avoid repeated Redis calls
    */
-  async removeJob(queueName, jobId) {
-    const queue = this.queues.get(queueName);
-    if (!queue) return false;
-    const job = await queue.getJob(jobId);
-    if (!job) return false;
-    await job.remove();
-    this.invalidateJobCache(queueName, jobId);
-    return true;
-  }
+  jobStateCache = new LRUCache({
+    max: 1e3,
+    ttl: 1e3 * 30
+    // 30 second TTL - job states don't change frequently
+  });
   /**
-   * Promote a delayed job to waiting
+   * Cache for job counts to avoid repeated Redis calls
+   * Short TTL since counts change frequently but are expensive to fetch
    */
-  async promoteJob(queueName, jobId) {
-    const queue = this.queues.get(queueName);
-    if (!queue) return false;
-    const job = await queue.getJob(jobId);
-    if (!job) return false;
-    await job.promote();
-    this.invalidateJobCache(queueName, jobId);
-    return true;
-  }
+  countCache = new LRUCache({
+    max: 100,
+    // Cache counts for up to 100 queues
+    ttl: 1e3 * 5
+    // 5 second TTL - counts change but not instantly
+  });
   /**
-   * Parse search query for field:value filters
-   * Returns { filters: { field: value }, text: remainingText }
+   * Get job counts with caching
    */
-  parseSearchQuery(query) {
-    const filters = {};
-    const textParts = [];
-    const len = query.length;
-    let i = 0;
-    while (i < len) {
-      while (i < len && query[i] === " ") i++;
-      if (i >= len) break;
-      let j = i;
-      while (j < len && /\w/.test(query[j])) j++;
-      if (j > i && j < len && query[j] === ":") {
-        const field = query.slice(i, j);
-        j++;
-        let value;
-        if (j < len && query[j] === '"') {
-          j++;
-          const closeQuote = query.indexOf('"', j);
-          if (closeQuote !== -1) {
-            value = query.slice(j, closeQuote);
-            j = closeQuote + 1;
-          } else {
-            value = query.slice(j);
-            j = len;
-          }
-        } else {
-          const valueStart = j;
-          while (j < len && query[j] !== " ") j++;
-          value = query.slice(valueStart, j);
-        }
-        if (value) {
-          filters[field] = value;
-        } else {
-          textParts.push(`${field}:`);
-        }
-        i = j;
-      } else {
-        const start = i;
-        while (i < len && query[i] !== " ") i++;
-        textParts.push(query.slice(start, i));
-      }
+  async getCachedJobCounts(queue) {
+    const cacheKey = queue.name;
+    const cached = this.countCache.get(cacheKey);
+    if (cached !== void 0) {
+      return cached;
     }
-    return {
-      filters,
-      text: textParts.filter(Boolean).join(" ")
-    };
+    const counts = await queue.getJobCounts();
+    this.countCache.set(cacheKey, counts);
+    return counts;
   }
   /**
-   * Check if a raw job matches all provided filters (before conversion)
-   * This is more efficient than converting to JobInfo first
+   * Invalidate caches related to a job or queue
    */
-  jobMatchesAllFilters(job, filters) {
-    if (filters.timeRange) {
-      const jobTime = job.processedOn || job.finishedOn || job.timestamp || 0;
-      if (jobTime < filters.timeRange.start || jobTime > filters.timeRange.end) {
-        return false;
-      }
-    }
-    if (filters.tags && Object.keys(filters.tags).length > 0) {
-      if (!job.data || typeof job.data !== "object") {
-        return false;
-      }
-      const dataObj = job.data;
-      for (const [field, value] of Object.entries(filters.tags)) {
-        const jobValue = dataObj[field];
-        if (jobValue === void 0 || jobValue === null) {
-          return false;
-        }
-        const strJobValue = String(jobValue).toLowerCase();
-        const strFilterValue = value.toLowerCase();
-        if (!strJobValue.includes(strFilterValue)) {
-          return false;
-        }
-      }
+  invalidateJobCache(queueName, jobId) {
+    this.countCache.delete(queueName);
+    if (jobId) {
+      const stateCacheKey = `${queueName}:${jobId}`;
+      this.jobStateCache.delete(stateCacheKey);
     }
-    if (filters.text) {
-      const lowerText = filters.text.toLowerCase();
-      const matchesId = job.id?.toLowerCase().includes(lowerText);
-      const matchesName = job.name?.toLowerCase().includes(lowerText);
-      if (!matchesId && !matchesName) {
-        const stringifiedData = JSON.stringify(job.data).toLowerCase();
-        if (!stringifiedData.includes(lowerText)) {
-          return false;
+    this.cache.delete("metrics");
+    this.cache.delete("overview");
+    this.cache.delete("activity");
+  }
+  /**
+   * Clear cache (useful after mutations)
+   */
+  clearCache(prefix) {
+    if (prefix) {
+      for (const key of this.cache.keys()) {
+        if (key.startsWith(prefix)) {
+          this.cache.delete(key);
         }
       }
+    } else {
+      this.cache.clear();
     }
-    return true;
   }
   /**
-   * Check if a job matches the given tag filters
+   * Get quick job counts across all queues (lightweight, for smart polling)
+   * Returns total counts per status - cached and very fast
+   */
+  async getQuickCounts() {
+    return this.cached("quick-counts", 2e3, async () => {
+      const totals = {
+        waiting: 0,
+        active: 0,
+        completed: 0,
+        failed: 0,
+        delayed: 0,
+        total: 0,
+        timestamp: Date.now()
+      };
+      await Promise.all(
+        Array.from(this.queues.values()).map(async (queue) => {
+          const counts = await this.getCachedJobCounts(queue);
+          totals.waiting += counts.waiting || 0;
+          totals.active += counts.active || 0;
+          totals.completed += counts.completed || 0;
+          totals.failed += counts.failed || 0;
+          totals.delayed += counts.delayed || 0;
+        })
+      );
+      totals.total = totals.waiting + totals.active + totals.completed + totals.failed + totals.delayed;
+      return totals;
+    });
+  }
+  /**
+   * Get configured tag field names
    */
-  jobMatchesFilters(job, filters) {
-    if (!job.data || typeof job.data !== "object") {
-      return Object.keys(filters).length === 0;
-    }
-    const dataObj = job.data;
-    for (const [field, value] of Object.entries(filters)) {
-      const jobValue = dataObj[field];
-      if (jobValue === void 0 || jobValue === null) {
-        return false;
-      }
-      const strJobValue = String(jobValue).toLowerCase();
-      const strFilterValue = value.toLowerCase();
-      if (!strJobValue.includes(strFilterValue)) {
-        return false;
-      }
-    }
-    return true;
+  getTagFields() {
+    return this.tagFields;
   }
   /**
-   * Search jobs across all queues
-   * Supports field:value syntax (e.g., "teamId:abc-123 invoice")
-   * Optimized with parallel processing, early exits, and count checks
+   * Get just queue names (very fast, no Redis calls)
+   * Used for sidebar initial render
    */
-  async search(query, limit = 20) {
-    const { filters, text } = this.parseSearchQuery(query);
-    const lowerText = text.toLowerCase();
-    const hasFilters = Object.keys(filters).length > 0;
-    const hasText = lowerText.length > 0;
-    if (!hasFilters && !hasText) {
-      return [];
-    }
-    const queueEntries = Array.from(this.queues.entries());
-    const queueChecks = await Promise.all(
-      queueEntries.map(async ([queueName, queue]) => {
-        const counts = await this.getCachedJobCounts(queue);
-        const hasJobs = (counts.waiting || 0) > 0 || (counts.active || 0) > 0 || (counts.completed || 0) > 0 || (counts.failed || 0) > 0 || (counts.delayed || 0) > 0;
-        return { queueName, queue, hasJobs };
-      })
-    );
-    const relevantQueues = queueChecks.filter((q) => q.hasJobs);
-    if (relevantQueues.length === 0) {
-      return [];
-    }
-    const types = ["waiting", "active", "completed", "failed", "delayed"];
-    const fetchLimit = Math.min(limit * 2, 50);
-    const stringifiedDataCache = /* @__PURE__ */ new WeakMap();
-    const queueResults = await Promise.allSettled(
-      relevantQueues.map(async ({ queueName, queue }) => {
-        const typeResults = await Promise.all(
-          types.map(async (type) => {
-            try {
-              const jobs = await queue.getJobs(type, 0, fetchLimit);
-              const matches = [];
-              for (const job of jobs) {
-                if (hasFilters && !this.jobMatchesFilters(job, filters)) {
-                  continue;
-                }
-                if (hasText) {
-                  const matchesId = job.id?.toLowerCase().includes(lowerText);
-                  const matchesName = job.name?.toLowerCase().includes(lowerText);
-                  let matchesData = false;
-                  if (!matchesId && !matchesName) {
-                    let stringifiedData = stringifiedDataCache.get(job);
-                    if (!stringifiedData) {
-                      stringifiedData = JSON.stringify(job.data).toLowerCase();
-                      stringifiedDataCache.set(job, stringifiedData);
-                    }
-                    matchesData = stringifiedData.includes(lowerText);
-                  }
-                  if (!matchesId && !matchesName && !matchesData) {
-                    continue;
-                  }
-                }
-                matches.push({
-                  queue: queueName,
-                  job: await this.jobToInfo(
-                    job,
-                    "full",
-                    type
-                  )
-                });
-              }
-              return matches;
-            } catch {
-              return [];
-            }
-          })
-        );
-        return typeResults.flat();
-      })
-    );
-    const allMatches = [];
-    for (const result of queueResults) {
-      if (result.status === "fulfilled") {
-        allMatches.push(...result.value);
+  getQueueNames() {
+    return Array.from(this.queues.keys());
+  }
+  /**
+   * Get configured queue groups (very fast, no Redis calls)
+   */
+  getQueueGroups() {
+    return this.queueGroups;
+  }
+  /**
+   * Get a queue by name
+   */
+  getQueue(name) {
+    return this.queues.get(name);
+  }
+  /**
+   * Get information for all queues (cached)
+   */
+  async getQueues() {
+    return this.cached("queues", this.CACHE_TTL.queues, async () => {
+      const queueEntries = Array.from(this.queues.entries());
+      const results = await Promise.all(
+        queueEntries.map(async ([name, queue]) => {
+          const [counts, isPaused] = await Promise.all([
+            this.getCachedJobCounts(queue),
+            queue.isPaused()
+          ]);
+          return {
+            name,
+            group: this.queueGroupByName.get(name),
+            counts: {
+              waiting: counts.waiting || 0,
+              active: counts.active || 0,
+              completed: counts.completed || 0,
+              failed: counts.failed || 0,
+              delayed: counts.delayed || 0,
+              paused: counts.paused || 0
+            },
+            isPaused
+          };
+        })
+      );
+      return results;
+    });
+  }
+  /**
+   * Get overview statistics (cached)
+   */
+  async getOverview() {
+    return this.cached("overview", this.CACHE_TTL.overview, async () => {
+      const queues = await this.getQueues();
+      let totalJobs = 0;
+      let activeJobs = 0;
+      let failedJobs = 0;
+      for (const queue of queues) {
+        totalJobs += queue.counts.waiting + queue.counts.active + queue.counts.delayed;
+        activeJobs += queue.counts.active;
+        failedJobs += queue.counts.failed;
       }
-    }
-    return allMatches.slice(0, limit);
+      const completedToday = queues.reduce(
+        (sum, q) => sum + q.counts.completed,
+        0
+      );
+      return {
+        totalJobs,
+        activeJobs,
+        failedJobs,
+        completedToday,
+        avgDuration: 0,
+        // Would need metrics tracking
+        queues
+      };
+    });
   }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Queue Control (Pause/Resume)
+  // ─────────────────────────────────────────────────────────────────────────────
   /**
-   * Clean jobs from a queue
+   * Pause a queue - stops processing new jobs
    */
-  async cleanJobs(queueName, status, grace = 0) {
+  async pauseQueue(queueName) {
     const queue = this.queues.get(queueName);
-    if (!queue) return 0;
-    const removed = await queue.clean(grace, 1e3, status);
-    return removed.length;
+    if (!queue) {
+      throw new Error(`Queue "${queueName}" not found`);
+    }
+    await queue.pause();
   }
   /**
-   * FAST PATH: Get latest runs without filters
-   * Optimized for the common case of viewing newest jobs (timestamp desc, no filters)
-   * - Single getJobs call per queue (not per status type)
-   * - No count checks needed
-   * - Minimal Redis round-trips
+   * Resume a paused queue
    */
-  async getLatestRuns(limit, start) {
-    const queueEntries = Array.from(this.queues.entries());
-    const numQueues = queueEntries.length;
-    if (numQueues === 0) {
-      return { data: [], total: -1, hasMore: false, cursor: void 0 };
-    }
-    const perQueueFetch = Math.max(5, Math.ceil((limit + 10) / numQueues) + 2);
-    const allTypes = [
-      "waiting",
-      "active",
-      "completed",
-      "failed",
-      "delayed"
-    ];
-    const results = await Promise.all(
-      queueEntries.map(async ([queueName, queue]) => {
-        const jobs = await queue.getJobs(allTypes, 0, perQueueFetch);
-        return jobs.map((job) => ({ job, queueName }));
-      })
-    );
-    const allJobs = results.flat();
-    allJobs.sort((a, b) => {
-      const timeDiff = (b.job.timestamp || 0) - (a.job.timestamp || 0);
-      if (timeDiff !== 0) return timeDiff;
-      return a.queueName.localeCompare(b.queueName);
-    });
-    const jobsToConvert = allJobs.slice(start, start + limit);
-    const runInfos = await Promise.all(
-      jobsToConvert.map(async ({ job, queueName }) => {
-        let state = "waiting";
-        if (job.finishedOn) {
-          state = job.failedReason ? "failed" : "completed";
-        } else if (job.processedOn) {
-          state = "active";
-        } else if (job.delay && job.delay > 0) {
-          state = "delayed";
-        }
-        const info = await this.jobToInfo(job, "list", state);
-        return { ...info, queueName };
-      })
-    );
-    const hasMore = allJobs.length > start + limit;
-    return {
-      data: runInfos,
-      total: -1,
-      // Don't calculate total for fast path - not needed for UI
-      hasMore,
-      cursor: hasMore ? String(start + runInfos.length) : void 0
-    };
+  async resumeQueue(queueName) {
+    const queue = this.queues.get(queueName);
+    if (!queue) {
+      throw new Error(`Queue "${queueName}" not found`);
+    }
+    await queue.resume();
   }
   /**
-   * Get all runs (jobs) across all queues with sorting and filtering
-   * Uses fast path for common case (no filters, timestamp desc)
+   * Check if a queue is paused
    */
-  async getAllRuns(limit = 50, start = 0, sort, filters) {
-    const sortField = sort?.field ?? "timestamp";
-    const sortDir = sort?.direction === "asc" ? 1 : -1;
-    const hasFilters = !!(filters?.status || filters?.tags || filters?.text || filters?.timeRange);
-    const isTimestampSort = sortField === "timestamp";
-    if (!hasFilters && isTimestampSort && sortDir === -1) {
-      return this.getLatestRuns(limit, start);
-    }
-    const queueEntries = Array.from(this.queues.entries());
-    const types = filters?.status ? [filters.status] : ["waiting", "active", "completed", "failed", "delayed"];
-    const hasTimeRange = !!filters?.timeRange;
-    const numQueues = Math.max(queueEntries.length, 1);
-    if (queueEntries.length === 0) {
-      return {
-        data: [],
-        total: 0,
-        hasMore: false,
-        cursor: void 0
-      };
+  async isQueuePaused(queueName) {
+    const queue = this.queues.get(queueName);
+    if (!queue) {
+      throw new Error(`Queue "${queueName}" not found`);
     }
-    const baseFetchPerQueue = Math.max(
-      Math.ceil(limit * 2 / numQueues) + 3,
-      5
-    );
-    let allJobs = [];
-    const fetchFromQueue = async (queueName, queue, fetchCount) => {
-      if (hasTimeRange && filters?.timeRange) {
-        const timeRangeJobs = [];
-        if (types.includes("completed")) {
-          const completedJobs = await this.getJobsByTimeRange(
-            queue,
-            "completed",
-            filters.timeRange.start,
-            filters.timeRange.end,
-            fetchCount
-          );
-          timeRangeJobs.push(
-            ...completedJobs.map((job) => ({
-              job,
-              state: "completed"
-            }))
-          );
-        }
-        if (types.includes("failed")) {
-          const failedJobs = await this.getJobsByTimeRange(
-            queue,
-            "failed",
-            filters.timeRange.start,
-            filters.timeRange.end,
-            fetchCount
-          );
-          timeRangeJobs.push(
-            ...failedJobs.map((job) => ({
-              job,
-              state: "failed"
-            }))
+    return queue.isPaused();
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Metrics
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Get metrics for the last 24 hours (cached - expensive operation)
+   */
+  async getMetrics() {
+    return this.cached("metrics", this.CACHE_TTL.metrics, async () => {
+      return this.withTimeout(
+        (async () => {
+          const now = Date.now();
+          const twentyFourHoursAgo = now - 24 * 60 * 60 * 1e3;
+          const createEmptyBuckets = () => {
+            const buckets = [];
+            const startHour = Math.floor(twentyFourHoursAgo / (60 * 60 * 1e3)) * (60 * 60 * 1e3);
+            for (let i = 0; i < 24; i++) {
+              buckets.push({
+                hour: startHour + i * 60 * 60 * 1e3,
+                completed: 0,
+                failed: 0,
+                avgDuration: 0,
+                avgWaitTime: 0
+              });
+            }
+            return buckets;
+          };
+          const queueMetricsMap = /* @__PURE__ */ new Map();
+          for (const queueName of this.queues.keys()) {
+            queueMetricsMap.set(queueName, {
+              buckets: createEmptyBuckets(),
+              durations: Array.from({ length: 24 }, () => []),
+              waitTimes: Array.from({ length: 24 }, () => [])
+            });
+          }
+          const allJobs = [];
+          const jobTypeStats = /* @__PURE__ */ new Map();
+          const queueEntries = Array.from(this.queues.entries());
+          const queueChecks = await Promise.all(
+            queueEntries.map(async ([queueName, queue]) => {
+              const counts = await this.getCachedJobCounts(queue);
+              return {
+                queueName,
+                queue,
+                hasRelevantJobs: (counts.completed || 0) > 0 || (counts.failed || 0) > 0
+              };
+            })
           );
-        }
-        const otherTypes = types.filter(
-          (t) => t !== "completed" && t !== "failed"
-        );
-        if (otherTypes.length > 0) {
-          const otherJobArrays = await Promise.all(
-            otherTypes.map(async (type) => {
-              const jobs = await queue.getJobs(type, 0, fetchCount);
-              return jobs.map((job) => ({ job, state: type }));
+          const relevantQueues = queueChecks.filter((q) => q.hasRelevantJobs);
+          const queueResults = await Promise.all(
+            relevantQueues.map(async ({ queueName, queue }) => {
+              const [completedJobs, failedJobs] = await Promise.all([
+                this.getJobsByTimeRange(
+                  queue,
+                  "completed",
+                  twentyFourHoursAgo,
+                  now,
+                  100
+                  // Reduced from 200 - only recent jobs needed
+                ),
+                this.getJobsByTimeRange(
+                  queue,
+                  "failed",
+                  twentyFourHoursAgo,
+                  now,
+                  100
+                  // Reduced from 200 - only recent jobs needed
+                )
+              ]);
+              return { queueName, completedJobs, failedJobs };
             })
           );
-          timeRangeJobs.push(...otherJobArrays.flat());
-        }
-        return timeRangeJobs.map(({ job, state }) => ({
-          job,
-          queueName,
-          state
-        }));
-      }
-      if (filters?.status) {
-        const jobs = await queue.getJobs(filters.status, 0, fetchCount);
-        return jobs.map((job) => ({
-          job,
-          queueName,
-          state: filters.status
-        }));
-      }
-      const jobArrays = await Promise.all(
-        types.map(async (type) => {
-          const jobs = await queue.getJobs(type, 0, fetchCount);
-          return jobs.map((job) => ({ job, state: type }));
-        })
-      );
-      return jobArrays.flat().map(({ job, state }) => ({ job, queueName, state }));
-    };
-    const results = await Promise.all(
-      queueEntries.map(
-        ([queueName, queue]) => fetchFromQueue(queueName, queue, baseFetchPerQueue)
-      )
-    );
-    allJobs = results.flat();
-    if (filters) {
-      allJobs = allJobs.filter(
-        ({ job }) => this.jobMatchesAllFilters(job, filters)
+          for (const { queueName, completedJobs, failedJobs } of queueResults) {
+            const metrics = queueMetricsMap.get(queueName);
+            for (const job of completedJobs) {
+              if (!job?.finishedOn || job.finishedOn < twentyFourHoursAgo)
+                continue;
+              const bucketIndex = Math.floor(
+                (job.finishedOn - (metrics.buckets[0]?.hour || 0)) / (60 * 60 * 1e3)
+              );
+              if (bucketIndex >= 0 && bucketIndex < 24) {
+                metrics.buckets[bucketIndex].completed++;
+                const duration = job.processedOn ? job.finishedOn - job.processedOn : 0;
+                const waitTime = job.processedOn ? job.processedOn - job.timestamp : 0;
+                if (duration > 0) {
+                  metrics.durations[bucketIndex].push(duration);
+                  allJobs.push({
+                    name: job.name,
+                    queueName,
+                    duration,
+                    jobId: job.id || ""
+                  });
+                }
+                if (waitTime > 0) {
+                  metrics.waitTimes[bucketIndex].push(waitTime);
+                }
+              }
+              const key = `${queueName}:${job.name}`;
+              const stats = jobTypeStats.get(key) || {
+                name: job.name,
+                queueName,
+                completed: 0,
+                failed: 0
+              };
+              stats.completed++;
+              jobTypeStats.set(key, stats);
+            }
+            for (const job of failedJobs) {
+              if (!job?.finishedOn || job.finishedOn < twentyFourHoursAgo)
+                continue;
+              const bucketIndex = Math.floor(
+                (job.finishedOn - (metrics.buckets[0]?.hour || 0)) / (60 * 60 * 1e3)
+              );
+              if (bucketIndex >= 0 && bucketIndex < 24) {
+                metrics.buckets[bucketIndex].failed++;
+              }
+              const key = `${queueName}:${job.name}`;
+              const stats = jobTypeStats.get(key) || {
+                name: job.name,
+                queueName,
+                completed: 0,
+                failed: 0
+              };
+              stats.failed++;
+              jobTypeStats.set(key, stats);
+            }
+          }
+          for (const metrics of queueMetricsMap.values()) {
+            for (let i = 0; i < 24; i++) {
+              const durations = metrics.durations[i];
+              const waitTimes = metrics.waitTimes[i];
+              if (durations.length > 0) {
+                metrics.buckets[i].avgDuration = Math.round(
+                  durations.reduce((a, b) => a + b, 0) / durations.length
+                );
+              }
+              if (waitTimes.length > 0) {
+                metrics.buckets[i].avgWaitTime = Math.round(
+                  waitTimes.reduce((a, b) => a + b, 0) / waitTimes.length
+                );
+              }
+            }
+          }
+          const aggregateBuckets = createEmptyBuckets();
+          const aggregateDurations = Array.from(
+            { length: 24 },
+            () => []
+          );
+          const aggregateWaitTimes = Array.from(
+            { length: 24 },
+            () => []
+          );
+          for (const metrics of queueMetricsMap.values()) {
+            for (let i = 0; i < 24; i++) {
+              aggregateBuckets[i].completed += metrics.buckets[i].completed;
+              aggregateBuckets[i].failed += metrics.buckets[i].failed;
+              aggregateDurations[i].push(...metrics.durations[i]);
+              aggregateWaitTimes[i].push(...metrics.waitTimes[i]);
+            }
+          }
+          for (let i = 0; i < 24; i++) {
+            if (aggregateDurations[i].length > 0) {
+              aggregateBuckets[i].avgDuration = Math.round(
+                aggregateDurations[i].reduce((a, b) => a + b, 0) / aggregateDurations[i].length
+              );
+            }
+            if (aggregateWaitTimes[i].length > 0) {
+              aggregateBuckets[i].avgWaitTime = Math.round(
+                aggregateWaitTimes[i].reduce((a, b) => a + b, 0) / aggregateWaitTimes[i].length
+              );
+            }
+          }
+          const totalCompleted = aggregateBuckets.reduce(
+            (sum, b) => sum + b.completed,
+            0
+          );
+          const totalFailed = aggregateBuckets.reduce(
+            (sum, b) => sum + b.failed,
+            0
+          );
+          const allDurations = aggregateDurations.flat();
+          const allWaitTimes = aggregateWaitTimes.flat();
+          const slowestJobs = allJobs.sort((a, b) => b.duration - a.duration).slice(0, 10);
+          const mostFailingTypes = Array.from(jobTypeStats.values()).filter((s) => s.failed > 0).map((s) => ({
+            name: s.name,
+            queueName: s.queueName,
+            failCount: s.failed,
+            totalCount: s.completed + s.failed,
+            errorRate: s.failed / (s.completed + s.failed)
+          })).sort((a, b) => b.failCount - a.failCount).slice(0, 10);
+          return {
+            queues: [],
+            // Empty - per-queue metrics not used by frontend
+            aggregate: {
+              queueName: "all",
+              buckets: aggregateBuckets,
+              summary: {
+                totalCompleted,
+                totalFailed,
+                errorRate: totalCompleted + totalFailed > 0 ? totalFailed / (totalCompleted + totalFailed) : 0,
+                avgDuration: allDurations.length > 0 ? Math.round(
+                  allDurations.reduce((a, b) => a + b, 0) / allDurations.length
+                ) : 0,
+                avgWaitTime: allWaitTimes.length > 0 ? Math.round(
+                  allWaitTimes.reduce((a, b) => a + b, 0) / allWaitTimes.length
+                ) : 0,
+                throughputPerHour: Math.round(
+                  (totalCompleted + totalFailed) / 24
+                )
+              }
+            },
+            slowestJobs,
+            mostFailingTypes,
+            computedAt: now
+          };
+        })(),
+        45e3,
+        // 45 second timeout (before proxy timeout)
+        "Metrics computation timed out after 45 seconds"
       );
-    }
-    if (isTimestampSort) {
-      allJobs.sort((a, b) => {
-        const aTime = a.job.timestamp || 0;
-        const bTime = b.job.timestamp || 0;
-        const timeDiff = sortDir === -1 ? bTime - aTime : aTime - bTime;
-        if (timeDiff !== 0) return timeDiff;
-        const queueDiff = a.queueName.localeCompare(b.queueName);
-        if (queueDiff !== 0) return queueDiff;
-        return (a.job.id || "").localeCompare(b.job.id || "");
-      });
-    }
-    const jobsToConvert = allJobs.slice(start, start + limit);
-    const runInfos = await Promise.all(
-      jobsToConvert.map(async ({ job, queueName, state }) => {
-        const info = await this.jobToInfo(job, "list", state);
-        return { ...info, queueName };
-      })
-    );
-    if (!isTimestampSort) {
-      runInfos.sort((a, b) => {
-        const aVal = this.getSortValueForList(a, sortField);
-        const bVal = this.getSortValueForList(b, sortField);
-        if (aVal < bVal) return -1 * sortDir;
-        if (aVal > bVal) return 1 * sortDir;
-        return 0;
-      });
-    }
-    const hasMore = allJobs.length > start + limit;
-    return {
-      data: runInfos,
-      total: -1,
-      // Don't calculate total - not needed for UI
-      hasMore,
-      cursor: hasMore ? String(start + runInfos.length) : void 0
-    };
-  }
-  /**
-   * Get all schedulers (repeatable and delayed jobs) with sorting
-   */
-  async getSchedulers(repeatableSort, delayedSort) {
-    const repeatable = [];
-    const delayed = [];
-    const queueEntries = Array.from(this.queues.entries());
-    const results = await Promise.all(
-      queueEntries.map(async ([queueName, queue]) => {
-        const [repeatableJobs, delayedJobs] = await Promise.all([
-          queue.getRepeatableJobs(),
-          queue.getJobs("delayed", 0, 50)
-        ]);
-        return { queueName, repeatableJobs, delayedJobs };
-      })
-    );
-    for (const { queueName, repeatableJobs, delayedJobs } of results) {
-      for (const job of repeatableJobs) {
-        repeatable.push({
-          key: job.key,
-          name: job.name || "unnamed",
-          queueName,
-          pattern: job.pattern ?? void 0,
-          every: job.every ? Number(job.every) : void 0,
-          next: job.next ?? void 0,
-          endDate: job.endDate ?? void 0,
-          tz: job.tz ?? void 0
-        });
-      }
-      for (const job of delayedJobs) {
-        const delay = job.opts.delay || 0;
-        delayed.push({
-          id: job.id || "",
-          name: job.name,
-          queueName,
-          delay,
-          processAt: job.timestamp + delay,
-          data: job.data
-        });
-      }
-    }
-    const repeatableField = repeatableSort?.field ?? "name";
-    const repeatableDir = repeatableSort?.direction === "desc" ? -1 : 1;
-    repeatable.sort((a, b) => {
-      const aVal = this.getSchedulerSortValue(a, repeatableField);
-      const bVal = this.getSchedulerSortValue(b, repeatableField);
-      if (aVal < bVal) return -1 * repeatableDir;
-      if (aVal > bVal) return 1 * repeatableDir;
-      return 0;
-    });
-    const delayedField = delayedSort?.field ?? "processAt";
-    const delayedDir = delayedSort?.direction === "desc" ? -1 : 1;
-    delayed.sort((a, b) => {
-      const aVal = this.getDelayedSortValue(a, delayedField);
-      const bVal = this.getDelayedSortValue(b, delayedField);
-      if (aVal < bVal) return -1 * delayedDir;
-      if (aVal > bVal) return 1 * delayedDir;
-      return 0;
-    });
-    return { repeatable, delayed };
-  }
-  /**
-   * Enqueue a new job (for testing)
-   */
-  async enqueueJob(request) {
-    const queue = this.queues.get(request.queueName);
-    if (!queue) {
-      throw new Error(`Queue "${request.queueName}" not found`);
-    }
-    const job = await queue.add(request.jobName, request.data, {
-      delay: request.opts?.delay,
-      priority: request.opts?.priority,
-      attempts: request.opts?.attempts
     });
-    return { id: job.id || "" };
   }
   /**
-   * Extract tag values from job data based on configured tag fields
+   * Get activity stats for the last 7 days (cached)
+   * Returns 4-hour buckets for the activity timeline
    */
-  extractTags(data) {
-    if (!this.tagFields.length || !data || typeof data !== "object") {
-      return void 0;
-    }
-    const tags = {};
-    const dataObj = data;
-    for (const field of this.tagFields) {
-      const value = dataObj[field];
-      if (value !== void 0 && (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null)) {
-        tags[field] = value;
+  async getActivityStats() {
+    return this.cached("activity", this.CACHE_TTL.activity, async () => {
+      const now = Date.now();
+      const bucketSize = 4 * 60 * 60 * 1e3;
+      const bucketCount = 42;
+      const startDate = new Date(now);
+      startDate.setHours(0, 0, 0, 0);
+      startDate.setDate(startDate.getDate() - 6);
+      const startTime = startDate.getTime();
+      const buckets = [];
+      for (let i = 0; i < bucketCount; i++) {
+        buckets.push({
+          time: startTime + i * bucketSize,
+          completed: 0,
+          failed: 0
+        });
       }
-    }
-    return Object.keys(tags).length > 0 ? tags : void 0;
-  }
-  /**
-   * Get unique values for a specific tag field across all jobs
-   */
-  async getTagValues(field, limit = 50) {
-    const valueMap = /* @__PURE__ */ new Map();
-    const types = ["waiting", "active", "completed", "failed", "delayed"];
-    const queueEntries = Array.from(this.queues.entries());
-    const queueResults = await Promise.all(
-      queueEntries.map(async ([, queue]) => {
-        const jobArrays = await Promise.all(
-          types.map((type) => queue.getJobs(type, 0, 100))
-        );
-        return jobArrays.flat();
-      })
-    );
-    for (const jobs of queueResults) {
-      for (const job of jobs) {
-        if (job.data && typeof job.data === "object") {
-          const dataObj = job.data;
-          const value = dataObj[field];
-          if (value !== void 0 && value !== null) {
-            const strValue = String(value);
-            valueMap.set(strValue, (valueMap.get(strValue) || 0) + 1);
+      const queueEntries = Array.from(this.queues.entries());
+      const queueChecks = await Promise.all(
+        queueEntries.map(async ([, queue]) => {
+          const counts = await this.getCachedJobCounts(queue);
+          return {
+            queue,
+            hasRelevantJobs: (counts.completed || 0) > 0 || (counts.failed || 0) > 0
+          };
+        })
+      );
+      const relevantQueues = queueChecks.filter((q) => q.hasRelevantJobs);
+      const queueResults = await Promise.all(
+        relevantQueues.map(async ({ queue }) => {
+          const [completedJobs, failedJobs] = await Promise.all([
+            this.getJobsByTimeRange(
+              queue,
+              "completed",
+              startTime,
+              now,
+              200
+              // Reduced from 500 - only jobs in time range needed
+            ),
+            this.getJobsByTimeRange(
+              queue,
+              "failed",
+              startTime,
+              now,
+              200
+              // Reduced from 500 - only jobs in time range needed
+            )
+          ]);
+          return { completedJobs, failedJobs };
+        })
+      );
+      for (const { completedJobs, failedJobs } of queueResults) {
+        for (const job of completedJobs) {
+          if (!job?.finishedOn || job.finishedOn < startTime) continue;
+          const bucketIndex = Math.floor(
+            (job.finishedOn - startTime) / bucketSize
+          );
+          if (bucketIndex >= 0 && bucketIndex < bucketCount) {
+            buckets[bucketIndex].completed++;
+          }
+        }
+        for (const job of failedJobs) {
+          if (!job?.finishedOn || job.finishedOn < startTime) continue;
+          const bucketIndex = Math.floor(
+            (job.finishedOn - startTime) / bucketSize
+          );
+          if (bucketIndex >= 0 && bucketIndex < bucketCount) {
+            buckets[bucketIndex].failed++;
           }
         }
       }
-    }
-    const sorted = Array.from(valueMap.entries()).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([value, count]) => ({ value, count }));
-    return sorted;
-  }
-  /**
-   * Get sortable value from JobInfo/RunInfo
-   */
-  getSortValue(item, field) {
-    switch (field) {
-      case "timestamp":
-        return item.timestamp ?? 0;
-      case "name":
-        return item.name.toLowerCase();
-      case "status":
-        return item.status;
-      case "duration":
-        return item.duration ?? 0;
-      case "queueName":
-        return "queueName" in item ? item.queueName.toLowerCase() : "";
-      case "processedOn":
-        return item.processedOn ?? 0;
-      default:
-        return item.timestamp ?? 0;
-    }
+      const totalCompleted = buckets.reduce((sum, b) => sum + b.completed, 0);
+      const totalFailed = buckets.reduce((sum, b) => sum + b.failed, 0);
+      return {
+        buckets,
+        startTime,
+        endTime: now,
+        bucketSize,
+        totalCompleted,
+        totalFailed,
+        computedAt: now
+      };
+    });
   }
   /**
-   * Get sortable value from RunInfoList (lightweight version)
+   * Get jobs for a specific queue with pagination and sorting
    */
-  getSortValueForList(item, field) {
-    switch (field) {
-      case "timestamp":
-        return item.timestamp ?? 0;
-      case "name":
-        return item.name.toLowerCase();
-      case "status":
-        return item.status;
-      case "duration":
-        return item.duration ?? 0;
-      case "queueName":
-        return item.queueName.toLowerCase();
-      case "processedOn":
-        return item.processedOn ?? 0;
-      default:
-        return item.timestamp ?? 0;
+  async getJobs(queueName, status, limit = 50, start = 0, sort) {
+    const queue = this.queues.get(queueName);
+    if (!queue) {
+      return { data: [], total: 0, hasMore: false };
     }
-  }
-  /**
-   * Get sortable value from SchedulerInfo
-   */
-  getSchedulerSortValue(item, field) {
-    switch (field) {
-      case "name":
-        return item.name.toLowerCase();
-      case "queueName":
-        return item.queueName.toLowerCase();
-      case "pattern":
-        return item.pattern?.toLowerCase() ?? "";
-      case "next":
-        return item.next ?? 0;
-      case "tz":
-        return item.tz?.toLowerCase() ?? "";
-      default:
-        return item.name.toLowerCase();
+    const types = status ? [status] : ["waiting", "active", "completed", "failed", "delayed"];
+    const counts = await this.getCachedJobCounts(queue);
+    const jobsWithState = [];
+    let total = 0;
+    for (const type of types) {
+      const typeJobs = await queue.getJobs(type, start, start + limit);
+      jobsWithState.push(
+        ...typeJobs.map((job) => ({ job, state: type }))
+      );
+      const typeCount = counts[type] || 0;
+      total += typeCount;
     }
+    const jobInfos = await Promise.all(
+      jobsWithState.map(({ job, state }) => this.jobToInfo(job, "full", state))
+    );
+    const sortField = sort?.field ?? "timestamp";
+    const sortDir = sort?.direction === "asc" ? 1 : -1;
+    jobInfos.sort((a, b) => {
+      const aVal = this.getSortValue(a, sortField);
+      const bVal = this.getSortValue(b, sortField);
+      if (aVal < bVal) return -1 * sortDir;
+      if (aVal > bVal) return 1 * sortDir;
+      return 0;
+    });
+    const data = jobInfos.slice(0, limit);
+    return {
+      data,
+      total,
+      hasMore: start + limit < total,
+      cursor: start + limit < total ? String(start + limit) : void 0
+    };
   }
   /**
-   * Get sortable value from DelayedJobInfo
+   * Get a single job by ID
    */
-  getDelayedSortValue(item, field) {
-    switch (field) {
-      case "name":
-        return item.name.toLowerCase();
-      case "queueName":
-        return item.queueName.toLowerCase();
-      case "processAt":
-        return item.processAt;
-      case "delay":
-        return item.delay;
-      default:
-        return item.processAt;
-    }
+  async getJob(queueName, jobId) {
+    const queue = this.queues.get(queueName);
+    if (!queue) return null;
+    const job = await queue.getJob(jobId);
+    if (!job) return null;
+    return this.jobToInfo(job, "full");
   }
   /**
-   * Convert a BullMQ Job to JobInfo or RunInfoList
-   * @param job - The BullMQ job to convert
-   * @param fields - "list" for lightweight list view, "full" for complete job details
-   * @param knownState - Optional: skip getState() call if state is already known from fetch
+   * Get BullMQ log lines for a job.
    */
-  async jobToInfo(job, _fields = "full", knownState) {
-    let state = knownState;
-    if (!state) {
-      const cacheKey = `${job.queueName}:${job.id}`;
-      state = this.jobStateCache.get(cacheKey);
-      if (!state) {
-        state = await job.getState();
-        this.jobStateCache.set(cacheKey, state);
-      }
-    }
-    const duration = job.finishedOn && job.processedOn ? job.finishedOn - job.processedOn : void 0;
-    let progress = 0;
-    if (typeof job.progress === "number") {
-      progress = job.progress;
-    } else if (typeof job.progress === "object" && job.progress !== null) {
-      progress = job.progress;
-    }
-    const tags = this.extractTags(job.data);
-    let parent;
-    if (job.parent?.id) {
-      parent = {
-        id: job.parent.id,
-        queueName: job.parent.queueKey?.split(":")[1] || job.parent.queueKey || ""
-      };
-    } else if (job.parentKey) {
-      const parts = job.parentKey.split(":");
-      if (parts.length >= 3) {
-        parent = {
-          id: parts[parts.length - 1] || "",
-          queueName: parts[parts.length - 2] || ""
-        };
-      }
-    }
+  async getJobLogs(queueName, jobId, start = 0, end = 999, asc = true) {
+    const queue = this.queues.get(queueName);
+    if (!queue) return null;
+    const job = await queue.getJob(jobId);
+    if (!job) return null;
+    const result = await queue.getJobLogs(jobId, start, end, asc);
     return {
-      id: job.id || "",
-      name: job.name,
-      data: job.data,
-      opts: {
-        attempts: job.opts.attempts,
-        delay: job.opts.delay,
-        priority: job.opts.priority
-      },
-      progress,
-      attemptsMade: job.attemptsMade,
-      processedOn: job.processedOn,
-      finishedOn: job.finishedOn,
-      timestamp: job.timestamp,
-      failedReason: job.failedReason,
-      stacktrace: job.stacktrace ?? void 0,
-      returnvalue: job.returnvalue,
-      status: state,
-      duration,
-      tags,
-      parent
+      logs: result.logs,
+      count: result.count,
+      start,
+      end
     };
   }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Bulk Operations
-  // ─────────────────────────────────────────────────────────────────────────────
   /**
-   * Retry multiple jobs across queues
-   * Processed in parallel for better performance
-   */
-  async bulkRetry(jobs) {
-    const results = await Promise.allSettled(
-      jobs.map(async ({ queueName, jobId }) => {
-        const queue = this.queues.get(queueName);
-        if (!queue) {
-          throw new Error("Queue not found");
-        }
-        const job = await queue.getJob(jobId);
-        if (!job) {
-          throw new Error("Job not found");
-        }
-        await job.retry();
-        this.invalidateJobCache(queueName, jobId);
-        return { success: true };
-      })
-    );
-    let success = 0;
-    let failed = 0;
-    for (const result of results) {
-      if (result.status === "fulfilled") {
-        success++;
-      } else {
-        failed++;
-      }
-    }
-    return { success, failed };
+   * Retry a failed job
+   */
+  async retryJob(queueName, jobId) {
+    const queue = this.queues.get(queueName);
+    if (!queue) return false;
+    const job = await queue.getJob(jobId);
+    if (!job) return false;
+    await job.retry();
+    this.invalidateJobCache(queueName, jobId);
+    return true;
   }
   /**
-   * Delete multiple jobs across queues
-   * Processed in parallel for better performance
+   * Remove a job
    */
-  async bulkDelete(jobs) {
-    const results = await Promise.allSettled(
-      jobs.map(async ({ queueName, jobId }) => {
-        const queue = this.queues.get(queueName);
-        if (!queue) {
-          throw new Error("Queue not found");
-        }
-        const job = await queue.getJob(jobId);
-        if (!job) {
-          throw new Error("Job not found");
-        }
-        await job.remove();
-        this.invalidateJobCache(queueName, jobId);
-        return { success: true };
-      })
-    );
-    let success = 0;
-    let failed = 0;
-    for (const result of results) {
-      if (result.status === "fulfilled") {
-        success++;
-      } else {
-        failed++;
-      }
-    }
-    return { success, failed };
+  async removeJob(queueName, jobId) {
+    const queue = this.queues.get(queueName);
+    if (!queue) return false;
+    const job = await queue.getJob(jobId);
+    if (!job) return false;
+    await job.remove();
+    this.invalidateJobCache(queueName, jobId);
+    return true;
   }
   /**
-   * Promote multiple delayed jobs across queues (move to waiting)
-   * Processed in parallel for better performance
+   * Promote a delayed job to waiting
    */
-  async bulkPromote(jobs) {
-    const results = await Promise.allSettled(
-      jobs.map(async ({ queueName, jobId }) => {
-        const queue = this.queues.get(queueName);
-        if (!queue) {
-          throw new Error("Queue not found");
+  async promoteJob(queueName, jobId) {
+    const queue = this.queues.get(queueName);
+    if (!queue) return false;
+    const job = await queue.getJob(jobId);
+    if (!job) return false;
+    await job.promote();
+    this.invalidateJobCache(queueName, jobId);
+    return true;
+  }
+  /**
+   * Parse search query for field:value filters
+   * Returns { filters: { field: value }, text: remainingText }
+   */
+  parseSearchQuery(query) {
+    const filters = {};
+    const textParts = [];
+    const len = query.length;
+    let i = 0;
+    while (i < len) {
+      while (i < len && query[i] === " ") i++;
+      if (i >= len) break;
+      let j = i;
+      while (j < len && /\w/.test(query[j])) j++;
+      if (j > i && j < len && query[j] === ":") {
+        const field = query.slice(i, j);
+        j++;
+        let value;
+        if (j < len && query[j] === '"') {
+          j++;
+          const closeQuote = query.indexOf('"', j);
+          if (closeQuote !== -1) {
+            value = query.slice(j, closeQuote);
+            j = closeQuote + 1;
+          } else {
+            value = query.slice(j);
+            j = len;
+          }
+        } else {
+          const valueStart = j;
+          while (j < len && query[j] !== " ") j++;
+          value = query.slice(valueStart, j);
         }
-        const job = await queue.getJob(jobId);
-        if (!job) {
-          throw new Error("Job not found");
+        if (value) {
+          filters[field] = value;
+        } else {
+          textParts.push(`${field}:`);
         }
-        await job.promote();
-        this.invalidateJobCache(queueName, jobId);
-        return { success: true };
-      })
-    );
-    let success = 0;
-    let failed = 0;
-    for (const result of results) {
-      if (result.status === "fulfilled") {
-        success++;
+        i = j;
       } else {
-        failed++;
+        const start = i;
+        while (i < len && query[i] !== " ") i++;
+        textParts.push(query.slice(start, i));
       }
     }
-    return { success, failed };
+    return {
+      filters,
+      text: textParts.filter(Boolean).join(" ")
+    };
   }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Flow Operations
-  // ─────────────────────────────────────────────────────────────────────────────
   /**
-   * Get all flows (jobs that have children or are part of a flow) - cached
-   * Optimized to focus on waiting-children type first and early exit
+   * Check if a raw job matches all provided filters (before conversion)
+   * This is more efficient than converting to JobInfo first
    */
-  async getFlows(limit = 50) {
-    if (!this.flowProducer) {
-      return [];
+  jobMatchesAllFilters(job, filters) {
+    if (filters.timeRange) {
+      const jobTime = job.processedOn || job.finishedOn || job.timestamp || 0;
+      if (jobTime < filters.timeRange.start || jobTime > filters.timeRange.end) {
+        return false;
+      }
     }
-    return this.cached(`flows:${limit}`, this.CACHE_TTL.flows, async () => {
-      const queueEntries = Array.from(this.queues.entries());
-      const queueChecks = await Promise.all(
-        queueEntries.map(async ([queueName, queue]) => {
-          const counts = await this.getCachedJobCounts(queue);
-          const hasRelevantJobs = (counts.waiting || 0) > 0 || (counts["waiting-children"] || 0) > 0 || (counts.active || 0) > 0;
-          return { queueName, queue, hasRelevantJobs };
-        })
-      );
-      const relevantQueues = queueChecks.filter((q) => q.hasRelevantJobs);
-      if (relevantQueues.length === 0) {
-        return [];
+    if (filters.tags && Object.keys(filters.tags).length > 0) {
+      if (!job.data || typeof job.data !== "object") {
+        return false;
       }
-      const queueResults = await Promise.all(
-        relevantQueues.map(async ({ queueName, queue }) => {
-          try {
-            const waitingChildrenJobs = await queue.getJobs(
-              ["waiting-children"],
-              0,
-              50
-            );
-            if (waitingChildrenJobs.length >= limit) {
-              return { queueName, jobs: waitingChildrenJobs };
-            }
-            const otherTypes = [
-              "waiting",
-              "active",
-              "completed",
-              "failed",
-              "delayed"
-            ];
-            const otherJobArrays = await Promise.all(
-              otherTypes.map(async (type) => {
-                try {
-                  return await queue.getJobs(type, 0, 30);
-                } catch {
-                  return [];
-                }
-              })
-            );
-            const allJobs = [...waitingChildrenJobs, ...otherJobArrays.flat()];
-            return { queueName, jobs: allJobs };
-          } catch {
-            return { queueName, jobs: [] };
-          }
-        })
-      );
-      const seenJobIds = /* @__PURE__ */ new Set();
-      const potentialRoots = [];
-      for (const { queueName, jobs } of queueResults) {
-        if (potentialRoots.length >= limit * 2) {
-          break;
+      const dataObj = job.data;
+      for (const [field, value] of Object.entries(filters.tags)) {
+        const jobValue = dataObj[field];
+        if (jobValue === void 0 || jobValue === null) {
+          return false;
         }
-        for (const job of jobs) {
-          if (!job?.id) continue;
-          const jobKey = `${queueName}:${job.id}`;
-          if (seenJobIds.has(jobKey)) continue;
-          seenJobIds.add(jobKey);
-          const hasParent = !!job.parent || !!job.parentKey;
-          if (!hasParent) {
-            potentialRoots.push({ queueName, job });
-            if (potentialRoots.length >= limit * 2) {
-              break;
-            }
-          }
+        const strJobValue = String(jobValue).toLowerCase();
+        const strFilterValue = value.toLowerCase();
+        if (!strJobValue.includes(strFilterValue)) {
+          return false;
         }
       }
-      const batchSize = 20;
-      const flows = [];
-      for (let i = 0; i < potentialRoots.length && flows.length < limit; i += batchSize) {
-        const batch = potentialRoots.slice(i, i + batchSize);
-        const batchResults = await Promise.all(
-          batch.map(async ({ queueName, job }) => {
-            try {
-              const flowTree = await this.flowProducer.getFlow({
-                id: job.id,
-                queueName
-              });
-              if (flowTree?.children && flowTree.children.length > 0) {
-                const stats = this.countFlowStats(flowTree);
-                const state = await job.getState();
-                return {
-                  id: job.id,
-                  name: job.name,
-                  queueName,
-                  status: state,
-                  totalJobs: stats.total,
-                  completedJobs: stats.completed,
-                  failedJobs: stats.failed,
-                  timestamp: job.timestamp,
-                  duration: job.finishedOn && job.processedOn ? job.finishedOn - job.processedOn : void 0
-                };
-              }
-            } catch {
-            }
-            return null;
-          })
-        );
-        for (const result of batchResults) {
-          if (result && flows.length < limit) {
-            flows.push(result);
-          }
+    }
+    if (filters.text) {
+      const lowerText = filters.text.toLowerCase();
+      const matchesId = job.id?.toLowerCase().includes(lowerText);
+      const matchesName = job.name?.toLowerCase().includes(lowerText);
+      if (!matchesId && !matchesName) {
+        const stringifiedData = JSON.stringify(job.data).toLowerCase();
+        if (!stringifiedData.includes(lowerText)) {
+          return false;
         }
       }
-      return flows.sort((a, b) => b.timestamp - a.timestamp);
-    });
+    }
+    return true;
   }
   /**
-   * Get a single flow tree by root job ID
+   * Check if a job matches the given tag filters
    */
-  async getFlow(queueName, jobId) {
-    if (!this.flowProducer) {
-      return null;
+  jobMatchesFilters(job, filters) {
+    if (!job.data || typeof job.data !== "object") {
+      return Object.keys(filters).length === 0;
     }
-    try {
-      const flowTree = await this.flowProducer.getFlow({
-        id: jobId,
-        queueName
-      });
-      if (!flowTree) {
-        return null;
+    const dataObj = job.data;
+    for (const [field, value] of Object.entries(filters)) {
+      const jobValue = dataObj[field];
+      if (jobValue === void 0 || jobValue === null) {
+        return false;
+      }
+      const strJobValue = String(jobValue).toLowerCase();
+      const strFilterValue = value.toLowerCase();
+      if (!strJobValue.includes(strFilterValue)) {
+        return false;
       }
-      return this.convertFlowTree(flowTree);
-    } catch {
-      return null;
     }
+    return true;
   }
   /**
-   * Create a new flow
+   * Search jobs across all queues
+   * Supports field:value syntax (e.g., "teamId:abc-123 invoice")
+   * Optimized with parallel processing, early exits, and count checks
    */
-  async createFlow(request) {
-    if (!this.flowProducer) {
-      throw new Error("FlowProducer not initialized");
+  async search(query, limit = 20) {
+    const { filters, text } = this.parseSearchQuery(query);
+    const lowerText = text.toLowerCase();
+    const hasFilters = Object.keys(filters).length > 0;
+    const hasText = lowerText.length > 0;
+    if (!hasFilters && !hasText) {
+      return [];
     }
-    const flowJob = this.buildFlowJob(request);
-    const result = await this.flowProducer.add(flowJob);
-    return { id: result.job.id || "" };
-  }
-  /**
-   * Build a FlowJob from CreateFlowRequest or CreateFlowChildRequest
-   */
-  buildFlowJob(request) {
-    const result = {
-      name: request.name,
-      queueName: request.queueName,
-      data: request.data || {}
-    };
-    if (request.children && request.children.length > 0) {
-      result.children = request.children.map(
-        (child) => this.buildFlowJob(child)
-      );
+    const queueEntries = Array.from(this.queues.entries());
+    const queueChecks = await Promise.all(
+      queueEntries.map(async ([queueName, queue]) => {
+        const counts = await this.getCachedJobCounts(queue);
+        const hasJobs = (counts.waiting || 0) > 0 || (counts.active || 0) > 0 || (counts.completed || 0) > 0 || (counts.failed || 0) > 0 || (counts.delayed || 0) > 0;
+        return { queueName, queue, hasJobs };
+      })
+    );
+    const relevantQueues = queueChecks.filter((q) => q.hasJobs);
+    if (relevantQueues.length === 0) {
+      return [];
     }
-    return result;
+    const types = ["waiting", "active", "completed", "failed", "delayed"];
+    const fetchLimit = Math.min(limit * 2, 50);
+    const stringifiedDataCache = /* @__PURE__ */ new WeakMap();
+    const queueResults = await Promise.allSettled(
+      relevantQueues.map(async ({ queueName, queue }) => {
+        const typeResults = await Promise.all(
+          types.map(async (type) => {
+            try {
+              const jobs = await queue.getJobs(type, 0, fetchLimit);
+              const matches = [];
+              for (const job of jobs) {
+                if (hasFilters && !this.jobMatchesFilters(job, filters)) {
+                  continue;
+                }
+                if (hasText) {
+                  const matchesId = job.id?.toLowerCase().includes(lowerText);
+                  const matchesName = job.name?.toLowerCase().includes(lowerText);
+                  let matchesData = false;
+                  if (!matchesId && !matchesName) {
+                    let stringifiedData = stringifiedDataCache.get(job);
+                    if (!stringifiedData) {
+                      stringifiedData = JSON.stringify(job.data).toLowerCase();
+                      stringifiedDataCache.set(job, stringifiedData);
+                    }
+                    matchesData = stringifiedData.includes(lowerText);
+                  }
+                  if (!matchesId && !matchesName && !matchesData) {
+                    continue;
+                  }
+                }
+                matches.push({
+                  queue: queueName,
+                  job: await this.jobToInfo(
+                    job,
+                    "full",
+                    type
+                  )
+                });
+              }
+              return matches;
+            } catch {
+              return [];
+            }
+          })
+        );
+        return typeResults.flat();
+      })
+    );
+    const allMatches = [];
+    for (const result of queueResults) {
+      if (result.status === "fulfilled") {
+        allMatches.push(...result.value);
+      }
+    }
+    return allMatches.slice(0, limit);
   }
   /**
-   * Convert BullMQ flow tree to our FlowNode structure
+   * Clean jobs from a queue
    */
-  async convertFlowTree(tree) {
-    const job = tree.job;
-    const state = await job.getState();
-    const duration = job.finishedOn && job.processedOn ? job.finishedOn - job.processedOn : void 0;
-    const jobInfo = {
-      id: job.id || "",
-      name: job.name,
-      data: job.data,
-      opts: {
-        attempts: job.opts?.attempts,
-        delay: job.opts?.delay,
-        priority: job.opts?.priority
-      },
-      progress: typeof job.progress === "number" ? job.progress : typeof job.progress === "object" ? job.progress : 0,
-      attemptsMade: job.attemptsMade || 0,
-      processedOn: job.processedOn,
-      finishedOn: job.finishedOn,
-      timestamp: job.timestamp,
-      failedReason: job.failedReason,
-      stacktrace: job.stacktrace ?? void 0,
-      returnvalue: job.returnvalue,
-      status: state,
-      duration,
-      tags: this.extractTags(job.data)
-    };
-    const children = [];
-    if (tree.children && tree.children.length > 0) {
-      for (const child of tree.children) {
-        children.push(await this.convertFlowTree(child));
-      }
-    }
-    return {
-      job: jobInfo,
-      queueName: job.queueName || tree.queueName || "",
-      children: children.length > 0 ? children : void 0
-    };
+  async cleanJobs(queueName, status, grace = 0) {
+    const queue = this.queues.get(queueName);
+    if (!queue) return 0;
+    const removed = await queue.clean(grace, 1e3, status);
+    return removed.length;
   }
   /**
-   * Count statistics for a flow tree
+   * FAST PATH: Get latest runs without filters
+   * Optimized for the common case of viewing newest jobs (timestamp desc, no filters)
+   * - Single getJobs call per queue (not per status type)
+   * - No count checks needed
+   * - Minimal Redis round-trips
    */
-  countFlowStats(tree) {
-    let total = 1;
-    let completed = 0;
-    let failed = 0;
-    const job = tree.job;
-    if (job.finishedOn && !job.failedReason) {
-      completed = 1;
-    } else if (job.failedReason) {
-      failed = 1;
-    }
-    if (tree.children) {
-      for (const child of tree.children) {
-        const childStats = this.countFlowStats(child);
-        total += childStats.total;
-        completed += childStats.completed;
-        failed += childStats.failed;
-      }
+  async getLatestRuns(limit, start) {
+    const queueEntries = Array.from(this.queues.entries());
+    const numQueues = queueEntries.length;
+    if (numQueues === 0) {
+      return { data: [], total: -1, hasMore: false, cursor: void 0 };
     }
-    return { total, completed, failed };
-  }
-};
-
-// src/core/workbench.ts
-var WorkbenchCore = class {
-  options;
-  queueManager;
-  constructor(options) {
-    const opts = Array.isArray(options) ? { queues: options } : options;
-    const queueGroups = [
-      ...opts.queueGroups || [],
-      ...opts.groups || []
-    ];
-    const queues = [
-      ...opts.queues || [],
-      ...queueGroups.flatMap((group) => group.queues)
+    const perQueueFetch = Math.max(5, Math.ceil((limit + 10) / numQueues) + 2);
+    const allTypes = [
+      "waiting",
+      "active",
+      "completed",
+      "failed",
+      "delayed"
     ];
-    this.options = {
-      title: "Workbench",
-      readonly: false,
-      ...opts,
-      queues
+    const results = await Promise.all(
+      queueEntries.map(async ([queueName, queue]) => {
+        const jobs = await queue.getJobs(allTypes, 0, perQueueFetch);
+        return jobs.map((job) => ({ job, queueName }));
+      })
+    );
+    const allJobs = results.flat();
+    allJobs.sort((a, b) => {
+      const timeDiff = (b.job.timestamp || 0) - (a.job.timestamp || 0);
+      if (timeDiff !== 0) return timeDiff;
+      return a.queueName.localeCompare(b.queueName);
+    });
+    const jobsToConvert = allJobs.slice(start, start + limit);
+    const runInfos = await Promise.all(
+      jobsToConvert.map(async ({ job, queueName }) => {
+        let state = "waiting";
+        if (job.finishedOn) {
+          state = job.failedReason ? "failed" : "completed";
+        } else if (job.processedOn) {
+          state = "active";
+        } else if (job.delay && job.delay > 0) {
+          state = "delayed";
+        }
+        const info = await this.jobToInfo(job, "list", state);
+        return { ...info, queueName };
+      })
+    );
+    const hasMore = allJobs.length > start + limit;
+    return {
+      data: runInfos,
+      total: -1,
+      // Don't calculate total for fast path - not needed for UI
+      hasMore,
+      cursor: hasMore ? String(start + runInfos.length) : void 0
     };
-    if (queues.length === 0) {
-      throw new Error(
-        "Workbench requires at least one queue. Pass queues directly, use queueGroups, or provide a redis connection for auto-discovery."
-      );
-    }
-    this.queueManager = new QueueManager(queues, this.options.tags || [], [
-      ...queueGroups
-    ]);
-  }
-  /**
-   * Get the queue manager instance
-   */
-  getQueueManager() {
-    return this.queueManager;
-  }
-  /**
-   * Check if authentication is required
-   */
-  requiresAuth() {
-    return !!(this.options.auth?.username && this.options.auth?.password);
-  }
-  /**
-   * Validate authentication credentials
-   */
-  validateAuth(username, password) {
-    if (!this.requiresAuth()) return true;
-    return username === this.options.auth?.username && password === this.options.auth?.password;
   }
   /**
-   * Get dashboard configuration for the UI
+   * Get all runs (jobs) across all queues with sorting and filtering
+   * Uses fast path for common case (no filters, timestamp desc)
    */
-  getConfig() {
-    return {
-      title: this.options.title,
-      logo: this.options.logo,
-      readonly: this.options.readonly,
-      queues: this.queueManager.getQueueNames(),
-      queueGroups: this.queueManager.getQueueGroups(),
-      tags: this.queueManager.getTagFields()
-    };
-  }
-};
-
-// src/server/hono-app.ts
-import { Hono as Hono2 } from "hono";
-import { basicAuth } from "hono/basic-auth";
-import { cors } from "hono/cors";
-
-// src/api/router.ts
-import { Hono } from "hono";
-
-// src/api/handlers.ts
-function parseSort(sort) {
-  if (!sort) return void 0;
-  const [field, dir] = sort.split(":");
-  if (!field) return void 0;
-  return {
-    field,
-    direction: dir === "asc" ? "asc" : "desc"
-  };
-}
-var readonlyError = {
-  status: 403,
-  body: { error: "Dashboard is in readonly mode" }
-};
-function buildRouteTable(core) {
-  const qm = core.queueManager;
-  const isReadonly = () => !!core.options.readonly;
-  return [
-    {
-      method: "post",
-      path: "/refresh",
-      handler: async () => {
-        qm.clearCache();
-        return { status: 200, body: { success: true } };
-      }
-    },
-    {
-      method: "get",
-      path: "/overview",
-      handler: async () => ({
-        status: 200,
-        body: await qm.getOverview()
-      })
-    },
-    {
-      method: "get",
-      path: "/counts",
-      handler: async () => ({
-        status: 200,
-        body: await qm.getQuickCounts()
-      })
-    },
-    {
-      method: "get",
-      path: "/runs",
-      handler: async ({ query }) => {
-        const limit = Number(query.limit) || 50;
-        const cursor = query.cursor;
-        const start = cursor ? Number(cursor) : 0;
-        const sort = parseSort(query.sort);
-        const status = query.status;
-        const q = query.q;
-        const from = query.from;
-        const to = query.to;
-        const tagsParam = query.tags;
-        let tags;
-        if (tagsParam) {
-          try {
-            tags = JSON.parse(tagsParam);
-          } catch {
-            const tagPairs = tagsParam.split(",");
-            tags = {};
-            for (const pair of tagPairs) {
-              const [key, value] = pair.split(":");
-              if (key && value) {
-                tags[key.trim()] = value.trim();
-              }
-            }
-          }
+  async getAllRuns(limit = 50, start = 0, sort, filters) {
+    const sortField = sort?.field ?? "timestamp";
+    const sortDir = sort?.direction === "asc" ? 1 : -1;
+    const hasFilters = !!(filters?.status || filters?.tags || filters?.text || filters?.timeRange);
+    const isTimestampSort = sortField === "timestamp";
+    if (!hasFilters && isTimestampSort && sortDir === -1) {
+      return this.getLatestRuns(limit, start);
+    }
+    const queueEntries = Array.from(this.queues.entries());
+    const types = filters?.status ? [filters.status] : ["waiting", "active", "completed", "failed", "delayed"];
+    const hasTimeRange = !!filters?.timeRange;
+    const numQueues = Math.max(queueEntries.length, 1);
+    if (queueEntries.length === 0) {
+      return {
+        data: [],
+        total: 0,
+        hasMore: false,
+        cursor: void 0
+      };
+    }
+    const baseFetchPerQueue = Math.max(
+      Math.ceil(limit * 2 / numQueues) + 3,
+      5
+    );
+    let allJobs = [];
+    const fetchFromQueue = async (queueName, queue, fetchCount) => {
+      if (hasTimeRange && filters?.timeRange) {
+        const timeRangeJobs = [];
+        if (types.includes("completed")) {
+          const completedJobs = await this.getJobsByTimeRange(
+            queue,
+            "completed",
+            filters.timeRange.start,
+            filters.timeRange.end,
+            fetchCount
+          );
+          timeRangeJobs.push(
+            ...completedJobs.map((job) => ({
+              job,
+              state: "completed"
+            }))
+          );
         }
-        let timeRange;
-        if (from && to) {
-          timeRange = {
-            start: Number(from),
-            end: Number(to)
-          };
+        if (types.includes("failed")) {
+          const failedJobs = await this.getJobsByTimeRange(
+            queue,
+            "failed",
+            filters.timeRange.start,
+            filters.timeRange.end,
+            fetchCount
+          );
+          timeRangeJobs.push(
+            ...failedJobs.map((job) => ({
+              job,
+              state: "failed"
+            }))
+          );
         }
-        let text;
-        if (q) {
-          if (!q.includes(":")) {
-            text = q;
-          } else {
-            const parts = q.split(" ");
-            const textParts = parts.filter((p) => !p.includes(":"));
-            if (textParts.length > 0) {
-              text = textParts.join(" ");
-            }
-          }
+        const otherTypes = types.filter(
+          (t) => t !== "completed" && t !== "failed"
+        );
+        if (otherTypes.length > 0) {
+          const otherJobArrays = await Promise.all(
+            otherTypes.map(async (type) => {
+              const jobs = await queue.getJobs(type, 0, fetchCount);
+              return jobs.map((job) => ({ job, state: type }));
+            })
+          );
+          timeRangeJobs.push(...otherJobArrays.flat());
         }
-        const filters = status || tags || text || timeRange ? {
-          status,
-          tags,
-          text,
-          timeRange
-        } : void 0;
-        return {
-          status: 200,
-          body: await qm.getAllRuns(limit, start, sort, filters)
-        };
-      }
-    },
-    {
-      method: "get",
-      path: "/schedulers",
-      handler: async ({ query }) => {
-        const repeatableSort = parseSort(query.repeatableSort);
-        const delayedSort = parseSort(query.delayedSort);
-        return {
-          status: 200,
-          body: await qm.getSchedulers(repeatableSort, delayedSort)
-        };
+        return timeRangeJobs.map(({ job, state }) => ({
+          job,
+          queueName,
+          state
+        }));
       }
-    },
-    {
-      method: "post",
-      path: "/test",
-      handler: async ({ body }) => {
-        if (isReadonly()) return readonlyError;
-        const req = body;
-        if (!req?.queueName || !req.jobName) {
-          return {
-            status: 400,
-            body: { error: "queueName and jobName are required" }
-          };
-        }
-        try {
-          const result = await qm.enqueueJob(req);
-          return { status: 200, body: result };
-        } catch (e) {
-          return { status: 400, body: { error: e.message } };
-        }
+      if (filters?.status) {
+        const jobs = await queue.getJobs(filters.status, 0, fetchCount);
+        return jobs.map((job) => ({
+          job,
+          queueName,
+          state: filters.status
+        }));
       }
-    },
-    {
-      method: "get",
-      path: "/queue-names",
-      handler: async () => ({
-        status: 200,
-        body: qm.getQueueNames()
-      })
-    },
-    {
-      method: "get",
-      path: "/queues",
-      handler: async () => ({
-        status: 200,
-        body: await qm.getQueues()
-      })
-    },
-    {
-      method: "get",
-      path: "/metrics",
-      handler: async () => ({
-        status: 200,
-        body: await qm.getMetrics()
+      const jobArrays = await Promise.all(
+        types.map(async (type) => {
+          const jobs = await queue.getJobs(type, 0, fetchCount);
+          return jobs.map((job) => ({ job, state: type }));
+        })
+      );
+      return jobArrays.flat().map(({ job, state }) => ({ job, queueName, state }));
+    };
+    const results = await Promise.all(
+      queueEntries.map(
+        ([queueName, queue]) => fetchFromQueue(queueName, queue, baseFetchPerQueue)
+      )
+    );
+    allJobs = results.flat();
+    if (filters) {
+      allJobs = allJobs.filter(
+        ({ job }) => this.jobMatchesAllFilters(job, filters)
+      );
+    }
+    if (isTimestampSort) {
+      allJobs.sort((a, b) => {
+        const aTime = a.job.timestamp || 0;
+        const bTime = b.job.timestamp || 0;
+        const timeDiff = sortDir === -1 ? bTime - aTime : aTime - bTime;
+        if (timeDiff !== 0) return timeDiff;
+        const queueDiff = a.queueName.localeCompare(b.queueName);
+        if (queueDiff !== 0) return queueDiff;
+        return (a.job.id || "").localeCompare(b.job.id || "");
+      });
+    }
+    const jobsToConvert = allJobs.slice(start, start + limit);
+    const runInfos = await Promise.all(
+      jobsToConvert.map(async ({ job, queueName, state }) => {
+        const info = await this.jobToInfo(job, "list", state);
+        return { ...info, queueName };
       })
-    },
-    {
-      method: "get",
-      path: "/activity",
-      handler: async () => ({
-        status: 200,
-        body: await qm.getActivityStats()
+    );
+    if (!isTimestampSort) {
+      runInfos.sort((a, b) => {
+        const aVal = this.getSortValueForList(a, sortField);
+        const bVal = this.getSortValueForList(b, sortField);
+        if (aVal < bVal) return -1 * sortDir;
+        if (aVal > bVal) return 1 * sortDir;
+        return 0;
+      });
+    }
+    const hasMore = allJobs.length > start + limit;
+    return {
+      data: runInfos,
+      total: -1,
+      // Don't calculate total - not needed for UI
+      hasMore,
+      cursor: hasMore ? String(start + runInfos.length) : void 0
+    };
+  }
+  /**
+   * Get all schedulers (repeatable and delayed jobs) with sorting
+   */
+  async getSchedulers(repeatableSort, delayedSort) {
+    const repeatable = [];
+    const delayed = [];
+    const queueEntries = Array.from(this.queues.entries());
+    const results = await Promise.all(
+      queueEntries.map(async ([queueName, queue]) => {
+        const [repeatableJobs, delayedJobs] = await Promise.all([
+          queue.getRepeatableJobs(),
+          queue.getJobs("delayed", 0, 50)
+        ]);
+        return { queueName, repeatableJobs, delayedJobs };
       })
-    },
-    {
-      method: "get",
-      path: "/queues/:name/jobs",
-      handler: async ({ params, query }) => {
-        const name = params.name;
-        const status = query.status;
-        const limit = Number(query.limit) || 50;
-        const cursor = query.cursor;
-        const start = cursor ? Number(cursor) : 0;
-        const sort = parseSort(query.sort);
-        return {
-          status: 200,
-          body: await qm.getJobs(name, status, limit, start, sort)
-        };
-      }
-    },
-    {
-      method: "get",
-      path: "/jobs/:queue/:id/logs",
-      handler: async ({ params, query }) => {
-        const start = query.start ? Number(query.start) : 0;
-        const end = query.end ? Number(query.end) : 999;
-        const asc = query.asc !== "false";
-        const logs = await qm.getJobLogs(
-          params.queue,
-          params.id,
-          start,
-          end,
-          asc
-        );
-        if (!logs) {
-          return { status: 404, body: { error: "Job not found" } };
-        }
-        return { status: 200, body: logs };
+    );
+    for (const { queueName, repeatableJobs, delayedJobs } of results) {
+      for (const job of repeatableJobs) {
+        repeatable.push({
+          key: job.key,
+          name: job.name || "unnamed",
+          queueName,
+          pattern: job.pattern ?? void 0,
+          every: job.every ? Number(job.every) : void 0,
+          next: job.next ?? void 0,
+          endDate: job.endDate ?? void 0,
+          tz: job.tz ?? void 0
+        });
       }
-    },
-    {
-      method: "get",
-      path: "/jobs/:queue/:id",
-      handler: async ({ params }) => {
-        const job = await qm.getJob(params.queue, params.id);
-        if (!job) {
-          return { status: 404, body: { error: "Job not found" } };
-        }
-        return { status: 200, body: job };
+      for (const job of delayedJobs) {
+        const delay = job.opts.delay || 0;
+        delayed.push({
+          id: job.id || "",
+          name: job.name,
+          queueName,
+          delay,
+          processAt: job.timestamp + delay,
+          data: job.data
+        });
       }
-    },
-    {
-      method: "post",
-      path: "/jobs/:queue/:id/retry",
-      handler: async ({ params }) => {
-        if (isReadonly()) return readonlyError;
-        const success = await qm.retryJob(params.queue, params.id);
-        if (!success) {
-          return { status: 400, body: { error: "Failed to retry job" } };
-        }
-        return { status: 200, body: { success: true } };
+    }
+    const repeatableField = repeatableSort?.field ?? "name";
+    const repeatableDir = repeatableSort?.direction === "desc" ? -1 : 1;
+    repeatable.sort((a, b) => {
+      const aVal = this.getSchedulerSortValue(a, repeatableField);
+      const bVal = this.getSchedulerSortValue(b, repeatableField);
+      if (aVal < bVal) return -1 * repeatableDir;
+      if (aVal > bVal) return 1 * repeatableDir;
+      return 0;
+    });
+    const delayedField = delayedSort?.field ?? "processAt";
+    const delayedDir = delayedSort?.direction === "desc" ? -1 : 1;
+    delayed.sort((a, b) => {
+      const aVal = this.getDelayedSortValue(a, delayedField);
+      const bVal = this.getDelayedSortValue(b, delayedField);
+      if (aVal < bVal) return -1 * delayedDir;
+      if (aVal > bVal) return 1 * delayedDir;
+      return 0;
+    });
+    return { repeatable, delayed };
+  }
+  /**
+   * Enqueue a new job (for testing)
+   */
+  async enqueueJob(request) {
+    const queue = this.queues.get(request.queueName);
+    if (!queue) {
+      throw new Error(`Queue "${request.queueName}" not found`);
+    }
+    const job = await queue.add(request.jobName, request.data, {
+      delay: request.opts?.delay,
+      priority: request.opts?.priority,
+      attempts: request.opts?.attempts
+    });
+    return { id: job.id || "" };
+  }
+  /**
+   * Extract tag values from job data based on configured tag fields
+   */
+  extractTags(data) {
+    if (!this.tagFields.length || !data || typeof data !== "object") {
+      return void 0;
+    }
+    const tags = {};
+    const dataObj = data;
+    for (const field of this.tagFields) {
+      const value = dataObj[field];
+      if (value !== void 0 && (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null)) {
+        tags[field] = value;
       }
-    },
-    {
-      method: "post",
-      path: "/jobs/:queue/:id/remove",
-      handler: async ({ params }) => {
-        if (isReadonly()) return readonlyError;
-        const success = await qm.removeJob(params.queue, params.id);
-        if (!success) {
-          return { status: 400, body: { error: "Failed to remove job" } };
+    }
+    return Object.keys(tags).length > 0 ? tags : void 0;
+  }
+  /**
+   * Get unique values for a specific tag field across all jobs
+   */
+  async getTagValues(field, limit = 50) {
+    const valueMap = /* @__PURE__ */ new Map();
+    const types = ["waiting", "active", "completed", "failed", "delayed"];
+    const queueEntries = Array.from(this.queues.entries());
+    const queueResults = await Promise.all(
+      queueEntries.map(async ([, queue]) => {
+        const jobArrays = await Promise.all(
+          types.map((type) => queue.getJobs(type, 0, 100))
+        );
+        return jobArrays.flat();
+      })
+    );
+    for (const jobs of queueResults) {
+      for (const job of jobs) {
+        if (job.data && typeof job.data === "object") {
+          const dataObj = job.data;
+          const value = dataObj[field];
+          if (value !== void 0 && value !== null) {
+            const strValue = String(value);
+            valueMap.set(strValue, (valueMap.get(strValue) || 0) + 1);
+          }
         }
-        return { status: 200, body: { success: true } };
       }
-    },
-    {
-      method: "post",
-      path: "/jobs/:queue/:id/promote",
-      handler: async ({ params }) => {
-        if (isReadonly()) return readonlyError;
-        const success = await qm.promoteJob(params.queue, params.id);
-        if (!success) {
-          return { status: 400, body: { error: "Failed to promote job" } };
-        }
-        return { status: 200, body: { success: true } };
+    }
+    const sorted = Array.from(valueMap.entries()).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([value, count]) => ({ value, count }));
+    return sorted;
+  }
+  /**
+   * Get sortable value from JobInfo/RunInfo
+   */
+  getSortValue(item, field) {
+    switch (field) {
+      case "timestamp":
+        return item.timestamp ?? 0;
+      case "name":
+        return item.name.toLowerCase();
+      case "status":
+        return item.status;
+      case "duration":
+        return item.duration ?? 0;
+      case "queueName":
+        return "queueName" in item ? item.queueName.toLowerCase() : "";
+      case "processedOn":
+        return item.processedOn ?? 0;
+      default:
+        return item.timestamp ?? 0;
+    }
+  }
+  /**
+   * Get sortable value from RunInfoList (lightweight version)
+   */
+  getSortValueForList(item, field) {
+    switch (field) {
+      case "timestamp":
+        return item.timestamp ?? 0;
+      case "name":
+        return item.name.toLowerCase();
+      case "status":
+        return item.status;
+      case "duration":
+        return item.duration ?? 0;
+      case "queueName":
+        return item.queueName.toLowerCase();
+      case "processedOn":
+        return item.processedOn ?? 0;
+      default:
+        return item.timestamp ?? 0;
+    }
+  }
+  /**
+   * Get sortable value from SchedulerInfo
+   */
+  getSchedulerSortValue(item, field) {
+    switch (field) {
+      case "name":
+        return item.name.toLowerCase();
+      case "queueName":
+        return item.queueName.toLowerCase();
+      case "pattern":
+        return item.pattern?.toLowerCase() ?? "";
+      case "next":
+        return item.next ?? 0;
+      case "tz":
+        return item.tz?.toLowerCase() ?? "";
+      default:
+        return item.name.toLowerCase();
+    }
+  }
+  /**
+   * Get sortable value from DelayedJobInfo
+   */
+  getDelayedSortValue(item, field) {
+    switch (field) {
+      case "name":
+        return item.name.toLowerCase();
+      case "queueName":
+        return item.queueName.toLowerCase();
+      case "processAt":
+        return item.processAt;
+      case "delay":
+        return item.delay;
+      default:
+        return item.processAt;
+    }
+  }
+  /**
+   * Convert a BullMQ Job to JobInfo or RunInfoList
+   * @param job - The BullMQ job to convert
+   * @param fields - "list" for lightweight list view, "full" for complete job details
+   * @param knownState - Optional: skip getState() call if state is already known from fetch
+   */
+  async jobToInfo(job, _fields = "full", knownState) {
+    let state = knownState;
+    if (!state) {
+      const cacheKey = `${job.queueName}:${job.id}`;
+      state = this.jobStateCache.get(cacheKey);
+      if (!state) {
+        state = await job.getState();
+        this.jobStateCache.set(cacheKey, state);
       }
-    },
-    {
-      method: "get",
-      path: "/search",
-      handler: async ({ query }) => {
-        const q = query.q || "";
-        const limit = Number(query.limit) || 20;
-        if (!q) return { status: 200, body: { results: [] } };
-        const results = await qm.search(q, limit);
-        return { status: 200, body: { results } };
+    }
+    const duration = job.finishedOn && job.processedOn ? job.finishedOn - job.processedOn : void 0;
+    let progress = 0;
+    if (typeof job.progress === "number") {
+      progress = job.progress;
+    } else if (typeof job.progress === "object" && job.progress !== null) {
+      progress = job.progress;
+    }
+    const tags = this.extractTags(job.data);
+    let parent;
+    if (job.parent?.id) {
+      parent = {
+        id: job.parent.id,
+        queueName: job.parent.queueKey?.split(":")[1] || job.parent.queueKey || ""
+      };
+    } else if (job.parentKey) {
+      const parts = job.parentKey.split(":");
+      if (parts.length >= 3) {
+        parent = {
+          id: parts[parts.length - 1] || "",
+          queueName: parts[parts.length - 2] || ""
+        };
       }
-    },
-    {
-      method: "get",
-      path: "/tags/:field/values",
-      handler: async ({ params, query }) => {
-        const field = params.field;
-        const limit = Number(query.limit) || 50;
-        const tagFields = qm.getTagFields();
-        if (tagFields.length > 0 && !tagFields.includes(field)) {
-          return {
-            status: 400,
-            body: {
-              error: `Field "${field}" is not a configured tag field`
-            }
-          };
+    }
+    return {
+      id: job.id || "",
+      name: job.name,
+      data: job.data,
+      opts: {
+        attempts: job.opts.attempts,
+        delay: job.opts.delay,
+        priority: job.opts.priority
+      },
+      progress,
+      attemptsMade: job.attemptsMade,
+      processedOn: job.processedOn,
+      finishedOn: job.finishedOn,
+      timestamp: job.timestamp,
+      failedReason: job.failedReason,
+      stacktrace: job.stacktrace ?? void 0,
+      returnvalue: job.returnvalue,
+      status: state,
+      duration,
+      tags,
+      parent
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Bulk Operations
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Retry multiple jobs across queues
+   * Processed in parallel for better performance
+   */
+  async bulkRetry(jobs) {
+    const results = await Promise.allSettled(
+      jobs.map(async ({ queueName, jobId }) => {
+        const queue = this.queues.get(queueName);
+        if (!queue) {
+          throw new Error("Queue not found");
         }
-        const values = await qm.getTagValues(field, limit);
-        return { status: 200, body: { field, values } };
-      }
-    },
-    {
-      method: "post",
-      path: "/queues/:name/clean",
-      handler: async ({ params, body }) => {
-        if (isReadonly()) return readonlyError;
-        const req = body;
-        if (!req) {
-          return { status: 400, body: { error: "Body required" } };
+        const job = await queue.getJob(jobId);
+        if (!job) {
+          throw new Error("Job not found");
         }
-        const count = await qm.cleanJobs(
-          params.name,
-          req.status,
-          req.grace || 0
-        );
-        return { status: 200, body: { removed: count } };
+        await job.retry();
+        this.invalidateJobCache(queueName, jobId);
+        return { success: true };
+      })
+    );
+    let success = 0;
+    let failed = 0;
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        success++;
+      } else {
+        failed++;
       }
-    },
-    {
-      method: "post",
-      path: "/bulk/retry",
-      handler: async ({ body }) => {
-        if (isReadonly()) return readonlyError;
-        const req = body;
-        if (!req?.jobs) {
-          return { status: 400, body: { error: "jobs is required" } };
+    }
+    return { success, failed };
+  }
+  /**
+   * Delete multiple jobs across queues
+   * Processed in parallel for better performance
+   */
+  async bulkDelete(jobs) {
+    const results = await Promise.allSettled(
+      jobs.map(async ({ queueName, jobId }) => {
+        const queue = this.queues.get(queueName);
+        if (!queue) {
+          throw new Error("Queue not found");
         }
-        return { status: 200, body: await qm.bulkRetry(req.jobs) };
-      }
-    },
-    {
-      method: "post",
-      path: "/bulk/delete",
-      handler: async ({ body }) => {
-        if (isReadonly()) return readonlyError;
-        const req = body;
-        if (!req?.jobs) {
-          return { status: 400, body: { error: "jobs is required" } };
+        const job = await queue.getJob(jobId);
+        if (!job) {
+          throw new Error("Job not found");
         }
-        return { status: 200, body: await qm.bulkDelete(req.jobs) };
+        await job.remove();
+        this.invalidateJobCache(queueName, jobId);
+        return { success: true };
+      })
+    );
+    let success = 0;
+    let failed = 0;
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        success++;
+      } else {
+        failed++;
       }
-    },
-    {
-      method: "post",
-      path: "/bulk/promote",
-      handler: async ({ body }) => {
-        if (isReadonly()) return readonlyError;
-        const req = body;
-        if (!req?.jobs) {
-          return { status: 400, body: { error: "jobs is required" } };
+    }
+    return { success, failed };
+  }
+  /**
+   * Promote multiple delayed jobs across queues (move to waiting)
+   * Processed in parallel for better performance
+   */
+  async bulkPromote(jobs) {
+    const results = await Promise.allSettled(
+      jobs.map(async ({ queueName, jobId }) => {
+        const queue = this.queues.get(queueName);
+        if (!queue) {
+          throw new Error("Queue not found");
         }
-        return { status: 200, body: await qm.bulkPromote(req.jobs) };
+        const job = await queue.getJob(jobId);
+        if (!job) {
+          throw new Error("Job not found");
+        }
+        await job.promote();
+        this.invalidateJobCache(queueName, jobId);
+        return { success: true };
+      })
+    );
+    let success = 0;
+    let failed = 0;
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        success++;
+      } else {
+        failed++;
       }
-    },
-    {
-      method: "post",
-      path: "/queues/:name/pause",
-      handler: async ({ params }) => {
-        if (isReadonly()) return readonlyError;
-        try {
-          await qm.pauseQueue(params.name);
-          return { status: 200, body: { success: true, paused: true } };
-        } catch (error) {
-          return {
-            status: 404,
-            body: {
-              error: error instanceof Error ? error.message : "Failed to pause queue"
+    }
+    return { success, failed };
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Flow Operations
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Get all flows (jobs that have children or are part of a flow) - cached
+   * Optimized to focus on waiting-children type first and early exit
+   */
+  async getFlows(limit = 50) {
+    if (!this.flowProducer) {
+      return [];
+    }
+    return this.cached(`flows:${limit}`, this.CACHE_TTL.flows, async () => {
+      const queueEntries = Array.from(this.queues.entries());
+      const queueChecks = await Promise.all(
+        queueEntries.map(async ([queueName, queue]) => {
+          const counts = await this.getCachedJobCounts(queue);
+          const hasRelevantJobs = (counts.waiting || 0) > 0 || (counts["waiting-children"] || 0) > 0 || (counts.active || 0) > 0;
+          return { queueName, queue, hasRelevantJobs };
+        })
+      );
+      const relevantQueues = queueChecks.filter((q) => q.hasRelevantJobs);
+      if (relevantQueues.length === 0) {
+        return [];
+      }
+      const queueResults = await Promise.all(
+        relevantQueues.map(async ({ queueName, queue }) => {
+          try {
+            const waitingChildrenJobs = await queue.getJobs(
+              ["waiting-children"],
+              0,
+              50
+            );
+            if (waitingChildrenJobs.length >= limit) {
+              return { queueName, jobs: waitingChildrenJobs };
             }
-          };
+            const otherTypes = [
+              "waiting",
+              "active",
+              "completed",
+              "failed",
+              "delayed"
+            ];
+            const otherJobArrays = await Promise.all(
+              otherTypes.map(async (type) => {
+                try {
+                  return await queue.getJobs(type, 0, 30);
+                } catch {
+                  return [];
+                }
+              })
+            );
+            const allJobs = [...waitingChildrenJobs, ...otherJobArrays.flat()];
+            return { queueName, jobs: allJobs };
+          } catch {
+            return { queueName, jobs: [] };
+          }
+        })
+      );
+      const seenJobIds = /* @__PURE__ */ new Set();
+      const potentialRoots = [];
+      for (const { queueName, jobs } of queueResults) {
+        if (potentialRoots.length >= limit * 2) {
+          break;
+        }
+        for (const job of jobs) {
+          if (!job?.id) continue;
+          const jobKey = `${queueName}:${job.id}`;
+          if (seenJobIds.has(jobKey)) continue;
+          seenJobIds.add(jobKey);
+          const hasParent = !!job.parent || !!job.parentKey;
+          if (!hasParent) {
+            potentialRoots.push({ queueName, job });
+            if (potentialRoots.length >= limit * 2) {
+              break;
+            }
+          }
         }
       }
-    },
-    {
-      method: "post",
-      path: "/queues/:name/resume",
-      handler: async ({ params }) => {
-        if (isReadonly()) return readonlyError;
-        try {
-          await qm.resumeQueue(params.name);
-          return { status: 200, body: { success: true, paused: false } };
-        } catch (error) {
-          return {
-            status: 404,
-            body: {
-              error: error instanceof Error ? error.message : "Failed to resume queue"
+      const batchSize = 20;
+      const flows = [];
+      for (let i = 0; i < potentialRoots.length && flows.length < limit; i += batchSize) {
+        const batch = potentialRoots.slice(i, i + batchSize);
+        const batchResults = await Promise.all(
+          batch.map(async ({ queueName, job }) => {
+            try {
+              const flowTree = await this.flowProducer.getFlow({
+                id: job.id,
+                queueName
+              });
+              if (flowTree?.children && flowTree.children.length > 0) {
+                const stats = this.countFlowStats(flowTree);
+                const state = await job.getState();
+                return {
+                  id: job.id,
+                  name: job.name,
+                  queueName,
+                  status: state,
+                  totalJobs: stats.total,
+                  completedJobs: stats.completed,
+                  failedJobs: stats.failed,
+                  timestamp: job.timestamp,
+                  duration: job.finishedOn && job.processedOn ? job.finishedOn - job.processedOn : void 0
+                };
+              }
+            } catch {
             }
-          };
+            return null;
+          })
+        );
+        for (const result of batchResults) {
+          if (result && flows.length < limit) {
+            flows.push(result);
+          }
         }
       }
-    },
-    {
-      method: "get",
-      path: "/flows",
-      handler: async ({ query }) => {
-        const limit = Number(query.limit) || 50;
-        const flows = await qm.getFlows(limit);
-        return { status: 200, body: { flows } };
+      return flows.sort((a, b) => b.timestamp - a.timestamp);
+    });
+  }
+  /**
+   * Get a single flow tree by root job ID
+   */
+  async getFlow(queueName, jobId) {
+    if (!this.flowProducer) {
+      return null;
+    }
+    try {
+      const flowTree = await this.flowProducer.getFlow({
+        id: jobId,
+        queueName
+      });
+      if (!flowTree) {
+        return null;
       }
-    },
-    {
-      method: "get",
-      path: "/flows/:queueName/:jobId",
-      handler: async ({ params }) => {
-        const flow = await qm.getFlow(params.queueName, params.jobId);
-        if (!flow) {
-          return { status: 404, body: { error: "Flow not found" } };
-        }
-        return { status: 200, body: flow };
+      return this.convertFlowTree(flowTree);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Create a new flow
+   */
+  async createFlow(request) {
+    if (!this.flowProducer) {
+      throw new Error("FlowProducer not initialized");
+    }
+    const flowJob = this.buildFlowJob(request);
+    const result = await this.flowProducer.add(flowJob);
+    return { id: result.job.id || "" };
+  }
+  /**
+   * Build a FlowJob from CreateFlowRequest or CreateFlowChildRequest
+   */
+  buildFlowJob(request) {
+    const result = {
+      name: request.name,
+      queueName: request.queueName,
+      data: request.data || {}
+    };
+    if (request.children && request.children.length > 0) {
+      result.children = request.children.map(
+        (child) => this.buildFlowJob(child)
+      );
+    }
+    return result;
+  }
+  /**
+   * Convert BullMQ flow tree to our FlowNode structure
+   */
+  async convertFlowTree(tree) {
+    const job = tree.job;
+    const state = await job.getState();
+    const duration = job.finishedOn && job.processedOn ? job.finishedOn - job.processedOn : void 0;
+    const jobInfo = {
+      id: job.id || "",
+      name: job.name,
+      data: job.data,
+      opts: {
+        attempts: job.opts?.attempts,
+        delay: job.opts?.delay,
+        priority: job.opts?.priority
+      },
+      progress: typeof job.progress === "number" ? job.progress : typeof job.progress === "object" ? job.progress : 0,
+      attemptsMade: job.attemptsMade || 0,
+      processedOn: job.processedOn,
+      finishedOn: job.finishedOn,
+      timestamp: job.timestamp,
+      failedReason: job.failedReason,
+      stacktrace: job.stacktrace ?? void 0,
+      returnvalue: job.returnvalue,
+      status: state,
+      duration,
+      tags: this.extractTags(job.data)
+    };
+    const children = [];
+    if (tree.children && tree.children.length > 0) {
+      for (const child of tree.children) {
+        children.push(await this.convertFlowTree(child));
       }
-    },
-    {
-      method: "post",
-      path: "/flows",
-      handler: async ({ body }) => {
-        if (isReadonly()) return readonlyError;
-        const req = body;
-        if (!req?.name || !req.queueName || !req.children?.length) {
-          return {
-            status: 400,
-            body: { error: "name, queueName, and children are required" }
-          };
-        }
-        try {
-          const result = await qm.createFlow(req);
-          return { status: 200, body: result };
-        } catch (e) {
-          return { status: 400, body: { error: e.message } };
-        }
+    }
+    return {
+      job: jobInfo,
+      queueName: job.queueName || tree.queueName || "",
+      children: children.length > 0 ? children : void 0
+    };
+  }
+  /**
+   * Count statistics for a flow tree
+   */
+  countFlowStats(tree) {
+    let total = 1;
+    let completed = 0;
+    let failed = 0;
+    const job = tree.job;
+    if (job.finishedOn && !job.failedReason) {
+      completed = 1;
+    } else if (job.failedReason) {
+      failed = 1;
+    }
+    if (tree.children) {
+      for (const child of tree.children) {
+        const childStats = this.countFlowStats(child);
+        total += childStats.total;
+        completed += childStats.completed;
+        failed += childStats.failed;
       }
     }
-  ];
-}
+    return { total, completed, failed };
+  }
+};
 
-// src/api/router.ts
-function createApiRoutes(core) {
-  const app = new Hono();
-  for (const route of buildRouteTable(core)) {
-    app[route.method](route.path, async (c) => {
-      let body;
-      const method = c.req.method;
-      if (method !== "GET" && method !== "HEAD") {
-        const contentType = c.req.header("content-type") ?? "";
-        if (contentType.includes("application/json")) {
-          try {
-            body = await c.req.json();
-          } catch {
-            body = void 0;
-          }
-        }
-      }
-      const input = {
-        params: c.req.param(),
-        query: c.req.query(),
-        body
-      };
-      const result = await route.handler(input);
-      return new Response(JSON.stringify(result.body), {
-        status: result.status,
-        headers: { "Content-Type": "application/json" }
-      });
-    });
+// ../core/src/core/workbench.ts
+var WorkbenchCore = class {
+  options;
+  queueManager;
+  constructor(options) {
+    const opts = Array.isArray(options) ? { queues: options } : options;
+    const queueGroups = [
+      ...opts.queueGroups || [],
+      ...opts.groups || []
+    ];
+    const queues = [
+      ...opts.queues || [],
+      ...queueGroups.flatMap((group) => group.queues)
+    ];
+    this.options = {
+      title: "Workbench",
+      readonly: false,
+      ...opts,
+      queues
+    };
+    if (queues.length === 0) {
+      throw new Error(
+        "Workbench requires at least one queue. Pass queues directly, use queueGroups, or provide a redis connection for auto-discovery."
+      );
+    }
+    this.queueManager = new QueueManager(queues, this.options.tags || [], [
+      ...queueGroups
+    ]);
   }
-  return app;
-}
+  /**
+   * Get the queue manager instance
+   */
+  getQueueManager() {
+    return this.queueManager;
+  }
+  /**
+   * Check if authentication is required
+   */
+  requiresAuth() {
+    return !!(this.options.auth?.username && this.options.auth?.password);
+  }
+  /**
+   * Validate authentication credentials
+   */
+  validateAuth(username, password) {
+    if (!this.requiresAuth()) return true;
+    return username === this.options.auth?.username && password === this.options.auth?.password;
+  }
+  /**
+   * Get dashboard configuration for the UI
+   */
+  getConfig() {
+    return {
+      title: this.options.title,
+      logo: this.options.logo,
+      readonly: this.options.readonly,
+      queues: this.queueManager.getQueueNames(),
+      queueGroups: this.queueManager.getQueueGroups(),
+      tags: this.queueManager.getTagFields()
+    };
+  }
+};
 
-// src/server/base-path.ts
+// ../core/src/server/base-path.ts
 var CLIENT_ROUTES = [
   /\/queues\/[^/]+\/jobs\/[^/]+\/?$/,
   /\/queues\/[^/]+\/?$/,
@@ -2263,16 +2223,47 @@ function resolveBasePath(override, pathname) {
   return computeBasePath(pathname);
 }
 
-// src/server/static-assets.ts
+// ../core/src/server/basic-auth.ts
+function checkBasicAuth(authHeader, username, password) {
+  if (!authHeader) return false;
+  const [scheme, encoded] = authHeader.split(" ");
+  if (!scheme || scheme.toLowerCase() !== "basic" || !encoded) return false;
+  let decoded;
+  try {
+    decoded = Buffer.from(encoded, "base64").toString("utf-8");
+  } catch {
+    return false;
+  }
+  const idx = decoded.indexOf(":");
+  if (idx === -1) return false;
+  const user = decoded.slice(0, idx);
+  const pass = decoded.slice(idx + 1);
+  return safeEqual(user, username) && safeEqual(pass, password);
+}
+function safeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return diff === 0;
+}
+var BASIC_AUTH_CHALLENGE = {
+  status: 401,
+  headers: { "WWW-Authenticate": 'Basic realm="Workbench"' },
+  body: "Unauthorized"
+};
+
+// ../core/src/server/static-assets.ts
 import { existsSync, readFileSync } from "fs";
 import { join as join2 } from "path";
 
-// src/ui-dist.ts
+// ../core/src/ui-dist.ts
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 var UI_DIST_PATH = join(dirname(fileURLToPath(import.meta.url)), "ui");
 
-// src/server/static-assets.ts
+// ../core/src/server/static-assets.ts
 function serveStaticAsset(filename) {
   const filePath = join2(UI_DIST_PATH, "assets", filename);
   if (!existsSync(filePath)) {
@@ -2364,127 +2355,23 @@ function fallbackHtml(title, basePath) {
   <body>
     <div class="message">
       <h1>${title}</h1>
-      <p>UI assets not found. Build @maydotinc/q-studio/core first:</p>
+      <p>UI assets not found. Build @maydotinc/q-studio first:</p>
       <code>pnpm --filter @maydotinc/q-studio-core build</code>
     </div>
   </body>
 </html>`;
 }
 
-// src/server/hono-app.ts
-function buildWorkbenchApp(core) {
-  const app = new Hono2();
-  app.use("/api/*", cors());
-  if (core.requiresAuth()) {
-    app.use(
-      "*",
-      basicAuth({
-        username: core.options.auth.username,
-        password: core.options.auth.password
-      })
-    );
-  }
-  app.route("/api", createApiRoutes(core));
-  app.get("/config", (c) => c.json(core.getConfig()));
-  app.get("/assets/:file", (c) => {
-    const fileName = c.req.param("file");
-    const asset = serveStaticAsset(fileName);
-    if (asset.status === 404 || !asset.body) {
-      return c.text("Not found", 404);
-    }
-    return new Response(new Uint8Array(asset.body), {
-      status: 200,
-      headers: { "Content-Type": asset.contentType }
-    });
-  });
-  app.get("*", (c) => {
-    const url = new URL(c.req.url);
-    const basePath = resolveBasePath(core.options.basePath, url.pathname);
-    const html = renderIndexHtml(basePath, core.options.title || "Workbench");
-    return c.html(html.body);
-  });
-  return app;
-}
-
-// src/api/fetch-handler.ts
-function createFetchHandler(options) {
-  const core = new WorkbenchCore(options);
-  const app = buildWorkbenchApp(core);
-  const basePath = normalizeBasePath(core.options.basePath);
-  const fetchHandler = async (req) => {
-    if (basePath) {
-      const url = new URL(req.url);
-      if (url.pathname === basePath || url.pathname.startsWith(`${basePath}/`)) {
-        const rewritten = url.pathname.slice(basePath.length) || "/";
-        url.pathname = rewritten;
-        const init = {
-          method: req.method,
-          headers: req.headers,
-          body: req.method === "GET" || req.method === "HEAD" ? void 0 : req.body,
-          // @ts-expect-error duplex is required for streaming bodies in Node 18+
-          duplex: "half",
-          redirect: req.redirect
-        };
-        return app.fetch(new Request(url.toString(), init));
-      }
-    }
-    return app.fetch(req);
-  };
-  return {
-    fetch: fetchHandler,
-    core
-  };
-}
-function normalizeBasePath(value) {
-  if (!value) return null;
-  const trimmed = value.endsWith("/") ? value.slice(0, -1) : value;
-  if (trimmed === "" || trimmed === "/") return null;
-  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-}
-
-// src/server/basic-auth.ts
-function checkBasicAuth(authHeader, username, password) {
-  if (!authHeader) return false;
-  const [scheme, encoded] = authHeader.split(" ");
-  if (!scheme || scheme.toLowerCase() !== "basic" || !encoded) return false;
-  let decoded;
-  try {
-    decoded = Buffer.from(encoded, "base64").toString("utf-8");
-  } catch {
-    return false;
-  }
-  const idx = decoded.indexOf(":");
-  if (idx === -1) return false;
-  const user = decoded.slice(0, idx);
-  const pass = decoded.slice(idx + 1);
-  return safeEqual(user, username) && safeEqual(pass, password);
-}
-function safeEqual(a, b) {
-  if (a.length !== b.length) return false;
-  let diff = 0;
-  for (let i = 0; i < a.length; i++) {
-    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
-  }
-  return diff === 0;
-}
-var BASIC_AUTH_CHALLENGE = {
-  status: 401,
-  headers: { "WWW-Authenticate": 'Basic realm="Workbench"' },
-  body: "Unauthorized"
-};
 export {
-  BASIC_AUTH_CHALLENGE,
+  buildRouteTable,
   QueueManager,
-  UI_DIST_PATH,
   WorkbenchCore,
-  buildRouteTable,
-  buildWorkbenchApp,
-  checkBasicAuth,
   computeBasePath,
-  createApiRoutes,
-  createFetchHandler,
-  renderIndexHtml,
   resolveBasePath,
-  serveStaticAsset
+  checkBasicAuth,
+  BASIC_AUTH_CHALLENGE,
+  UI_DIST_PATH,
+  serveStaticAsset,
+  renderIndexHtml
 };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=chunk-L36RXNVW.js.map