bunqueue 2.4.8 → 2.5.1

package/dist/mcp/adapter.js

@@ -0,0 +1,695 @@
+/* eslint-disable @typescript-eslint/no-unnecessary-condition, @typescript-eslint/no-unnecessary-type-conversion, @typescript-eslint/no-base-to-string, @typescript-eslint/prefer-readonly, @typescript-eslint/require-await */
+/**
+ * MCP Backend Adapter
+ * Abstraction layer for embedded (SQLite direct) and TCP (remote server) modes.
+ */
+import { jobId as toJobId } from '../domain/types/job';
+/** Serialize a Job to a plain object */
+function serializeJob(job) {
+    return {
+        id: String(job.id),
+        queue: job.queue,
+        data: job.data,
+        priority: job.priority,
+        progress: job.progress,
+        attempts: job.attempts,
+        maxAttempts: job.maxAttempts,
+        createdAt: new Date(job.createdAt).toISOString(),
+        startedAt: job.startedAt ? new Date(job.startedAt).toISOString() : undefined,
+    };
+}
+function serializeCron(c) {
+    return {
+        name: c.name,
+        queue: c.queue,
+        schedule: c.schedule ?? undefined,
+        repeatEvery: c.repeatEvery ?? undefined,
+        nextRun: c.nextRun ? new Date(c.nextRun).toISOString() : null,
+        executions: c.executions,
+    };
+}
+// ============ Embedded Backend ============
+import { getSharedManager, shutdownManager } from '../client/manager';
+export class EmbeddedBackend {
+    get manager() {
+        return getSharedManager();
+    }
+    async addJob(queue, name, data, opts) {
+        const job = await this.manager.push(queue, {
+            data: { name, ...data },
+            priority: opts?.priority,
+            delay: opts?.delay,
+            maxAttempts: opts?.attempts,
+        });
+        return { jobId: String(job.id) };
+    }
+    async addJobsBulk(queue, jobs) {
+        const inputs = jobs.map((j) => ({
+            data: { name: j.name, ...j.data },
+            priority: j.priority,
+            delay: j.delay,
+        }));
+        const ids = await this.manager.pushBatch(queue, inputs);
+        return { jobIds: ids.map(String) };
+    }
+    async getJob(id) {
+        const job = await this.manager.getJob(toJobId(id));
+        return job ? serializeJob(job) : null;
+    }
+    getJobState(id) {
+        return Promise.resolve(this.manager.getJobState(toJobId(id)));
+    }
+    getJobResult(id) {
+        return Promise.resolve(this.manager.getResult(toJobId(id)));
+    }
+    cancelJob(id) {
+        return Promise.resolve(this.manager.cancel(toJobId(id)));
+    }
+    promoteJob(id) {
+        return Promise.resolve(this.manager.promote(toJobId(id)));
+    }
+    updateProgress(id, progress, message) {
+        return Promise.resolve(this.manager.updateProgress(toJobId(id), progress, message));
+    }
+    updateJobData(id, data) {
+        return Promise.resolve(this.manager.updateJobData(toJobId(id), data));
+    }
+    changeJobPriority(id, priority) {
+        return Promise.resolve(this.manager.changePriority(toJobId(id), priority));
+    }
+    moveToDelayed(id, delay) {
+        return Promise.resolve(this.manager.moveToDelayed(toJobId(id), delay));
+    }
+    discardJob(id) {
+        return Promise.resolve(this.manager.discard(toJobId(id)));
+    }
+    getChildrenValues(parentJobId) {
+        return Promise.resolve(this.manager.getChildrenValues(toJobId(parentJobId)));
+    }
+    getJobByCustomId(customId) {
+        const job = this.manager.getJobByCustomId(customId);
+        return Promise.resolve(job ? serializeJob(job) : null);
+    }
+    waitForJobCompletion(id, timeoutMs) {
+        return this.manager.waitForJobCompletion(toJobId(id), timeoutMs);
+    }
+    async pullJob(queue, timeoutMs) {
+        const job = await this.manager.pull(queue, timeoutMs);
+        return job ? serializeJob(job) : null;
+    }
+    async pullJobBatch(queue, count, timeoutMs) {
+        const jobs = await this.manager.pullBatch(queue, count, timeoutMs);
+        return jobs.map(serializeJob);
+    }
+    async ackJob(id, result) {
+        await this.manager.ack(toJobId(id), result);
+    }
+    async ackJobBatch(ids) {
+        await this.manager.ackBatch(ids.map(toJobId));
+    }
+    async failJob(id, error) {
+        await this.manager.fail(toJobId(id), error);
+    }
+    jobHeartbeat(id) {
+        return Promise.resolve(this.manager.jobHeartbeat(toJobId(id)));
+    }
+    jobHeartbeatBatch(ids) {
+        return Promise.resolve(this.manager.jobHeartbeatBatch(ids.map(toJobId)));
+    }
+    getProgress(id) {
+        return Promise.resolve(this.manager.getProgress(toJobId(id)));
+    }
+    changeDelay(id, delay) {
+        return Promise.resolve(this.manager.changeDelay(toJobId(id), delay));
+    }
+    extendLock(id, token, duration) {
+        return Promise.resolve(this.manager.extendLock(toJobId(id), token, duration));
+    }
+    getJobs(queue, opts) {
+        const jobs = this.manager.getJobs(queue, {
+            state: opts?.state,
+            start: opts?.start,
+            end: opts?.end,
+        });
+        return Promise.resolve(jobs.map(serializeJob));
+    }
+    getJobCounts(queue) {
+        return Promise.resolve(this.manager.getQueueJobCounts(queue));
+    }
+    pauseQueue(queue) {
+        this.manager.pause(queue);
+        return Promise.resolve();
+    }
+    resumeQueue(queue) {
+        this.manager.resume(queue);
+        return Promise.resolve();
+    }
+    drainQueue(queue) {
+        return Promise.resolve(this.manager.drain(queue));
+    }
+    obliterateQueue(queue) {
+        this.manager.obliterate(queue);
+        return Promise.resolve();
+    }
+    listQueues() {
+        return Promise.resolve(this.manager.listQueues());
+    }
+    countJobs(queue) {
+        return Promise.resolve(this.manager.count(queue));
+    }
+    cleanQueue(queue, graceMs, state, limit) {
+        return Promise.resolve(this.manager.clean(queue, graceMs, state, limit));
+    }
+    isPaused(queue) {
+        return Promise.resolve(this.manager.isPaused(queue));
+    }
+    getCountsPerPriority(queue) {
+        return Promise.resolve(this.manager.getCountsPerPriority(queue));
+    }
+    getDlq(queue, limit) {
+        return Promise.resolve(this.manager.getDlq(queue, limit).map(serializeJob));
+    }
+    retryDlq(queue, id) {
+        return Promise.resolve(this.manager.retryDlq(queue, id ? toJobId(id) : undefined));
+    }
+    purgeDlq(queue) {
+        return Promise.resolve(this.manager.purgeDlq(queue));
+    }
+    retryCompleted(queue, id) {
+        return Promise.resolve(this.manager.retryCompleted(queue, id ? toJobId(id) : undefined));
+    }
+    setRateLimit(queue, limit) {
+        this.manager.setRateLimit(queue, limit);
+        return Promise.resolve();
+    }
+    clearRateLimit(queue) {
+        this.manager.clearRateLimit(queue);
+        return Promise.resolve();
+    }
+    setConcurrency(queue, limit) {
+        this.manager.setConcurrency(queue, limit);
+        return Promise.resolve();
+    }
+    clearConcurrency(queue) {
+        this.manager.clearConcurrency(queue);
+        return Promise.resolve();
+    }
+    addCron(input) {
+        const cron = this.manager.addCron(input);
+        return Promise.resolve(serializeCron(cron));
+    }
+    listCrons() {
+        return Promise.resolve(this.manager.listCrons().map(serializeCron));
+    }
+    getCron(name) {
+        const cron = this.manager.getCron(name);
+        return Promise.resolve(cron ? serializeCron(cron) : null);
+    }
+    deleteCron(name) {
+        return Promise.resolve(this.manager.removeCron(name));
+    }
+    addWebhook(url, events, queue) {
+        const wh = this.manager.webhookManager.add(url, events, queue);
+        return Promise.resolve({
+            id: String(wh.id),
+            url: wh.url,
+            events: wh.events,
+            queue: wh.queue ?? undefined,
+            enabled: wh.enabled,
+        });
+    }
+    removeWebhook(id) {
+        return Promise.resolve(this.manager.webhookManager.remove(id));
+    }
+    listWebhooks() {
+        return Promise.resolve(this.manager.webhookManager.list().map((wh) => ({
+            id: String(wh.id),
+            url: wh.url,
+            events: wh.events,
+            queue: wh.queue ?? undefined,
+            enabled: wh.enabled,
+        })));
+    }
+    setWebhookEnabled(id, enabled) {
+        return Promise.resolve(this.manager.webhookManager.setEnabled(id, enabled));
+    }
+    registerWorker(name, queues) {
+        const w = this.manager.workerManager.register(name, queues);
+        return Promise.resolve({
+            id: String(w.id),
+            name: w.name,
+            queues: w.queues,
+            active: w.activeJobs,
+            processed: w.processedJobs,
+            failed: w.failedJobs,
+            lastHeartbeat: w.lastSeen,
+        });
+    }
+    unregisterWorker(id) {
+        return Promise.resolve(this.manager.workerManager.unregister(id));
+    }
+    workerHeartbeat(id) {
+        return Promise.resolve(this.manager.workerManager.heartbeat(id));
+    }
+    getStats() {
+        const stats = this.manager.getStats();
+        return Promise.resolve(JSON.parse(JSON.stringify(stats, (_key, value) => typeof value === 'bigint' ? Number(value) : value)));
+    }
+    listWorkers() {
+        return Promise.resolve(this.manager.workerManager.list().map((w) => ({
+            id: String(w.id),
+            name: w.name,
+            queues: w.queues,
+            active: w.activeJobs,
+            processed: w.processedJobs,
+            failed: w.failedJobs,
+            lastHeartbeat: w.lastSeen,
+        })));
+    }
+    getJobLogs(id) {
+        return Promise.resolve(this.manager.getLogs(toJobId(id)));
+    }
+    addJobLog(id, message, level) {
+        return Promise.resolve(this.manager.addLog(toJobId(id), message, level));
+    }
+    getPerQueueStats() {
+        const stats = this.manager.getPerQueueStats();
+        const result = {};
+        for (const [k, v] of stats)
+            result[k] = v;
+        return Promise.resolve(result);
+    }
+    getMemoryStats() {
+        return Promise.resolve(this.manager.getMemoryStats());
+    }
+    getPrometheusMetrics() {
+        return Promise.resolve(this.manager.getPrometheusMetrics());
+    }
+    getStorageStatus() {
+        const status = this.manager.getStorageStatus();
+        return Promise.resolve({ diskFull: status.diskFull, error: status.error });
+    }
+    clearJobLogs(id, keepLogs) {
+        this.manager.clearLogs(toJobId(id), keepLogs);
+        return Promise.resolve();
+    }
+    compactMemory() {
+        this.manager.compactMemory();
+        return Promise.resolve();
+    }
+    shutdown() {
+        shutdownManager();
+    }
+}
+// ============ TCP Backend ============
+import { TcpConnectionPool } from '../client/tcpPool';
+export class TcpBackend {
+    pool;
+    constructor(opts) {
+        this.pool = new TcpConnectionPool({
+            host: opts.host ?? 'localhost',
+            port: opts.port ?? 6789,
+            token: opts.token,
+            poolSize: 2,
+        });
+    }
+    async connect() {
+        await this.pool.connect();
+    }
+    async send(cmd) {
+        return this.pool.send(cmd);
+    }
+    parseJob(j) {
+        return {
+            id: String(j.id),
+            queue: j.queue ?? '',
+            data: j.data,
+            priority: j.priority ?? 0,
+            progress: j.progress ?? 0,
+            attempts: j.attempts ?? 0,
+            maxAttempts: j.maxAttempts ?? 3,
+            createdAt: j.createdAt
+                ? new Date(j.createdAt).toISOString()
+                : new Date().toISOString(),
+            startedAt: j.startedAt ? new Date(j.startedAt).toISOString() : undefined,
+        };
+    }
+    async addJob(queue, name, data, opts) {
+        const res = await this.send({
+            cmd: 'PUSH',
+            queue,
+            data: { name, ...data },
+            priority: opts?.priority,
+            delay: opts?.delay,
+            maxAttempts: opts?.attempts,
+        });
+        return { jobId: String(res.id) };
+    }
+    async addJobsBulk(queue, jobs) {
+        const res = await this.send({
+            cmd: 'PUSHB',
+            queue,
+            jobs: jobs.map((j) => ({
+                data: { name: j.name, ...j.data },
+                priority: j.priority,
+                delay: j.delay,
+            })),
+        });
+        return { jobIds: (res.ids ?? []).map(String) };
+    }
+    async getJob(id) {
+        const res = await this.send({ cmd: 'GetJob', id });
+        if (!res.job)
+            return null;
+        return this.parseJob(res.job);
+    }
+    async getJobState(id) {
+        const res = await this.send({ cmd: 'GetState', id });
+        return res.state ?? 'unknown';
+    }
+    async getJobResult(id) {
+        const res = await this.send({ cmd: 'GetResult', id });
+        return res.result;
+    }
+    async cancelJob(id) {
+        const res = await this.send({ cmd: 'Cancel', id });
+        return res.ok ?? false;
+    }
+    async promoteJob(id) {
+        const res = await this.send({ cmd: 'Promote', id });
+        return res.ok ?? false;
+    }
+    async updateProgress(id, progress, message) {
+        const res = await this.send({ cmd: 'Progress', id, progress, message });
+        return res.ok ?? false;
+    }
+    async updateJobData(id, data) {
+        const res = await this.send({ cmd: 'Update', id, data });
+        return res.ok ?? false;
+    }
+    async changeJobPriority(id, priority) {
+        const res = await this.send({ cmd: 'ChangePriority', id, priority });
+        return res.ok ?? false;
+    }
+    async moveToDelayed(id, delay) {
+        const res = await this.send({ cmd: 'MoveToDelayed', id, delay });
+        return res.ok ?? false;
+    }
+    async discardJob(id) {
+        const res = await this.send({ cmd: 'Discard', id });
+        return res.ok ?? false;
+    }
+    async getChildrenValues(parentJobId) {
+        // TCP doesn't have a direct command for this; get job and iterate children
+        const res = await this.send({ cmd: 'GetJob', id: parentJobId });
+        if (!res.job)
+            return {};
+        const job = res.job;
+        const childrenIds = job.childrenIds ?? [];
+        const results = {};
+        for (const childId of childrenIds) {
+            const childRes = await this.send({ cmd: 'GetResult', id: childId });
+            if (childRes.result !== undefined) {
+                const childJob = await this.send({ cmd: 'GetJob', id: childId });
+                const queue = childJob.job?.queue ?? '';
+                results[`${queue}:${childId}`] = childRes.result;
+            }
+        }
+        return results;
+    }
+    async getJobByCustomId(customId) {
+        const res = await this.send({ cmd: 'GetJobByCustomId', customId });
+        if (!res.job)
+            return null;
+        return this.parseJob(res.job);
+    }
+    async waitForJobCompletion(id, timeoutMs) {
+        const res = await this.send({ cmd: 'WaitJob', id, timeout: timeoutMs });
+        return res.ok ?? false;
+    }
+    async getProgress(id) {
+        const res = await this.send({ cmd: 'GetProgress', id });
+        if (res.progress === undefined)
+            return null;
+        return {
+            progress: res.progress ?? 0,
+            message: res.message ?? null,
+        };
+    }
+    async changeDelay(id, delay) {
+        const res = await this.send({ cmd: 'MoveToDelayed', id, delay });
+        return res.ok ?? false;
+    }
+    async extendLock(id, token, duration) {
+        const res = await this.send({ cmd: 'JobHeartbeat', id, token, duration });
+        return res.ok ?? false;
+    }
+    async pullJob(queue, timeoutMs) {
+        const res = await this.send({ cmd: 'PULL', queue, timeout: timeoutMs });
+        if (!res.job)
+            return null;
+        return this.parseJob(res.job);
+    }
+    async pullJobBatch(queue, count, timeoutMs) {
+        const res = await this.send({ cmd: 'PULLB', queue, count, timeout: timeoutMs });
+        return (res.jobs ?? []).map((j) => this.parseJob(j));
+    }
+    async ackJob(id, result) {
+        await this.send({ cmd: 'ACK', id, result });
+    }
+    async ackJobBatch(ids) {
+        await this.send({ cmd: 'ACKB', ids });
+    }
+    async failJob(id, error) {
+        await this.send({ cmd: 'FAIL', id, error });
+    }
+    async jobHeartbeat(id) {
+        const res = await this.send({ cmd: 'JobHeartbeat', id });
+        return res.ok ?? false;
+    }
+    async jobHeartbeatBatch(ids) {
+        const res = await this.send({ cmd: 'JobHeartbeatB', ids });
+        return res.count ?? 0;
+    }
+    async getJobs(queue, opts) {
+        const res = await this.send({ cmd: 'GetJobs', queue, ...opts });
+        return (res.jobs ?? []).map((j) => this.parseJob(j));
+    }
+    async getJobCounts(queue) {
+        const res = await this.send({ cmd: 'GetJobCounts', queue });
+        return {
+            waiting: res.waiting ?? 0,
+            delayed: res.delayed ?? 0,
+            active: res.active ?? 0,
+            completed: res.completed ?? 0,
+            failed: res.failed ?? 0,
+        };
+    }
+    async pauseQueue(queue) {
+        await this.send({ cmd: 'Pause', queue });
+    }
+    async resumeQueue(queue) {
+        await this.send({ cmd: 'Resume', queue });
+    }
+    async drainQueue(queue) {
+        const res = await this.send({ cmd: 'Drain', queue });
+        return res.removed ?? 0;
+    }
+    async obliterateQueue(queue) {
+        await this.send({ cmd: 'Obliterate', queue });
+    }
+    async listQueues() {
+        const res = await this.send({ cmd: 'ListQueues' });
+        return res.queues ?? [];
+    }
+    async countJobs(queue) {
+        const res = await this.send({ cmd: 'Count', queue });
+        return res.count ?? 0;
+    }
+    async cleanQueue(queue, graceMs, state, limit) {
+        const res = await this.send({ cmd: 'Clean', queue, grace: graceMs, state, limit });
+        return res.removed ?? 0;
+    }
+    async isPaused(queue) {
+        const res = await this.send({ cmd: 'IsPaused', queue });
+        return res.paused ?? false;
+    }
+    async getCountsPerPriority(queue) {
+        const res = await this.send({ cmd: 'GetCountsPerPriority', queue });
+        return res.counts ?? {};
+    }
+    async getDlq(queue, limit) {
+        const res = await this.send({ cmd: 'Dlq', queue, count: limit });
+        return (res.jobs ?? []).map((j) => this.parseJob(j));
+    }
+    async retryDlq(queue, id) {
+        const res = await this.send({ cmd: 'RetryDlq', queue, id });
+        return res.retried ?? 0;
+    }
+    async purgeDlq(queue) {
+        const res = await this.send({ cmd: 'PurgeDlq', queue });
+        return res.purged ?? 0;
+    }
+    async retryCompleted(queue, id) {
+        const res = await this.send({ cmd: 'RetryCompleted', queue, id });
+        return res.retried ?? 0;
+    }
+    async setRateLimit(queue, limit) {
+        await this.send({ cmd: 'RateLimit', queue, limit });
+    }
+    async clearRateLimit(queue) {
+        await this.send({ cmd: 'RateLimitClear', queue });
+    }
+    async setConcurrency(queue, limit) {
+        await this.send({ cmd: 'SetConcurrency', queue, limit });
+    }
+    async clearConcurrency(queue) {
+        await this.send({ cmd: 'ClearConcurrency', queue });
+    }
+    async addCron(input) {
+        const res = await this.send({ cmd: 'Cron', ...input });
+        return {
+            name: input.name,
+            queue: input.queue,
+            schedule: input.schedule ?? undefined,
+            repeatEvery: input.repeatEvery ?? undefined,
+            nextRun: res.nextRun ? new Date(res.nextRun).toISOString() : null,
+            executions: 0,
+        };
+    }
+    async listCrons() {
+        const res = await this.send({ cmd: 'CronList' });
+        return (res.crons ?? []).map((c) => ({
+            name: c.name,
+            queue: c.queue,
+            schedule: c.schedule,
+            repeatEvery: c.repeatEvery,
+            nextRun: c.nextRun ? new Date(c.nextRun).toISOString() : null,
+            executions: c.executions ?? 0,
+        }));
+    }
+    async getCron(name) {
+        const res = await this.send({ cmd: 'CronList' });
+        const crons = res.crons ?? [];
+        const c = crons.find((cr) => cr.name === name);
+        if (!c)
+            return null;
+        return {
+            name: c.name,
+            queue: c.queue,
+            schedule: c.schedule,
+            repeatEvery: c.repeatEvery,
+            nextRun: c.nextRun ? new Date(c.nextRun).toISOString() : null,
+            executions: c.executions ?? 0,
+        };
+    }
+    async deleteCron(name) {
+        const res = await this.send({ cmd: 'CronDelete', name });
+        return res.ok ?? true;
+    }
+    async addWebhook(url, events, queue) {
+        const res = await this.send({ cmd: 'AddWebhook', url, events, queue });
+        return { id: String(res.id ?? '0'), url, events, queue, enabled: true };
+    }
+    async removeWebhook(id) {
+        const res = await this.send({ cmd: 'RemoveWebhook', id });
+        return res.ok ?? true;
+    }
+    async listWebhooks() {
+        const res = await this.send({ cmd: 'ListWebhooks' });
+        return (res.webhooks ?? []).map((wh) => ({
+            id: String(wh.id),
+            url: wh.url,
+            events: wh.events ?? [],
+            queue: wh.queue,
+            enabled: wh.enabled ?? true,
+        }));
+    }
+    async getStats() {
+        return this.send({ cmd: 'Stats' });
+    }
+    async listWorkers() {
+        const res = await this.send({ cmd: 'ListWorkers' });
+        return (res.workers ?? []).map((w) => ({
+            id: String(w.id),
+            name: w.name,
+            queues: w.queues ?? [],
+            active: w.activeJobs ?? 0,
+            processed: w.processed ?? 0,
+            failed: w.failed ?? 0,
+            lastHeartbeat: w.lastHeartbeat ?? 0,
+        }));
+    }
+    async getJobLogs(id) {
+        const res = await this.send({ cmd: 'GetLogs', id });
+        return res.logs ?? [];
+    }
+    async addJobLog(id, message, level) {
+        const res = await this.send({ cmd: 'AddLog', id, message, level });
+        return res.ok ?? true;
+    }
+    async setWebhookEnabled(id, enabled) {
+        const res = await this.send({ cmd: 'SetWebhookEnabled', id, enabled });
+        return res.ok ?? true;
+    }
+    async registerWorker(name, queues) {
+        const res = await this.send({ cmd: 'RegisterWorker', name, queues });
+        return {
+            id: String(res.id ?? '0'),
+            name,
+            queues,
+            active: 0,
+            processed: 0,
+            failed: 0,
+            lastHeartbeat: Date.now(),
+        };
+    }
+    async unregisterWorker(id) {
+        const res = await this.send({ cmd: 'UnregisterWorker', id });
+        return res.ok ?? true;
+    }
+    async workerHeartbeat(id) {
+        const res = await this.send({ cmd: 'Heartbeat', id });
+        return res.ok ?? true;
+    }
+    async getPerQueueStats() {
+        const res = await this.send({ cmd: 'Metrics' });
+        return res.queues ?? res;
+    }
+    async getMemoryStats() {
+        const res = await this.send({ cmd: 'Stats' });
+        return res.memory ?? {};
+    }
+    async getPrometheusMetrics() {
+        const res = await this.send({ cmd: 'Prometheus' });
+        return res.metrics ?? '';
+    }
+    async clearJobLogs(id, _keepLogs) {
+        await this.send({ cmd: 'ClearLogs', id });
+    }
+    async compactMemory() {
+        await this.send({ cmd: 'CompactMemory' });
+    }
+    async getStorageStatus() {
+        // TCP mode doesn't have direct access to storage health; return healthy default
+        return { diskFull: false, error: null };
+    }
+    shutdown() {
+        this.pool.close();
+    }
+}
+/** Create backend based on environment configuration */
+export async function createBackend() {
+    const mode = process.env.BUNQUEUE_MODE ?? 'embedded';
+    if (mode === 'tcp') {
+        const backend = new TcpBackend({
+            host: process.env.BUNQUEUE_HOST,
+            port: process.env.BUNQUEUE_PORT ? parseInt(process.env.BUNQUEUE_PORT, 10) : undefined,
+            token: process.env.BUNQUEUE_TOKEN,
+        });
+        await backend.connect();
+        return backend;
+    }
+    return new EmbeddedBackend();
+}
+//# sourceMappingURL=adapter.js.map