@furystack/redis-task-runner 1.0.0

package/esm/redis-queue-adapter.unit.spec.js

@@ -0,0 +1,860 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { describe, expect, it, vi } from 'vitest';
+import { RedisQueueAdapter } from './redis-queue-adapter.js';
+/**
+ * Default mocks for the redis client. `xReadGroup` simulates BLOCK
+ * by awaiting `opts.BLOCK` ms before resolving — without this the
+ * slot loop spins as fast as possible and `mock.calls` accumulates
+ * unbounded (OOMs vitest).
+ */
+const buildClient = (overrides = {}) => {
+    const client = {
+        xAdd: vi.fn().mockResolvedValue('1-0'),
+        xGroupCreate: vi.fn().mockResolvedValue('OK'),
+        xReadGroup: vi.fn().mockImplementation(async (_g, _c, _streams, opts) => {
+            if (opts?.BLOCK)
+                await new Promise((r) => setTimeout(r, opts.BLOCK));
+            return null;
+        }),
+        xAutoClaim: vi.fn().mockImplementation(async () => {
+            await new Promise((r) => setTimeout(r, 1));
+            return { nextId: '0-0', messages: [] };
+        }),
+        xAck: vi.fn().mockResolvedValue(1),
+        xClaimJustId: vi.fn().mockResolvedValue([]),
+        set: vi.fn().mockResolvedValue('OK'),
+        get: vi.fn().mockResolvedValue(null),
+        zAdd: vi.fn().mockResolvedValue(1),
+        zRem: vi.fn().mockResolvedValue(1),
+        eval: vi.fn().mockResolvedValue(0),
+        duplicate: vi.fn(),
+        connect: vi.fn(),
+        destroy: vi.fn(),
+        isOpen: true,
+        ...overrides,
+    };
+    // The adapter duplicates the client for its blocking read loop. Return the
+    // same mock so blocking-read / reclaim assertions still observe the calls.
+    client.duplicate = vi.fn(() => client);
+    client.connect = vi.fn().mockResolvedValue(client);
+    return client;
+};
+const makeAdapter = (client, prefix = 'svc-a/', schedulerIntervalMs = 1_000_000, concurrencyLimits) => {
+    return new RedisQueueAdapter({
+        client: client,
+        serviceName: 'svc-a',
+        topicPrefix: prefix,
+        blockTimeoutMs: 5,
+        retryBackoffMs: 5,
+        // Disable the auto-tick by default — tests that exercise the
+        // scheduler trigger it manually via internal test hooks. A huge
+        // value keeps `setInterval` cheap without rewriting timer plumbing.
+        schedulerIntervalMs,
+        concurrencyLimits,
+    });
+};
+describe('RedisQueueAdapter', () => {
+    describe('capabilities', () => {
+        it('declares persistent + distributed + brokerSideReclaim + delayedDispatch', () => {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const adapter = __addDisposableResource(env_1, makeAdapter(buildClient()), false);
+                expect(adapter.capabilities.persistent).toBe(true);
+                expect(adapter.capabilities.distributed).toBe(true);
+                expect(adapter.capabilities.brokerSideReclaim).toBe(true);
+                expect(adapter.capabilities.delayedDispatch).toBe(true);
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
+        });
+        it('declares fleetCapEnforcement support', () => {
+            const env_2 = { stack: [], error: void 0, hasError: false };
+            try {
+                const adapter = __addDisposableResource(env_2, makeAdapter(buildClient()), false);
+                expect(adapter.capabilities.fleetCapEnforcement).toBe(true);
+            }
+            catch (e_2) {
+                env_2.error = e_2;
+                env_2.hasError = true;
+            }
+            finally {
+                __disposeResources(env_2);
+            }
+        });
+    });
+    describe('fleet cap', () => {
+        it('admits a claim via the cap script and releases the slot after onClaim', async () => {
+            const env_3 = { stack: [], error: void 0, hasError: false };
+            try {
+                const onClaim = vi.fn().mockResolvedValue({ kind: 'success' });
+                const xReadGroup = oneShotXReadGroup({
+                    stream: 'svc-a/tasks:queue:echo:v1',
+                    message: { id: '1-0', fields: { taskId: 't1', type: 'echo', handlerVersion: '1' } },
+                });
+                // eval resolves 1 → admitted.
+                const client = buildClient({ xReadGroup, eval: vi.fn().mockResolvedValue(1) });
+                const adapter = __addDisposableResource(env_3, makeAdapter(client, 'svc-a/', 1_000_000, { echo: 2 }), false);
+                const sub = __addDisposableResource(env_3, adapter.subscribe({
+                    workerId: 'w-1',
+                    concurrency: 1,
+                    tags: [],
+                    types: ['echo'],
+                    compatibleVersions: { echo: [1] },
+                    shouldDrain: () => false,
+                    onClaim,
+                }), false);
+                void sub;
+                await waitFor(() => onClaim.mock.calls.length > 0, 1000);
+                const evalCall = client.eval.mock.calls[0];
+                expect(evalCall[1].keys).toEqual(['svc-a/tasks:cap:echo']);
+                // ARGV[2] is the cap.
+                expect(evalCall[1].arguments[1]).toBe('2');
+                await waitFor(() => client.zRem.mock.calls.length > 0, 1000);
+                expect(client.zRem).toHaveBeenCalledWith('svc-a/tasks:cap:echo', 'w-1-slot-0:1-0');
+            }
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
+            }
+            finally {
+                __disposeResources(env_3);
+            }
+        });
+        it('releases the entry back to the stream without running onClaim when the lane is full', async () => {
+            const env_4 = { stack: [], error: void 0, hasError: false };
+            try {
+                const onClaim = vi.fn().mockResolvedValue({ kind: 'success' });
+                const xReadGroup = oneShotXReadGroup({
+                    stream: 'svc-a/tasks:queue:echo:v1',
+                    message: { id: '1-0', fields: { taskId: 't1', type: 'echo', handlerVersion: '1' } },
+                });
+                // eval resolves 0 → lane full.
+                const client = buildClient({ xReadGroup, eval: vi.fn().mockResolvedValue(0) });
+                const adapter = __addDisposableResource(env_4, makeAdapter(client, 'svc-a/', 1_000_000, { echo: 1 }), false);
+                const sub = __addDisposableResource(env_4, adapter.subscribe({
+                    workerId: 'w-1',
+                    concurrency: 1,
+                    tags: [],
+                    types: ['echo'],
+                    compatibleVersions: { echo: [1] },
+                    shouldDrain: () => false,
+                    onClaim,
+                }), false);
+                void sub;
+                await waitFor(() => client.xAdd.mock.calls.length > 0, 1000);
+                expect(onClaim).not.toHaveBeenCalled();
+                expect(client.xAck).toHaveBeenCalledWith('svc-a/tasks:queue:echo:v1', 'runner', '1-0');
+                expect(client.xAdd).toHaveBeenCalledWith('svc-a/tasks:queue:echo:v1', '*', {
+                    taskId: 't1',
+                    type: 'echo',
+                    handlerVersion: '1',
+                });
+                // Slot never admitted → nothing to release.
+                expect(client.zRem).not.toHaveBeenCalled();
+            }
+            catch (e_4) {
+                env_4.error = e_4;
+                env_4.hasError = true;
+            }
+            finally {
+                __disposeResources(env_4);
+            }
+        });
+        it('does not consult the cap script for uncapped types', async () => {
+            const env_5 = { stack: [], error: void 0, hasError: false };
+            try {
+                const onClaim = vi.fn().mockResolvedValue({ kind: 'success' });
+                const xReadGroup = oneShotXReadGroup({
+                    stream: 'svc-a/tasks:queue:echo:v1',
+                    message: { id: '1-0', fields: { taskId: 't1', type: 'echo', handlerVersion: '1' } },
+                });
+                const client = buildClient({ xReadGroup });
+                const adapter = __addDisposableResource(env_5, makeAdapter(client, 'svc-a/', 1_000_000), false);
+                const sub = __addDisposableResource(env_5, adapter.subscribe({
+                    workerId: 'w-1',
+                    concurrency: 1,
+                    tags: [],
+                    types: ['echo'],
+                    compatibleVersions: { echo: [1] },
+                    shouldDrain: () => false,
+                    onClaim,
+                }), false);
+                void sub;
+                await waitFor(() => onClaim.mock.calls.length > 0, 1000);
+                expect(client.eval).not.toHaveBeenCalled();
+                expect(client.zRem).not.toHaveBeenCalled();
+            }
+            catch (e_5) {
+                env_5.error = e_5;
+                env_5.hasError = true;
+            }
+            finally {
+                __disposeResources(env_5);
+            }
+        });
+        it('refreshes the holder lease on heartbeat for capped types', async () => {
+            const env_6 = { stack: [], error: void 0, hasError: false };
+            try {
+                const client = buildClient();
+                const adapter = __addDisposableResource(env_6, makeAdapter(client, 'svc-a/', 1_000_000, { echo: 2 }), false);
+                await adapter.heartbeat({
+                    taskId: 't1',
+                    type: 'echo',
+                    receipt: { stream: 'svc-a/tasks:queue:echo:v1', msgId: '1-0', consumer: 'w-0', deliveryCount: 0 },
+                });
+                expect(client.zAdd).toHaveBeenCalledWith('svc-a/tasks:cap:echo', expect.objectContaining({ value: 'w-0:1-0' }), {
+                    XX: true,
+                });
+            }
+            catch (e_6) {
+                env_6.error = e_6;
+                env_6.hasError = true;
+            }
+            finally {
+                __disposeResources(env_6);
+            }
+        });
+        it('does not refresh a holder lease on heartbeat for uncapped types', async () => {
+            const env_7 = { stack: [], error: void 0, hasError: false };
+            try {
+                const client = buildClient();
+                const adapter = __addDisposableResource(env_7, makeAdapter(client), false);
+                await adapter.heartbeat({
+                    taskId: 't1',
+                    type: 'echo',
+                    receipt: { stream: 'svc-a/tasks:queue:echo:v1', msgId: '1-0', consumer: 'w-0', deliveryCount: 0 },
+                });
+                expect(client.zAdd).not.toHaveBeenCalled();
+            }
+            catch (e_7) {
+                env_7.error = e_7;
+                env_7.hasError = true;
+            }
+            finally {
+                __disposeResources(env_7);
+            }
+        });
+    });
+    describe('enqueue', () => {
+        it('writes to per-(type,version) stream with the documented field shape', async () => {
+            const env_8 = { stack: [], error: void 0, hasError: false };
+            try {
+                const client = buildClient();
+                const adapter = __addDisposableResource(env_8, makeAdapter(client), false);
+                await adapter.enqueue({ taskId: 'task-1', type: 'video-encode', handlerVersion: 2 });
+                expect(client.xGroupCreate).toHaveBeenCalledWith('svc-a/tasks:queue:video-encode:v2', 'runner', '$', {
+                    MKSTREAM: true,
+                });
+                expect(client.xAdd).toHaveBeenCalledWith('svc-a/tasks:queue:video-encode:v2', '*', {
+                    taskId: 'task-1',
+                    type: 'video-encode',
+                    handlerVersion: '2',
+                });
+            }
+            catch (e_8) {
+                env_8.error = e_8;
+                env_8.hasError = true;
+            }
+            finally {
+                __disposeResources(env_8);
+            }
+        });
+        it('caches consumer-group creation per stream', async () => {
+            const env_9 = { stack: [], error: void 0, hasError: false };
+            try {
+                const client = buildClient();
+                const adapter = __addDisposableResource(env_9, makeAdapter(client), false);
+                await adapter.enqueue({ taskId: 't1', type: 'echo', handlerVersion: 1 });
+                await adapter.enqueue({ taskId: 't2', type: 'echo', handlerVersion: 1 });
+                expect(client.xGroupCreate).toHaveBeenCalledTimes(1);
+                expect(client.xAdd).toHaveBeenCalledTimes(2);
+            }
+            catch (e_9) {
+                env_9.error = e_9;
+                env_9.hasError = true;
+            }
+            finally {
+                __disposeResources(env_9);
+            }
+        });
+        it('tolerates BUSYGROUP errors when the consumer group already exists', async () => {
+            const env_10 = { stack: [], error: void 0, hasError: false };
+            try {
+                const client = buildClient({
+                    xGroupCreate: vi.fn().mockRejectedValue(new Error('BUSYGROUP Consumer Group name already exists')),
+                });
+                const adapter = __addDisposableResource(env_10, makeAdapter(client), false);
+                await expect(adapter.enqueue({ taskId: 't1', type: 'echo', handlerVersion: 1 })).resolves.toBeUndefined();
+                expect(client.xAdd).toHaveBeenCalledOnce();
+            }
+            catch (e_10) {
+                env_10.error = e_10;
+                env_10.hasError = true;
+            }
+            finally {
+                __disposeResources(env_10);
+            }
+        });
+    });
+    describe('delayed dispatch', () => {
+        it('ZADDs to the scheduler ZSET when notBefore is in the future', async () => {
+            const env_11 = { stack: [], error: void 0, hasError: false };
+            try {
+                const client = buildClient();
+                const adapter = __addDisposableResource(env_11, makeAdapter(client), false);
+                const future = new Date(Date.now() + 60_000);
+                await adapter.enqueue({ taskId: 't1', type: 'echo', handlerVersion: 1, notBefore: future });
+                expect(client.xAdd).not.toHaveBeenCalled();
+                expect(client.zAdd).toHaveBeenCalledWith('svc-a/tasks:scheduler', {
+                    score: future.getTime(),
+                    value: JSON.stringify({ taskId: 't1', type: 'echo', handlerVersion: 1 }),
+                });
+            }
+            catch (e_11) {
+                env_11.error = e_11;
+                env_11.hasError = true;
+            }
+            finally {
+                __disposeResources(env_11);
+            }
+        });
+        it('XADDs immediately when notBefore is in the past', async () => {
+            const env_12 = { stack: [], error: void 0, hasError: false };
+            try {
+                const client = buildClient();
+                const adapter = __addDisposableResource(env_12, makeAdapter(client), false);
+                await adapter.enqueue({
+                    taskId: 't1',
+                    type: 'echo',
+                    handlerVersion: 1,
+                    notBefore: new Date(Date.now() - 1000),
+                });
+                expect(client.zAdd).not.toHaveBeenCalled();
+                expect(client.xAdd).toHaveBeenCalledOnce();
+            }
+            catch (e_12) {
+                env_12.error = e_12;
+                env_12.hasError = true;
+            }
+            finally {
+                __disposeResources(env_12);
+            }
+        });
+        it('eagerly creates the consumer group on the destination stream so scheduler XADDs are not lost', async () => {
+            const env_13 = { stack: [], error: void 0, hasError: false };
+            try {
+                const client = buildClient();
+                const adapter = __addDisposableResource(env_13, makeAdapter(client), false);
+                await adapter.enqueue({
+                    taskId: 't1',
+                    type: 'echo',
+                    handlerVersion: 1,
+                    notBefore: new Date(Date.now() + 60_000),
+                });
+                expect(client.xGroupCreate).toHaveBeenCalledWith('svc-a/tasks:queue:echo:v1', 'runner', '$', {
+                    MKSTREAM: true,
+                });
+            }
+            catch (e_13) {
+                env_13.error = e_13;
+                env_13.hasError = true;
+            }
+            finally {
+                __disposeResources(env_13);
+            }
+        });
+        it('runs the scheduler tick on the configured interval and EVALs the dispatch script', async () => {
+            const env_14 = { stack: [], error: void 0, hasError: false };
+            try {
+                const client = buildClient();
+                const adapter = __addDisposableResource(env_14, makeAdapter(client, 'svc-a/', 20)
+                // Block until at least one tick fired against the broker.
+                , false);
+                // Block until at least one tick fired against the broker.
+                await waitFor(() => client.eval.mock.calls.length > 0, 500);
+                const firstCall = client.eval.mock.calls[0];
+                const opts = firstCall[1];
+                expect(opts.keys).toEqual(['svc-a/tasks:scheduler']);
+                expect(opts.arguments[2]).toBe('svc-a/');
+                // ARGV[1] is `now` epoch ms; sanity-check it parses.
+                expect(Number.isFinite(Number(opts.arguments[0]))).toBe(true);
+                // ARGV[2] is the batch limit — must be a positive integer.
+                expect(Number(opts.arguments[1])).toBeGreaterThan(0);
+                void adapter;
+            }
+            catch (e_14) {
+                env_14.error = e_14;
+                env_14.hasError = true;
+            }
+            finally {
+                __disposeResources(env_14);
+            }
+        });
+        it('swallows EVAL errors so a transient broker failure does not poison the timer', async () => {
+            const env_15 = { stack: [], error: void 0, hasError: false };
+            try {
+                const errors = [];
+                const client = buildClient({
+                    eval: vi.fn().mockImplementation(() => {
+                        const error = new Error('LOADING Redis is starting');
+                        errors.push(error);
+                        throw error;
+                    }),
+                });
+                const adapter = __addDisposableResource(env_15, makeAdapter(client, 'svc-a/', 10), false);
+                await waitFor(() => errors.length >= 2, 500);
+                void adapter;
+            }
+            catch (e_15) {
+                env_15.error = e_15;
+                env_15.hasError = true;
+            }
+            finally {
+                __disposeResources(env_15);
+            }
+        });
+    });
+    describe('acquireIdempotencyLease', () => {
+        it('returns own taskId when SET NX wins the race', async () => {
+            const env_16 = { stack: [], error: void 0, hasError: false };
+            try {
+                const client = buildClient({ set: vi.fn().mockResolvedValue('OK') });
+                const adapter = __addDisposableResource(env_16, makeAdapter(client), false);
+                const winner = await adapter.acquireIdempotencyLease({ type: 'echo', key: 'nightly', taskId: 'mine' });
+                expect(winner).toBe('mine');
+                expect(client.set).toHaveBeenCalledWith('svc-a/tasks:idem:echo:nightly', 'mine', {
+                    NX: true,
+                    EX: 86_400,
+                });
+            }
+            catch (e_16) {
+                env_16.error = e_16;
+                env_16.hasError = true;
+            }
+            finally {
+                __disposeResources(env_16);
+            }
+        });
+        it('returns the stored taskId when SET NX loses', async () => {
+            const env_17 = { stack: [], error: void 0, hasError: false };
+            try {
+                const client = buildClient({
+                    set: vi.fn().mockResolvedValue(null),
+                    get: vi.fn().mockResolvedValue('previous'),
+                });
+                const adapter = __addDisposableResource(env_17, makeAdapter(client), false);
+                const winner = await adapter.acquireIdempotencyLease({ type: 'echo', key: 'nightly', taskId: 'mine' });
+                expect(winner).toBe('previous');
+            }
+            catch (e_17) {
+                env_17.error = e_17;
+                env_17.hasError = true;
+            }
+            finally {
+                __disposeResources(env_17);
+            }
+        });
+        it('falls back to own taskId when SET loses but GET sees no value (TTL expired between calls)', async () => {
+            const env_18 = { stack: [], error: void 0, hasError: false };
+            try {
+                const client = buildClient({
+                    set: vi.fn().mockResolvedValue(null),
+                    get: vi.fn().mockResolvedValue(null),
+                });
+                const adapter = __addDisposableResource(env_18, makeAdapter(client), false);
+                const winner = await adapter.acquireIdempotencyLease({ type: 'echo', key: 'nightly', taskId: 'mine' });
+                expect(winner).toBe('mine');
+            }
+            catch (e_18) {
+                env_18.error = e_18;
+                env_18.hasError = true;
+            }
+            finally {
+                __disposeResources(env_18);
+            }
+        });
+    });
+    describe('heartbeat', () => {
+        it('XCLAIMs the message id with idle=0 to refresh PEL idle counter', async () => {
+            const env_19 = { stack: [], error: void 0, hasError: false };
+            try {
+                const client = buildClient();
+                const adapter = __addDisposableResource(env_19, makeAdapter(client), false);
+                await adapter.heartbeat({
+                    taskId: 't1',
+                    type: 'echo',
+                    receipt: { stream: 'svc-a/tasks:queue:echo:v1', msgId: '1-0', consumer: 'w-0', deliveryCount: 0 },
+                });
+                expect(client.xClaimJustId).toHaveBeenCalledWith('svc-a/tasks:queue:echo:v1', 'runner', 'w-0', 0, ['1-0']);
+            }
+            catch (e_19) {
+                env_19.error = e_19;
+                env_19.hasError = true;
+            }
+            finally {
+                __disposeResources(env_19);
+            }
+        });
+        it('swallows broker errors so transient failures do not bubble into handler land', async () => {
+            const env_20 = { stack: [], error: void 0, hasError: false };
+            try {
+                const client = buildClient({
+                    xClaimJustId: vi.fn().mockRejectedValue(new Error('connection lost')),
+                });
+                const adapter = __addDisposableResource(env_20, makeAdapter(client), false);
+                await expect(adapter.heartbeat({
+                    taskId: 't1',
+                    type: 'echo',
+                    receipt: { stream: 'svc-a/tasks:queue:echo:v1', msgId: '1-0', consumer: 'w-0', deliveryCount: 0 },
+                })).resolves.toBeUndefined();
+            }
+            catch (e_20) {
+                env_20.error = e_20;
+                env_20.hasError = true;
+            }
+            finally {
+                __disposeResources(env_20);
+            }
+        });
+    });
+    describe('subscribe — claim loop', () => {
+        it('reads from per-(type,version) streams matching compatibleVersions', async () => {
+            const env_21 = { stack: [], error: void 0, hasError: false };
+            try {
+                const seenStreams = [];
+                const client = buildClient({
+                    xReadGroup: vi.fn().mockImplementation((_g, _c, streams) => {
+                        seenStreams.push(streams.map((s) => s.key));
+                        return Promise.resolve(null);
+                    }),
+                });
+                const adapter = __addDisposableResource(env_21, makeAdapter(client), false);
+                const onClaim = vi.fn().mockResolvedValue({ kind: 'success' });
+                const sub = __addDisposableResource(env_21, adapter.subscribe({
+                    workerId: 'w-1',
+                    concurrency: 1,
+                    tags: [],
+                    types: ['video-encode'],
+                    compatibleVersions: { 'video-encode': [1, 2] },
+                    shouldDrain: () => false,
+                    onClaim,
+                }), false);
+                void sub;
+                await waitFor(() => seenStreams.length > 0, 500);
+                expect(seenStreams[0]?.sort()).toEqual(['svc-a/tasks:queue:video-encode:v1', 'svc-a/tasks:queue:video-encode:v2']);
+            }
+            catch (e_21) {
+                env_21.error = e_21;
+                env_21.hasError = true;
+            }
+            finally {
+                __disposeResources(env_21);
+            }
+        });
+        it('defaults to v1 stream when compatibleVersions for a type is missing', async () => {
+            const env_22 = { stack: [], error: void 0, hasError: false };
+            try {
+                const seenStreams = [];
+                const client = buildClient({
+                    xReadGroup: vi.fn().mockImplementation((_g, _c, streams) => {
+                        seenStreams.push(streams.map((s) => s.key));
+                        return Promise.resolve(null);
+                    }),
+                });
+                const adapter = __addDisposableResource(env_22, makeAdapter(client), false);
+                const sub = __addDisposableResource(env_22, adapter.subscribe({
+                    workerId: 'w-1',
+                    concurrency: 1,
+                    tags: [],
+                    types: ['echo'],
+                    compatibleVersions: {},
+                    shouldDrain: () => false,
+                    onClaim: vi.fn().mockResolvedValue({ kind: 'success' }),
+                }), false);
+                void sub;
+                await waitFor(() => seenStreams.length > 0, 500);
+                expect(seenStreams[0]).toEqual(['svc-a/tasks:queue:echo:v1']);
+            }
+            catch (e_22) {
+                env_22.error = e_22;
+                env_22.hasError = true;
+            }
+            finally {
+                __disposeResources(env_22);
+            }
+        });
+        it('delivers a claim and ACKs on success', async () => {
+            const env_23 = { stack: [], error: void 0, hasError: false };
+            try {
+                const claims = [];
+                const onClaim = vi.fn().mockImplementation((claim) => {
+                    claims.push({ taskId: claim.taskId, type: claim.type });
+                    return Promise.resolve({ kind: 'success' });
+                });
+                const xReadGroup = oneShotXReadGroup({
+                    stream: 'svc-a/tasks:queue:echo:v1',
+                    message: { id: '1-0', fields: { taskId: 't1', type: 'echo', handlerVersion: '1' } },
+                });
+                const client = buildClient({ xReadGroup });
+                const adapter = __addDisposableResource(env_23, makeAdapter(client), false);
+                const sub = __addDisposableResource(env_23, adapter.subscribe({
+                    workerId: 'w-1',
+                    concurrency: 1,
+                    tags: [],
+                    types: ['echo'],
+                    compatibleVersions: { echo: [1] },
+                    shouldDrain: () => false,
+                    onClaim,
+                }), false);
+                void sub;
+                await waitFor(() => claims.length > 0, 1000);
+                expect(claims[0]).toEqual({ taskId: 't1', type: 'echo' });
+                await waitFor(() => client.xAck.mock.calls.length > 0, 1000);
+                expect(client.xAck).toHaveBeenCalledWith('svc-a/tasks:queue:echo:v1', 'runner', '1-0');
+            }
+            catch (e_23) {
+                env_23.error = e_23;
+                env_23.hasError = true;
+            }
+            finally {
+                __disposeResources(env_23);
+            }
+        });
+        it('ACKs the original entry and re-XADDs when onClaim returns requeue', async () => {
+            const env_24 = { stack: [], error: void 0, hasError: false };
+            try {
+                const xReadGroup = oneShotXReadGroup({
+                    stream: 'svc-a/tasks:queue:echo:v1',
+                    message: { id: '1-0', fields: { taskId: 't1', type: 'echo', handlerVersion: '1' } },
+                });
+                const client = buildClient({ xReadGroup });
+                const adapter = __addDisposableResource(env_24, makeAdapter(client), false);
+                const sub = __addDisposableResource(env_24, adapter.subscribe({
+                    workerId: 'w-1',
+                    concurrency: 1,
+                    tags: [],
+                    types: ['echo'],
+                    compatibleVersions: { echo: [1] },
+                    shouldDrain: () => false,
+                    onClaim: vi.fn().mockResolvedValue({ kind: 'requeue' }),
+                }), false);
+                void sub;
+                await waitFor(() => client.xAck.mock.calls.length > 0, 1000);
+                await waitFor(() => client.xAdd.mock.calls.length > 0, 1000);
+                expect(client.xAck).toHaveBeenCalledWith('svc-a/tasks:queue:echo:v1', 'runner', '1-0');
+                expect(client.xAdd).toHaveBeenCalledWith('svc-a/tasks:queue:echo:v1', '*', {
+                    taskId: 't1',
+                    type: 'echo',
+                    handlerVersion: '1',
+                });
+            }
+            catch (e_24) {
+                env_24.error = e_24;
+                env_24.hasError = true;
+            }
+            finally {
+                __disposeResources(env_24);
+            }
+        });
+        it('runs XAUTOCLAIM and delivers the reclaimed entry through onClaim', async () => {
+            const env_25 = { stack: [], error: void 0, hasError: false };
+            try {
+                const claims = [];
+                let autoClaimCall = 0;
+                const xAutoClaim = vi.fn().mockImplementation(async () => {
+                    autoClaimCall += 1;
+                    await new Promise((r) => setTimeout(r, 1));
+                    if (autoClaimCall === 1) {
+                        return {
+                            nextId: '2-0',
+                            messages: [{ id: '1-0', message: { taskId: 't-stale', type: 'echo', handlerVersion: '1' } }],
+                        };
+                    }
+                    return { nextId: '0-0', messages: [] };
+                });
+                const client = buildClient({ xAutoClaim });
+                const adapter = __addDisposableResource(env_25, makeAdapter(client), false);
+                const sub = __addDisposableResource(env_25, adapter.subscribe({
+                    workerId: 'w-1',
+                    concurrency: 1,
+                    tags: [],
+                    types: ['echo'],
+                    compatibleVersions: { echo: [1] },
+                    shouldDrain: () => false,
+                    onClaim: vi.fn().mockImplementation((claim) => {
+                        claims.push({ taskId: claim.taskId, type: claim.type });
+                        return Promise.resolve({ kind: 'success' });
+                    }),
+                }), false);
+                void sub;
+                await waitFor(() => claims.length > 0, 1000);
+                expect(claims[0]).toEqual({ taskId: 't-stale', type: 'echo' });
+            }
+            catch (e_25) {
+                env_25.error = e_25;
+                env_25.hasError = true;
+            }
+            finally {
+                __disposeResources(env_25);
+            }
+        });
+        it('drops malformed entries (missing taskId) without invoking onClaim', async () => {
+            const env_26 = { stack: [], error: void 0, hasError: false };
+            try {
+                const onClaim = vi.fn();
+                const xReadGroup = oneShotXReadGroup({
+                    stream: 'svc-a/tasks:queue:echo:v1',
+                    message: { id: '1-0', fields: { type: 'echo' } },
+                });
+                const client = buildClient({ xReadGroup });
+                const adapter = __addDisposableResource(env_26, makeAdapter(client), false);
+                const sub = __addDisposableResource(env_26, adapter.subscribe({
+                    workerId: 'w-1',
+                    concurrency: 1,
+                    tags: [],
+                    types: ['echo'],
+                    compatibleVersions: { echo: [1] },
+                    shouldDrain: () => false,
+                    onClaim,
+                }), false);
+                void sub;
+                await waitFor(() => client.xAck.mock.calls.length > 0, 1000);
+                expect(onClaim).not.toHaveBeenCalled();
+                expect(client.xAck).toHaveBeenCalledWith('svc-a/tasks:queue:echo:v1', 'runner', '1-0');
+            }
+            catch (e_26) {
+                env_26.error = e_26;
+                env_26.hasError = true;
+            }
+            finally {
+                __disposeResources(env_26);
+            }
+        });
+        it('stops the slot loop when subscription.shouldDrain() flips to true', async () => {
+            const env_27 = { stack: [], error: void 0, hasError: false };
+            try {
+                let draining = false;
+                const xReadGroup = vi.fn().mockResolvedValue(null);
+                const client = buildClient({ xReadGroup });
+                const adapter = __addDisposableResource(env_27, makeAdapter(client), false);
+                const sub = __addDisposableResource(env_27, adapter.subscribe({
+                    workerId: 'w-1',
+                    concurrency: 1,
+                    tags: [],
+                    types: ['echo'],
+                    compatibleVersions: { echo: [1] },
+                    shouldDrain: () => draining,
+                    onClaim: vi.fn().mockResolvedValue({ kind: 'success' }),
+                }), false);
+                void sub;
+                await waitFor(() => xReadGroup.mock.calls.length > 0, 500);
+                const callsBefore = xReadGroup.mock.calls.length;
+                draining = true;
+                await new Promise((r) => setTimeout(r, 80));
+                const callsAfter = xReadGroup.mock.calls.length;
+                // The loop may issue one or two more reads before observing the drain
+                // signal between iterations; what matters is that it stops growing.
+                await new Promise((r) => setTimeout(r, 50));
+                const callsAfterSettle = xReadGroup.mock.calls.length;
+                expect(callsAfter).toBeLessThanOrEqual(callsBefore + 4);
+                expect(callsAfterSettle).toBeLessThanOrEqual(callsAfter + 1);
+            }
+            catch (e_27) {
+                env_27.error = e_27;
+                env_27.hasError = true;
+            }
+            finally {
+                __disposeResources(env_27);
+            }
+        });
+    });
+});
+const waitFor = async (predicate, timeoutMs) => {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (predicate())
+            return;
+        await new Promise((r) => setTimeout(r, 5));
+    }
+    throw new Error(`waitFor: predicate did not satisfy within ${timeoutMs}ms`);
+};
+/**
+ * Returns an `xReadGroup` mock that yields `message` exactly once on
+ * the first call, then returns `null` on every subsequent call (with
+ * the BLOCK delay simulated so the slot loop paces itself and
+ * `mock.calls` does not grow unbounded).
+ */
+const oneShotXReadGroup = (delivery) => {
+    let delivered = false;
+    return vi.fn().mockImplementation(async (_g, _c, _streams, opts) => {
+        if (!delivered) {
+            delivered = true;
+            return [
+                {
+                    name: delivery.stream,
+                    messages: [{ id: delivery.message.id, message: delivery.message.fields }],
+                },
+            ];
+        }
+        if (opts?.BLOCK)
+            await new Promise((r) => setTimeout(r, opts.BLOCK));
+        return null;
+    });
+};
+//# sourceMappingURL=redis-queue-adapter.unit.spec.js.map