bullpane 0.5.2 → 0.6.0

package/dist/server.mjs

@@ -4,9 +4,16 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// packages/redis-inspector/src/inspector.ts
-import { Cluster as Cluster2 } from "ioredis";
-import { Job, Queue, UnrecoverableError } from "bullmq";
+// packages/pg-inspector/src/inspector.ts
+import {
+  assertSchemaCompatibility,
+  createPostgresBackend,
+  Job,
+  Queue,
+  SchemaMigrationRequiredError,
+  UnrecoverableError
+} from "bullmq";
+import pg from "pg";
 
 // packages/shared/src/index.ts
 import { z } from "zod";
@@ -142,21 +149,53 @@ var ssoSettingsSchema = z.object({
   autoProvisionDomains: z.array(ssoDomainSchema).max(50).optional()
 });
 var SSO_AUTO_PROVISION_ROLE = "viewer";
-var createConnectionSchema = z.object({
+var CONNECTION_KINDS = ["redis", "postgres"];
+var DEFAULT_NAMESPACE = {
+  redis: "bull",
+  postgres: "bullmq"
+};
+var URL_SCHEMES = {
+  redis: { test: /^rediss?:\/\//, message: "Must start with redis:// or rediss://" },
+  postgres: { test: /^postgres(ql)?:\/\//, message: "Must start with postgres:// or postgresql://" }
+};
+var PG_SCHEMA_RE = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/;
+function connectionIssues(v) {
+  const issues = [];
+  const kind = v.kind ?? "redis";
+  if (v.url !== void 0 && !URL_SCHEMES[kind].test.test(v.url)) {
+    issues.push({ path: "url", message: URL_SCHEMES[kind].message });
+  }
+  if (kind === "postgres") {
+    if (v.prefix !== void 0 && !PG_SCHEMA_RE.test(v.prefix)) {
+      issues.push({ path: "prefix", message: "A Postgres schema: letters, digits and _, not starting with a digit" });
+    }
+    if (v.cluster === true) issues.push({ path: "cluster", message: "Cluster mode is Redis only" });
+  }
+  return issues;
+}
+var connectionFields = z.object({
   name: z.string().min(1).max(80),
-  url: z.string().min(1).refine((u) => /^rediss?:\/\//.test(u), "Must start with redis:// or rediss://"),
-  prefix: z.string().min(1).max(64).default("bull"),
+  kind: z.enum(CONNECTION_KINDS).default("redis"),
+  url: z.string().min(1),
+  /** omitted → DEFAULT_NAMESPACE of the kind */
+  prefix: z.string().min(1).max(64).optional(),
   cluster: z.boolean().default(false),
   queueFilter: z.string().max(200).nullable().optional()
 });
-var updateConnectionSchema = createConnectionSchema.partial();
+var createConnectionSchema = connectionFields.superRefine((v, ctx) => {
+  for (const issue of connectionIssues(v)) ctx.addIssue({ code: z.ZodIssueCode.custom, path: [issue.path], message: issue.message });
+}).transform((v) => ({ ...v, prefix: v.prefix ?? DEFAULT_NAMESPACE[v.kind] }));
+var updateConnectionSchema = connectionFields.omit({ kind: true }).partial();
 var reorderSchema = z.object({
   ids: z.array(z.string().min(1)).min(1)
 });
 var testConnectionSchema = z.object({
+  kind: z.enum(CONNECTION_KINDS).default("redis"),
   url: z.string().min(1),
   prefix: z.string().optional(),
   cluster: z.boolean().optional()
+}).superRefine((v, ctx) => {
+  for (const issue of connectionIssues(v)) ctx.addIssue({ code: z.ZodIssueCode.custom, path: [issue.path], message: issue.message });
 });
 var JOB_STATES = [
   "waiting",
@@ -427,34 +466,1317 @@ var EMPTY_COUNTS = {
   paused: 0,
   "waiting-children": 0
 };
-var ROLE_RANK = { admin: 3, operator: 2, viewer: 1 };
-function hasRole(userRole, required) {
-  return ROLE_RANK[userRole] >= ROLE_RANK[required];
-}
-function redactRedisUrl(url) {
-  try {
-    const u = new URL(url);
-    if (u.password) u.password = "****";
-    return u.toString();
-  } catch {
-    return url.replace(/:\/\/([^:@/]*):([^@/]*)@/, "://$1:****@");
+var ROLE_RANK = { admin: 3, operator: 2, viewer: 1 };
+function hasRole(userRole, required) {
+  return ROLE_RANK[userRole] >= ROLE_RANK[required];
+}
+function redactRedisUrl(url) {
+  try {
+    const u = new URL(url);
+    if (u.password) u.password = "****";
+    return u.toString();
+  } catch {
+    return url.replace(/:\/\/([^:@/]*):([^@/]*)@/, "://$1:****@");
+  }
+}
+var MCP_ACCESS_LEVELS = ["off", "read", "write"];
+var MCP_ACCESS_RANK = { off: 0, read: 1, write: 2 };
+function mcpRoleCeiling(role) {
+  return hasRole(role, "operator") ? "write" : "read";
+}
+function mcpEffectiveAccess(ceiling, granted, role) {
+  const levels = [ceiling, granted, mcpRoleCeiling(role)];
+  return levels.reduce((min, l) => MCP_ACCESS_RANK[l] < MCP_ACCESS_RANK[min] ? l : min);
+}
+var updateMcpSettingsSchema = z.object({ maxAccess: z.enum(MCP_ACCESS_LEVELS) });
+var mcpConsentDecisionSchema = z.object({
+  request: z.string().min(1).max(4096),
+  approve: z.boolean(),
+  access: z.enum(["read", "write"]).default("read")
+});
+
+// packages/inspector/src/glob.ts
+function globToRegExp(glob) {
+  const escaped = glob.split("").map((ch) => {
+    if (ch === "*") return ".*";
+    if (ch === "?") return ".";
+    return ch.replace(/[.+^${}()|[\]\\/]/g, "\\$&");
+  }).join("");
+  return new RegExp(`^${escaped}$`);
+}
+
+// packages/pg-inspector/src/rows.ts
+function num(v, fallback = 0) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : fallback;
+  if (typeof v === "string" && v !== "") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : fallback;
+  }
+  return fallback;
+}
+function numOrNull(v) {
+  if (v === null || v === void 0 || v === "") return null;
+  const n = num(v, Number.NaN);
+  return Number.isNaN(n) ? null : n;
+}
+function queueKeyOf(schema, queue) {
+  return `${schema}:${queue}`;
+}
+function jobKeyOf(schema, queue, id3) {
+  return `${schema}:${queue}:${id3}`;
+}
+function parentRef(schema, parentQueue, parentId) {
+  if (typeof parentQueue !== "string" || parentQueue === "" || parentId === null || parentId === void 0) return null;
+  return { id: String(parentId), queueKey: queueKeyOf(schema, parentQueue), queue: parentQueue };
+}
+function bullpaneState(physical, priority) {
+  switch (physical) {
+    case "waiting":
+      return num(priority) > 0 ? "prioritized" : "waiting";
+    case "active":
+    case "completed":
+    case "failed":
+    case "delayed":
+    case "waiting-children":
+      return physical;
+    default:
+      return "unknown";
+  }
+}
+function progressOf(v) {
+  if (v === null || v === void 0) return 0;
+  if (typeof v === "number" || typeof v === "string") return v;
+  if (typeof v === "object" && !Array.isArray(v)) return v;
+  return JSON.stringify(v);
+}
+function attemptsOf(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : null;
+}
+function rowToSummary(schema, row, previewBytes) {
+  const state = bullpaneState(row.state, row.priority);
+  const read = row.data_preview !== null && row.data_preview !== void 0;
+  const bytes = read ? num(row.data_bytes) : num(row.data_stored);
+  return {
+    id: String(row.id),
+    name: row.name ?? "",
+    timestamp: num(row.added_at_ms),
+    processedOn: numOrNull(row.processed_at_ms),
+    finishedOn: numOrNull(row.finished_at_ms),
+    attemptsMade: num(row.attempts_made),
+    attempts: attemptsOf(row.opt_attempts),
+    failedReason: row.failed_reason ?? null,
+    progress: progressOf(row.progress),
+    delay: num(row.delay_ms),
+    // Postgres stores the due time itself (process_at_ms): no score decoding.
+    delayedUntil: state === "delayed" ? numOrNull(row.process_at_ms) : null,
+    priority: num(row.priority),
+    dataPreview: read ? row.data_preview : "",
+    // Above the list cap the payload was not read at all; `dataBytes` is then the
+    // stored (possibly compressed) size, which is what pg_column_size can tell
+    // without detoasting it.
+    dataTruncated: !read || bytes > previewBytes,
+    dataBytes: bytes,
+    parent: parentRef(schema, row.parent_queue, row.parent_id),
+    groupId: row.group_id ?? null,
+    repeatJobKey: row.scheduler_id ?? null,
+    stalledCounter: num(row.stalled_count),
+    state
+  };
+}
+function rowToDetail(schema, row) {
+  const state = bullpaneState(row.state, row.priority);
+  const opts = row.opts && typeof row.opts === "object" ? row.opts : {};
+  const group = opts.group;
+  const processed = num(row.processed);
+  const unprocessed = num(row.unprocessed);
+  return {
+    id: String(row.id),
+    name: row.name ?? "",
+    timestamp: num(row.added_at_ms),
+    processedOn: numOrNull(row.processed_at_ms),
+    finishedOn: numOrNull(row.finished_at_ms),
+    attemptsMade: num(row.attempts_made),
+    attempts: attemptsOf(opts.attempts),
+    failedReason: row.failed_reason ?? null,
+    progress: progressOf(row.progress),
+    delay: num(row.delay_ms),
+    delayedUntil: state === "delayed" ? numOrNull(row.process_at_ms) : null,
+    priority: num(row.priority),
+    dataBytes: numOrNull(row.data_bytes),
+    parent: parentRef(schema, row.parent_queue, row.parent_id),
+    groupId: group && (typeof group.id === "string" || typeof group.id === "number") ? String(group.id) : null,
+    repeatJobKey: row.scheduler_id ?? null,
+    stalledCounter: num(row.stalled_count),
+    state,
+    data: row.data ?? null,
+    opts,
+    returnvalue: row.return_value ?? null,
+    stacktrace: stacktraceOf(row.stacktrace),
+    logs: row.logs ?? [],
+    logsCount: num(row.logs_count),
+    dependencies: processed + unprocessed > 0 ? { processed, unprocessed } : null
+  };
+}
+function stacktraceOf(v) {
+  if (v === null || v === void 0) return [];
+  if (Array.isArray(v)) return v.map((s) => typeof s === "string" ? s : JSON.stringify(s));
+  return [typeof v === "string" ? v : JSON.stringify(v)];
+}
+function rowToScheduler(row) {
+  const key = String(row.scheduler_id);
+  const name = row.name ?? key;
+  return {
+    key,
+    name,
+    next: numOrNull(row.next_run_ms),
+    pattern: row.pattern ?? null,
+    every: numOrNull(row.every_ms),
+    tz: row.tz ?? null,
+    offset: numOrNull(row.offset_ms),
+    limit: numOrNull(row.limit_count),
+    iterationCount: numOrNull(row.iteration_count),
+    startDate: numOrNull(row.start_date_ms),
+    endDate: numOrNull(row.end_date_ms),
+    template: row.template_data !== null || row.template_opts !== null ? { name, data: row.template_data ?? null, opts: row.template_opts ?? null } : null
+  };
+}
+function prunesCompleted(v) {
+  if (v === void 0 || v === null || v === false) return false;
+  if (v === true || typeof v === "number") return true;
+  if (typeof v === "object") {
+    const o = v;
+    return typeof o.count === "number" || typeof o.age === "number";
+  }
+  return false;
+}
+function metricPoints(newestFirst) {
+  if (!Array.isArray(newestFirst)) return [];
+  return newestFirst.map((v) => num(v)).reverse();
+}
+
+// packages/pg-inspector/src/metrics.ts
+function side(row, nowMin) {
+  if (!row) {
+    return { has: false, read: (w) => ({ total: 0, covered: w }) };
+  }
+  const count2 = num(row.count);
+  const prevTs = numOrNull(row.prevTs);
+  if (prevTs === null) return { has: true, read: (w) => ({ total: count2, covered: w }) };
+  const m0 = Math.floor(prevTs / 6e4);
+  const ref = Math.max(nowMin, m0);
+  const pending = count2 - num(row.prevCount);
+  const points = (row.data ?? []).map((v) => num(v));
+  return {
+    has: true,
+    read: (w) => {
+      const startMin = ref - w + 1;
+      if (m0 < startMin) return { total: 0, covered: w };
+      const n = Math.min(m0 - startMin, points.length);
+      let total = pending;
+      for (let i = 0; i < n; i += 1) total += points[i] ?? 0;
+      return { total, covered: Math.min(ref - m0 + 1 + n, w) };
+    }
+  };
+}
+function percentile(sorted, q) {
+  const idx = Math.max(1, Math.ceil(q / 100 * sorted.length));
+  return sorted[idx - 1] ?? -1;
+}
+function windowMetricsFrom(request, rows, durations, now) {
+  const nowMin = Math.floor(now / 6e4);
+  const completed = side(rows?.find((r) => r.kind === "completed"), nowMin);
+  const failed = side(rows?.find((r) => r.kind === "failed"), nowMin);
+  const sampled = (durations ?? []).map(([f, d]) => [num(f), num(d)]);
+  return {
+    hasMetrics: completed.has || failed.has,
+    rates: request.rateWindows.map((windowMinutes) => {
+      const c = completed.read(windowMinutes);
+      const f = failed.read(windowMinutes);
+      return { windowMinutes, completed: c.total, failed: f.total, coveredMinutes: Math.min(c.covered, f.covered) };
+    }),
+    durations: request.durationWindows.map((windowMinutes) => {
+      const since = now - windowMinutes * 6e4;
+      const ds = sampled.filter(([f]) => f >= since).map(([, d]) => d).sort((a, b) => a - b);
+      return {
+        windowMinutes,
+        sampled: ds.length,
+        p50Ms: ds.length > 0 ? percentile(ds, 50) : null,
+        p95Ms: ds.length > 0 ? percentile(ds, 95) : null
+      };
+    }),
+    collectedAt: now
+  };
+}
+function ratesFrom(input) {
+  const pct = (c, f) => c + f === 0 ? null : Math.round(c / (c + f) * 1e3) / 10;
+  if (input.completed || input.failed) {
+    const nowMin = Math.floor(input.now / 6e4);
+    const c = side(input.completed ?? void 0, nowMin).read(input.windowMinutes);
+    const f = side(input.failed ?? void 0, nowMin).read(input.windowMinutes);
+    return {
+      windowMinutes: Math.min(c.covered, f.covered),
+      completed: c.total,
+      failed: f.total,
+      successPct: pct(c.total, f.total),
+      source: "metrics",
+      retentionSkewed: false
+    };
+  }
+  return {
+    windowMinutes: input.windowMinutes,
+    completed: input.storedCompleted,
+    failed: input.storedFailed,
+    successPct: pct(input.storedCompleted, input.storedFailed),
+    // QueueRates calls this source "zset" (the Redis name); here it is a COUNT of stored rows.
+    source: "zset",
+    retentionSkewed: input.prunesCompleted && input.storedFailed > 0
+  };
+}
+
+// packages/pg-inspector/src/sql.ts
+var STATE_SQL = {
+  waiting: { where: "state = 'waiting' AND priority = 0", order: ["seq"] },
+  // job_ready_idx
+  prioritized: { where: "state = 'waiting' AND priority > 0", order: ["priority", "seq"] },
+  // job_ready_idx
+  active: { where: "state = 'active'", order: ["seq"] },
+  // small by nature (bounded by worker concurrency)
+  completed: { where: "state = 'completed'", order: ["finished_at_ms"] },
+  // job_finished_idx
+  failed: { where: "state = 'failed'", order: ["finished_at_ms"] },
+  // job_finished_idx
+  delayed: { where: "state = 'delayed'", order: ["process_at_ms"] },
+  // job_delayed_idx
+  "waiting-children": { where: "state = 'waiting-children'", order: ["seq"] },
+  // job_waiting_children_idx
+  paused: null
+};
+function orderBy(state, order) {
+  const s = STATE_SQL[state];
+  if (!s) throw new Error(`no physical state for ${state}`);
+  const dir = order === "asc" ? "ASC" : "DESC";
+  return s.order.map((c) => `${c} ${dir}`).join(", ");
+}
+function summaryColumns(alias, previewParam, capParam) {
+  const j = alias;
+  return `${j}.id, ${j}.name, ${j}.state::text AS state, ${j}.priority, ${j}.delay_ms, ${j}.attempts_made,
+    ${j}.added_at_ms, ${j}.processed_at_ms, ${j}.finished_at_ms, ${j}.process_at_ms, ${j}.failed_reason,
+    ${j}.progress, ${j}.opts->'attempts' AS opt_attempts, ${j}.opts #>> '{group,id}' AS group_id,
+    ${j}.scheduler_id, ${j}.stalled_count, ${j}.parent_queue, ${j}.parent_id,
+    pg_column_size(${j}.data) AS data_stored,
+    CASE WHEN pg_column_size(${j}.data) <= $${capParam} THEN left(${j}.data::text, $${previewParam}) END AS data_preview,
+    CASE WHEN pg_column_size(${j}.data) <= $${capParam} THEN octet_length(${j}.data::text) END AS data_bytes`;
+}
+var count = (state, where) => `CASE WHEN '${state}' = ANY(string_to_array(q.skip, ',')) THEN NULL ELSE (SELECT count(*) FROM job WHERE queue = q.queue AND ${where}) END`;
+var QUEUE_STATS = `
+SELECT q.queue,
+  ${count("waiting", "state = 'waiting' AND priority = 0")} AS waiting,
+  ${count("prioritized", "state = 'waiting' AND priority > 0")} AS prioritized,
+  ${count("active", "state = 'active'")} AS active,
+  ${count("completed", "state = 'completed'")} AS completed,
+  ${count("failed", "state = 'failed'")} AS failed,
+  ${count("delayed", "state = 'delayed'")} AS delayed,
+  ${count("waiting-children", "state = 'waiting-children'")} AS waiting_children,
+  -- An active job whose lock expired: the worker stopped renewing it. This is
+  -- what Redis' stalled SET means, read straight off job_active_idx.
+  (SELECT count(*) FROM job WHERE queue = q.queue AND state = 'active' AND locked_until_ms < $2) AS stalled,
+  EXISTS (SELECT 1 FROM meta WHERE queue = q.queue AND field = 'paused') AS paused,
+  (SELECT value FROM meta WHERE queue = q.queue AND field = 'version') AS version,
+  (SELECT count(*) FROM scheduler WHERE queue = q.queue) AS schedulers,
+  -- the whole metrics row per side: count, prev_ts and prev_count carry the
+  -- current minute, which is not in data until the minute rolls over
+  (SELECT json_build_object('kind', kind, 'count', count, 'prevTs', prev_ts, 'prevCount', prev_count, 'data', data[1:$3])
+     FROM metrics WHERE queue = q.queue AND kind = 'completed') AS m_completed,
+  (SELECT json_build_object('kind', kind, 'count', count, 'prevTs', prev_ts, 'prevCount', prev_count, 'data', data[1:$3])
+     FROM metrics WHERE queue = q.queue AND kind = 'failed') AS m_failed,
+  (SELECT data[1:$3] FROM metrics WHERE queue = q.queue AND kind = 'completed') AS m_completed_data,
+  (SELECT data[1:$3] FROM metrics WHERE queue = q.queue AND kind = 'failed') AS m_failed_data,
+  -- Only read when the queue has no metrics (the rate then falls back to stored
+  -- rows); a busy queue with metrics would otherwise count an hour of jobs per read.
+  CASE WHEN EXISTS (SELECT 1 FROM metrics WHERE queue = q.queue) THEN NULL
+       ELSE (SELECT count(*) FROM job WHERE queue = q.queue AND state = 'completed' AND finished_at_ms >= $4) END AS w_completed,
+  CASE WHEN EXISTS (SELECT 1 FROM metrics WHERE queue = q.queue) THEN NULL
+       ELSE (SELECT count(*) FROM job WHERE queue = q.queue AND state = 'failed' AND finished_at_ms >= $4) END AS w_failed,
+  -- removeOnComplete lives in each job's opts; one job tells whether the queue prunes.
+  (SELECT opts->'removeOnComplete' FROM job WHERE queue = q.queue AND state = 'completed'
+     ORDER BY finished_at_ms DESC LIMIT 1) AS remove_on_complete
+FROM unnest($1::text[], $5::text[]) AS q(queue, skip)`;
+var DISCOVER_QUEUES = `
+WITH RECURSIVE jq AS (
+  (SELECT queue FROM job ORDER BY queue LIMIT 1)
+  UNION ALL
+  SELECT (SELECT j.queue FROM job j WHERE j.queue > jq.queue ORDER BY j.queue LIMIT 1)
+  FROM jq WHERE jq.queue IS NOT NULL
+)
+SELECT queue FROM jq WHERE queue IS NOT NULL
+UNION
+SELECT DISTINCT queue FROM meta
+ORDER BY queue`;
+var PING = `SELECT current_setting('server_version') AS version`;
+var SERVER_INFO = `
+SELECT current_setting('server_version') AS version,
+  extract(epoch FROM now() - pg_postmaster_start_time())::bigint AS uptime,
+  (SELECT count(*) FROM pg_stat_activity WHERE datname = current_database()) AS clients,
+  current_setting('max_connections')::int AS max_connections,
+  pg_database_size(current_database()) AS db_bytes,
+  COALESCE(pg_total_relation_size(to_regclass('job')), 0) AS job_bytes,
+  COALESCE(pg_total_relation_size(to_regclass('event')), 0) AS event_bytes,
+  d.xact_commit + d.xact_rollback AS transactions,
+  d.blks_hit, d.blks_read, d.deadlocks
+FROM pg_stat_database d
+WHERE d.datname = current_database()`;
+var WINDOW_COUNTS = `
+SELECT
+  (SELECT count(*) FROM job WHERE queue = $1 AND state = 'completed' AND finished_at_ms >= $2) AS completed,
+  (SELECT count(*) FROM job WHERE queue = $1 AND state = 'failed' AND finished_at_ms >= $2) AS failed`;
+var METRICS_COUNTERS = `SELECT kind, count FROM metrics WHERE queue = $1`;
+var METRICS = `SELECT kind, data[1:$2] AS data FROM metrics WHERE queue = $1`;
+var WINDOW_METRICS = `
+SELECT q.queue,
+  (SELECT json_agg(json_build_object('kind', m.kind, 'count', m.count, 'prevTs', m.prev_ts,
+            'prevCount', m.prev_count, 'data', m.data[1:$3]))
+     FROM metrics m WHERE m.queue = q.queue) AS metrics,
+  (SELECT json_agg(json_build_array(s.finished_at_ms, s.finished_at_ms - s.processed_at_ms))
+     FROM (SELECT finished_at_ms, processed_at_ms FROM job
+            WHERE queue = q.queue AND state = 'completed' AND finished_at_ms >= q.since
+            ORDER BY finished_at_ms DESC LIMIT $4) s
+    WHERE s.processed_at_ms IS NOT NULL AND s.finished_at_ms >= s.processed_at_ms) AS durations
+FROM unnest($1::text[], $2::bigint[]) AS q(queue, since)`;
+var JOB_DETAIL = `
+SELECT j.id, j.name, j.state::text AS state, j.priority, j.delay_ms, j.attempts_made,
+  j.added_at_ms, j.processed_at_ms, j.finished_at_ms, j.process_at_ms, j.failed_reason,
+  j.progress, j.data, j.opts, j.return_value, j.stacktrace, j.scheduler_id, j.stalled_count,
+  j.parent_queue, j.parent_id, octet_length(j.data::text) AS data_bytes,
+  (SELECT array_agg(t.row ORDER BY t.idx)
+     FROM (SELECT idx, row FROM job_log WHERE queue = $1 AND job_id = $2 ORDER BY idx DESC LIMIT $3) t) AS logs,
+  (SELECT count(*) FROM job_log WHERE queue = $1 AND job_id = $2) AS logs_count,
+  (SELECT count(*) FILTER (WHERE status = 'pending') FROM job_dependency
+     WHERE parent_queue = $1 AND parent_id = $2) AS unprocessed,
+  (SELECT count(*) FILTER (WHERE status <> 'pending') FROM job_dependency
+     WHERE parent_queue = $1 AND parent_id = $2) AS processed,
+  EXISTS (SELECT 1 FROM meta WHERE queue = $1 AND field = 'paused') AS queue_paused
+FROM job j
+WHERE j.queue = $1 AND j.id = $2`;
+var JOB_LOGS = `
+SELECT
+  ARRAY(SELECT row FROM job_log WHERE queue = $1 AND job_id = $2 ORDER BY idx OFFSET $3 LIMIT $4) AS logs,
+  (SELECT count(*) FROM job_log WHERE queue = $1 AND job_id = $2) AS count`;
+var QUEUE_SETUP = `
+SELECT
+  (SELECT json_object_agg(field, value) FROM meta WHERE queue = $1) AS meta,
+  (SELECT expire_at_ms FROM rate_limit WHERE queue = $1) AS limiter_expire_at,
+  EXISTS (SELECT 1 FROM metrics WHERE queue = $1 AND kind = 'completed') AS metrics_enabled`;
+var WORKERS = `
+SELECT application_name FROM pg_stat_activity
+WHERE datname = current_database() AND (application_name = $1 OR application_name LIKE $2)`;
+var SCHEDULERS = `
+SELECT
+  (SELECT count(*) FROM scheduler WHERE queue = $1) AS total,
+  (SELECT json_agg(row_to_json(s)) FROM (
+     SELECT scheduler_id, name, next_run_ms, pattern, every_ms, tz, offset_ms, limit_count,
+            iteration_count, start_date_ms, end_date_ms,
+            left(template_data::text, $4) AS template_data, left(template_opts::text, $4) AS template_opts
+       FROM scheduler WHERE queue = $1
+      ORDER BY next_run_ms ASC NULLS LAST, scheduler_id
+     OFFSET $2 LIMIT $3) s) AS rows`;
+var SAMPLE_PARENTS = `
+WITH sampled AS (
+  (SELECT parent_queue FROM job WHERE queue = $1 AND state = 'completed' ORDER BY finished_at_ms DESC LIMIT $2)
+  UNION ALL
+  (SELECT parent_queue FROM job WHERE queue = $1 AND state = 'failed' ORDER BY finished_at_ms DESC LIMIT $2)
+  UNION ALL
+  (SELECT parent_queue FROM job WHERE queue = $1 AND state = 'waiting-children' ORDER BY seq DESC LIMIT $2)
+  UNION ALL
+  (SELECT parent_queue FROM job WHERE queue = $1 AND state = 'waiting' AND priority = 0 ORDER BY seq DESC LIMIT $2)
+  UNION ALL
+  (SELECT parent_queue FROM job WHERE queue = $1 AND state = 'active' ORDER BY seq DESC LIMIT $2)
+  UNION ALL
+  (SELECT parent_queue FROM job WHERE queue = $1 AND state = 'delayed' ORDER BY process_at_ms DESC LIMIT $2)
+)
+SELECT
+  (SELECT count(*) FROM sampled) AS sampled,
+  (SELECT json_agg(json_build_array(parent_queue, n)) FROM (
+     SELECT parent_queue, count(*) AS n FROM sampled WHERE parent_queue IS NOT NULL GROUP BY parent_queue
+  ) g) AS edges`;
+var TREE_NODES = `
+SELECT r.ord, j.id IS NOT NULL AS found, j.name, j.state::text AS state, j.priority, j.added_at_ms,
+  j.finished_at_ms, j.attempts_made, j.failed_reason, j.progress, j.parent_queue, j.parent_id,
+  (SELECT count(*) FILTER (WHERE status = 'pending') FROM job_dependency
+     WHERE parent_queue = r.queue AND parent_id = r.id) AS unprocessed,
+  (SELECT count(*) FILTER (WHERE status <> 'pending') FROM job_dependency
+     WHERE parent_queue = r.queue AND parent_id = r.id) AS processed,
+  (SELECT json_agg(json_build_array(c.child_queue, c.child_id)) FROM (
+     SELECT child_queue, child_id FROM job_dependency
+      WHERE parent_queue = r.queue AND parent_id = r.id
+      ORDER BY child_key LIMIT $3 + 1) c) AS children
+FROM unnest($1::text[], $2::text[]) WITH ORDINALITY AS r(queue, id, ord)
+LEFT JOIN job j ON j.queue = r.queue AND j.id = r.id
+ORDER BY r.ord`;
+
+// packages/pg-inspector/src/connection.ts
+var LIBPQ_ALIASED_MODES = /* @__PURE__ */ new Set(["prefer", "require", "verify-ca"]);
+function nodePgConnectionString(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return url;
+  }
+  const mode = parsed.searchParams.get("sslmode");
+  if (!mode || !LIBPQ_ALIASED_MODES.has(mode) || parsed.searchParams.has("uselibpqcompat")) return url;
+  parsed.searchParams.set("uselibpqcompat", "true");
+  return parsed.toString();
+}
+
+// packages/pg-inspector/src/inspector.ts
+var DEFAULTS = {
+  discoveryTtlMs: 3e4,
+  previewBytes: 2048,
+  maxScanPerCall: 1e3,
+  connectTimeoutMs: 5e3,
+  listFieldCapBytes: 32 * 1024,
+  searchFieldCapBytes: 256 * 1024,
+  searchByteBudget: 8 * 1024 * 1024
+};
+var READ_POOL_MAX = 4;
+var STATEMENT_TIMEOUT_MS = 1e4;
+var SESSION_SETTINGS = [
+  ["statement_timeout", STATEMENT_TIMEOUT_MS],
+  ["max_parallel_workers_per_gather", 0]
+];
+var APPLICATION_NAME = "bullpane-dashboard";
+var STATS_METRIC_POINTS = 60;
+var DEFAULT_RATE_WINDOW_MINUTES = 60;
+var SETUP_CACHE_MS = 1e4;
+var STATS_CACHE_MS = 2e3;
+var LARGE_COUNT = 1e5;
+var LARGE_COUNT_MAX_TTL_MS = 6e4;
+var DETAIL_LOG_TAIL = 100;
+var BULK_CONCURRENCY = 8;
+var FORCE_DISCOVERY_MIN_MS = 5e3;
+var MAX_TREE_CLIMB = 50;
+function quoteIdent(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+function likeSubstring(query) {
+  return `%${query.replace(/[\\%_]/g, (c) => `\\${c}`)}%`;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var PgInspector = class {
+  config;
+  opts;
+  pool;
+  /**
+   * How reads carry their settings (schema, statement timeout, no parallel query):
+   *  - "session": as startup options on each connection. One round trip per
+   *    read. Used on a direct connection.
+   *  - "transaction": behind a transaction pooler (PgBouncer, Supavisor, RDS
+   *    Proxy...), which refuses or silently drops startup options and hands each
+   *    transaction a different server connection. Each read is then its own
+   *    READ ONLY transaction with SET LOCAL, so nothing depends on session state.
+   * Decided once in ensureReady, by trying the first and checking it took effect.
+   */
+  mode = "session";
+  filter;
+  ready = null;
+  discovered = null;
+  discovering = null;
+  setupCache = /* @__PURE__ */ new Map();
+  /** per queue + rate window; see STATS_CACHE_MS */
+  statsCache = /* @__PURE__ */ new Map();
+  /** per queue + state, filled by stats reads and by job pages; see STATS_CACHE_MS */
+  countCache = /* @__PURE__ */ new Map();
+  /** bullmq Queue per queue name, created lazily for writes only. */
+  queues = /* @__PURE__ */ new Map();
+  closed = false;
+  constructor(config, options = {}) {
+    if (config.kind !== "postgres") throw new Error("PgInspector only opens postgres connections");
+    this.config = { ...config, kind: "postgres", prefix: config.prefix ?? "bullmq", cluster: false };
+    this.opts = { ...DEFAULTS };
+    for (const [k, v] of Object.entries(options)) {
+      if (v !== void 0 && k in DEFAULTS) this.opts[k] = v;
+    }
+    this.filter = config.queueFilter ? globToRegExp(config.queueFilter) : null;
+    this.pool = this.createPool(true);
+  }
+  /**
+   * The read pool. The settings every read runs with:
+   *  - search_path = the BullMQ schema, so its unqualified table names resolve;
+   *  - statement_timeout, so no read can hold the database for long;
+   *  - no parallel query: a count over a big state would otherwise run as a
+   *    parallel index scan on 3 cores at once, and the smoke test measured
+   *    what that does to the workers sharing the database (throughput down to
+   *    a third under a read storm). A dashboard gets one core per query, ever.
+   * `withOptions: false` is the pooler fallback: no startup options at all.
+   */
+  createPool(withOptions) {
+    const pool = new pg.Pool({
+      connectionString: nodePgConnectionString(this.config.url),
+      max: READ_POOL_MAX,
+      idleTimeoutMillis: 3e4,
+      connectionTimeoutMillis: this.opts.connectTimeoutMs,
+      application_name: APPLICATION_NAME,
+      ...withOptions ? { options: `-c search_path=${quoteIdent(this.config.prefix)} -c ${SESSION_SETTINGS.map(([k, v]) => `${k}=${v}`).join(" -c ")}` } : {}
+    });
+    pool.on("error", () => void 0);
+    return pool;
+  }
+  // ---------------------------------------------------------------------------
+  // connection
+  // ---------------------------------------------------------------------------
+  /**
+   * Once per inspector: the schema exists and was migrated by a BullMQ this
+   * version can read (BullMQ's own assertSchemaCompatibility, read only — the
+   * dashboard never runs migrations on a customer database). Retried on the
+   * next call after a failure.
+   */
+  async ensureReady() {
+    if (this.closed) throw new Error("inspector_closed");
+    if (!this.ready) {
+      this.ready = (async () => {
+        await this.pickMode();
+        const client = await this.pool.connect();
+        try {
+          await assertSchemaCompatibility(client, this.config.prefix);
+        } catch (err) {
+          if (err instanceof SchemaMigrationRequiredError) {
+            throw new Error(
+              `postgres_schema_missing: no BullMQ schema "${this.config.prefix}" in this database. Check the schema name, or start a BullMQ worker with \`migrate: true\` once.`
+            );
+          }
+          throw err;
+        } finally {
+          client.release();
+        }
+      })().catch((err) => {
+        this.ready = null;
+        throw err;
+      });
+    }
+    return this.ready;
+  }
+  /**
+   * Session mode if the server takes the startup options AND they took effect;
+   * transaction mode otherwise. A pooler can refuse them ("unsupported startup
+   * parameter", PgBouncer ≥ 1.20 accepts search_path only) or drop them silently
+   * (`ignore_startup_parameters`), so success alone proves nothing: the
+   * settings are read back.
+   */
+  async pickMode() {
+    if (this.mode === "transaction") return;
+    try {
+      const { rows } = await this.pool.query(
+        "SELECT current_setting('statement_timeout') AS timeout, current_setting('max_parallel_workers_per_gather') AS parallel"
+      );
+      const applied = rows[0]?.parallel === "0" && rows[0]?.timeout !== "0";
+      if (!applied) this.mode = "transaction";
+    } catch (err) {
+      if (!/unsupported startup parameter/i.test(errorMessage(err))) throw err;
+      const old = this.pool;
+      this.pool = this.createPool(false);
+      void old.end().catch(() => void 0);
+      this.mode = "transaction";
+    }
+  }
+  async query(text3, values = []) {
+    await this.ensureReady();
+    if (this.mode === "session") return (await this.pool.query(text3, values)).rows;
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN READ ONLY");
+      await client.query(
+        `SELECT set_config('search_path', $1, true), ${SESSION_SETTINGS.map(([k], i) => `set_config('${k}', $${i + 2}, true)`).join(", ")}`,
+        [quoteIdent(this.config.prefix), ...SESSION_SETTINGS.map(([, v]) => String(v))]
+      );
+      const res = await client.query(text3, values);
+      await client.query("COMMIT");
+      return res.rows;
+    } catch (err) {
+      await client.query("ROLLBACK").catch(() => void 0);
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  /** "session" or "transaction" (behind a pooler); see `mode`. For diagnostics and tests. */
+  async connectionMode() {
+    await this.ensureReady();
+    return this.mode;
+  }
+  async ping() {
+    const t0 = performance.now();
+    try {
+      const [row] = await this.query(PING);
+      return { ok: true, latencyMs: Math.round((performance.now() - t0) * 10) / 10, redisVersion: row?.version ?? null, error: null };
+    } catch (err) {
+      return { ok: false, latencyMs: Math.round((performance.now() - t0) * 10) / 10, redisVersion: null, error: errorMessage(err) };
+    }
+  }
+  async serverInfo() {
+    const startedAt = Date.now();
+    const [r] = await this.query(SERVER_INFO);
+    const latencyMs = Date.now() - startedAt;
+    const hit = numOrNull(r?.blks_hit);
+    const read = numOrNull(r?.blks_read);
+    const lookups = (hit ?? 0) + (read ?? 0);
+    return {
+      backend: "postgres",
+      serverVersion: String(r?.version ?? "unknown"),
+      schema: this.config.prefix,
+      uptimeSeconds: num(r?.uptime),
+      connectedClients: num(r?.clients),
+      maxConnections: num(r?.max_connections),
+      databaseSizeBytes: num(r?.db_bytes),
+      jobTableBytes: num(r?.job_bytes),
+      eventTableBytes: num(r?.event_bytes),
+      totalTransactions: numOrNull(r?.transactions),
+      cacheHitRatePct: lookups > 0 ? Math.round((hit ?? 0) / lookups * 1e3) / 10 : null,
+      deadlocks: numOrNull(r?.deadlocks),
+      latencyMs,
+      sampledAt: new Date(startedAt).toISOString()
+    };
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    await Promise.allSettled([...this.queues.values()].map((q) => q.close()));
+    this.queues.clear();
+    await this.pool.end().catch(() => void 0);
+  }
+  // ---------------------------------------------------------------------------
+  // discovery
+  // ---------------------------------------------------------------------------
+  /** `SELECT DISTINCT queue FROM meta`, cached for discoveryTtlMs. See sql.ts. */
+  async discoverQueues(opts = {}) {
+    const age = this.discovered ? Date.now() - this.discovered.at : Number.POSITIVE_INFINITY;
+    if (this.discovered && age < (opts.force ? FORCE_DISCOVERY_MIN_MS : this.opts.discoveryTtlMs)) {
+      return this.discovered.names;
+    }
+    if (!this.discovering) {
+      this.discovering = this.query(DISCOVER_QUEUES).then((rows) => {
+        const names = rows.map((r) => r.queue).filter((n) => !this.filter || this.filter.test(n));
+        names.sort((a, b) => a.localeCompare(b));
+        this.discovered = { at: Date.now(), names };
+        return names;
+      }).finally(() => {
+        this.discovering = null;
+      });
+    }
+    return this.discovering;
+  }
+  /** One query lists every queue: discovery is complete from the first call. */
+  async discoveryStatus() {
+    return { complete: true, scannedIterations: 0, totalKeys: null };
+  }
+  // ---------------------------------------------------------------------------
+  // reads
+  // ---------------------------------------------------------------------------
+  async getQueueStats(queueNames, opts = {}) {
+    if (queueNames.length === 0) return {};
+    const windowMinutes = opts.rateWindowMinutes ?? DEFAULT_RATE_WINDOW_MINUTES;
+    const now = Date.now();
+    for (const [k, v] of this.statsCache) if (now - v.at >= STATS_CACHE_MS) this.statsCache.delete(k);
+    const key = (q) => `${windowMinutes}\0${q}`;
+    const stale = queueNames.filter((q) => !this.statsCache.has(key(q)));
+    if (stale.length > 0) {
+      const read = this.readQueueStats(stale, windowMinutes);
+      for (const q of stale) {
+        const value = read.then((all) => all[q]);
+        this.statsCache.set(key(q), { at: now, value });
+        value.catch(() => this.statsCache.delete(key(q)));
+      }
+    }
+    const out = {};
+    for (const q of queueNames) {
+      const stats = await this.statsCache.get(key(q))?.value;
+      if (!stats) continue;
+      const { metrics: _metrics, ...withoutMetrics } = stats;
+      out[q] = opts.withMetrics ? stats : withoutMetrics;
+    }
+    return out;
+  }
+  /** A count still fresh for its size (see LARGE_COUNT), from stats or from a job page. */
+  cachedCount(queue, state) {
+    const c = this.countCache.get(`${queue}\0${state}`);
+    return c && Date.now() - c.at < c.ttl ? c.n : null;
+  }
+  rememberCount(queue, state, n) {
+    const ttl = n < LARGE_COUNT ? STATS_CACHE_MS : Math.min(LARGE_COUNT_MAX_TTL_MS, Math.round(STATS_CACHE_MS * n / LARGE_COUNT));
+    this.countCache.set(`${queue}\0${state}`, { at: Date.now(), n, ttl });
+    if (this.countCache.size > 1e4) this.countCache.clear();
+  }
+  async readQueueStats(queueNames, windowMinutes) {
+    const out = {};
+    const now = Date.now();
+    const points = Math.max(STATS_METRIC_POINTS, windowMinutes);
+    const countable = ["waiting", "prioritized", "active", "completed", "failed", "delayed", "waiting-children"];
+    const reuse = queueNames.map(
+      (q) => countable.filter((state) => {
+        const n = this.cachedCount(q, state);
+        return n !== null && n >= LARGE_COUNT;
+      })
+    );
+    const rows = await this.query(QUEUE_STATS, [
+      queueNames,
+      now,
+      points,
+      now - windowMinutes * 6e4,
+      reuse.map((states) => states.join(","))
+    ]);
+    const counted = (queue, state, value) => {
+      if (value === null || value === void 0) return this.cachedCount(queue, state) ?? 0;
+      const n = num(value);
+      this.rememberCount(queue, state, n);
+      return n;
+    };
+    for (const r of rows) {
+      const queue = String(r.queue);
+      const metricsCompleted = metricPoints(r.m_completed_data);
+      const metricsFailed = metricPoints(r.m_failed_data);
+      const version = typeof r.version === "string" && r.version !== "" ? r.version : null;
+      const stats = {
+        counts: {
+          ...EMPTY_COUNTS,
+          waiting: counted(queue, "waiting", r.waiting),
+          prioritized: counted(queue, "prioritized", r.prioritized),
+          active: counted(queue, "active", r.active),
+          completed: counted(queue, "completed", r.completed),
+          failed: counted(queue, "failed", r.failed),
+          delayed: counted(queue, "delayed", r.delayed),
+          "waiting-children": counted(queue, "waiting-children", r.waiting_children)
+        },
+        isPaused: r.paused === true,
+        isPro: version !== null && version.startsWith("bullmq-pro"),
+        groupsCount: 0,
+        rates: ratesFrom({
+          windowMinutes,
+          now,
+          completed: r.m_completed ?? null,
+          failed: r.m_failed ?? null,
+          storedCompleted: num(r.w_completed),
+          storedFailed: num(r.w_failed),
+          prunesCompleted: prunesCompleted(r.remove_on_complete)
+        }),
+        library: version,
+        schedulersCount: num(r.schedulers),
+        stalledCount: num(r.stalled)
+      };
+      stats.metrics = { completed: metricsCompleted.slice(-STATS_METRIC_POINTS), failed: metricsFailed.slice(-STATS_METRIC_POINTS) };
+      out[queue] = stats;
+    }
+    return out;
+  }
+  async getWindowCounts(queueName, since) {
+    const [r] = await this.query(WINDOW_COUNTS, [queueName, since]);
+    return { completed: num(r?.completed), failed: num(r?.failed) };
+  }
+  /** The cumulative `count` of the metrics rows; null per side when the row is absent (no metrics). */
+  async getMetricsCounters(queueName) {
+    const collectedAt = Date.now();
+    const rows = await this.query(METRICS_COUNTERS, [queueName]);
+    const read = (kind) => numOrNull(rows.find((r) => r.kind === kind)?.count);
+    return { completed: read("completed"), failed: read("failed"), collectedAt };
+  }
+  async getWindowMetrics(requests, opts = {}) {
+    const out = {};
+    if (requests.length === 0) return out;
+    const now = opts.now ?? Date.now();
+    const sample = Math.max(1, Math.min(opts.durationSample ?? 100, 100));
+    const maxRate = Math.max(1, ...requests.flatMap((r) => r.rateWindows));
+    const sinces = requests.map((r) => now - Math.max(0, ...r.durationWindows) * 6e4);
+    const rows = await this.query(
+      WINDOW_METRICS,
+      [requests.map((r) => r.queue), sinces, maxRate + 1, sample]
+    );
+    requests.forEach((request, i) => {
+      const row = rows[i];
+      if (!row) return;
+      out[request.queue] = windowMetricsFrom(request, row.metrics, request.durationWindows.length > 0 ? row.durations : null, now);
+    });
+    return out;
+  }
+  /**
+   * A page of one state: the ids come off the state's partial index (OFFSET over
+   * a narrow index, never over full rows), then only that page is joined to
+   * `job` for its columns. The total comes from the count cache when a stats read
+   * just counted the state (the usual case: the queue page polls both), and is
+   * counted in the same statement otherwise.
+   */
+  async getJobs(queueName, state, opts) {
+    const s = STATE_SQL[state];
+    if (!s) return { jobs: [], total: 0, start: opts.start, end: opts.end };
+    const ob = orderBy(state, opts.order);
+    const limit = Math.max(0, opts.end - opts.start + 1);
+    const known = this.cachedCount(queueName, state);
+    const sql2 = `
+      WITH page AS (
+        SELECT id, row_number() OVER (ORDER BY ${ob}) AS ord
+        FROM job WHERE queue = $1 AND ${s.where} ORDER BY ${ob} OFFSET $2 LIMIT $3
+      )
+      SELECT ${known === null ? `(SELECT count(*) FROM job WHERE queue = $1 AND ${s.where})` : "NULL::bigint"} AS total,
+        (SELECT json_agg(r ORDER BY r.ord) FROM (
+           SELECT page.ord, ${summaryColumns("j", 4, 5)}
+           FROM page JOIN job j ON j.queue = $1 AND j.id = page.id) r) AS rows`;
+    const [r] = await this.query(sql2, [
+      queueName,
+      Math.max(0, opts.start),
+      limit,
+      this.opts.previewBytes,
+      this.opts.listFieldCapBytes
+    ]);
+    const total = known ?? num(r?.total);
+    if (known === null) this.rememberCount(queueName, state, total);
+    return {
+      jobs: (r?.rows ?? []).map((row) => rowToSummary(this.config.prefix, row, this.opts.previewBytes)),
+      total,
+      start: opts.start,
+      end: opts.end
+    };
+  }
+  /**
+   * Bounded, resumable search, with the same bounds as Redis: at most
+   * maxScanPerCall jobs and at most searchByteBudget payload bytes per call, and
+   * payloads over searchFieldCapBytes are matched on id / name / error only.
+   * Case-insensitive substring (ILIKE with the wildcards escaped). The cursor is
+   * the index of the next job to inspect (newest = 0).
+   */
+  async searchJobs(queueName, state, query, opts) {
+    const s = STATE_SQL[state];
+    if (!s) return { jobs: [], nextCursor: null, scanned: 0, total: 0, skippedLargePayloads: 0 };
+    const cursor = Math.max(0, Math.trunc(Number(opts.cursor ?? 0)) || 0);
+    const limit = Math.max(1, opts.limit);
+    const ob = orderBy(state, "desc");
+    const known = this.cachedCount(queueName, state);
+    const sql2 = `
+      WITH scan AS (
+        SELECT id, row_number() OVER (ORDER BY ${ob}) AS rn
+        FROM job WHERE queue = $1 AND ${s.where} ORDER BY ${ob} OFFSET $2 LIMIT $3
+      ), sized AS (
+        SELECT s.rn, s.id, pg_column_size(j.data) AS sz
+        FROM scan s JOIN job j ON j.queue = $1 AND j.id = s.id
+      ), budgeted AS (
+        -- a job is inspected when the payload bytes spent BEFORE it are inside the budget
+        SELECT rn, id, sz > $6 AS too_big FROM (
+          SELECT rn, id, sz, sum(CASE WHEN sz > $6 THEN 0 ELSE sz END) OVER (ORDER BY rn) AS spent FROM sized
+        ) b
+        WHERE spent - CASE WHEN sz > $6 THEN 0 ELSE sz END < $7
+      ), hits AS (
+        SELECT b.rn, ${summaryColumns("j", 8, 9)}
+        FROM budgeted b JOIN job j ON j.queue = $1 AND j.id = b.id
+        WHERE j.id ILIKE $4 ESCAPE '\\' OR j.name ILIKE $4 ESCAPE '\\' OR j.failed_reason ILIKE $4 ESCAPE '\\'
+           OR (NOT b.too_big AND j.data::text ILIKE $4 ESCAPE '\\')
+        ORDER BY b.rn LIMIT $5
+      )
+      SELECT ${known === null ? `(SELECT count(*) FROM job WHERE queue = $1 AND ${s.where})` : "NULL::bigint"} AS total,
+        (SELECT count(*) FROM budgeted) AS scanned,
+        (SELECT json_agg(rn) FROM budgeted WHERE too_big) AS big,
+        (SELECT json_agg(h ORDER BY h.rn) FROM hits h) AS rows`;
+    const [r] = await this.query(sql2, [
+      queueName,
+      cursor,
+      this.opts.maxScanPerCall,
+      likeSubstring(query),
+      limit,
+      this.opts.searchFieldCapBytes,
+      this.opts.searchByteBudget,
+      this.opts.previewBytes,
+      this.opts.listFieldCapBytes
+    ]);
+    const total = known ?? num(r?.total);
+    if (known === null) this.rememberCount(queueName, state, total);
+    const rows = r?.rows ?? [];
+    const stoppedAt = rows.length >= limit ? num(rows[rows.length - 1]?.rn) : cursor + num(r?.scanned);
+    const big = (r?.big ?? []).filter((rn) => rn <= stoppedAt).length;
+    return {
+      jobs: rows.map((row) => rowToSummary(this.config.prefix, row, this.opts.previewBytes)),
+      nextCursor: stoppedAt >= total ? null : String(stoppedAt),
+      scanned: stoppedAt - cursor,
+      total,
+      skippedLargePayloads: big
+    };
+  }
+  async getJob(queueName, jobId) {
+    const [row] = await this.query(JOB_DETAIL, [queueName, jobId, DETAIL_LOG_TAIL]);
+    return row ? rowToDetail(this.config.prefix, row) : null;
+  }
+  async getJobLogs(queueName, jobId, opts) {
+    const start = Math.max(0, opts.start);
+    const limit = opts.end < 0 ? null : Math.max(0, opts.end - start + 1);
+    const [r] = await this.query(JOB_LOGS, [queueName, jobId, start, limit]);
+    return { logs: r?.logs ?? [], count: num(r?.count) };
+  }
+  async getMetrics(queueName, points) {
+    const rows = await this.query(METRICS, [queueName, Math.max(1, points)]);
+    const read = (kind) => metricPoints(rows.find((r) => r.kind === kind)?.data);
+    return { completed: read("completed"), failed: read("failed") };
+  }
+  /**
+   * meta + the limiter window + whether metrics are collected, then the workers
+   * from pg_stat_activity. Cached SETUP_CACHE_MS, like Redis (pg_stat_activity
+   * is cheap, but there is no reason to read it on every poll).
+   */
+  async getQueueSetup(queueName) {
+    const cached = this.setupCache.get(queueName);
+    if (cached && Date.now() - cached.at < SETUP_CACHE_MS) return cached.value;
+    const [[r], workers] = await Promise.all([
+      this.query(QUEUE_SETUP, [queueName]),
+      this.listWorkers(queueName).catch(() => null)
+    ]);
+    const meta = r?.meta ?? {};
+    const version = meta.version ?? null;
+    const max = numOrNull(meta.max);
+    const duration = numOrNull(meta.duration);
+    const expireAt = numOrNull(r?.limiter_expire_at);
+    const ttl = expireAt === null ? -1 : expireAt - Date.now();
+    const { version: _v, paused: _p, concurrency: _c, max: _m, duration: _d, ...rest } = meta;
+    const rawMeta = {};
+    for (const [k, v] of Object.entries(rest)) if (v !== null && v !== void 0) rawMeta[k] = v;
+    const value = {
+      library: version,
+      isPro: version !== null && version.startsWith("bullmq-pro"),
+      isPaused: meta.paused !== void 0,
+      globalConcurrency: numOrNull(meta.concurrency),
+      globalRateLimit: max !== null && duration !== null ? { max, durationMs: duration } : null,
+      rateLimitedNow: ttl >= 0 ? { ttlMs: ttl } : null,
+      workers,
+      groups: null,
+      batch: "unknown",
+      metricsEnabled: r?.metrics_enabled === true,
+      maxLenEvents: numOrNull(meta["opts.maxLenEvents"]),
+      rawMeta
+    };
+    this.setupCache.set(queueName, { at: Date.now(), value });
+    return value;
+  }
+  async listWorkers(queueName) {
+    const rows = await this.query(WORKERS, [
+      queueName,
+      `${queueName.replace(/[\\%_]/g, (c) => `\\${c}`)}:w:%`
+    ]);
+    const names = rows.map((r) => {
+      const idx = r.application_name.indexOf(":w:");
+      return idx === -1 ? "worker" : r.application_name.slice(idx + 3);
+    });
+    return { count: names.length, names };
+  }
+  // --- BullMQ Pro groups: the open-source Postgres backend has no groups ------
+  async getGroups() {
+    return { groups: [], total: 0, byStatus: { waiting: 0, limited: 0, maxed: 0, paused: 0 } };
+  }
+  async getGroupJobs(_queueName, _groupId, opts) {
+    return { jobs: [], total: 0, start: opts.start, end: opts.end };
+  }
+  // ---------------------------------------------------------------------------
+  // job schedulers
+  // ---------------------------------------------------------------------------
+  async getSchedulers(queueName, opts) {
+    const limit = opts.end < 0 ? null : Math.max(0, opts.end - opts.start + 1);
+    const [r] = await this.query(SCHEDULERS, [
+      queueName,
+      Math.max(0, opts.start),
+      limit,
+      this.opts.previewBytes
+    ]);
+    return { schedulers: (r?.rows ?? []).map(rowToScheduler), total: num(r?.total) };
+  }
+  /** Official API: removes the scheduler AND the delayed job it has queued. */
+  async removeScheduler(queueName, key) {
+    const queue = await this.getQueue(queueName);
+    return { removed: await queue.removeJobScheduler(key) === true };
+  }
+  // ---------------------------------------------------------------------------
+  // flows
+  // ---------------------------------------------------------------------------
+  async sampleFlowEdges(queueName, opts = {}) {
+    const sample = Math.max(1, opts.sample ?? 50);
+    const [r] = await this.query(SAMPLE_PARENTS, [queueName, sample]);
+    const edges = (r?.edges ?? []).map(([parentQueue, count2]) => ({ parentQueue, childQueue: queueName, count: num(count2) }));
+    edges.sort((a, b) => b.count - a.count);
+    return { edges, sampled: num(r?.sampled) };
+  }
+  /**
+   * Walk ONE flow instance, breadth first, at most `maxNodes` jobs read. Same
+   * shape and budget as the Redis walk, but each wave is ONE statement across
+   * every queue it touches (job_dependency holds both ends of every edge).
+   */
+  async getJobTree(queueName, jobId, opts = {}) {
+    const maxNodes = Math.max(1, Math.min(opts.maxNodes ?? 200, 500));
+    const schema = this.config.prefix;
+    let visited = 0;
+    const read = async (refs) => {
+      if (refs.length === 0) return [];
+      visited += refs.length;
+      const rows = await this.query(TREE_NODES, [refs.map((r) => r.queue), refs.map((r) => r.id), maxNodes]);
+      return refs.map((_, i) => {
+        const row = rows[i];
+        return row && row.found ? row : null;
+      });
+    };
+    const [focus] = await read([{ queue: queueName, id: jobId }]);
+    if (!focus) return null;
+    const focusKey = jobKeyOf(schema, queueName, jobId);
+    let root = { queue: queueName, id: jobId };
+    let climbedLevels = 0;
+    if (opts.fromRoot !== false) {
+      const seen = /* @__PURE__ */ new Set([focusKey]);
+      let current2 = focus;
+      while (current2.parent_queue && current2.parent_id && climbedLevels < MAX_TREE_CLIMB && visited < maxNodes) {
+        const next = { queue: current2.parent_queue, id: current2.parent_id };
+        const key = jobKeyOf(schema, next.queue, next.id);
+        if (seen.has(key)) break;
+        const [parent] = await read([next]);
+        if (!parent) break;
+        seen.add(key);
+        root = next;
+        climbedLevels += 1;
+        current2 = parent;
+      }
+    }
+    const nodes = /* @__PURE__ */ new Map();
+    let frontier = [{ ...root, parentKey: null }];
+    let truncated = false;
+    while (frontier.length > 0 && !truncated) {
+      const wave = frontier.filter((f) => !nodes.has(jobKeyOf(schema, f.queue, f.id)));
+      const room = maxNodes - nodes.size;
+      if (room <= 0) {
+        truncated = wave.length > 0;
+        break;
+      }
+      const slice = wave.length > room ? (truncated = true, wave.slice(0, room)) : wave;
+      const rows = await read(slice);
+      const next = [];
+      slice.forEach((entry, i) => {
+        const key = jobKeyOf(schema, entry.queue, entry.id);
+        const row = rows[i] ?? null;
+        nodes.set(key, treeNode(schema, entry, row, maxNodes));
+        for (const [childQueue, childId] of (row?.children ?? []).slice(0, maxNodes)) {
+          const childKey = jobKeyOf(schema, childQueue, childId);
+          if (!nodes.has(childKey)) next.push({ queue: childQueue, id: childId, parentKey: key });
+        }
+      });
+      frontier = next;
+    }
+    return {
+      rootKey: jobKeyOf(schema, root.queue, root.id),
+      focusKey,
+      nodes: [...nodes.values()],
+      truncated: truncated || nodes.size >= maxNodes,
+      visited,
+      climbedLevels
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // writes (official bullmq API; we never write BullMQ's tables ourselves)
+  // ---------------------------------------------------------------------------
+  /**
+   * One bullmq Queue per queue name, created on the first write. BullMQ builds
+   * its own pool from the config object (that is the only way it honours a
+   * non-default schema); `max: 1` and a short idle timeout keep a dashboard
+   * that touched 50 queues from holding 50 connections. A Queue never opens the
+   * LISTEN connection — only Workers and QueueEvents do.
+   */
+  async getQueue(queueName) {
+    await this.ensureReady();
+    this.invalidateStats();
+    let q = this.queues.get(queueName);
+    if (q) return q;
+    q = new Queue(
+      queueName,
+      {
+        connection: {
+          connectionString: nodePgConnectionString(this.config.url),
+          schema: this.config.prefix,
+          max: 1,
+          idleTimeoutMillis: 1e4,
+          application_name: APPLICATION_NAME
+        },
+        skipMetasUpdate: true
+      },
+      createPostgresBackend
+    );
+    q.on("error", () => void 0);
+    this.queues.set(queueName, q);
+    return q;
+  }
+  /**
+   * Every write goes through getQueue, so dropping the stats window here keeps
+   * an action from being followed by a count from before it.
+   */
+  invalidateStats() {
+    this.statsCache.clear();
+    this.countCache.clear();
+  }
+  async getBullJob(queueName, jobId) {
+    const queue = await this.getQueue(queueName);
+    const job = await Job.fromId(queue, jobId);
+    if (!job) throw new Error("job_not_found");
+    return job;
+  }
+  async addJob(queueName, name, data, opts = {}) {
+    const queue = await this.getQueue(queueName);
+    const job = await queue.add(name, data, opts);
+    return { id: String(job.id) };
+  }
+  async retryJob(queueName, jobId) {
+    const job = await this.getBullJob(queueName, jobId);
+    const state = await job.getState();
+    if (state !== "failed" && state !== "completed") throw new Error(`cannot_retry_job_in_state_${state}`);
+    await job.retry(state);
+  }
+  async removeJob(queueName, jobId) {
+    const job = await this.getBullJob(queueName, jobId);
+    await job.remove();
+  }
+  /** Same rules as the Redis inspector: a scheduler's job asks the operator first. */
+  async promoteJob(queueName, jobId, scheduler = "run_copy") {
+    const job = await this.getBullJob(queueName, jobId);
+    if (!job.repeatJobKey) {
+      await job.promote();
+      return { mode: "promoted" };
+    }
+    if (scheduler === "skip_next") {
+      await job.promote();
+      return { mode: "skipped_next", schedulerId: job.repeatJobKey };
+    }
+    const state = await job.getState();
+    if (state !== "delayed") throw new Error(`cannot_promote_job_in_state_${state}`);
+    const { repeat: _r, jobId: _j, repeatJobKey: _k, prevMillis: _p, delay: _d, timestamp: _t, ...opts } = job.opts;
+    const copy = await this.addJob(queueName, job.name, job.data, opts);
+    return { mode: "ran_copy", jobId: copy.id, schedulerId: job.repeatJobKey };
+  }
+  /** Partial result, bounded concurrency: see Inspector.bulkJobAction. */
+  async bulkJobAction(queueName, action, jobIds) {
+    const ok = [];
+    const failed = [];
+    const ids = [...new Set(jobIds)];
+    const run = async (jobId) => {
+      try {
+        if (action === "retry") await this.retryJob(queueName, jobId);
+        else if (action === "remove") await this.removeJob(queueName, jobId);
+        else await this.promoteJob(queueName, jobId);
+        ok.push(jobId);
+      } catch (err) {
+        failed.push({ jobId, reason: errorMessage(err) });
+      }
+    };
+    for (let i = 0; i < ids.length; i += BULK_CONCURRENCY) {
+      await Promise.all(ids.slice(i, i + BULK_CONCURRENCY).map(run));
+    }
+    return { action, ok, failed, requested: ids.length };
+  }
+  /** Operator "discard": an active job straight to failed, no retry (see RedisInspector.discardJob). */
+  async discardJob(queueName, jobId) {
+    const job = await this.getBullJob(queueName, jobId);
+    const state = await job.getState();
+    if (state !== "active") throw new Error(`cannot_discard_job_in_state_${state}`);
+    try {
+      await job.moveToFailed(new UnrecoverableError("Discarded from Bullpane"), "0");
+    } catch (err) {
+      throw new Error(`cannot_discard_active_job: ${errorMessage(err)}`);
+    }
+  }
+  async pauseQueue(queueName) {
+    await (await this.getQueue(queueName)).pause();
+    this.setupCache.delete(queueName);
+    this.invalidateStats();
+  }
+  async resumeQueue(queueName) {
+    await (await this.getQueue(queueName)).resume();
+    this.setupCache.delete(queueName);
+    this.invalidateStats();
+  }
+  async cleanQueue(queueName, state, graceMs, limit) {
+    const ids = await (await this.getQueue(queueName)).clean(graceMs, limit, state);
+    return { removed: ids.length };
+  }
+  async retryAll(queueName, state) {
+    await (await this.getQueue(queueName)).retryJobs({ state });
+  }
+  async drainQueue(queueName, includeDelayed) {
+    await (await this.getQueue(queueName)).drain(includeDelayed);
+  }
+  async obliterateQueue(queueName) {
+    const queue = await this.getQueue(queueName);
+    await queue.obliterate({ force: true });
+    this.queues.delete(queueName);
+    await queue.close().catch(() => void 0);
+    this.discovered = null;
+  }
+};
+function treeNode(schema, entry, row, maxNodes) {
+  const key = jobKeyOf(schema, entry.queue, entry.id);
+  const base = { key, id: entry.id, queueName: entry.queue, queueKey: queueKeyOf(schema, entry.queue) };
+  if (!row) {
+    return {
+      ...base,
+      name: "",
+      state: "unknown",
+      timestamp: 0,
+      finishedOn: null,
+      attemptsMade: 0,
+      failedReason: null,
+      progress: null,
+      parentKey: entry.parentKey,
+      dependencies: null,
+      childrenTruncated: false,
+      missing: true
+    };
   }
+  const processed = num(row.processed);
+  const unprocessed = num(row.unprocessed);
+  return {
+    ...base,
+    name: row.name ?? "",
+    state: bullpaneState(row.state, row.priority),
+    timestamp: num(row.added_at_ms),
+    finishedOn: numOrNull(row.finished_at_ms),
+    attemptsMade: num(row.attempts_made),
+    failedReason: row.failed_reason ?? null,
+    progress: progressOf(row.progress),
+    // the walk's own edge wins over the stored parent: it is the edge being drawn
+    parentKey: entry.parentKey ?? (row.parent_queue && row.parent_id ? jobKeyOf(schema, row.parent_queue, row.parent_id) : null),
+    dependencies: processed + unprocessed > 0 ? { processed, unprocessed } : null,
+    // TREE_NODES reads maxNodes + 1 children: one more than the walk could hold means there are more
+    childrenTruncated: (row.children?.length ?? 0) > maxNodes,
+    missing: false
+  };
 }
-var MCP_ACCESS_LEVELS = ["off", "read", "write"];
-var MCP_ACCESS_RANK = { off: 0, read: 1, write: 2 };
-function mcpRoleCeiling(role) {
-  return hasRole(role, "operator") ? "write" : "read";
-}
-function mcpEffectiveAccess(ceiling, granted, role) {
-  const levels = [ceiling, granted, mcpRoleCeiling(role)];
-  return levels.reduce((min, l) => MCP_ACCESS_RANK[l] < MCP_ACCESS_RANK[min] ? l : min);
+
+// packages/pg-inspector/src/pool.ts
+var PgInspectorPool = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  inspectors = /* @__PURE__ */ new Map();
+  get(config) {
+    const existing = this.inspectors.get(config.id);
+    if (existing && sameTarget(existing.config, config)) return existing;
+    if (existing) void existing.close().catch(() => void 0);
+    const created = new PgInspector(config, this.options);
+    this.inspectors.set(config.id, created);
+    return created;
+  }
+  async evict(id3) {
+    const existing = this.inspectors.get(id3);
+    if (!existing) return;
+    this.inspectors.delete(id3);
+    await existing.close();
+  }
+  async closeAll() {
+    const all = [...this.inspectors.values()];
+    this.inspectors.clear();
+    await Promise.allSettled(all.map((i) => i.close()));
+  }
+};
+function sameTarget(a, b) {
+  return a.url === b.url && a.prefix === (b.prefix ?? "bullmq") && (a.queueFilter ?? null) === (b.queueFilter ?? null);
 }
-var updateMcpSettingsSchema = z.object({ maxAccess: z.enum(MCP_ACCESS_LEVELS) });
-var mcpConsentDecisionSchema = z.object({
-  request: z.string().min(1).max(4096),
-  approve: z.boolean(),
-  access: z.enum(["read", "write"]).default("read")
-});
+
+// packages/redis-inspector/src/inspector.ts
+import { Cluster as Cluster2 } from "ioredis";
+import { Job as Job2, Queue as Queue2, UnrecoverableError as UnrecoverableError2 } from "bullmq";
 
 // packages/redis-inspector/src/connection.ts
 import Redis, { Cluster } from "ioredis";
@@ -664,14 +1986,6 @@ function queueNameFromQueueKey(prefix, qualified) {
 }
 
 // packages/redis-inspector/src/util.ts
-function globToRegExp(glob) {
-  const escaped = glob.split("").map((ch) => {
-    if (ch === "*") return ".*";
-    if (ch === "?") return ".";
-    return ch.replace(/[.+^${}()|[\]\\/]/g, "\\$&");
-  }).join("");
-  return new RegExp(`^${escaped}$`);
-}
 function safeJsonParse(raw, fallback) {
   if (raw === null || raw === void 0) return fallback === void 0 ? null : fallback;
   try {
@@ -721,7 +2035,7 @@ function totalKeysFromInfo(info) {
   }
   return seen ? total : null;
 }
-function errorMessage(err) {
+function errorMessage2(err) {
   if (err instanceof Error) return err.message;
   return String(err);
 }
@@ -870,13 +2184,13 @@ function asNumber(reply, fallback = 0) {
 function asStringArray(reply) {
   return asArray(reply).map((v) => typeof v === "string" ? v : String(v ?? ""));
 }
-function metricPoints(reply) {
+function metricPoints2(reply) {
   return asStringArray(reply).map((s) => Number(s) || 0).reverse();
 }
 function str(v) {
   return typeof v === "string" && v !== "" ? v : typeof v === "number" ? String(v) : null;
 }
-function rowToScheduler(row) {
+function rowToScheduler2(row) {
   const key = String(row[0] ?? "");
   const name = str(row[2]);
   const data = str(row[11]);
@@ -982,7 +2296,7 @@ function pipelineScript(pipeline, name, args) {
 }
 
 // packages/redis-inspector/src/inspector.ts
-var DEFAULTS = {
+var DEFAULTS2 = {
   discoveryTtlMs: 3e4,
   previewBytes: 2048,
   maxScanPerCall: 1e3,
@@ -995,12 +2309,12 @@ var DEFAULTS = {
   searchByteBudget: 8 * 1024 * 1024
 };
 var SCAN_COUNT = 1e3;
-var STATS_METRIC_POINTS = 60;
-var BULK_CONCURRENCY = 8;
-var DEFAULT_RATE_WINDOW_MINUTES = 60;
-var FORCE_DISCOVERY_MIN_MS = 5e3;
-var SETUP_CACHE_MS = 1e4;
-var DETAIL_LOG_TAIL = 100;
+var STATS_METRIC_POINTS2 = 60;
+var BULK_CONCURRENCY2 = 8;
+var DEFAULT_RATE_WINDOW_MINUTES2 = 60;
+var FORCE_DISCOVERY_MIN_MS2 = 5e3;
+var SETUP_CACHE_MS2 = 1e4;
+var DETAIL_LOG_TAIL2 = 100;
 var FLOW_SAMPLE_STATES = ["completed", "failed", "waiting-children", "waiting", "active", "delayed"];
 var RedisInspector = class {
   config;
@@ -1025,12 +2339,14 @@ var RedisInspector = class {
   bullmqCluster = null;
   closed = false;
   constructor(config, options = {}) {
+    if (config.kind && config.kind !== "redis") throw new Error(`RedisInspector cannot open a ${config.kind} connection`);
     this.config = {
       ...config,
+      kind: "redis",
       prefix: config.prefix ?? "bull",
       cluster: config.cluster ?? false
     };
-    this.opts = { ...DEFAULTS, ...stripUndefined(options) };
+    this.opts = { ...DEFAULTS2, ...stripUndefined(options) };
     this.filter = config.queueFilter ? globToRegExp(config.queueFilter) : null;
     this.client = createReadClient(this.config, this.opts.connectTimeoutMs);
     this.client.on("error", () => void 0);
@@ -1091,7 +2407,7 @@ var RedisInspector = class {
         ok: false,
         latencyMs: Math.round((performance.now() - t0) * 10) / 10,
         redisVersion: null,
-        error: errorMessage(err)
+        error: errorMessage2(err)
       };
     }
   }
@@ -1174,7 +2490,7 @@ var RedisInspector = class {
   async discoverQueues(opts = {}) {
     const now = Date.now();
     const age = this.discovered ? now - this.discovered.at : Number.POSITIVE_INFINITY;
-    if (this.discovered && age < (opts.force ? FORCE_DISCOVERY_MIN_MS : this.opts.discoveryTtlMs)) {
+    if (this.discovered && age < (opts.force ? FORCE_DISCOVERY_MIN_MS2 : this.opts.discoveryTtlMs)) {
       return this.discovered.names;
     }
     if (!this.discovering) {
@@ -1328,19 +2644,19 @@ var RedisInspector = class {
     if (queueNames.length === 0) return out;
     const c = await this.ensureConnected();
     const withMetrics = opts.withMetrics ? 1 : 0;
-    const windowMinutes = opts.rateWindowMinutes ?? DEFAULT_RATE_WINDOW_MINUTES;
+    const windowMinutes = opts.rateWindowMinutes ?? DEFAULT_RATE_WINDOW_MINUTES2;
     const since = Date.now() - windowMinutes * 6e4;
     let replies;
     if (c instanceof Cluster2) {
       replies = await Promise.all(
         queueNames.map(
-          (q) => callScript(c, "queueStats", [...this.statsKeys(q), withMetrics, STATS_METRIC_POINTS, since, queueKeyPrefix(this.config.prefix, q)]).catch(() => null)
+          (q) => callScript(c, "queueStats", [...this.statsKeys(q), withMetrics, STATS_METRIC_POINTS2, since, queueKeyPrefix(this.config.prefix, q)]).catch(() => null)
         )
       );
     } else {
       const pipeline = c.pipeline();
       for (const q of queueNames) {
-        pipelineScript(pipeline, "queueStats", [...this.statsKeys(q), withMetrics, STATS_METRIC_POINTS, since, queueKeyPrefix(this.config.prefix, q)]);
+        pipelineScript(pipeline, "queueStats", [...this.statsKeys(q), withMetrics, STATS_METRIC_POINTS2, since, queueKeyPrefix(this.config.prefix, q)]);
       }
       const results = await pipeline.exec() ?? [];
       replies = results.map(([err, reply]) => err ? null : reply);
@@ -1497,7 +2813,7 @@ var RedisInspector = class {
       p + JOB_KEY.processed(jobId),
       ...allStateKeys(this.config.prefix, queueName),
       jobId,
-      DETAIL_LOG_TAIL
+      DETAIL_LOG_TAIL2
     ]);
     if (!Array.isArray(reply)) return null;
     const hash = flatToHash(asArray(reply[0]));
@@ -1515,8 +2831,8 @@ var RedisInspector = class {
   async getJobLogs(queueName, jobId, opts) {
     const c = await this.ensureConnected();
     const key = queueKeyPrefix(this.config.prefix, queueName) + JOB_KEY.logs(jobId);
-    const [logs, count] = await Promise.all([c.lrange(key, opts.start, opts.end), c.llen(key)]);
-    return { logs, count };
+    const [logs, count2] = await Promise.all([c.lrange(key, opts.start, opts.end), c.llen(key)]);
+    return { logs, count: count2 };
   }
   /** Metric lists are LPUSHed (newest at index 0); we return oldest first. */
   async getMetrics(queueName, points) {
@@ -1527,7 +2843,7 @@ var RedisInspector = class {
       c.lrange(p + QUEUE_KEY.metricsCompletedData, 0, n - 1),
       c.lrange(p + QUEUE_KEY.metricsFailedData, 0, n - 1)
     ]);
-    return { completed: metricPoints(completed), failed: metricPoints(failed) };
+    return { completed: metricPoints2(completed), failed: metricPoints2(failed) };
   }
   // ---------------------------------------------------------------------------
   // BullMQ Pro groups (read only)
@@ -1543,7 +2859,7 @@ var RedisInspector = class {
    */
   async getQueueSetup(queueName) {
     const cached = this.setupCache.get(queueName);
-    if (cached && Date.now() - cached.at < SETUP_CACHE_MS) return cached.value;
+    if (cached && Date.now() - cached.at < SETUP_CACHE_MS2) return cached.value;
     const c = await this.ensureConnected();
     const p = queueKeyPrefix(this.config.prefix, queueName);
     const [reply, workers] = await Promise.all([
@@ -1682,7 +2998,7 @@ var RedisInspector = class {
     const reply = asArray(
       await callScript(c, "getSchedulers", [p + SCHEDULER_KEY.repeat, opts.start, opts.end, p, this.opts.previewBytes])
     );
-    const schedulers = asArray(reply[1]).map((row) => rowToScheduler(asArray(row)));
+    const schedulers = asArray(reply[1]).map((row) => rowToScheduler2(asArray(row)));
     return { schedulers, total: asNumber(reply[0]) };
   }
   /**
@@ -1756,7 +3072,7 @@ var RedisInspector = class {
     if (opts.fromRoot !== false) {
       const seen = /* @__PURE__ */ new Set([focusKey]);
       let current2 = focus;
-      while (current2.parentKey && climbedLevels < MAX_TREE_CLIMB) {
+      while (current2.parentKey && climbedLevels < MAX_TREE_CLIMB2) {
         const next = current2.parentKey;
         if (seen.has(next)) break;
         const parent = await readOne(next);
@@ -1870,7 +3186,7 @@ var RedisInspector = class {
         this.bullmqCluster = ownedCluster;
       }
     }
-    q = new Queue(queueName, {
+    q = new Queue2(queueName, {
       connection: this.bullmqCluster ?? connection,
       prefix: this.config.prefix,
       skipMetasUpdate: true
@@ -1881,7 +3197,7 @@ var RedisInspector = class {
   }
   async getBullJob(queueName, jobId) {
     const queue = await this.getQueue(queueName);
-    const job = await Job.fromId(queue, jobId);
+    const job = await Job2.fromId(queue, jobId);
     if (!job) throw new Error("job_not_found");
     return job;
   }
@@ -1940,11 +3256,11 @@ var RedisInspector = class {
         else await this.promoteJob(queueName, jobId);
         ok.push(jobId);
       } catch (err) {
-        failed.push({ jobId, reason: errorMessage(err) });
+        failed.push({ jobId, reason: errorMessage2(err) });
       }
     };
-    for (let i = 0; i < ids.length; i += BULK_CONCURRENCY) {
-      await Promise.all(ids.slice(i, i + BULK_CONCURRENCY).map(run));
+    for (let i = 0; i < ids.length; i += BULK_CONCURRENCY2) {
+      await Promise.all(ids.slice(i, i + BULK_CONCURRENCY2).map(run));
     }
     return { action, ok, failed, requested: ids.length };
   }
@@ -1963,9 +3279,9 @@ var RedisInspector = class {
       throw new Error(`cannot_discard_job_in_state_${state}`);
     }
     try {
-      await job.moveToFailed(new UnrecoverableError("Discarded from Bullpane"), "0");
+      await job.moveToFailed(new UnrecoverableError2("Discarded from Bullpane"), "0");
     } catch (err) {
-      throw new Error(`cannot_discard_active_job: ${errorMessage(err)}`);
+      throw new Error(`cannot_discard_active_job: ${errorMessage2(err)}`);
     }
   }
   async pauseQueue(queueName) {
@@ -2003,9 +3319,9 @@ function parseStats(reply, withMetrics, windowMinutes) {
   STATE_ORDER.forEach((state, i) => {
     counts[state] = asNumber(r[i]);
   });
-  const metricsCompleted = metricPoints(r[11] ?? []);
-  const metricsFailed = metricPoints(r[12] ?? []);
-  const prunesCompleted = optsPrunesCompleted(typeof r[16] === "string" ? r[16] : null);
+  const metricsCompleted = metricPoints2(r[11] ?? []);
+  const metricsFailed = metricPoints2(r[12] ?? []);
+  const prunesCompleted2 = optsPrunesCompleted(typeof r[16] === "string" ? r[16] : null);
   const totalCompleted = toIntOrNull(typeof r[17] === "string" ? r[17] : null);
   const totalFailed = toIntOrNull(typeof r[18] === "string" ? r[18] : null);
   const hasMetrics = totalCompleted !== null || totalFailed !== null;
@@ -2037,7 +3353,7 @@ function parseStats(reply, withMetrics, windowMinutes) {
       source: "zset",
       // only skewed if the queue really does prune completed jobs AND there are
       // failures to unbalance the ratio; with no failures, 100% is still 100%.
-      retentionSkewed: prunesCompleted && failed > 0
+      retentionSkewed: prunesCompleted2 && failed > 0
     };
   }
   const stats = {
@@ -2080,7 +3396,7 @@ var JOB_STATE_SET = new Set(STATE_ORDER);
 function isJobState(s) {
   return JOB_STATE_SET.has(s);
 }
-var MAX_TREE_CLIMB = 50;
+var MAX_TREE_CLIMB2 = 50;
 function splitJobKey(prefix, fullKey) {
   const cut = fullKey.lastIndexOf(":");
   if (cut <= 0) return null;
@@ -2178,7 +3494,7 @@ var RedisInspectorPool = class {
   inspectors = /* @__PURE__ */ new Map();
   get(config) {
     const existing = this.inspectors.get(config.id);
-    if (existing && sameTarget(existing.config, config)) return existing;
+    if (existing && sameTarget2(existing.config, config)) return existing;
     if (existing) {
       void existing.close().catch(() => void 0);
     }
@@ -2202,11 +3518,26 @@ var RedisInspectorPool = class {
     return [...this.inspectors.keys()];
   }
 };
-function sameTarget(a, b) {
+function sameTarget2(a, b) {
   return a.url === b.url && a.prefix === (b.prefix ?? "bull") && a.cluster === (b.cluster ?? false) && (a.queueFilter ?? null) === (b.queueFilter ?? null);
 }
-function createInspectorPool(options = {}) {
-  return new RedisInspectorPool(options);
+
+// apps/server/src/services/inspectorPool.ts
+function createInspectorPool2(options = {}) {
+  const redis = new RedisInspectorPool(options);
+  const postgres = new PgInspectorPool(options);
+  const pick = (config) => config.kind === "postgres" ? postgres : redis;
+  return {
+    get: (config) => pick(config).get(config),
+    // A connection's kind never changes (updateConnectionSchema omits it), but
+    // evicting from both costs nothing and cannot leave a stale inspector behind.
+    evict: async (id3) => {
+      await Promise.all([redis.evict(id3), postgres.evict(id3)]);
+    },
+    closeAll: async () => {
+      await Promise.all([redis.closeAll(), postgres.closeAll()]);
+    }
+  };
 }
 
 // apps/server/src/app.ts
@@ -2487,6 +3818,8 @@ var ssoProviders = mysqlTable(
 var connections = mysqlTable("connections", {
   id: id(),
   name: varchar("name", { length: 80 }).notNull(),
+  /** "redis" | "postgres" (BullMQ 6's Postgres backend). `prefix` holds the Postgres schema. */
+  kind: varchar("kind", { length: 16 }).$type().notNull().default("redis"),
   url: text("url").notNull(),
   prefix: varchar("prefix", { length: 64 }).notNull().default("bull"),
   cluster: boolean("cluster").notNull().default(false),
@@ -2713,6 +4046,7 @@ var ssoProviders2 = sqliteTable(
 var connections2 = sqliteTable("connections", {
   id: id2(),
   name: text2("name").notNull(),
+  kind: text2("kind").$type().notNull().default("redis"),
   url: text2("url").notNull(),
   prefix: text2("prefix").notNull().default("bull"),
   cluster: bool("cluster").notNull().default(false),
@@ -2941,8 +4275,8 @@ var readOnlyLocked = () => new HttpError(423, "read_only", "This instance runs i
 var invalidLicense = (reason) => new HttpError(400, "invalid_license", `Invalid license: ${reason}`);
 var licenseAlreadyActivated = (message) => new HttpError(409, "license_already_activated", message);
 var licenseServerUnavailable = (reason) => new HttpError(502, "license_server_unavailable", `Could not reach the license server: ${reason}`);
-var redisUnavailable = (err) => new HttpError(502, "redis_unavailable", `Redis connection failed: ${errorMessage2(err)}`);
-function errorMessage2(err) {
+var redisUnavailable = (err) => new HttpError(502, "redis_unavailable", `Redis connection failed: ${errorMessage3(err)}`);
+function errorMessage3(err) {
   if (err instanceof Error) return err.message;
   return typeof err === "string" ? err : JSON.stringify(err);
 }
@@ -2986,7 +4320,7 @@ function registerErrorHandling(app) {
     if (mapped.unexpected) {
       request.log.error({ err }, "unhandled error");
     } else if (mapped.status >= 500) {
-      request.log.warn({ err: errorMessage2(err), url: request.url }, mapped.body.error);
+      request.log.warn({ err: errorMessage3(err), url: request.url }, mapped.body.error);
     }
     void reply.status(mapped.status).send(mapped.body);
   });
@@ -4890,7 +6224,17 @@ var CONNECTION_ERROR_PATTERNS = [
   /CLUSTERDOWN/i,
   /Failed to refresh slots cache/i,
   /All sentinels are unreachable/i,
-  /socket closed unexpectedly/i
+  /socket closed unexpectedly/i,
+  // Postgres (node-postgres / BullMQ's Postgres backend)
+  /password authentication failed/i,
+  /no pg_hba\.conf entry/i,
+  /Connection terminated/i,
+  /timeout exceeded when trying to connect/i,
+  /the database system is (starting up|shutting down)/i,
+  /too many clients already/i,
+  /postgres_schema_missing/,
+  /the PostgreSQL schema requires BullMQ/i,
+  /the PostgreSQL backend requires server version/i
 ];
 var NOT_FOUND_PATTERNS = [/missing key for job/i, /job .* not found/i, /could not be found/i, /does not exist/i];
 function isRedisConnectionError(err) {
@@ -4899,14 +6243,26 @@ function isRedisConnectionError(err) {
     if (name === "MaxRetriesPerRequestError" || name === "ClusterAllFailedError") return true;
     const code = err.code;
     if (code && CONNECTION_ERROR_PATTERNS.some((p) => p.test(code))) return true;
+    if (code && /^(08...|28...|3D000|57P0\d)$/.test(code)) return true;
   }
-  const message = errorMessage2(err);
+  const message = errorMessage3(err);
   return CONNECTION_ERROR_PATTERNS.some((p) => p.test(message));
 }
+function isPermissionDenied(err) {
+  const code = typeof err === "object" && err !== null ? err.code : void 0;
+  return code === "42501" || /permission denied for (table|schema|function|sequence|relation)/i.test(errorMessage3(err));
+}
 function mapInspectorError(err) {
   if (err instanceof HttpError) return err;
   if (isRedisConnectionError(err)) return redisUnavailable(err);
-  const message = errorMessage2(err);
+  if (isPermissionDenied(err)) {
+    return new HttpError(
+      403,
+      "database_permission_denied",
+      `The database refused the action: ${errorMessage3(err)}. This connection's role can read but not write; give it the same rights your workers have to use actions from Bullpane.`
+    );
+  }
+  const message = errorMessage3(err);
   if (NOT_FOUND_PATTERNS.some((p) => p.test(message))) return notFound("Job");
   return conflict(message);
 }
@@ -4930,14 +6286,14 @@ async function connectionRoutes(app) {
     const input = createConnectionSchema.parse(request.body);
     const created = await app.ctx.connections.create(input);
     request.auditTarget({ connectionId: created.id, connectionName: created.name });
-    request.auditDetail({ prefix: created.prefix, cluster: created.cluster, queueFilter: created.queueFilter });
+    request.auditDetail({ kind: created.kind, prefix: created.prefix, cluster: created.cluster, queueFilter: created.queueFilter });
     reply.status(201);
     return created;
   });
   app.post("/connections/test", { preHandler: [admin] }, async (request) => {
     const input = testConnectionSchema.parse(request.body);
     const id3 = `test:${Date.now()}:${Math.random().toString(36).slice(2)}`;
-    const inspector = app.ctx.pool.get({ id: id3, url: input.url, prefix: input.prefix ?? "bull", cluster: input.cluster ?? false });
+    const inspector = app.ctx.pool.get({ id: id3, kind: input.kind, url: input.url, prefix: input.prefix, cluster: input.cluster ?? false });
     try {
       return await inspector.ping();
     } catch (err) {
@@ -6197,6 +7553,7 @@ function toConnectionDto(row, status) {
   const dto = {
     id: row.id,
     name: row.name,
+    kind: row.kind,
     url: redactRedisUrl(row.url),
     prefix: row.prefix,
     cluster: row.cluster,
@@ -6258,6 +7615,7 @@ var ConnectionsService = class {
     await this.db.insert(connections3).values({
       id: id3,
       name: input.name,
+      kind: input.kind,
       url: input.url,
       prefix: input.prefix,
       cluster: input.cluster,
@@ -6295,7 +7653,9 @@ var ConnectionsService = class {
     return this.list();
   }
   async update(id3, input) {
-    await this.getRow(id3);
+    const current2 = await this.getRow(id3);
+    const issue = connectionIssues({ ...input, kind: current2.kind })[0];
+    if (issue) throw validation(issue.message, [{ path: [issue.path], message: issue.message }]);
     const patch = {};
     if (input.name !== void 0) patch.name = input.name;
     if (input.url !== void 0) patch.url = input.url;
@@ -6325,6 +7685,7 @@ var ConnectionsService = class {
   inspectorFor(row) {
     return this.pool.get({
       id: row.id,
+      kind: row.kind,
       url: row.url,
       prefix: row.prefix,
       cluster: row.cluster,
@@ -6881,7 +8242,7 @@ var EditionService = class {
       if (!this.needsRefresh(boot)) return;
       await this.refresh();
     } catch (err) {
-      this.log.warn({ err: errorMessage2(err) }, "license refresh failed");
+      this.log.warn({ err: errorMessage3(err) }, "license refresh failed");
     }
   }
   async doRefresh() {
@@ -6947,7 +8308,7 @@ var EditionService = class {
       await this.client.deactivate({ key, activationId: state.activationId });
       this.log.info({ activationId: state.activationId }, "license activation released");
     } catch (err) {
-      this.log.warn({ err: errorMessage2(err) }, "could not release the license activation; free it from the customer portal if needed");
+      this.log.warn({ err: errorMessage3(err) }, "could not release the license activation; free it from the customer portal if needed");
     }
   }
   rebuild() {
@@ -7002,7 +8363,7 @@ function toCheckError(err) {
     };
   }
   if (err instanceof HttpError) return { code: err.error, message: err.message, definitive: false };
-  return { code: "unknown", message: errorMessage2(err), definitive: false };
+  return { code: "unknown", message: errorMessage3(err), definitive: false };
 }
 function toHttpError(err) {
   if (err instanceof HttpError) return err;
@@ -7020,7 +8381,7 @@ function toHttpError(err) {
         return licenseServerUnavailable(err.message);
     }
   }
-  return licenseServerUnavailable(errorMessage2(err));
+  return licenseServerUnavailable(errorMessage3(err));
 }
 
 // apps/server/src/services/attention.ts
@@ -7311,6 +8672,7 @@ function toFolderDto(row, queues) {
 // apps/server/src/services/health.ts
 var MIN_SAMPLE_INTERVAL_MS = 2e3;
 var HISTORY_POINTS = 200;
+var EVENT_TABLE_WARN_BYTES = 1024 * 1024 * 1024;
 var HealthService = class {
   constructor(connections5) {
     this.connections = connections5;
@@ -7328,10 +8690,11 @@ var HealthService = class {
     const st = this.stateFor(row.id);
     const snap = await this.sample(row, st);
     const info = snap.info;
-    const memoryUsedPct = info && info.maxMemoryBytes && info.maxMemoryBytes > 0 ? Math.round(info.usedMemoryBytes / info.maxMemoryBytes * 1e3) / 10 : null;
+    const memoryUsedPct = info && info.backend !== "postgres" && info.maxMemoryBytes && info.maxMemoryBytes > 0 ? Math.round(info.usedMemoryBytes / info.maxMemoryBytes * 1e3) / 10 : null;
     return {
       connectionId: row.id,
       connectionName: row.name,
+      kind: row.kind,
       ok: snap.error === null,
       error: snap.error,
       info,
@@ -7339,7 +8702,7 @@ var HealthService = class {
       cpuCores: snap.cpuCores,
       memoryUsedPct,
       history: [...st.history],
-      warnings: buildWarnings(info, snap.error, memoryUsedPct)
+      warnings: row.kind === "postgres" ? buildPostgresWarnings(info?.backend === "postgres" ? info : null, snap.error) : buildWarnings(info?.backend === "postgres" ? null : info, snap.error, memoryUsedPct)
     };
   }
   /** Drop cached state when a connection is edited or deleted. */
@@ -7373,8 +8736,9 @@ var HealthService = class {
           at,
           info,
           error: null,
-          commandsPerSec: rate(previous?.info?.totalCommandsProcessed, info.totalCommandsProcessed, elapsedSec),
-          cpuCores: rate(previous?.info?.cpuSecondsTotal, info.cpuSecondsTotal, elapsedSec)
+          // Postgres: transactions/sec from xact_commit + xact_rollback. No CPU counter there.
+          commandsPerSec: rate(throughputCounter(previous?.info), throughputCounter(info), elapsedSec),
+          cpuCores: info.backend === "postgres" ? null : rate(redisInfo(previous?.info)?.cpuSecondsTotal, info.cpuSecondsTotal, elapsedSec)
         };
         pushHistory(st, snap2);
         return snap2;
@@ -7402,12 +8766,20 @@ function rate(before, after, elapsedSec) {
   if (delta < 0) return null;
   return Math.round(delta / elapsedSec * 100) / 100;
 }
+function redisInfo(info) {
+  return info && info.backend !== "postgres" ? info : null;
+}
+function throughputCounter(info) {
+  if (!info) return null;
+  return info.backend === "postgres" ? info.totalTransactions : info.totalCommandsProcessed;
+}
 function pushHistory(st, snap) {
   if (!snap.info) return;
   st.history.push({
     t: snap.at,
     latencyMs: snap.info.latencyMs,
-    memoryBytes: snap.info.usedMemoryBytes,
+    // Postgres has no memory ceiling to plot; the database size is what grows.
+    memoryBytes: snap.info.backend === "postgres" ? snap.info.databaseSizeBytes : snap.info.usedMemoryBytes,
     commandsPerSec: snap.commandsPerSec,
     cpuCores: snap.cpuCores,
     connectedClients: snap.info.connectedClients
@@ -7463,6 +8835,34 @@ function buildWarnings(info, error, memoryUsedPct) {
   }
   return out;
 }
+function buildPostgresWarnings(info, error) {
+  if (error !== null || info === null) {
+    const detail = error?.trim();
+    return [{ level: "critical", code: "unreachable", message: detail ? `Postgres is unreachable: ${detail}` : "Postgres is unreachable" }];
+  }
+  const out = [];
+  if (info.maxConnections > 0 && info.connectedClients / info.maxConnections >= 0.9) {
+    out.push({
+      level: "critical",
+      code: "connections_high",
+      message: `${info.connectedClients} of ${info.maxConnections} connections in use: new workers will be refused`
+    });
+  } else if (info.maxConnections > 0 && info.connectedClients / info.maxConnections >= 0.75) {
+    out.push({ level: "warn", code: "connections_high", message: `${info.connectedClients} of ${info.maxConnections} connections in use` });
+  }
+  if (info.eventTableBytes >= EVENT_TABLE_WARN_BYTES) {
+    const gib = Math.round(info.eventTableBytes / 1024 ** 3 * 10) / 10;
+    out.push({
+      level: "warn",
+      code: "event_table_large",
+      message: `BullMQ's event table is ${gib} GiB and is never trimmed by BullMQ 6: delete old rows on a schedule`
+    });
+  }
+  if (info.latencyMs >= 250) {
+    out.push({ level: "warn", code: "latency_high", message: `Health query round trip took ${info.latencyMs} ms` });
+  }
+  return out;
+}
 
 // apps/server/src/ee/services/sso.ts
 import { asc as asc2, eq as eq8 } from "drizzle-orm";
@@ -8493,13 +9893,13 @@ async function waitForDatabase(database2, log, opts = {}) {
       lastError = err;
       if (database2.dialect === "sqlite") break;
       const elapsed = Math.round((Date.now() - startedAt) / 1e3);
-      log.info(`${name} not reachable yet (${elapsed}s): ${errorMessage3(err)}. Retrying in ${intervalMs / 1e3}s...`);
+      log.info(`${name} not reachable yet (${elapsed}s): ${errorMessage4(err)}. Retrying in ${intervalMs / 1e3}s...`);
       await new Promise((r) => setTimeout(r, intervalMs));
     }
   }
-  throw new Error(`${name} did not become reachable within ${timeoutMs / 1e3}s: ${errorMessage3(lastError)}`);
+  throw new Error(`${name} did not become reachable within ${timeoutMs / 1e3}s: ${errorMessage4(lastError)}`);
 }
-function errorMessage3(err) {
+function errorMessage4(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
@@ -8572,6 +9972,7 @@ async function seedDemo(ctx, log) {
   if (!connection && await ctx.connections.count() === 0) {
     const created = await ctx.connections.create({
       name: DEMO_CONNECTION_NAME,
+      kind: "redis",
       url: config.demoRedisUrl,
       prefix: "bull",
       cluster: false,
@@ -8637,7 +10038,7 @@ async function seedConnections(connections5, wanted, log) {
 async function main() {
   const config = loadConfig(process.env, { warn: (m) => console.warn(`[config] ${m}`) });
   const database2 = createDatabase(config.database);
-  const pool = createInspectorPool({
+  const pool = createInspectorPool2({
     discoveryTtlMs: config.queueDiscoveryTtl * 1e3,
     previewBytes: config.jobPreviewBytes
   });