@fedify/redis 2.0.0-pr.479.1922 → 2.0.0-pr.559.4

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright 2024–2025 Hong Minhee
+Copyright 2024–2026 Hong Minhee
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

package/README.md

@@ -38,10 +38,10 @@ const federation = createFederation({
 });
 ~~~~
 
-[JSR]: https://jsr.io/@fedify/redis
 [JSR badge]: https://jsr.io/badges/@fedify/redis
-[npm]: https://www.npmjs.com/package/@fedify/redis
+[JSR]: https://jsr.io/@fedify/redis
 [npm badge]: https://img.shields.io/npm/v/@fedify/redis?logo=npm
+[npm]: https://www.npmjs.com/package/@fedify/redis
 [Fedify]: https://fedify.dev/
 [`KvStore`]: https://jsr.io/@fedify/fedify/doc/federation/~/KvStore
 [`MessageQueue`]: https://jsr.io/@fedify/fedify/doc/federation/~/MessageQueue

package/dist/kv.cjs

@@ -36,6 +36,7 @@ const node_buffer = require_rolldown_runtime.__toESM(require("node:buffer"));
 var RedisKvStore = class {
 	#redis;
 	#keyPrefix;
+	#keyPrefixStr;
 	#codec;
 	#textEncoder = new TextEncoder();
 	/**
@@ -46,6 +47,7 @@ var RedisKvStore = class {
 	constructor(redis, options = {}) {
 		this.#redis = redis;
 		this.#keyPrefix = options.keyPrefix ?? "fedify::";
+		this.#keyPrefixStr = typeof this.#keyPrefix === "string" ? this.#keyPrefix : new TextDecoder().decode(new Uint8Array(this.#keyPrefix));
 		this.#codec = options.codec ?? new require_codec.JsonCodec();
 	}
 	#serializeKey(key) {
@@ -70,6 +72,45 @@ var RedisKvStore = class {
 		const serializedKey = this.#serializeKey(key);
 		await this.#redis.del(serializedKey);
 	}
+	#deserializeKey(redisKey) {
+		const suffix = redisKey.slice(this.#keyPrefixStr.length);
+		return suffix.split("::").map((p) => p.replaceAll("_:", ":"));
+	}
+	/**
+	* {@inheritDoc KvStore.list}
+	* @since 1.10.0
+	*/
+	async *list(prefix) {
+		let pattern;
+		let exactKey = null;
+		if (prefix == null || prefix.length === 0) pattern = `${this.#keyPrefixStr}*`;
+		else {
+			const prefixKey = this.#serializeKey(prefix);
+			const prefixKeyFullStr = typeof prefixKey === "string" ? prefixKey : new TextDecoder().decode(new Uint8Array(prefixKey));
+			exactKey = prefixKey;
+			pattern = `${prefixKeyFullStr}::*`;
+		}
+		if (exactKey != null) {
+			const exactValue = await this.#redis.getBuffer(exactKey);
+			if (exactValue != null) yield {
+				key: prefix,
+				value: this.#codec.decode(exactValue)
+			};
+		}
+		let cursor = "0";
+		do {
+			const [nextCursor, keys] = await this.#redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
+			cursor = nextCursor;
+			for (const key of keys) {
+				const encodedValue = await this.#redis.getBuffer(key);
+				if (encodedValue == null) continue;
+				yield {
+					key: this.#deserializeKey(key),
+					value: this.#codec.decode(encodedValue)
+				};
+			}
+		} while (cursor !== "0");
+	}
 };
 
 //#endregion

package/dist/kv.d.cts

@@ -1,5 +1,5 @@
 import { Codec } from "./codec.cjs";
-import { KvKey, KvStore, KvStoreSetOptions } from "@fedify/fedify";
+import { KvKey, KvStore, KvStoreListEntry, KvStoreSetOptions } from "@fedify/fedify";
 import { Cluster, Redis, RedisKey } from "ioredis";
 
 //#region src/kv.d.ts
