@fedify/redis 2.0.0-pr.412.1559 → 2.0.0-pr.412.1794

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,33 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/codec.cjs

@@ -0,0 +1,66 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const node_buffer = require_rolldown_runtime.__toESM(require("node:buffer"));
+
+//#region src/codec.ts
+/**
+* An error that occurs when encoding or decoding data.
+*/
+var CodecError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CodecError";
+	}
+};
+/**
+* An error that occurs when encoding data.
+*/
+var EncodingError = class extends CodecError {
+	constructor(message) {
+		super(message);
+		this.name = "EncodingError";
+	}
+};
+/**
+* An error that occurs when decoding data.
+*/
+var DecodingError = class extends CodecError {
+	constructor(message) {
+		super(message);
+		this.name = "DecodingError";
+	}
+};
+/**
+* A codec that encodes and decodes JavaScript objects to and from JSON.
+*/
+var JsonCodec = class {
+	#textEncoder = new TextEncoder();
+	#textDecoder = new TextDecoder();
+	encode(value) {
+		let json;
+		try {
+			json = JSON.stringify(value);
+		} catch (e) {
+			if (e instanceof TypeError) throw new EncodingError(e.message);
+			throw e;
+		}
+		return node_buffer.Buffer.from(this.#textEncoder.encode(json));
+	}
+	decode(encoded) {
+		const json = this.#textDecoder.decode(encoded);
+		try {
+			return JSON.parse(json);
+		} catch (e) {
+			if (e instanceof SyntaxError) throw new DecodingError(e.message);
+			throw e;
+		}
+	}
+};
+
+//#endregion
+exports.CodecError = CodecError;
+exports.DecodingError = DecodingError;
+exports.EncodingError = EncodingError;
+exports.JsonCodec = JsonCodec;

package/dist/codec.d.cts

@@ -0,0 +1,50 @@
+import { Buffer } from "node:buffer";
+
+//#region src/codec.d.ts
+/**
+ * Encode and decodes JavaScript objects to and from binary data.
+ */
+interface Codec {
+  /**
+   * Encodes a JavaScript object to binary data.
+   * @param value The JavaScript object to encode.
+   * @returns The encoded binary data.
+   * @throws {EncodingError} If the JavaScript object cannot be encoded.
+   */
+  encode(value: unknown): Buffer;
+  /**
+   * Decodes a JavaScript object from binary data.
+   * @param encoded The binary data to decode.
+   * @returns The decoded JavaScript object.
+   * @throws {DecodingError} If the binary data is invalid.
+   */
+  decode(encoded: Buffer): unknown;
+}
+/**
+ * An error that occurs when encoding or decoding data.
+ */
+declare class CodecError extends Error {
+  constructor(message: string);
+}
+/**
+ * An error that occurs when encoding data.
+ */
+declare class EncodingError extends CodecError {
+  constructor(message: string);
+}
+/**
+ * An error that occurs when decoding data.
+ */
+declare class DecodingError extends CodecError {
+  constructor(message: string);
+}
+/**
+ * A codec that encodes and decodes JavaScript objects to and from JSON.
+ */
+declare class JsonCodec implements Codec {
+  #private;
+  encode(value: unknown): Buffer;
+  decode(encoded: Buffer): unknown;
+}
+//#endregion
+export { Codec, CodecError, DecodingError, EncodingError, JsonCodec };

package/dist/codec.js

@@ -1,6 +1,6 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-    
+        import { Temporal } from "@js-temporal/polyfill";
+      
 import { Buffer } from "node:buffer";
 
 //#region src/codec.ts

package/dist/kv.cjs

@@ -0,0 +1,76 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_codec = require('./codec.cjs');
+const node_buffer = require_rolldown_runtime.__toESM(require("node:buffer"));
+
+//#region src/kv.ts
+/**
+* A key–value store that uses Redis as the underlying storage.
+*
+* @example
+* ```ts ignore
+* import { createFederation } from "@fedify/fedify";
+* import { RedisKvStore } from "@fedify/redis";
+* import { Redis, Cluster } from "ioredis";
+*
+* // Using a standalone Redis instance:
+* const federation = createFederation({
+*   // ...
+*   kv: new RedisKvStore(new Redis()),
+* });
+*
+* // Using a Redis Cluster:
+* const cluster = new Cluster([
+*   { host: "127.0.0.1", port: 7000 },
+*   { host: "127.0.0.1", port: 7001 },
+*   { host: "127.0.0.1", port: 7002 },
+* ]);
+* const federation = createFederation({
+*   // ...
+*   kv: new RedisKvStore(cluster),
+* });
+* ```
+*/
+var RedisKvStore = class {
+	#redis;
+	#keyPrefix;
+	#codec;
+	#textEncoder = new TextEncoder();
+	/**
+	* Creates a new Redis key–value store.
+	* @param redis The Redis client (standalone or cluster) to use.
+	* @param options The options for the key–value store.
+	*/
+	constructor(redis, options = {}) {
+		this.#redis = redis;
+		this.#keyPrefix = options.keyPrefix ?? "fedify::";
+		this.#codec = options.codec ?? new require_codec.JsonCodec();
+	}
+	#serializeKey(key) {
+		const suffix = key.map((part) => part.replaceAll(":", "_:")).join("::");
+		if (typeof this.#keyPrefix === "string") return `${this.#keyPrefix}${suffix}`;
+		const suffixBytes = this.#textEncoder.encode(suffix);
+		return node_buffer.Buffer.concat([new Uint8Array(this.#keyPrefix), suffixBytes]);
+	}
+	async get(key) {
+		const serializedKey = this.#serializeKey(key);
+		const encodedValue = await this.#redis.getBuffer(serializedKey);
+		if (encodedValue == null) return void 0;
+		return this.#codec.decode(encodedValue);
+	}
+	async set(key, value, options) {
+		const serializedKey = this.#serializeKey(key);
+		const encodedValue = this.#codec.encode(value);
+		if (options?.ttl != null) await this.#redis.setex(serializedKey, options.ttl.total("second"), encodedValue);
+		else await this.#redis.set(serializedKey, encodedValue);
+	}
+	async delete(key) {
+		const serializedKey = this.#serializeKey(key);
+		await this.#redis.del(serializedKey);
+	}
+};
+
+//#endregion
+exports.RedisKvStore = RedisKvStore;

package/dist/kv.d.cts

@@ -0,0 +1,61 @@
+import { Codec } from "./codec.cjs";
+import { KvKey, KvStore, KvStoreSetOptions } from "@fedify/fedify";
+import { Cluster, Redis, RedisKey } from "ioredis";
+
+//#region src/kv.d.ts
+/**
+ * Options for {@link RedisKvStore} class.
+ */
+interface RedisKvStoreOptions {
+  /**
+   * The prefix to use for all keys in the key–value store in Redis.
+   * Defaults to `"fedify::"`.
+   */
+  keyPrefix?: RedisKey;
+  /**
+   * The codec to use for encoding and decoding values in the key–value store.
+   * Defaults to {@link JsonCodec}.
+   */
+  codec?: Codec;
+}
+/**
+ * A key–value store that uses Redis as the underlying storage.
+ *
+ * @example
+ * ```ts ignore
+ * import { createFederation } from "@fedify/fedify";
+ * import { RedisKvStore } from "@fedify/redis";
+ * import { Redis, Cluster } from "ioredis";
+ *
+ * // Using a standalone Redis instance:
+ * const federation = createFederation({
+ *   // ...
+ *   kv: new RedisKvStore(new Redis()),
+ * });
+ *
+ * // Using a Redis Cluster:
+ * const cluster = new Cluster([
+ *   { host: "127.0.0.1", port: 7000 },
+ *   { host: "127.0.0.1", port: 7001 },
+ *   { host: "127.0.0.1", port: 7002 },
+ * ]);
+ * const federation = createFederation({
+ *   // ...
+ *   kv: new RedisKvStore(cluster),
+ * });
+ * ```
+ */
+declare class RedisKvStore implements KvStore {
+  #private;
+  /**
+   * Creates a new Redis key–value store.
+   * @param redis The Redis client (standalone or cluster) to use.
+   * @param options The options for the key–value store.
+   */
+  constructor(redis: Redis | Cluster, options?: RedisKvStoreOptions);
+  get<T = unknown>(key: KvKey): Promise<T | undefined>;
+  set(key: KvKey, value: unknown, options?: KvStoreSetOptions | undefined): Promise<void>;
+  delete(key: KvKey): Promise<void>;
+}
+//#endregion
+export { RedisKvStore, RedisKvStoreOptions };

package/dist/kv.js

@@ -1,6 +1,6 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-    
+        import { Temporal } from "@js-temporal/polyfill";
+      
 import { JsonCodec } from "./codec.js";
 import { Buffer } from "node:buffer";
 

package/dist/mod.cjs

@@ -0,0 +1,13 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+const require_codec = require('./codec.cjs');
+const require_kv = require('./kv.cjs');
+const require_mq = require('./mq.cjs');
+
+exports.CodecError = require_codec.CodecError;
+exports.DecodingError = require_codec.DecodingError;
+exports.EncodingError = require_codec.EncodingError;
+exports.JsonCodec = require_codec.JsonCodec;
+exports.RedisKvStore = require_kv.RedisKvStore;
+exports.RedisMessageQueue = require_mq.RedisMessageQueue;

package/dist/mod.d.cts

@@ -0,0 +1,4 @@
+import { Codec, CodecError, DecodingError, EncodingError, JsonCodec } from "./codec.cjs";
+import { RedisKvStore, RedisKvStoreOptions } from "./kv.cjs";
+import { RedisMessageQueue, RedisMessageQueueOptions } from "./mq.cjs";
+export { Codec, CodecError, DecodingError, EncodingError, JsonCodec, RedisKvStore, RedisKvStoreOptions, RedisMessageQueue, RedisMessageQueueOptions };

package/dist/mod.js

@@ -1,6 +1,6 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-    
+        import { Temporal } from "@js-temporal/polyfill";
+      
 import { CodecError, DecodingError, EncodingError, JsonCodec } from "./codec.js";
 import { RedisKvStore } from "./kv.js";
 import { RedisMessageQueue } from "./mq.js";

package/dist/mq.cjs

@@ -0,0 +1,171 @@
+
+        const { Temporal } = require("@js-temporal/polyfill");
+      
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_codec = require('./codec.cjs');
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+
+//#region src/mq.ts
+const logger = (0, __logtape_logtape.getLogger)([
+	"fedify",
+	"redis",
+	"mq"
+]);
+/**
+* A message queue that uses Redis as the underlying storage.
+*
+* @example
+* ```ts ignore
+* import { createFederation } from "@fedify/fedify";
+* import { RedisMessageQueue } from "@fedify/redis";
+* import { Redis, Cluster } from "ioredis";
+*
+* // Using a standalone Redis instance:
+* const federation = createFederation({
+*   // ...
+*   queue: new RedisMessageQueue(() => new Redis()),
+* });
+*
+* // Using a Redis Cluster:
+* const federation = createFederation({
+*   // ...
+*   queue: new RedisMessageQueue(() => new Cluster([
+*     { host: "127.0.0.1", port: 7000 },
+*     { host: "127.0.0.1", port: 7001 },
+*     { host: "127.0.0.1", port: 7002 },
+*   ])),
+* });
+* ```
+*/
+var RedisMessageQueue = class {
+	#redis;
+	#subRedis;
+	#workerId;
+	#channelKey;
+	#queueKey;
+	#lockKey;
+	#codec;
+	#pollIntervalMs;
+	#loopHandle;
+	/**
+	* Creates a new Redis message queue.
+	* @param redis The Redis client factory.
+	* @param options The options for the message queue.
+	*/
+	constructor(redis, options = {}) {
+		this.#redis = redis();
+		this.#subRedis = redis();
+		this.#workerId = options.workerId ?? crypto.randomUUID();
+		this.#channelKey = options.channelKey ?? "fedify_channel";
+		this.#queueKey = options.queueKey ?? "fedify_queue";
+		this.#lockKey = options.lockKey ?? "fedify_lock";
+		this.#codec = options.codec ?? new require_codec.JsonCodec();
+		this.#pollIntervalMs = Temporal.Duration.from(options.pollInterval ?? { seconds: 5 }).total("millisecond");
+	}
+	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]);
+		await this.#redis.zadd(this.#queueKey, ts, encodedMessage);
+		if (ts < 1) 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 multi = this.#redis.multi();
+		for (const message of messages) {
+			const encodedMessage = this.#codec.encode([crypto.randomUUID(), message]);
+			multi.zadd(this.#queueKey, ts, encodedMessage);
+		}
+		await multi.exec();
+		if (ts < 1) this.#redis.publish(this.#channelKey, "");
+	}
+	async #poll() {
+		logger.debug("Polling for messages...");
+		const result = await this.#redis.set(this.#lockKey, this.#workerId, "EX", Math.floor(this.#pollIntervalMs / 1e3 * 2), "NX");
+		if (result == null) {
+			logger.debug("Another worker is already processing messages; skipping...");
+			return;
+		}
+		logger.debug("Acquired lock; processing messages...");
+		const messages = await this.#redis.zrangebyscoreBuffer(this.#queueKey, 0, Temporal.Now.instant().epochMilliseconds);
+		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;
+		} finally {
+			await this.#redis.del(this.#lockKey);
+		}
+	}
+	async listen(handler, options = {}) {
+		if (this.#loopHandle != null) throw new Error("Already listening");
+		const signal = options.signal;
+		const poll = async () => {
+			while (!signal?.aborted) {
+				let message;
+				try {
+					message = await this.#poll();
+				} catch (error) {
+					logger.error("Error polling for messages: {error}", { error });
+					return;
+				}
+				if (message === void 0) return;
+				await handler(message);
+			}
+		};
+		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);
+			});
+		});
+		signal?.addEventListener("abort", () => {
+			for (const timeout of timeouts) clearTimeout(timeout);
+		});
+		const timeouts = /* @__PURE__ */ new Set();
+		while (!signal?.aborted) {
+			let timeout;
+			await new Promise((resolve) => {
+				signal?.addEventListener("abort", resolve);
+				timeout = setTimeout(() => {
+					signal?.removeEventListener("abort", resolve);
+					resolve(0);
+				}, this.#pollIntervalMs);
+				timeouts.add(timeout);
+			});
+			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);
+		this.#redis.disconnect();
+		this.#subRedis.disconnect();
+	}
+};
+
+//#endregion
+exports.RedisMessageQueue = RedisMessageQueue;

