adonisjs-server-stats 1.12.2 → 1.13.0

package/README.md

@@ -271,7 +271,7 @@ Each collector is a factory function that returns a `MetricCollector`. All colle
 | `httpCollector(opts?)`   | Requests/sec, avg response time, error rate, active connections | optional     | --                |
 | `dbPoolCollector(opts?)` | Pool used/free/pending/max connections                          | optional     | `@adonisjs/lucid` |
 | `redisCollector()`       | Status, memory, clients, keys, hit rate                         | none         | `@adonisjs/redis` |
-| `queueCollector(opts)`   | Active/waiting/delayed/failed jobs, worker count                | **required** | `bullmq`          |
+| `queueCollector(opts)`   | Active/waiting/delayed/failed jobs, worker count                | **required** | `bullmq` or `@adonisjs/queue`/`@boringnode/queue` (auto-detected) |
 | `logCollector(opts?)`    | Errors/warnings/entries (5m window), entries/minute             | optional     | --                |
 | `appCollector()`         | Online users, pending webhooks, pending emails                  | none         | `@adonisjs/lucid` |
 
@@ -673,7 +673,7 @@ The debug toolbar captures all emails sent via AdonisJS mail (`mail:sending`, `m
 
 ### Cross-Process Email Capture (Queue Workers)
 
-AdonisJS mail events (`mail:sending`, `mail:sent`, etc.) are process-local. If your app sends emails from **Bull queue workers** or other separate processes, the web server's email collector never sees them.
+AdonisJS mail events (`mail:sending`, `mail:sent`, etc.) are process-local. If your app sends emails from **queue workers** (BullMQ via `@rlanz/bull-queue`, or `@adonisjs/queue`/`@boringnode/queue`) or other separate processes, the web server's email collector never sees them.
 
 The provider handles this automatically via a **Redis pub/sub bridge**:
 
@@ -681,6 +681,8 @@ The provider handles this automatically via a **Redis pub/sub bridge**:
 2. When an email is sent, the event is published to a Redis pub/sub channel
 3. In the web server (`web` environment), the provider subscribes to the same channel and ingests the email into both the debug panel and the dashboard
 
+Worker-sent emails appear in the dashboard with HTML preview alongside emails sent from web requests — no additional configuration needed.
+
 **Requirements:**
 - `@adonisjs/redis` must be installed and configured (used for pub/sub between processes)
 - The provider must be registered **without** an `environment` restriction so it loads in all environments:
@@ -810,7 +812,7 @@ export default defineConfig({
 | **Emails**   | Email history with sender, recipient, subject, status. Click for HTML preview in iframe                                                                 |
 | **Timeline** | Per-request waterfall timeline (requires `tracing: true`)                                                                                               |
 | **Cache**    | Redis key browser with SCAN-based listing, type-aware detail view, and server stats (requires `@adonisjs/redis`)                                        |
-| **Jobs**     | Queue overview with job listing, detail, and retry for failed jobs (requires `@rlanz/bull-queue`)                                                       |
+| **Jobs**     | Queue overview with job listing, detail, and retry for failed jobs (requires `bullmq` or `@adonisjs/queue`/`@boringnode/queue` — auto-detected)         |
 | **Config**   | Sanitized view of app configuration and environment variables. Secrets are auto-redacted                                                                |
 
 #### Access Control
@@ -1069,7 +1071,9 @@ All integrations use lazy `import()` -- missing peer deps won't crash the app. T
 | `@adonisjs/transmit`        | Provider (SSE broadcast), dashboard real-time       |
 | `@adonisjs/transmit-client` | React/Vue real-time updates (falls back to polling) |
 | `@julr/adonisjs-prometheus` | `serverStatsCollector`                              |
-| `bullmq`                    | `queueCollector`                                    |
+| `bullmq`                    | `queueCollector` (BullMQ backend)                   |
+| `@adonisjs/queue`           | `queueCollector` (AdonisJS queue backend, auto-detected) |
+| `@boringnode/queue`         | `queueCollector` (AdonisJS queue backend, auto-detected) |
 | `better-sqlite3`            | Dashboard (`dashboard: true`)                       |
 | `edge.js`                   | Edge tag                                            |
 | `react`, `react-dom`        | React components (alpha)                            |

package/dist/src/collectors/adonisjs_queue_collector.d.ts

@@ -0,0 +1,21 @@
+import type { MetricCollector } from './collector.js';
+import type { QueueStoreReader } from '../dashboard/integrations/adonisjs_queue_store.js';
+/**
+ * Options for {@link adonisQueueCollector}.
+ */
+export interface AdonisQueueCollectorOptions {
+}
+/** Internal deps seam — NOT part of the public API; for unit tests only. */
+interface AdonisQueueCollectorDeps {
+    resolveReader?: () => Promise<QueueStoreReader | null>;
+}
+/**
+ * Monitors an @adonisjs/queue job queue for active, waiting, delayed, and failed jobs.
+ *
+ * Auto-detects the driver (database or redis) from the host app's queue config.
+ * Returns zeros if @adonisjs/queue is unavailable or the store cannot be reached.
+ *
+ * **Peer dependencies:** `@adonisjs/queue`
+ */
+export declare function adonisQueueCollector(_opts?: AdonisQueueCollectorOptions, deps?: AdonisQueueCollectorDeps): MetricCollector;
+export {};

package/dist/src/collectors/adonisjs_queue_collector.js

@@ -0,0 +1,61 @@
+import { resolveFromAppImport } from '../dashboard/integrations/adonisjs_queue_store.js';
+import { log, dim, bold } from '../utils/logger.js';
+/** Default metrics returned when queue data is unavailable. */
+const QUEUE_DEFAULTS = {
+    queueActive: 0,
+    queueWaiting: 0,
+    queueDelayed: 0,
+    queueFailed: 0,
+    queueWorkerCount: 0,
+};
+/**
+ * Monitors an @adonisjs/queue job queue for active, waiting, delayed, and failed jobs.
+ *
+ * Auto-detects the driver (database or redis) from the host app's queue config.
+ * Returns zeros if @adonisjs/queue is unavailable or the store cannot be reached.
+ *
+ * **Peer dependencies:** `@adonisjs/queue`
+ */
+export function adonisQueueCollector(_opts, deps) {
+    let warnedNotInstalled = false;
+    return {
+        name: 'queue',
+        label: 'queue — @adonisjs/queue (auto-detected driver)',
+        getConfig() {
+            return {
+                driver: 'auto',
+                source: '@adonisjs/queue',
+            };
+        },
+        async collect() {
+            try {
+                const resolve = deps?.resolveReader ?? resolveFromAppImport;
+                const reader = await resolve();
+                if (!reader) {
+                    if (!warnedNotInstalled) {
+                        warnedNotInstalled = true;
+                        log.block(`Queue collector ${bold('skipped')} — @adonisjs/queue is not installed or not reachable`, [
+                            dim('Queue metrics will return zeros until the package is available.'),
+                            `Run ${bold('node ace add @adonisjs/queue')} to install it.`,
+                        ]);
+                    }
+                    return QUEUE_DEFAULTS;
+                }
+                const [counts, workerCount] = await Promise.all([
+                    reader.getCounts(),
+                    reader.getWorkerCount(),
+                ]);
+                return {
+                    queueActive: counts.active,
+                    queueWaiting: counts.waiting,
+                    queueDelayed: counts.delayed,
+                    queueFailed: counts.failed,
+                    queueWorkerCount: workerCount,
+                };
+            }
+            catch {
+                return QUEUE_DEFAULTS;
+            }
+        },
+    };
+}

package/dist/src/collectors/auto_detect.js

@@ -64,15 +64,21 @@ async function registerOptionalCollectors(collectors, entries) {
         pkg: '@adonisjs/redis',
     });
     const hasBullMQ = await isInstalled('bullmq');
+    const hasAdonisQueue = hasBullMQ ? false : await isInstalled('@adonisjs/queue');
     if (hasBullMQ) {
         const { queueCollector } = await import('./queue_collector.js');
         collectors.push(queueCollector({ queueName: 'default', connection: { host: '127.0.0.1', port: 6379 } }));
     }
+    else if (hasAdonisQueue) {
+        const { adonisQueueCollector } = await import('./adonisjs_queue_collector.js');
+        collectors.push(adonisQueueCollector());
+    }
+    const queueEnabled = hasBullMQ || hasAdonisQueue;
     pushOptionalEntry(entries, {
         name: 'queue',
         description: 'jobs, wait time, throughput',
-        enabled: hasBullMQ,
-        pkg: 'bullmq',
+        enabled: queueEnabled,
+        pkg: hasBullMQ ? 'bullmq' : hasAdonisQueue ? '@adonisjs/queue' : 'bullmq',
     });
 }
 function printBootLog(entries) {

package/dist/src/collectors/index.d.ts

@@ -8,6 +8,8 @@ export type { DbPoolCollectorOptions } from './db_pool_collector.js';
 export { redisCollector } from './redis_collector.js';
 export { queueCollector } from './queue_collector.js';
 export type { QueueCollectorOptions, QueueRedisConnection } from './queue_collector.js';
+export { adonisQueueCollector } from './adonisjs_queue_collector.js';
+export type { AdonisQueueCollectorOptions } from './adonisjs_queue_collector.js';
 export { logCollector, getLogStreamService } from './log_collector.js';
 export type { LogCollectorOptions } from './log_collector.js';
 export { appCollector } from './app_collector.js';

package/dist/src/collectors/index.js

@@ -4,6 +4,7 @@ export { httpCollector, getRequestMetrics } from './http_collector.js';
 export { dbPoolCollector } from './db_pool_collector.js';
 export { redisCollector } from './redis_collector.js';
 export { queueCollector } from './queue_collector.js';
+export { adonisQueueCollector } from './adonisjs_queue_collector.js';
 export { logCollector, getLogStreamService } from './log_collector.js';
 export { appCollector } from './app_collector.js';
 export { autoDetectCollectors } from './auto_detect.js';

package/dist/src/dashboard/inspector_manager.d.ts

@@ -1,9 +1,9 @@
 import { CacheInspector } from './integrations/cache_inspector.js';
-import { QueueInspector } from './integrations/queue_inspector.js';
 import type { ApplicationService } from '@adonisjs/core/types';
+import type { QueueInspectorContract } from './integrations/queue_inspector_contract.js';
 /**
  * Manages lazy initialization and availability detection for
- * cache (Redis) and queue (BullMQ) inspectors.
+ * cache (Redis) and queue (BullMQ / @adonisjs/queue) inspectors.
  *
  * Extracted from DashboardController to reduce file size and complexity.
  */
@@ -16,8 +16,8 @@ export declare class InspectorManager {
     constructor(app: ApplicationService);
     /** Lazy-init the cache inspector. Returns null if Redis is unavailable. */
     getCacheInspector(): Promise<CacheInspector | null>;
-    /** Lazy-init the queue inspector. Returns null if BullMQ is unavailable. */
-    getQueueInspector(): Promise<QueueInspector | null>;
+    /** Lazy-init the queue inspector. Returns null if neither BullMQ nor @adonisjs/queue is available. */
+    getQueueInspector(): Promise<QueueInspectorContract | null>;
     /** Fetch cache overview stats for the overview page. */
     fetchCacheOverview(): Promise<{
         available: boolean;

package/dist/src/dashboard/inspector_manager.js

@@ -1,9 +1,10 @@
 import { log } from '../utils/logger.js';
 import { CacheInspector } from './integrations/cache_inspector.js';
 import { QueueInspector } from './integrations/queue_inspector.js';
+import { AdonisQueueInspector } from './integrations/adonisjs_queue_inspector.js';
 /**
  * Manages lazy initialization and availability detection for
- * cache (Redis) and queue (BullMQ) inspectors.
+ * cache (Redis) and queue (BullMQ / @adonisjs/queue) inspectors.
  *
  * Extracted from DashboardController to reduce file size and complexity.
  */
@@ -39,22 +40,31 @@ export class InspectorManager {
             return null;
         }
     }
-    /** Lazy-init the queue inspector. Returns null if BullMQ is unavailable. */
+    /** Lazy-init the queue inspector. Returns null if neither BullMQ nor @adonisjs/queue is available. */
     async getQueueInspector() {
         if (this.queueAvailable === false)
             return null;
         if (this.queueInspector)
             return this.queueInspector;
         try {
-            const available = await QueueInspector.isAvailable(this.app);
-            this.queueAvailable = available;
-            if (!available) {
-                log.info('dashboard: Queue not detected — Jobs panel disabled');
-                return null;
+            // Try BullMQ (@rlanz/bull-queue) first.
+            if (await QueueInspector.isAvailable(this.app)) {
+                const queue = await this.app.container.make('rlanz/queue');
+                this.queueInspector = new QueueInspector(queue);
+                this.queueAvailable = true;
+                log.info('dashboard: BullMQ detected — Jobs panel enabled');
+                return this.queueInspector;
             }
-            const queue = await this.app.container.make('rlanz/queue');
-            this.queueInspector = new QueueInspector(queue);
-            return this.queueInspector;
+            // Fall back to @adonisjs/queue.
+            if (await AdonisQueueInspector.isAvailable(this.app)) {
+                this.queueInspector = new AdonisQueueInspector(this.app);
+                this.queueAvailable = true;
+                log.info('dashboard: @adonisjs/queue detected — Jobs panel enabled');
+                return this.queueInspector;
+            }
+            this.queueAvailable = false;
+            log.info('dashboard: Queue not detected — Jobs panel disabled');
+            return null;
         }
         catch (err) {
             this.queueAvailable = false;

package/dist/src/dashboard/integrations/adonisjs_queue_inspector.d.ts

@@ -0,0 +1,42 @@
+import type { ApplicationService } from '@adonisjs/core/types';
+import type { QueueInspectorContract } from './queue_inspector_contract.js';
+import type { QueueOverview, QueueJobDetail, QueueJobListResult, JobStatus } from './queue_inspector_contract.js';
+import type { QueueStoreReader } from './adonisjs_queue_store.js';
+/**
+ * Inspects @adonisjs/queue jobs via the shared store reader.
+ *
+ * Supports both the database (Lucid/Knex) and Redis drivers.
+ * All methods catch errors and return safe defaults.
+ */
+export declare class AdonisQueueInspector implements QueueInspectorContract {
+    #private;
+    _resolveReader: (app: ApplicationService) => Promise<QueueStoreReader | null>;
+    constructor(app: ApplicationService, ...args: unknown[]);
+    /**
+     * Detect whether `@adonisjs/queue` is registered in the application container.
+     */
+    static isAvailable(app: ApplicationService): Promise<boolean>;
+    /**
+     * Get an overview of job counts by status across all queues.
+     * The @adonisjs/queue driver has no concept of paused queues, so `paused` is always 0.
+     */
+    getOverview(): Promise<QueueOverview>;
+    /**
+     * List jobs filtered by status with pagination.
+     *
+     * @param status   Job status to filter by, or `'all'` for every status.
+     * @param page     Page number (1-based).
+     * @param perPage  Jobs per page.
+     */
+    listJobs(status?: JobStatus | 'all', page?: number, perPage?: number): Promise<QueueJobListResult>;
+    /**
+     * Get full detail for a single job by ID.
+     */
+    getJob(id: string): Promise<QueueJobDetail | null>;
+    /**
+     * Retry a failed job.
+     *
+     * @returns `true` if the job was successfully requeued.
+     */
+    retryJob(id: string): Promise<boolean>;
+}

package/dist/src/dashboard/integrations/adonisjs_queue_inspector.js

@@ -0,0 +1,135 @@
+import { resolveFromApplication } from './adonisjs_queue_store.js';
+// ---------------------------------------------------------------------------
+// AdonisQueueInspector
+// ---------------------------------------------------------------------------
+/**
+ * Inspects @adonisjs/queue jobs via the shared store reader.
+ *
+ * Supports both the database (Lucid/Knex) and Redis drivers.
+ * All methods catch errors and return safe defaults.
+ */
+export class AdonisQueueInspector {
+    #app;
+    #readerPromise = null;
+    constructor(app, ...args) {
+        this.#app = app;
+        // Allow an optional second arg to inject a fake resolver in tests.
+        if (typeof args[0] === 'function') {
+            this._resolveReader = args[0];
+        }
+        else {
+            this._resolveReader = (a) => resolveFromApplication(a);
+        }
+    }
+    /**
+     * Detect whether `@adonisjs/queue` is registered in the application container.
+     */
+    static async isAvailable(app) {
+        try {
+            await app.container.make('queue.manager');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    /**
+     * Lazily resolve and cache the store reader.
+     *
+     * Memoizes the *promise* (not a boolean flag) so concurrent callers —
+     * e.g. `getOverview()` + `listJobs()` fired together via `Promise.all` —
+     * all await the same in-flight resolution instead of racing on a half-set
+     * flag and getting a still-null reader.
+     */
+    async #getReader() {
+        if (!this.#readerPromise) {
+            this.#readerPromise = this._resolveReader(this.#app);
+        }
+        return this.#readerPromise;
+    }
+    // ---------------------------------------------------------------------------
+    // QueueInspectorContract implementation
+    // ---------------------------------------------------------------------------
+    /**
+     * Get an overview of job counts by status across all queues.
+     * The @adonisjs/queue driver has no concept of paused queues, so `paused` is always 0.
+     */
+    async getOverview() {
+        const defaults = {
+            active: 0,
+            waiting: 0,
+            delayed: 0,
+            completed: 0,
+            failed: 0,
+            paused: 0,
+        };
+        try {
+            const reader = await this.#getReader();
+            if (!reader)
+                return defaults;
+            const counts = await reader.getCounts();
+            return {
+                active: counts.active,
+                waiting: counts.waiting,
+                delayed: counts.delayed,
+                completed: counts.completed,
+                failed: counts.failed,
+                paused: 0,
+            };
+        }
+        catch {
+            return defaults;
+        }
+    }
+    /**
+     * List jobs filtered by status with pagination.
+     *
+     * @param status   Job status to filter by, or `'all'` for every status.
+     * @param page     Page number (1-based).
+     * @param perPage  Jobs per page.
+     */
+    async listJobs(status = 'all', page = 1, perPage = 25) {
+        try {
+            const reader = await this.#getReader();
+            if (!reader)
+                return { jobs: [], total: 0 };
+            return await reader.listJobs(status === 'paused' ? 'all' : status, page, perPage);
+        }
+        catch {
+            return { jobs: [], total: 0 };
+        }
+    }
+    /**
+     * Get full detail for a single job by ID.
+     */
+    async getJob(id) {
+        try {
+            const reader = await this.#getReader();
+            if (!reader)
+                return null;
+            return await reader.getJob(id);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Retry a failed job.
+     *
+     * @returns `true` if the job was successfully requeued.
+     */
+    async retryJob(id) {
+        try {
+            const reader = await this.#getReader();
+            if (!reader)
+                return false;
+            return await reader.retryJob(id);
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/src/dashboard/integrations/adonisjs_queue_store.d.ts

@@ -0,0 +1,166 @@
+import type { QueueJobSummary, QueueJobDetail, QueueJobListResult } from './queue_inspector.js';
+/** JobStatus as stored in the queue_jobs table / Redis hashes. */
+type BoringJobStatus = 'pending' | 'active' | 'delayed' | 'completed' | 'failed';
+/** JobData — the JSON blob stored in queue_jobs.data / Redis ::data hash. */
+interface BoringJobData {
+    id: string;
+    name: string;
+    payload?: unknown;
+    attempts: number;
+    priority?: number;
+    nextRetryAt?: Date;
+    stalledCount?: number;
+    groupId?: string;
+    /** Unix ms timestamp set when the job was dispatched. */
+    createdAt?: number;
+    /** Not persisted per-row; best-effort from static job options. */
+    maxRetries?: number;
+    [key: string]: unknown;
+}
+/** JobRecord — returned by adapter.getJob / stored in completed|failed hashes. */
+interface BoringJobRecord {
+    status: BoringJobStatus;
+    data: BoringJobData;
+    finishedAt?: number;
+    error?: string;
+}
+/** Minimal Lucid db service interface. */
+interface LucidDb {
+    primaryConnectionName: string;
+    connection(name?: string): {
+        getWriteClient(): unknown;
+    };
+}
+/** Minimal @adonisjs/redis manager interface. */
+interface AdonisRedisManager {
+    connection(name?: string): AdonisRedisConnection;
+}
+/**
+ * Minimal ioredis-compatible connection interface.
+ * All methods present on a real ioredis client that we call.
+ */
+interface AdonisRedisConnection {
+    zcard(key: string): Promise<number>;
+    hlen(key: string): Promise<number>;
+    zrange(key: string, start: number, stop: number): Promise<string[]>;
+    hget(key: string, field: string): Promise<string | null>;
+    hscan(key: string, cursor: string, countKeyword: string, count: string): Promise<[string, string[]]>;
+    hset(key: string, field: string, value: string): Promise<number>;
+    zadd(key: string, score: number, member: string): Promise<number>;
+    hdel(key: string, field: string): Promise<number>;
+    zrem(key: string, member: string): Promise<number>;
+    zscore(key: string, member: string): Promise<string | null>;
+    hkeys(key: string): Promise<string[]>;
+}
+/** Minimal adapter interface (only what we need for driver detection). */
+interface BoringAdapter {
+    constructor: {
+        name: string;
+    };
+}
+/** Minimal QueueManagerSingleton (only what we call). */
+interface BoringQueueManager {
+    use(name?: string): BoringAdapter;
+}
+/** Config shape for @adonisjs/queue. */
+interface QueueConfig {
+    default?: string;
+    adapters?: Record<string, {
+        connectionName?: string;
+    }>;
+    queues?: Record<string, unknown>;
+}
+/** Job counts aggregated across all configured queues. */
+export interface QueueCounts {
+    active: number;
+    waiting: number;
+    delayed: number;
+    completed: number;
+    failed: number;
+}
+/** Thin interface implemented by both the database and redis readers. */
+export interface QueueStoreReader {
+    getCounts(): Promise<QueueCounts>;
+    listJobs(status: QueueJobSummary['status'] | 'all', page: number, perPage: number): Promise<QueueJobListResult>;
+    getJob(id: string): Promise<QueueJobDetail | null>;
+    retryJob(id: string): Promise<boolean>;
+    getWorkerCount(): Promise<number>;
+}
+/**
+ * Map a @boringnode `JobRecord` (plus optional DB `acquired_at` timestamp) to
+ * the `QueueJobSummary` shape used by the dashboard.
+ *
+ * Known gaps (no per-row data; documented inline):
+ *   - `progress`: always 0 — @boringnode/queue does not persist per-row progress.
+ *   - `returnValue`: always null — not stored in the queue table/hash.
+ *   - `maxAttempts`: best-effort from `data.maxRetries`; falls back to `attempts`.
+ *   - `stackTrace`: collapsed to `[record.error]`; no real stack trace in store.
+ *
+ * @param record       The raw job record from the store.
+ * @param acquiredAtMs Unix-ms timestamp from DB `acquired_at` column, or null.
+ */
+export declare function mapJobRecordToSummary(record: BoringJobRecord, acquiredAtMs: number | null): QueueJobSummary;
+/** Pre-resolved services, accepted by the factory for both call paths. */
+export interface QueueStoreReaderServices {
+    queueManager: BoringQueueManager;
+    config: QueueConfig;
+    /** Lucid db instance — required for the database driver. */
+    db?: LucidDb;
+    /** AdonisJS redis manager — required for the redis driver. */
+    redis?: AdonisRedisManager;
+    /** Override the database/redis connection name derived from config. */
+    connectionName?: string;
+}
+/**
+ * Build a {@link QueueStoreReader} from already-resolved services.
+ *
+ * Both the inspector path (`app.container.make`) and the collector path
+ * (`appImport`) resolve their own services and pass them here.
+ * Returns a safe-defaults no-op reader if driver detection fails or the
+ * required service (db or redis) is absent.
+ */
+export declare function buildQueueStoreReader(services: QueueStoreReaderServices): QueueStoreReader;
+/** Minimal shape of the AdonisJS Application instance we depend on. */
+interface ApplicationLike {
+    config: {
+        get(key: string): unknown;
+    };
+    container: {
+        make(binding: string): Promise<unknown>;
+    };
+}
+/**
+ * Resolve services from an AdonisJS Application instance and build a store reader.
+ *
+ * This is the canonical resolver: the queue config lives in the app's
+ * `config/queue.ts` (there is no package-level config export), so it can only
+ * be read from `app.config.get('queue')`. Both the inspector and collector
+ * paths funnel through here.
+ *
+ * Returns null if @adonisjs/queue is not registered (e.g. wrong environment).
+ */
+export declare function resolveFromApplication(app: ApplicationLike): Promise<QueueStoreReader | null>;
+/**
+ * Resolve services for the inspector path.
+ *
+ * Accepts either a full Application-like object (with `config` + `container`)
+ * or a bare container (legacy). When given a bare container it resolves the
+ * application via the `app` binding to read the queue config.
+ *
+ * Returns null if @adonisjs/queue is not registered (e.g. wrong environment).
+ */
+export declare function resolveFromContainer(appOrContainer: ApplicationLike | {
+    make(binding: string): Promise<unknown>;
+}): Promise<QueueStoreReader | null>;
+/**
+ * Resolve services via `appImport` and build a store reader.
+ *
+ * Designed for the collector path where no IoC container reference is held.
+ * Resolves the running Application via `@adonisjs/core/services/app` (the same
+ * service the official `@adonisjs/queue` package uses), then reads the queue
+ * config and services from it.
+ *
+ * Returns null if @adonisjs/queue is not installed in the host application.
+ */
+export declare function resolveFromAppImport(): Promise<QueueStoreReader | null>;
+export {};