@@ -11,12 +11,12 @@ interface RedisKvStoreOptions {
    * The prefix to use for all keys in the key–value store in Redis.
    * Defaults to `"fedify::"`.
    */
-  keyPrefix?: RedisKey;
+  readonly keyPrefix?: RedisKey;
   /**
    * The codec to use for encoding and decoding values in the key–value store.
    * Defaults to {@link JsonCodec}.
    */
-  codec?: Codec;
+  readonly codec?: Codec;
 }
 /**
  * A key–value store that uses Redis as the underlying storage.
@@ -56,6 +56,11 @@ declare class RedisKvStore implements KvStore {
   get<T = unknown>(key: KvKey): Promise<T | undefined>;
   set(key: KvKey, value: unknown, options?: KvStoreSetOptions | undefined): Promise<void>;
   delete(key: KvKey): Promise<void>;
+  /**
+   * {@inheritDoc KvStore.list}
+   * @since 1.10.0
+   */
+  list(prefix?: KvKey): AsyncIterable<KvStoreListEntry>;
 }
 //#endregion
 export { RedisKvStore, RedisKvStoreOptions };

package/dist/kv.d.ts

@@ -1,6 +1,6 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { Codec } from "./codec.js";
-import { KvKey, KvStore, KvStoreSetOptions } from "@fedify/fedify";
+import { KvKey, KvStore, KvStoreListEntry, KvStoreSetOptions } from "@fedify/fedify";
 import { Cluster, Redis, RedisKey } from "ioredis";
 
 //#region src/kv.d.ts
@@ -12,12 +12,12 @@ interface RedisKvStoreOptions {
    * The prefix to use for all keys in the key–value store in Redis.
    * Defaults to `"fedify::"`.
    */
-  keyPrefix?: RedisKey;
+  readonly keyPrefix?: RedisKey;
   /**
    * The codec to use for encoding and decoding values in the key–value store.
    * Defaults to {@link JsonCodec}.
    */
-  codec?: Codec;
+  readonly codec?: Codec;
 }
 /**
  * A key–value store that uses Redis as the underlying storage.
@@ -57,6 +57,11 @@ declare class RedisKvStore implements KvStore {
   get<T = unknown>(key: KvKey): Promise<T | undefined>;
   set(key: KvKey, value: unknown, options?: KvStoreSetOptions | undefined): Promise<void>;
   delete(key: KvKey): Promise<void>;
+  /**
+   * {@inheritDoc KvStore.list}
+   * @since 1.10.0
+   */
+  list(prefix?: KvKey): AsyncIterable<KvStoreListEntry>;
 }
 //#endregion
 export { RedisKvStore, RedisKvStoreOptions };

package/dist/kv.js

