@getworkbench/core 0.1.0

package/dist/index.js

@@ -0,0 +1,2047 @@
+// src/index.ts
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+// src/api/router.ts
+import { Hono } from "hono";
+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"
+  };
+}
+function createApiRoutes(core) {
+  const app = new Hono();
+  const qm = core.queueManager;
+  app.post("/refresh", async (c) => {
+    qm.clearCache();
+    return c.json({ success: true });
+  });
+  app.get("/overview", async (c) => {
+    const stats = await qm.getOverview();
+    return c.json(stats);
+  });
+  app.get("/counts", async (c) => {
+    const counts = await qm.getQuickCounts();
+    return c.json(counts);
+  });
+  app.get("/runs", async (c) => {
+    const limit = Number(c.req.query("limit")) || 50;
+    const cursor = c.req.query("cursor");
+    const start = cursor ? Number(cursor) : 0;
+    const sort = parseSort(c.req.query("sort"));
+    const status = c.req.query("status");
+    const q = c.req.query("q");
+    const from = c.req.query("from");
+    const to = c.req.query("to");
+    const tagsParam = c.req.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;
+    const result = await qm.getAllRuns(limit, start, sort, filters);
+    return c.json(result);
+  });
+  app.get("/schedulers", async (c) => {
+    const repeatableSort = parseSort(c.req.query("repeatableSort"));
+    const delayedSort = parseSort(c.req.query("delayedSort"));
+    const result = await qm.getSchedulers(repeatableSort, delayedSort);
+    return c.json(result);
+  });
+  app.post("/test", async (c) => {
+    if (core.options.readonly) {
+      return c.json({ error: "Dashboard is in readonly mode" }, 403);
+    }
+    const body = await c.req.json();
+    if (!body.queueName || !body.jobName) {
+      return c.json({ error: "queueName and jobName are required" }, 400);
+    }
+    try {
+      const result = await qm.enqueueJob(body);
+      return c.json(result);
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+  });
+  app.get("/queue-names", (c) => {
+    const names = qm.getQueueNames();
+    return c.json(names);
+  });
+  app.get("/queues", async (c) => {
+    const queues = await qm.getQueues();
+    return c.json(queues);
+  });
+  app.get("/metrics", async (c) => {
+    const metrics = await qm.getMetrics();
+    return c.json(metrics);
+  });
+  app.get("/activity", async (c) => {
+    const stats = await qm.getActivityStats();
+    return c.json(stats);
+  });
+  app.get("/queues/:name/jobs", async (c) => {
+    const { name } = c.req.param();
+    const status = c.req.query("status");
+    const limit = Number(c.req.query("limit")) || 50;
+    const cursor = c.req.query("cursor");
+    const start = cursor ? Number(cursor) : 0;
+    const sort = parseSort(c.req.query("sort"));
+    const result = await qm.getJobs(name, status, limit, start, sort);
+    return c.json(result);
+  });
+  app.get("/jobs/:queue/:id", async (c) => {
+    const { queue, id } = c.req.param();
+    const job = await qm.getJob(queue, id);
+    if (!job) {
+      return c.json({ error: "Job not found" }, 404);
+    }
+    return c.json(job);
+  });
+  app.post("/jobs/:queue/:id/retry", async (c) => {
+    if (core.options.readonly) {
+      return c.json({ error: "Dashboard is in readonly mode" }, 403);
+    }
+    const { queue, id } = c.req.param();
+    const success = await qm.retryJob(queue, id);
+    if (!success) {
+      return c.json({ error: "Failed to retry job" }, 400);
+    }
+    return c.json({ success: true });
+  });
+  app.post("/jobs/:queue/:id/remove", async (c) => {
+    if (core.options.readonly) {
+      return c.json({ error: "Dashboard is in readonly mode" }, 403);
+    }
+    const { queue, id } = c.req.param();
+    const success = await qm.removeJob(queue, id);
+    if (!success) {
+      return c.json({ error: "Failed to remove job" }, 400);
+    }
+    return c.json({ success: true });
+  });
+  app.post("/jobs/:queue/:id/promote", async (c) => {
+    if (core.options.readonly) {
+      return c.json({ error: "Dashboard is in readonly mode" }, 403);
+    }
+    const { queue, id } = c.req.param();
+    const success = await qm.promoteJob(queue, id);
+    if (!success) {
+      return c.json({ error: "Failed to promote job" }, 400);
+    }
+    return c.json({ success: true });
+  });
+  app.get("/search", async (c) => {
+    const query = c.req.query("q") || "";
+    const limit = Number(c.req.query("limit")) || 20;
+    if (!query) {
+      return c.json({ results: [] });
+    }
+    const results = await qm.search(query, limit);
+    return c.json({ results });
+  });
+  app.get("/tags/:field/values", async (c) => {
+    const { field } = c.req.param();
+    const limit = Number(c.req.query("limit")) || 50;
+    const tagFields = qm.getTagFields();
+    if (tagFields.length > 0 && !tagFields.includes(field)) {
+      return c.json(
+        { error: `Field "${field}" is not a configured tag field` },
+        400
+      );
+    }
+    const values = await qm.getTagValues(field, limit);
+    return c.json({ field, values });
+  });
+  app.post("/queues/:name/clean", async (c) => {
+    if (core.options.readonly) {
+      return c.json({ error: "Dashboard is in readonly mode" }, 403);
+    }
+    const { name } = c.req.param();
+    const body = await c.req.json();
+    const count = await qm.cleanJobs(name, body.status, body.grace || 0);
+    return c.json({ removed: count });
+  });
+  app.post("/bulk/retry", async (c) => {
+    if (core.options.readonly) {
+      return c.json({ error: "Dashboard is in readonly mode" }, 403);
+    }
+    const body = await c.req.json();
+    const result = await qm.bulkRetry(body.jobs);
+    return c.json(result);
+  });
+  app.post("/bulk/delete", async (c) => {
+    if (core.options.readonly) {
+      return c.json({ error: "Dashboard is in readonly mode" }, 403);
+    }
+    const body = await c.req.json();
+    const result = await qm.bulkDelete(body.jobs);
+    return c.json(result);
+  });
+  app.post("/bulk/promote", async (c) => {
+    if (core.options.readonly) {
+      return c.json({ error: "Dashboard is in readonly mode" }, 403);
+    }
+    const body = await c.req.json();
+    const result = await qm.bulkPromote(body.jobs);
+    return c.json(result);
+  });
+  app.post("/queues/:name/pause", async (c) => {
+    if (core.options.readonly) {
+      return c.json({ error: "Dashboard is in readonly mode" }, 403);
+    }
+    const { name } = c.req.param();
+    try {
+      await qm.pauseQueue(name);
+      return c.json({ success: true, paused: true });
+    } catch (error) {
+      return c.json(
+        {
+          error: error instanceof Error ? error.message : "Failed to pause queue"
+        },
+        404
+      );
+    }
+  });
+  app.post("/queues/:name/resume", async (c) => {
+    if (core.options.readonly) {
+      return c.json({ error: "Dashboard is in readonly mode" }, 403);
+    }
+    const { name } = c.req.param();
+    try {
+      await qm.resumeQueue(name);
+      return c.json({ success: true, paused: false });
+    } catch (error) {
+      return c.json(
+        {
+          error: error instanceof Error ? error.message : "Failed to resume queue"
+        },
+        404
+      );
+    }
+  });
+  app.get("/flows", async (c) => {
+    const limit = Number(c.req.query("limit")) || 50;
+    const flows = await qm.getFlows(limit);
+    return c.json({ flows });
+  });
+  app.get("/flows/:queueName/:jobId", async (c) => {
+    const { queueName, jobId } = c.req.param();
+    const flow = await qm.getFlow(queueName, jobId);
+    if (!flow) {
+      return c.json({ error: "Flow not found" }, 404);
+    }
+    return c.json(flow);
+  });
+  app.post("/flows", async (c) => {
+    if (core.options.readonly) {
+      return c.json({ error: "Dashboard is in readonly mode" }, 403);
+    }
+    const body = await c.req.json();
+    if (!body.name || !body.queueName || !body.children?.length) {
+      return c.json(
+        { error: "name, queueName, and children are required" },
+        400
+      );
+    }
+    try {
+      const result = await qm.createFlow(body);
+      return c.json(result);
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+  });
+  return app;
+}
+
+// src/core/queue-manager.ts
+import { FlowProducer } from "bullmq";
+import { LRUCache } from "lru-cache";
+var QueueManager = class {
+  queues = /* @__PURE__ */ new Map();
+  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 = []) {
+    for (const queue of queues) {
+      this.queues.set(queue.name, queue);
+    }
+    this.tagFields = tagFields;
+    const firstQueue = queues[0];
+    if (firstQueue) {
+      const connection = firstQueue.opts?.connection;
+      if (connection) {
+        this.flowProducer = new FlowProducer({ connection });
+      }
+    }
+  }
+  /**
+   * 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
+        );
+      }
+      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
+      );
+    }
+  }
+  /**
+   * 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);
+        }
+      }
+    } 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 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,
+            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;
+      }
+      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);
+          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"
+      );
+    });
+  }
+  /**
+   * 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);
+          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 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;
+    }
+    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
+   */
+  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");
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Remove a job
+   */
+  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 a delayed job to waiting
+   */
+  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);
+        }
+        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));
+      }
+    }
+    return {
+      filters,
+      text: textParts.filter(Boolean).join(" ")
+    };
+  }
+  /**
+   * Check if a raw job matches all provided filters (before conversion)
+   * This is more efficient than converting to JobInfo first
+   */
+  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;
+        }
+      }
+    }
+    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 true;
+  }
+  /**
+   * Check if a job matches the given tag filters
+   */
+  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;
+  }
+  /**
+   * 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 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);
+      }
+    }
+    return allMatches.slice(0, limit);
+  }
+  /**
+   * Clean jobs from a queue
+   */
+  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;
+  }
+  /**
+   * 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
+   */
+  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
+    };
+  }
+  /**
+   * Get all runs (jobs) across all queues with sorting and filtering
+   * Uses fast path for common case (no filters, timestamp desc)
+   */
+  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"
+            }))
+          );
+        }
+        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"
+            }))
+          );
+        }
+        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());
+        }
+        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)
+      );
+    }
+    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
+   */
+  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;
+      }
+    }
+    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 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);
+      }
+    }
+    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] || ""
+        };
+      }
+    }
+    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 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 };
+  }
+  /**
+   * 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");
+        }
+        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 };
+  }
+  /**
+   * 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");
+        }
+        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++;
+      }
+    }
+    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;
+            }
+          }
+        }
+      }
+      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);
+          }
+        }
+      }
+      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;
+      }
+      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));
+      }
+    }
+    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/core/workbench.ts
+var WorkbenchCore = class {
+  options;
+  queueManager;
+  constructor(options) {
+    const opts = Array.isArray(options) ? { queues: options } : options;
+    this.options = {
+      title: "Workbench",
+      readonly: false,
+      ...opts
+    };
+    if (!this.options.queues || this.options.queues.length === 0) {
+      throw new Error(
+        "Workbench requires at least one queue. Pass queues directly or provide a redis connection for auto-discovery."
+      );
+    }
+    this.queueManager = new QueueManager(
+      this.options.queues,
+      this.options.tags || []
+    );
+  }
+  /**
+   * 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(),
+      tags: this.queueManager.getTagFields()
+    };
+  }
+};
+
+// src/index.ts
+var UI_DIST_PATH = join(dirname(fileURLToPath(import.meta.url)), "ui");
+export {
+  QueueManager,
+  UI_DIST_PATH,
+  WorkbenchCore,
+  createApiRoutes
+};
+//# sourceMappingURL=index.js.map