package/dist/mq.d.cts

@@ -0,0 +1,86 @@
+import { Codec } from "./codec.cjs";
+import { MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions } from "@fedify/fedify";
+import { Cluster, Redis, RedisKey } from "ioredis";
+
+//#region src/mq.d.ts
+/**
+ * Options for {@link RedisMessageQueue} class.
+ */
+interface RedisMessageQueueOptions {
+  /**
+   * The unique identifier for the worker that is processing messages from the
+   * queue.  If this is not specified, a random identifier will be generated.
+   * This is used to prevent multiple workers from processing the same message,
+   * so it should be unique for each worker.
+   */
+  workerId?: string;
+  /**
+   * The Pub/Sub channel key to use for the message queue.  `"fedify_channel"`
+   * by default.
+   * @default `"fedify_channel"`
+   */
+  channelKey?: RedisKey;
+  /**
+   * The Sorted Set key to use for the delayed message queue.  `"fedify_queue"`
+   * by default.
+   * @default `"fedify_queue"`
+   */
+  queueKey?: RedisKey;
+  /**
+   * The key to use for locking the message queue.  `"fedify_lock"` by default.
+   * @default `"fedify_lock"`
+   */
+  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;
+  /**
+   * The poll interval for the message queue.  5 seconds by default.
+   * @default `{ seconds: 5 }`
+   */
+  pollInterval?: Temporal.Duration | Temporal.DurationLike;
+}
+/**
+ * A message queue that uses Redis as the underlying storage.
+ *
+ * @example
+ * ```ts ignore
+ * import { createFederation } from "@fedify/fedify";
+ * import { RedisMessageQueue } from "@fedify/redis";
+ * import { Redis, Cluster } from "ioredis";
+ *
+ * // Using a standalone Redis instance:
+ * const federation = createFederation({
+ *   // ...
+ *   queue: new RedisMessageQueue(() => new Redis()),
+ * });
+ *
+ * // Using a Redis Cluster:
+ * const federation = createFederation({
+ *   // ...
+ *   queue: new RedisMessageQueue(() => new Cluster([
+ *     { host: "127.0.0.1", port: 7000 },
+ *     { host: "127.0.0.1", port: 7001 },
+ *     { host: "127.0.0.1", port: 7002 },
+ *   ])),
+ * });
+ * ```
+ */
+declare class RedisMessageQueue implements MessageQueue, Disposable {
+  #private;
+  /**
+   * Creates a new Redis message queue.
+   * @param redis The Redis client factory.
+   * @param options The options for the message queue.
+   */
+  constructor(redis: () => Redis | Cluster, options?: RedisMessageQueueOptions);
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  enqueueMany(messages: any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  listen(handler: (message: any) => void | Promise<void>, options?: MessageQueueListenOptions): Promise<void>;
+  [Symbol.dispose](): void;
+}
+//#endregion
+export { RedisMessageQueue, RedisMessageQueueOptions };

package/dist/mq.js

@@ -1,6 +1,6 @@
 
-      import { Temporal } from "@js-temporal/polyfill";
-    
+        import { Temporal } from "@js-temporal/polyfill";
+      
 import { JsonCodec } from "./codec.js";
 import { getLogger } from "@logtape/logtape";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/redis",
-  "version": "2.0.0-pr.412.1559+4a4b1861",
+  "version": "2.0.0-pr.412.1794+5c393341",
   "description": "Redis drivers for Fedify",
   "keywords": [
     "fedify",
@@ -26,28 +26,48 @@
     "https://github.com/sponsors/dahlia"
   ],
   "type": "module",
-  "main": "./dist/mod.js",
+  "main": "./dist/mod.cjs",
   "module": "./dist/mod.js",
   "types": "./dist/mod.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/mod.d.ts",
+      "types": {
+        "import": "./dist/mod.d.ts",
+        "require": "./dist/mod.d.cts",
+        "default": "./dist/mod.d.ts"
+      },
       "import": "./dist/mod.js",
+      "require": "./dist/mod.cjs",
       "default": "./dist/mod.js"
     },
     "./codec": {
-      "types": "./dist/codec.d.ts",
+      "types": {
+        "import": "./dist/codec.d.ts",
+        "require": "./dist/codec.d.cts",
+        "default": "./dist/codec.d.ts"
+      },
       "import": "./dist/codec.js",
+      "require": "./dist/codec.cjs",
       "default": "./dist/codec.js"
     },
     "./kv": {
-      "types": "./dist/kv.d.ts",
+      "types": {
+        "import": "./dist/kv.d.ts",
+        "require": "./dist/kv.d.cts",
+        "default": "./dist/kv.d.ts"
+      },
       "import": "./dist/kv.js",
+      "require": "./dist/kv.cjs",
       "default": "./dist/kv.js"
     },
     "./mq": {
-      "types": "./dist/mq.d.ts",
+      "types": {
+        "import": "./dist/mq.d.ts",
+        "require": "./dist/mq.d.cts",
+        "default": "./dist/mq.d.ts"
+      },
       "import": "./dist/mq.js",
+      "require": "./dist/mq.cjs",
       "default": "./dist/mq.js"
     },
     "./package.json": "./package.json"
@@ -58,11 +78,11 @@
   ],
   "dependencies": {
     "@js-temporal/polyfill": "^0.5.1",
-    "@logtape/logtape": "^1.0.0"
+    "@logtape/logtape": "^1.1.1"
   },
   "peerDependencies": {
     "ioredis": "^5.6.1",
-    "@fedify/fedify": "2.0.0-pr.412.1559+4a4b1861"
+    "@fedify/fedify": "^2.0.0-pr.412.1794+5c393341"
   },
   "devDependencies": {
     "@std/async": "npm:@jsr/std__async@^1.0.13",