@@ -35,6 +35,7 @@ import { Buffer } from "node:buffer";
 var RedisKvStore = class {
 	#redis;
 	#keyPrefix;
+	#keyPrefixStr;
 	#codec;
 	#textEncoder = new TextEncoder();
 	/**
@@ -45,6 +46,7 @@ var RedisKvStore = class {
 	constructor(redis, options = {}) {
 		this.#redis = redis;
 		this.#keyPrefix = options.keyPrefix ?? "fedify::";
+		this.#keyPrefixStr = typeof this.#keyPrefix === "string" ? this.#keyPrefix : new TextDecoder().decode(new Uint8Array(this.#keyPrefix));
 		this.#codec = options.codec ?? new JsonCodec();
 	}
 	#serializeKey(key) {
@@ -69,6 +71,45 @@ var RedisKvStore = class {
 		const serializedKey = this.#serializeKey(key);
 		await this.#redis.del(serializedKey);
 	}
+	#deserializeKey(redisKey) {
+		const suffix = redisKey.slice(this.#keyPrefixStr.length);
+		return suffix.split("::").map((p) => p.replaceAll("_:", ":"));
+	}
+	/**
+	* {@inheritDoc KvStore.list}
+	* @since 1.10.0
+	*/
+	async *list(prefix) {
+		let pattern;
+		let exactKey = null;
+		if (prefix == null || prefix.length === 0) pattern = `${this.#keyPrefixStr}*`;
+		else {
+			const prefixKey = this.#serializeKey(prefix);
+			const prefixKeyFullStr = typeof prefixKey === "string" ? prefixKey : new TextDecoder().decode(new Uint8Array(prefixKey));
+			exactKey = prefixKey;
+			pattern = `${prefixKeyFullStr}::*`;
+		}
+		if (exactKey != null) {
+			const exactValue = await this.#redis.getBuffer(exactKey);
+			if (exactValue != null) yield {
+				key: prefix,
+				value: this.#codec.decode(exactValue)
+			};
+		}
+		let cursor = "0";
+		do {
+			const [nextCursor, keys] = await this.#redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
+			cursor = nextCursor;
+			for (const key of keys) {
+				const encodedValue = await this.#redis.getBuffer(key);
+				if (encodedValue == null) continue;
+				yield {
+					key: this.#deserializeKey(key),
+					value: this.#codec.decode(encodedValue)
+				};
+			}
+		} while (cursor !== "0");
+	}
 };
 
 //#endregion

package/dist/mq.cjs

@@ -47,6 +47,8 @@ var RedisMessageQueue = class {
 	#codec;
 	#pollIntervalMs;
 	#loopHandle;
+	#lastTimestamp = 0;
+	#sequenceInMs = 0;
 	/**
 	* Creates a new Redis message queue.
 	* @param redis The Redis client factory.
@@ -62,22 +64,53 @@ var RedisMessageQueue = class {
 		this.#codec = options.codec ?? new require_codec.JsonCodec();
 		this.#pollIntervalMs = Temporal.Duration.from(options.pollInterval ?? { seconds: 5 }).total("millisecond");
 	}
+	/**
+	* Returns a monotonically increasing timestamp to ensure message ordering.
+	* When multiple messages are enqueued in the same millisecond, a fractional
+	* sequence number is added to preserve insertion order.
+	*/
+	#getMonotonicTimestamp(baseTimestamp) {
+		if (baseTimestamp === this.#lastTimestamp) this.#sequenceInMs++;
+		else {
+			this.#lastTimestamp = baseTimestamp;
+			this.#sequenceInMs = 0;
+		}
+		return baseTimestamp + this.#sequenceInMs * .001;
+	}
 	async enqueue(message, options) {
-		const ts = options?.delay == null ? 0 : Temporal.Now.instant().add(options.delay).epochMilliseconds;
-		const encodedMessage = this.#codec.encode([crypto.randomUUID(), message]);
+		const now = Temporal.Now.instant().epochMilliseconds;
+		const baseTs = options?.delay == null ? now : now + options.delay.total("millisecond");
+		const ts = this.#getMonotonicTimestamp(baseTs);
+		const encodedMessage = this.#codec.encode([
+			crypto.randomUUID(),
+			message,
+			options?.orderingKey
+		]);
 		await this.#redis.zadd(this.#queueKey, ts, encodedMessage);
-		if (ts < 1) this.#redis.publish(this.#channelKey, "");
+		if (baseTs <= now) this.#redis.publish(this.#channelKey, "");
 	}
 	async enqueueMany(messages, options) {
 		if (messages.length === 0) return;
-		const ts = options?.delay == null ? 0 : Temporal.Now.instant().add(options.delay).epochMilliseconds;
+		const now = Temporal.Now.instant().epochMilliseconds;
+		const baseTs = options?.delay == null ? now : now + options.delay.total("millisecond");
 		const multi = this.#redis.multi();
 		for (const message of messages) {
-			const encodedMessage = this.#codec.encode([crypto.randomUUID(), message]);
+			const ts = this.#getMonotonicTimestamp(baseTs);
+			const encodedMessage = this.#codec.encode([
+				crypto.randomUUID(),
+				message,
+				options?.orderingKey
+			]);
 			multi.zadd(this.#queueKey, ts, encodedMessage);
 		}
 		await multi.exec();
