@maydotinc/q-studio 0.1.0 → 0.8.0

package/dist/core/index.js

@@ -1,2490 +0,0 @@
-// 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 });
-      }
-    }
-  }
-  /**
-   * 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 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;
-      }
-      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");
-  }
-  /**
-   * Get BullMQ log lines for a job.
-   */
-  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
-    };
-  }
-  /**
-   * 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;
-    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
-    ]);
-  }
-  /**
-   * 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/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();
-              }
-            }
-          }
-        }
-        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)
-        };
-      }
-    },
-    {
-      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)
-        };
-      }
-    },
-    {
-      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 } };
-        }
-      }
-    },
-    {
-      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 };
-      }
-    },
-    {
-      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 {
-            status: 400,
-            body: {
-              error: `Field "${field}" is not a configured tag field`
-            }
-          };
-        }
-        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 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 {
-            status: 404,
-            body: {
-              error: error instanceof Error ? error.message : "Failed to pause 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 {
-            status: 404,
-            body: {
-              error: error instanceof Error ? error.message : "Failed to resume queue"
-            }
-          };
-        }
-      }
-    },
-    {
-      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 } };
-        }
-      }
-    }
-  ];
-}
-
-// 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" }
-      });
-    });
-  }
-  return app;
-}
-
-// src/server/base-path.ts
-var CLIENT_ROUTES = [
-  /\/queues\/[^/]+\/jobs\/[^/]+\/?$/,
-  /\/queues\/[^/]+\/?$/,
-  /\/queues\/?$/,
-  /\/flows\/[^/]+\/[^/]+\/?$/,
-  /\/schedulers\/?$/,
-  /\/flows\/?$/,
-  /\/metrics\/?$/,
-  /\/test\/?$/
-];
-function computeBasePath(pathname) {
-  let basePath = pathname;
-  for (const route of CLIENT_ROUTES) {
-    basePath = basePath.replace(route, "");
-  }
-  if (!basePath.endsWith("/")) {
-    basePath = `${basePath}/`;
-  }
-  return basePath;
-}
-function resolveBasePath(override, pathname) {
-  if (override) {
-    return override.endsWith("/") ? override : `${override}/`;
-  }
-  return computeBasePath(pathname);
-}
-
-// src/server/static-assets.ts
-import { existsSync, readFileSync } from "fs";
-import { join as join2 } from "path";
-
-// 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
-function serveStaticAsset(filename) {
-  const filePath = join2(UI_DIST_PATH, "assets", filename);
-  if (!existsSync(filePath)) {
-    return { status: 404, body: null, contentType: "text/plain" };
-  }
-  const body = readFileSync(filePath);
-  const contentType = filename.endsWith(".js") ? "application/javascript" : filename.endsWith(".css") ? "text/css" : filename.endsWith(".svg") ? "image/svg+xml" : filename.endsWith(".png") ? "image/png" : filename.endsWith(".ico") ? "image/x-icon" : filename.endsWith(".woff2") ? "font/woff2" : "application/octet-stream";
-  return { status: 200, body, contentType };
-}
-function renderIndexHtml(basePath, title) {
-  const devServerUrl = process.env.WORKBENCH_UI_DEV_SERVER;
-  if (devServerUrl) {
-    return {
-      body: devServerHtml(title, basePath, devServerUrl),
-      contentType: "text/html; charset=utf-8"
-    };
-  }
-  const indexPath = join2(UI_DIST_PATH, "index.html");
-  if (existsSync(indexPath)) {
-    let html = readFileSync(indexPath, "utf-8");
-    html = html.replace("<head>", `<head>
-    <base href="${basePath}">`);
-    return { body: html, contentType: "text/html; charset=utf-8" };
-  }
-  return {
-    body: fallbackHtml(title, basePath),
-    contentType: "text/html; charset=utf-8"
-  };
-}
-function devServerHtml(title, basePath, devServerUrl) {
-  const origin = devServerUrl.replace(/\/$/, "");
-  const devBasePath = basePath.endsWith("/") ? basePath : `${basePath}/`;
-  return `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <base href="${basePath}">
-    <meta charset="UTF-8" />
-    <link rel="icon" href="assets/favicon.ico" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>${title}</title>
-    <script type="module">
-      import RefreshRuntime from "${origin}${devBasePath}@react-refresh";
-      RefreshRuntime.injectIntoGlobalHook(window);
-      window.$RefreshReg$ = () => {};
-      window.$RefreshSig$ = () => (type) => type;
-      window.__vite_plugin_react_preamble_installed__ = true;
-    </script>
-    <script type="module" src="${origin}${devBasePath}@vite/client"></script>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="${origin}${devBasePath}main.tsx"></script>
-  </body>
-</html>`;
-}
-function fallbackHtml(title, basePath) {
-  return `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <base href="${basePath}">
-    <meta charset="UTF-8" />
-    <link rel="icon" href="assets/favicon.ico" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>${title}</title>
-    <style>
-      body {
-        font-family: system-ui, sans-serif;
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        min-height: 100vh;
-        margin: 0;
-        background: #0a0a0a;
-        color: #fafafa;
-      }
-      .message {
-        text-align: center;
-        padding: 2rem;
-      }
-      code {
-        background: #1a1a1a;
-        padding: 0.5rem 1rem;
-        border-radius: 0.5rem;
-        display: block;
-        margin-top: 1rem;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="message">
-      <h1>${title}</h1>
-      <p>UI assets not found. Build @maydotinc/q-studio/core 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,
-  QueueManager,
-  UI_DIST_PATH,
-  WorkbenchCore,
-  buildRouteTable,
-  buildWorkbenchApp,
-  checkBasicAuth,
-  computeBasePath,
-  createApiRoutes,
-  createFetchHandler,
-  renderIndexHtml,
-  resolveBasePath,
-  serveStaticAsset
-};
-//# sourceMappingURL=index.js.map