-		if (ts < 1) this.#redis.publish(this.#channelKey, "");
+		if (baseTs <= now) this.#redis.publish(this.#channelKey, "");
+	}
+	/**
+	* Returns the Redis key used to lock a specific ordering key.
+	*/
+	#getOrderingLockKey(orderingKey) {
+		return `${this.#lockKey}:ordering:${orderingKey}`;
 	}
 	async #poll() {
 		logger.debug("Polling for messages...");
@@ -91,10 +124,25 @@ var RedisMessageQueue = class {
 		logger.debug("Found {messages} messages to process.", { messages: messages.length });
 		try {
 			if (messages.length < 1) return;
-			const encodedMessage = messages[0];
-			await this.#redis.zrem(this.#queueKey, encodedMessage);
-			const [_, message] = this.#codec.decode(encodedMessage);
-			return message;
+			for (const encodedMessage of messages) {
+				const decoded = this.#codec.decode(encodedMessage);
+				const orderingKey = decoded[2];
+				if (orderingKey != null) {
+					const orderingLockKey = this.#getOrderingLockKey(orderingKey);
+					const lockResult = await this.#redis.set(orderingLockKey, this.#workerId, "EX", 60, "NX");
+					if (lockResult == null) continue;
+				}
+				const removed = await this.#redis.zrem(this.#queueKey, encodedMessage);
+				if (removed === 0) {
+					if (orderingKey != null) await this.#redis.del(this.#getOrderingLockKey(orderingKey));
+					continue;
+				}
+				return {
+					message: decoded[1],
+					orderingKey
+				};
+			}
+			return;
 		} finally {
 			await this.#redis.del(this.#lockKey);
 		}
@@ -104,42 +152,45 @@ var RedisMessageQueue = class {
 		const signal = options.signal;
 		const poll = async () => {
 			while (!signal?.aborted) {
-				let message;
+				let result;
 				try {
-					message = await this.#poll();
+					result = await this.#poll();
 				} catch (error) {
 					logger.error("Error polling for messages: {error}", { error });
 					return;
 				}
-				if (message === void 0) return;
-				await handler(message);
+				if (result === void 0) return;
+				const { message, orderingKey } = result;
+				try {
+					await handler(message);
+				} finally {
+					if (orderingKey != null) await this.#redis.del(this.#getOrderingLockKey(orderingKey));
+				}
 			}
 		};
-		const promise = this.#subRedis.subscribe(this.#channelKey, () => {
-			/**
-			* Cast to Redis for event methods. Both Redis and Cluster extend EventEmitter
-			* and get the same methods via applyMixin at runtime, but their TypeScript
-			* interfaces are incompatible:
-			* - Redis declares specific overloads: on(event: "message", cb: (channel, message) => void)
-			* - Cluster only has generic: on(event: string | symbol, listener: Function)
-			*
-			* This makes the union type Redis | Cluster incompatible for these method calls.
-			* The cast is safe because both classes use applyMixin(Class, EventEmitter) which
-			* copies all EventEmitter prototype methods, giving them identical pub/sub functionality.
-			*
-			* @see https://github.com/redis/ioredis/blob/main/lib/Redis.ts#L863 (has specific overloads)
-			* @see https://github.com/redis/ioredis/blob/main/lib/cluster/index.ts#L1110 (empty interface)
-			*/
-			const subRedis = this.#subRedis;
-			subRedis.on("message", poll);
-			signal?.addEventListener("abort", () => {
-				subRedis.off("message", poll);
-			});
-		});
+		await this.#subRedis.subscribe(this.#channelKey);
+		/**
+		* Cast to Redis for event methods. Both Redis and Cluster extend EventEmitter
+		* and get the same methods via applyMixin at runtime, but their TypeScript
+		* interfaces are incompatible:
+		* - Redis declares specific overloads: on(event: "message", cb: (channel, message) => void)
+		* - Cluster only has generic: on(event: string | symbol, listener: Function)
+		*
+		* This makes the union type Redis | Cluster incompatible for these method calls.
+		* The cast is safe because both classes use applyMixin(Class, EventEmitter) which
+		* copies all EventEmitter prototype methods, giving them identical pub/sub functionality.
+		*
+		* @see https://github.com/redis/ioredis/blob/main/lib/Redis.ts#L863 (has specific overloads)
+		* @see https://github.com/redis/ioredis/blob/main/lib/cluster/index.ts#L1110 (empty interface)
+		*/
+		const subRedis = this.#subRedis;
+		subRedis.on("message", poll);
+		const timeouts = /* @__PURE__ */ new Set();
 		signal?.addEventListener("abort", () => {
+			subRedis.off("message", poll);
 			for (const timeout of timeouts) clearTimeout(timeout);
 		});
-		const timeouts = /* @__PURE__ */ new Set();
+		await poll();
 		while (!signal?.aborted) {
 			let timeout;
 			await new Promise((resolve) => {
@@ -153,12 +204,6 @@ var RedisMessageQueue = class {
 			if (timeout != null) timeouts.delete(timeout);
 			await poll();
 		}
-		return await new Promise((resolve) => {
-			signal?.addEventListener("abort", () => {
-				promise.catch(() => resolve()).then(() => resolve());
-			});
-			promise.catch(() => resolve()).then(() => resolve());
-		});
 	}
 	[Symbol.dispose]() {
 		clearInterval(this.#loopHandle);

package/dist/mq.d.cts

@@ -13,35 +13,35 @@ interface RedisMessageQueueOptions {
    * This is used to prevent multiple workers from processing the same message,
    * so it should be unique for each worker.
    */
-  workerId?: string;
+  readonly workerId?: string;
   /**
    * The Pub/Sub channel key to use for the message queue.  `"fedify_channel"`
    * by default.
    * @default `"fedify_channel"`
    */
-  channelKey?: RedisKey;
+  readonly channelKey?: RedisKey;
   /**
    * The Sorted Set key to use for the delayed message queue.  `"fedify_queue"`
    * by default.
    * @default `"fedify_queue"`
    */
-  queueKey?: RedisKey;
+  readonly queueKey?: RedisKey;
   /**
    * The key to use for locking the message queue.  `"fedify_lock"` by default.
    * @default `"fedify_lock"`
    */
-  lockKey?: RedisKey;
+  readonly lockKey?: RedisKey;
   /**
    * The codec to use for encoding and decoding messages in the key–value store.
    * Defaults to {@link JsonCodec}.
    * @default {@link JsonCodec}
    */
-  codec?: Codec;
+  readonly codec?: Codec;
   /**
    * The poll interval for the message queue.  5 seconds by default.
    * @default `{ seconds: 5 }`
    */
-  pollInterval?: Temporal.Duration | Temporal.DurationLike;
+  readonly pollInterval?: Temporal.Duration | Temporal.DurationLike;
 }
 /**
  * A message queue that uses Redis as the underlying storage.
@@ -78,7 +78,7 @@ declare class RedisMessageQueue implements MessageQueue, Disposable {
    */
   constructor(redis: () => Redis | Cluster, options?: RedisMessageQueueOptions);
   enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
-  enqueueMany(messages: any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  enqueueMany(messages: readonly any[], options?: MessageQueueEnqueueOptions): Promise<void>;
   listen(handler: (message: any) => void | Promise<void>, options?: MessageQueueListenOptions): Promise<void>;
   [Symbol.dispose](): void;
 }

package/dist/mq.d.ts

@@ -14,35 +14,35 @@ interface RedisMessageQueueOptions {
    * This is used to prevent multiple workers from processing the same message,
    * so it should be unique for each worker.
    */
-  workerId?: string;
+  readonly workerId?: string;
   /**
    * The Pub/Sub channel key to use for the message queue.  `"fedify_channel"`
    * by default.
    * @default `"fedify_channel"`
    */
-  channelKey?: RedisKey;
+  readonly channelKey?: RedisKey;
   /**
    * The Sorted Set key to use for the delayed message queue.  `"fedify_queue"`
    * by default.
    * @default `"fedify_queue"`
    */
-  queueKey?: RedisKey;
+  readonly queueKey?: RedisKey;
   /**
    * The key to use for locking the message queue.  `"fedify_lock"` by default.
    * @default `"fedify_lock"`
    */
-  lockKey?: RedisKey;
+  readonly lockKey?: RedisKey;
   /**
    * The codec to use for encoding and decoding messages in the key–value store.
    * Defaults to {@link JsonCodec}.
    * @default {@link JsonCodec}
    */
-  codec?: Codec;
+  readonly codec?: Codec;
   /**
    * The poll interval for the message queue.  5 seconds by default.
    * @default `{ seconds: 5 }`
    */
-  pollInterval?: Temporal.Duration | Temporal.DurationLike;
+  readonly pollInterval?: Temporal.Duration | Temporal.DurationLike;
 }
 /**
  * A message queue that uses Redis as the underlying storage.
@@ -79,7 +79,7 @@ declare class RedisMessageQueue implements MessageQueue, Disposable {
    */
   constructor(redis: () => Redis | Cluster, options?: RedisMessageQueueOptions);
   enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
-  enqueueMany(messages: any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  enqueueMany(messages: readonly any[], options?: MessageQueueEnqueueOptions): Promise<void>;
   listen(handler: (message: any) => void | Promise<void>, options?: MessageQueueListenOptions): Promise<void>;
   [Symbol.dispose](): void;
 }

package/dist/mq.js

@@ -46,6 +46,8 @@ var RedisMessageQueue = class {
 	#codec;
 	#pollIntervalMs;
 	#loopHandle;
+	#lastTimestamp = 0;
+	#sequenceInMs = 0;
 	/**
 	* Creates a new Redis message queue.
 	* @param redis The Redis client factory.
@@ -61,22 +63,53 @@ var RedisMessageQueue = class {
 		this.#codec = options.codec ?? new JsonCodec();
 		this.#pollIntervalMs = Temporal.Duration.from(options.pollInterval ?? { seconds: 5 }).total("millisecond");
 	}
+	/**
+	* Returns a monotonically increasing timestamp to ensure message ordering.
+	* When multiple messages are enqueued in the same millisecond, a fractional
+	* sequence number is added to preserve insertion order.
+	*/
+	#getMonotonicTimestamp(baseTimestamp) {
+		if (baseTimestamp === this.#lastTimestamp) this.#sequenceInMs++;
+		else {
+			this.#lastTimestamp = baseTimestamp;
+			this.#sequenceInMs = 0;
+		}
+		return baseTimestamp + this.#sequenceInMs * .001;
+	}
 	async enqueue(message, options) {
-		const ts = options?.delay == null ? 0 : Temporal.Now.instant().add(options.delay).epochMilliseconds;
-		const encodedMessage = this.#codec.encode([crypto.randomUUID(), message]);
+		const now = Temporal.Now.instant().epochMilliseconds;
+		const baseTs = options?.delay == null ? now : now + options.delay.total("millisecond");
+		const ts = this.#getMonotonicTimestamp(baseTs);
+		const encodedMessage = this.#codec.encode([
+			crypto.randomUUID(),
+			message,
+			options?.orderingKey
+		]);
 		await this.#redis.zadd(this.#queueKey, ts, encodedMessage);
-		if (ts < 1) this.#redis.publish(this.#channelKey, "");
+		if (baseTs <= now) this.#redis.publish(this.#channelKey, "");
 	}
 	async enqueueMany(messages, options) {
 		if (messages.length === 0) return;
-		const ts = options?.delay == null ? 0 : Temporal.Now.instant().add(options.delay).epochMilliseconds;
+		const now = Temporal.Now.instant().epochMilliseconds;
+		const baseTs = options?.delay == null ? now : now + options.delay.total("millisecond");
 		const multi = this.#redis.multi();
 		for (const message of messages) {
-			const encodedMessage = this.#codec.encode([crypto.randomUUID(), message]);
+			const ts = this.#getMonotonicTimestamp(baseTs);
+			const encodedMessage = this.#codec.encode([
+				crypto.randomUUID(),
+				message,
+				options?.orderingKey
+			]);
 			multi.zadd(this.#queueKey, ts, encodedMessage);
 		}
 		await multi.exec();
-		if (ts < 1) this.#redis.publish(this.#channelKey, "");
+		if (baseTs <= now) this.#redis.publish(this.#channelKey, "");
+	}
+	/**
+	* Returns the Redis key used to lock a specific ordering key.
+	*/
+	#getOrderingLockKey(orderingKey) {
+		return `${this.#lockKey}:ordering:${orderingKey}`;
 	}
 	async #poll() {
 		logger.debug("Polling for messages...");
@@ -90,10 +123,25 @@ var RedisMessageQueue = class {
 		logger.debug("Found {messages} messages to process.", { messages: messages.length });
 		try {
 			if (messages.length < 1) return;
-			const encodedMessage = messages[0];
-			await this.#redis.zrem(this.#queueKey, encodedMessage);
-			const [_, message] = this.#codec.decode(encodedMessage);
-			return message;
+			for (const encodedMessage of messages) {
+				const decoded = this.#codec.decode(encodedMessage);
+				const orderingKey = decoded[2];
+				if (orderingKey != null) {
+					const orderingLockKey = this.#getOrderingLockKey(orderingKey);
+					const lockResult = await this.#redis.set(orderingLockKey, this.#workerId, "EX", 60, "NX");
+					if (lockResult == null) continue;
+				}
+				const removed = await this.#redis.zrem(this.#queueKey, encodedMessage);
+				if (removed === 0) {
+					if (orderingKey != null) await this.#redis.del(this.#getOrderingLockKey(orderingKey));
+					continue;
+				}
+				return {
+					message: decoded[1],
+					orderingKey
+				};
+			}
+			return;
 		} finally {
 			await this.#redis.del(this.#lockKey);
 		}
@@ -103,42 +151,45 @@ var RedisMessageQueue = class {
 		const signal = options.signal;
 		const poll = async () => {
 			while (!signal?.aborted) {
-				let message;
+				let result;
 				try {
-					message = await this.#poll();
+					result = await this.#poll();
 				} catch (error) {
 					logger.error("Error polling for messages: {error}", { error });
 					return;
 				}
-				if (message === void 0) return;
-				await handler(message);
+				if (result === void 0) return;
+				const { message, orderingKey } = result;
+				try {
+					await handler(message);
+				} finally {
+					if (orderingKey != null) await this.#redis.del(this.#getOrderingLockKey(orderingKey));
+				}
 			}
 		};
-		const promise = this.#subRedis.subscribe(this.#channelKey, () => {
-			/**
-			* Cast to Redis for event methods. Both Redis and Cluster extend EventEmitter
-			* and get the same methods via applyMixin at runtime, but their TypeScript
-			* interfaces are incompatible:
-			* - Redis declares specific overloads: on(event: "message", cb: (channel, message) => void)
-			* - Cluster only has generic: on(event: string | symbol, listener: Function)
-			*
-			* This makes the union type Redis | Cluster incompatible for these method calls.
-			* The cast is safe because both classes use applyMixin(Class, EventEmitter) which
-			* copies all EventEmitter prototype methods, giving them identical pub/sub functionality.
-			*
-			* @see https://github.com/redis/ioredis/blob/main/lib/Redis.ts#L863 (has specific overloads)
-			* @see https://github.com/redis/ioredis/blob/main/lib/cluster/index.ts#L1110 (empty interface)
-			*/
-			const subRedis = this.#subRedis;
-			subRedis.on("message", poll);
-			signal?.addEventListener("abort", () => {
-				subRedis.off("message", poll);
-			});
-		});
+		await this.#subRedis.subscribe(this.#channelKey);
+		/**
+		* Cast to Redis for event methods. Both Redis and Cluster extend EventEmitter
+		* and get the same methods via applyMixin at runtime, but their TypeScript
+		* interfaces are incompatible:
+		* - Redis declares specific overloads: on(event: "message", cb: (channel, message) => void)
+		* - Cluster only has generic: on(event: string | symbol, listener: Function)
+		*
+		* This makes the union type Redis | Cluster incompatible for these method calls.
+		* The cast is safe because both classes use applyMixin(Class, EventEmitter) which
+		* copies all EventEmitter prototype methods, giving them identical pub/sub functionality.
+		*
+		* @see https://github.com/redis/ioredis/blob/main/lib/Redis.ts#L863 (has specific overloads)
+		* @see https://github.com/redis/ioredis/blob/main/lib/cluster/index.ts#L1110 (empty interface)
+		*/
+		const subRedis = this.#subRedis;
+		subRedis.on("message", poll);
+		const timeouts = /* @__PURE__ */ new Set();
 		signal?.addEventListener("abort", () => {
+			subRedis.off("message", poll);
 			for (const timeout of timeouts) clearTimeout(timeout);
 		});
-		const timeouts = /* @__PURE__ */ new Set();
+		await poll();
 		while (!signal?.aborted) {
 			let timeout;
 			await new Promise((resolve) => {
@@ -152,12 +203,6 @@ var RedisMessageQueue = class {
 			if (timeout != null) timeouts.delete(timeout);
 			await poll();
 		}
-		return await new Promise((resolve) => {
-			signal?.addEventListener("abort", () => {
-				promise.catch(() => resolve()).then(() => resolve());
-			});
-			promise.catch(() => resolve()).then(() => resolve());
-		});
 	}
 	[Symbol.dispose]() {
 		clearInterval(this.#loopHandle);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/redis",
-  "version": "2.0.0-pr.479.1922+564a1890",
+  "version": "2.0.0-pr.559.4+6357309b",
   "description": "Redis drivers for Fedify",
   "keywords": [
     "fedify",
@@ -78,22 +78,27 @@
   ],
   "dependencies": {
     "@js-temporal/polyfill": "^0.5.1",
-    "@logtape/logtape": "^1.1.1"
+    "@logtape/logtape": "^2.0.0"
   },
   "peerDependencies": {
-    "ioredis": "^5.6.1",
-    "@fedify/fedify": "^2.0.0-pr.479.1922+564a1890"
+    "ioredis": "^5.8.2",
+    "@fedify/fedify": "^2.0.0-pr.559.4+6357309b"
   },
   "devDependencies": {
     "@std/async": "npm:@jsr/std__async@^1.0.13",
     "@types/node": "^22.17.0",
     "tsdown": "^0.12.9",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "@fedify/fixture": "^2.0.0",
+    "@fedify/testing": "^2.0.0-pr.559.4+6357309b"
   },
   "scripts": {
-    "build": "tsdown",
-    "prepublish": "tsdown",
-    "test": "tsdown && node --experimental-transform-types --test",
-    "test:bun": "tsdown && bun test --timeout=10000"
+    "build:self": "tsdown",
+    "build": "pnpm --filter @fedify/redis... run build:self",
+    "prepublish": "pnpm build",
+    "pretest": "pnpm build",
+    "test": "node --experimental-transform-types --test",
+    "pretest:bun": "pnpm build",
+    "test:bun": "bun test --timeout=10000"
   }
 }