@fedify/fedify 2.3.0 → 2.4.0-dev.1422

package/dist/testing/mod.d.mts

@@ -2,11 +2,12 @@ import { Temporal } from "@js-temporal/polyfill";
 import { URLPattern } from "urlpattern-polyfill";
 import { ExportResultCode } from "@opentelemetry/core";
 import { Router } from "@fedify/uri-template";
-import { Activity, Actor, Collection, CryptographicKey, Hashtag, Link, LookupObjectOptions, Multikey, Object as Object$1, Recipient, Tombstone, TraverseCollectionOptions } from "@fedify/vocab";
+import { Activity, Actor, Collection, CryptographicKey, Hashtag, Link, LookupObjectOptions, Multikey, Note, Object as Object$1, Recipient, Tombstone, TraverseCollectionOptions } from "@fedify/vocab";
 import { Link as Link$1, LookupWebFingerOptions, ResourceDescriptor } from "@fedify/webfinger";
 import { MeterProvider, TracerProvider } from "@opentelemetry/api";
 import { DocumentLoader, GetUserAgentOptions } from "@fedify/vocab-runtime";
 import { MeterProvider as MeterProvider$1, MetricReader } from "@opentelemetry/sdk-metrics";
+import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region src/nodeinfo/types.d.ts
 /**
@@ -580,6 +581,278 @@ type CustomCollectionCounter<TParam extends string, TContextData> = (context: Re
  */
 type CustomCollectionCursor<TParam extends string, TContext extends Context<TContextData>, TContextData> = (context: TContext, values: Record<TParam, string>) => string | null | Promise<string | null>;
 //#endregion
+//#region src/federation/mq.d.ts
+/**
+ * Additional options for enqueuing a message in a queue.
+ *
+ * @since 0.5.0
+ */
+interface MessageQueueEnqueueOptions {
+  /**
+   * The delay before the message is enqueued.  No delay by default.
+   *
+   * It must not be negative.
+   */
+  readonly delay?: Temporal.Duration;
+  /**
+   * An optional key that ensures messages with the same ordering key are
+   * processed sequentially (one at a time).  Messages with different ordering
+   * keys (or no ordering key) may be processed in parallel.
+   *
+   * This is useful for ensuring that related messages are processed in order,
+   * such as ensuring that a `Delete` activity is processed after a `Create`
+   * activity for the same object.
+   *
+   * @since 2.0.0
+   */
+  readonly orderingKey?: string;
+}
+/**
+ * Additional options for listening to a message queue.
+ *
+ * @since 1.0.0
+ */
+interface MessageQueueListenOptions {
+  /**
+   * The signal to abort listening to the message queue.
+   */
+  signal?: AbortSignal;
+}
+/**
+ * The number of messages waiting in a message queue.
+ *
+ * @since 2.3.0
+ */
+interface MessageQueueDepth {
+  /**
+   * The total number of messages still waiting in the backend queue.
+   *
+   * This does not include messages that have already been handed to a worker
+   * for processing.
+   */
+  readonly queued: number;
+  /**
+   * The number of queued messages eligible for immediate processing.
+   *
+   * Queue backends that cannot cheaply distinguish ready and delayed messages
+   * may omit this field.
+   */
+  readonly ready?: number;
+  /**
+   * The number of queued messages scheduled for later delivery.
+   *
+   * Queue backends that cannot cheaply distinguish ready and delayed messages
+   * may omit this field.
+   */
+  readonly delayed?: number;
+}
+/**
+ * An abstract interface for a message queue.
+ *
+ * @since 0.5.0
+ */
+interface MessageQueue {
+  /**
+   * Whether the message queue backend provides native retry mechanisms.
+   * When `true`, Fedify will skip its own retry logic and rely on the backend
+   * to handle retries. When `false` or omitted, Fedify will handle retries
+   * using its own retry policies.
+   *
+   * @default `false`
+   * @since 1.7.0
+   */
+  readonly nativeRetrial?: boolean;
+  /**
+   * Enqueues a message in the queue.
+   * @param message The message to enqueue.
+   * @param options Additional options for enqueuing the message.
+   */
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  /**
+   * Enqueues multiple messages in the queue.  This operation is optional,
+   * and may not be supported by all implementations.  If not supported,
+   * Fedify will invoke {@link enqueue} for each message.
+   *
+   * @param messages The messages to enqueue.
+   * @param options Additional options for enqueuing the messages.
+   */
+  enqueueMany?: (messages: readonly any[], options?: MessageQueueEnqueueOptions) => Promise<void>;
+  /**
+   * Listens for messages in the queue.
+   * @param handler The handler for messages in the queue.
+   * @param options Additional options for listening to the message queue.
+   * @returns A promise that resolves when the listening is done.  It never
+   *          rejects, and is resolved when the signal is aborted.  If no
+   *          signal is provided, it never resolves.
+   */
+  listen(handler: (message: any) => Promise<void> | void, options?: MessageQueueListenOptions): Promise<void>;
+  /**
+   * Gets the number of messages waiting in the queue.
+   *
+   * This operation is optional, and may not be supported by all
+   * implementations.  The returned counts exclude messages currently being
+   * handled by a worker.
+   *
+   * @since 2.3.0
+   */
+  getDepth?(): Promise<MessageQueueDepth>;
+}
+//#endregion
+//#region src/federation/retry.d.ts
+/**
+ * The context passed to a {@link RetryPolicy} callback.
+ * @since 0.12.0
+ */
+interface RetryContext {
+  /**
+   * The elapsed time since the first attempt.
+   */
+  readonly elapsedTime: Temporal.Duration;
+  /**
+   * The number of attempts so far.
+   */
+  readonly attempts: number;
+}
+/**
+ * A policy that determines the delay before the next retry.
+ * @param context The retry context.
+ * @returns The delay before the next retry, or `null` to stop retrying.
+ *          It must not negative.
+ * @since 0.12.0
+ */
+type RetryPolicy = (context: RetryContext) => Temporal.Duration | null;
+//#endregion
+//#region src/federation/tasks/task.d.ts
+/**
+ * A callback that processes a custom background task.
+ * @template TContextData The context data to pass to the {@link Context}.
+ * @template TData The type of the task payload, inferred from the task's
+ *                 schema.
+ * @param ctx The context for the worker processing the task.
+ * @param data The decoded and validated task payload.
+ * @since 2.x.x
+ */
+type TaskHandler<TContextData, TData> = (ctx: Context<TContextData>, data: TData) => Promise<void> | void;
+/**
+ * Options for {@link TaskRegistry.defineTask}.
+ * @template TContextData The context data to pass to the {@link Context}.
+ * @template TSchema The [Standard Schema](https://standardschema.dev/) that
+ *                   validates the task payload.
+ * @since 2.x.x
+ */
+interface TaskDefinitionOptions<TContextData, TSchema extends StandardSchemaV1> {
+  /**
+   * The [Standard Schema](https://standardschema.dev/) that validates the
+   * task payload.  The payload type is inferred from this schema.
+   *
+   * The payload is validated twice: once at enqueue time (fail fast) and
+   * once at dequeue time (drift protection against payloads enqueued by an
+   * older deployment).  Because the same schema runs on both sides, its
+   * validation must be idempotent: the validated output must itself be
+   * a valid input.  Transforming schemas (e.g., Zod's `.transform()`) whose
+   * output differs in shape from their input are not supported.
+   */
+  readonly schema: TSchema;
+  /**
+   * The callback that processes the task on a background worker.
+   */
+  readonly handler: TaskHandler<TContextData, StandardSchemaV1.InferOutput<TSchema>>;
+  /**
+   * The retry policy for this task.  If omitted, the federation-wide
+   * task retry policy is used, which defaults to an exponential backoff
+   * policy.
+   */
+  readonly retryPolicy?: RetryPolicy;
+  /**
+   * A callback invoked when the {@link handler} throws an error, before
+   * a retry is scheduled.
+   * @param ctx The context for the worker processing the task.
+   * @param error The error thrown by the handler.
+   * @param data The decoded and validated task payload.
+   */
+  readonly onError?: (ctx: Context<TContextData>, error: unknown, data: StandardSchemaV1.InferOutput<TSchema>) => Promise<void> | void;
+  /**
+   * The message queue dedicated to this task.  If omitted, the task is
+   * routed to the federation-wide task queue, falling back to the outbox
+   * queue (unless `taskQueueResolution: "strict"` is configured).
+   */
+  readonly queue?: MessageQueue;
+}
+/**
+ * Phantom key binding a {@link TaskDefinition} to its federation's context
+ * data type.  Declared only—no value exists at runtime, and the symbol is
+ * not exported, so the marker stays out of user-facing completions.
+ */
+declare const contextDataBrand: unique symbol;
+/**
+ * The handle returned by {@link TaskRegistry.defineTask}.  It carries the
+ * task name and schema so that {@link Context.enqueueTask} can validate the
+ * payload and infer its type at every call site.
+ * @template TContextData The context data to pass to the {@link Context}.
+ * @template TData The type of the task payload, inferred from the task's
+ *                 schema.
+ * @since 2.x.x
+ */
+interface TaskDefinition<TContextData, TData> {
+  /**
+   * The unique name of the task.
+   */
+  readonly name: string;
+  /**
+   * The [Standard Schema](https://standardschema.dev/) that validates the
+   * task payload.
+   */
+  readonly schema: StandardSchemaV1<unknown, TData>;
+  /**
+   * @internal Phantom marker binding the handle to its federation.
+   */
+  readonly [contextDataBrand]?: TContextData;
+}
+/**
+ * Registration of custom background tasks.  Both {@link Federation} and
+ * {@link FederationBuilder} implement this interface.
+ * @template TContextData The context data to pass to the {@link Context}.
+ * @since 2.x.x
+ */
+interface TaskRegistry<TContextData> {
+  /**
+   * Defines a custom background task.  The returned handle is passed to
+   * {@link Context.enqueueTask} to enqueue the task.
+   *
+   * @example
+   * ``` typescript
+   * const sendDigest = federation.defineTask("sendDigest", {
+   *   schema: digestSchema,
+   *   handler: async (ctx, data) => {
+   *     // …process the payload on a background worker…
+   *   },
+   * });
+   * ```
+   *
+   * @param name The unique name of the task.
+   * @param options The task definition options.  The payload type is
+   *                inferred from `options.schema`.
+   * @returns The handle to pass to {@link Context.enqueueTask}.
+   * @throws {TypeError} If a task with the same name is already defined.
+   */
+  defineTask<TSchema extends StandardSchemaV1>(name: string, options: TaskDefinitionOptions<TContextData, TSchema>): TaskDefinition<TContextData, StandardSchemaV1.InferOutput<TSchema>>;
+}
+/**
+ * Options for {@link Context.enqueueTask} and {@link Context.enqueueTaskMany}.
+ * @since 2.x.x
+ */
+interface TaskEnqueueOptions {
+  /**
+   * The delay before the task is processed.  No delay by default.
+   */
+  readonly delay?: Temporal.DurationLike;
+  /**
+   * An optional key that ensures tasks with the same ordering key are
+   * processed sequentially (one at a time).
+   */
+  readonly orderingKey?: string;
+}
+//#endregion
 //#region src/federation/queue.d.ts
 interface SenderKeyJwkPair {
   readonly keyId: string;
@@ -594,7 +867,7 @@ interface SenderKeyJwkPair {
  * type.
  * @since 1.6.0
  */
-type Message = FanoutMessage | OutboxMessage | InboxMessage;
+type Message = FanoutMessage | OutboxMessage | InboxMessage | TaskMessage;
 interface FanoutMessage {
   readonly type: "fanout";
   readonly id: ReturnType<typeof crypto.randomUUID>;
@@ -648,6 +921,24 @@ interface OutboxMessage {
   readonly circuitHeldSince?: string;
   readonly traceContext: Readonly<Record<string, string>>;
 }
+/**
+ * A message that carries a custom background task.  Every field is
+ * a string, number, or plain record so that the message survives both
+ * JSON serialization and structured clone on every queue backend.
+ * @since 2.x.x
+ */
+interface TaskMessage {
+  readonly type: "task";
+  readonly id: ReturnType<typeof crypto.randomUUID>;
+  readonly baseUrl: string;
+  readonly taskName: string;
+  /** devalue-encoded task data; vocab objects bridged to expanded JSON-LD. */
+  readonly data: string;
+  readonly started: string;
+  readonly attempt: number;
+  readonly orderingKey?: string;
+  readonly traceContext: Readonly<Record<string, string>>;
+}
 interface InboxMessage {
   readonly type: "inbox";
   readonly id: ReturnType<typeof crypto.randomUUID>;
@@ -707,18 +998,18 @@ interface FederationStartQueueOptions {
   signal?: AbortSignal;
   /**
    * Starts the task worker only for the specified queue.  If unspecified,
-   * which is the default, the task worker starts for all three queues:
-   * inbox, outbox, and fanout.
+   * which is the default, the task worker starts for all four queues:
+   * inbox, outbox, fanout, and task.
    * @since 1.3.0
    */
-  queue?: "inbox" | "outbox" | "fanout";
+  queue?: "inbox" | "outbox" | "fanout" | "task";
 }
 /**
  * A common interface between {@link Federation} and {@link FederationBuilder}.
  * @template TContextData The context data to pass to the {@link Context}.
  * @since 1.6.0
  */
-interface Federatable<TContextData> {
+interface Federatable<TContextData> extends TaskRegistry<TContextData> {
   /**
    * Registers a NodeInfo dispatcher.
    * @param path The URI path pattern for the NodeInfo dispatcher.  The syntax
@@ -1887,6 +2178,44 @@ interface Context<TContextData> {
    * @since 1.3.0
    */
   routeActivity(recipient: string | null, activity: Activity, options?: RouteActivityOptions): Promise<boolean>;
+  /**
+   * Enqueues a custom background task.  The payload is validated against
+   * the task's schema, serialized, and processed by the task's handler on
+   * a background worker.
+   *
+   * @example
+   * ``` typescript
+   * await ctx.enqueueTask(sendDigest, { userId: "alice" });
+   * ```
+   *
+   * @template TData The type of the task payload, inferred from the task's
+   *                 schema.
+   * @param task The handle returned by {@link TaskRegistry.defineTask}.
+   * @param data The task payload.  It is validated against the task's
+   *             schema before being enqueued.
+   * @param options Options for enqueuing the task.
+   * @throws {TypeError} If the task is not defined on this federation,
+   *                     if no message queue is configured for tasks, or if
+   *                     the payload fails schema validation.
+   * @since 2.x.x
+   */
+  enqueueTask<TData>(task: TaskDefinition<TContextData, TData>, data: TData, options?: TaskEnqueueOptions): Promise<void>;
+  /**
+   * Enqueues multiple payloads for a custom background task at once.
+   * Uses the queue's bulk enqueue operation when available, falling back
+   * to parallel single enqueues.
+   * @template TData The type of the task payload, inferred from the task's
+   *                 schema.
+   * @param task The handle returned by {@link TaskRegistry.defineTask}.
+   * @param payloads The task payloads.  Each is validated against the
+   *                 task's schema before being enqueued.
+   * @param options Options for enqueuing the tasks.
+   * @throws {TypeError} If the task is not defined on this federation,
+   *                     if no message queue is configured for tasks, or if
+   *                     a payload fails schema validation.
+   * @since 2.x.x
+   */
+  enqueueTaskMany<TData>(task: TaskDefinition<TContextData, TData>, payloads: readonly TData[], options?: TaskEnqueueOptions): Promise<void>;
   /**
    * Builds the URI of a collection of objects with the given name and values.
    * @param name The name of the collection, which can be a string or a symbol.
@@ -2470,9 +2799,51 @@ declare function createOutboxContext<TContextData>(args: Partial<OutboxContext<T
   federation: Federation<TContextData>;
 }): OutboxContext<TContextData>;
 //#endregion
+//#region src/testing/tasks.d.ts
+/**
+ * Builds a minimal [Standard Schema](https://standardschema.dev/) from a type
+ * guard, for use as a task payload schema in tests.
+ */
+declare const makeSchema: <T>(check: (data: unknown) => data is T) => StandardSchemaV1<unknown, T>;
+declare const stringSchema: StandardSchemaV1<unknown, string>;
+declare const numberSchema: StandardSchemaV1<unknown, number>;
+/** A task payload that carries a vocabulary object, to exercise the codec's
+ * vocab-to-JSON-LD bridging. */
+interface Envelope {
+  note: Note;
+  title: string;
+}
+declare const envelopeSchema: StandardSchemaV1<unknown, Envelope>;
+/** Options for {@link MockQueue}. */
+interface MockQueueOptions {
+  readonly nativeRetrial?: boolean;
+  readonly supportsEnqueueMany?: boolean;
+}
+/**
+ * A {@link MessageQueue} that records what it was asked to enqueue and resolves
+ * its `listen()` when the abort signal fires, so tests can inspect dispatch
+ * without a real backend.
+ */
+declare class MockQueue implements MessageQueue {
+  readonly nativeRetrial: boolean;
+  readonly enqueued: {
+    message: TaskMessage;
+    options?: MessageQueueEnqueueOptions;
+  }[];
+  readonly enqueuedMany: {
+    messages: readonly TaskMessage[];
+    options?: MessageQueueEnqueueOptions;
+  }[];
+  listenCount: number;
+  enqueueMany?: (messages: readonly TaskMessage[], options?: MessageQueueEnqueueOptions) => Promise<void>;
+  constructor(options?: MockQueueOptions);
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  listen(_handler: (message: any) => Promise<void> | void, options?: MessageQueueListenOptions): Promise<void>;
+}
+//#endregion
 //#region ../fixture/dist/mod.d.ts
 //#endregion
 //#region src/test.d.ts
 declare const testDefinitions: Deno.TestDefinition[];
 //#endregion
-export { createInboxContext, createOutboxContext, createRequestContext, testDefinitions };
+export { type Envelope, MockQueue, type MockQueueOptions, createInboxContext, createOutboxContext, createRequestContext, envelopeSchema, makeSchema, numberSchema, stringSchema, testDefinitions };

package/dist/testing/mod.mjs

@@ -1,5 +1,6 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { i as testDefinitions, n as createOutboxContext, r as createRequestContext, t as createInboxContext } from "../context-DVoTs_wM.mjs";
-export { createInboxContext, createOutboxContext, createRequestContext, testDefinitions };
+import { i as testDefinitions, n as createOutboxContext, r as createRequestContext, t as createInboxContext } from "../context-BrIOaBSs.mjs";
+import { a as stringSchema, i as numberSchema, n as envelopeSchema, r as makeSchema, t as MockQueue } from "../testing-CjYPStvE.mjs";
+export { MockQueue, createInboxContext, createOutboxContext, createRequestContext, envelopeSchema, makeSchema, numberSchema, stringSchema, testDefinitions };

package/dist/testing-CjYPStvE.mjs

@@ -0,0 +1,55 @@
+import "@js-temporal/polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import "./context-BrIOaBSs.mjs";
+import { Note } from "@fedify/vocab";
+//#region src/testing/tasks.ts
+/**
+* Builds a minimal [Standard Schema](https://standardschema.dev/) from a type
+* guard, for use as a task payload schema in tests.
+*/
+const makeSchema = (check) => ({ "~standard": {
+	version: 1,
+	vendor: "fedify-test",
+	validate: (value) => check(value) ? { value } : { issues: [{ message: "Invalid task data." }] }
+} });
+const stringSchema = makeSchema((d) => typeof d === "string");
+const numberSchema = makeSchema((d) => typeof d === "number");
+const envelopeSchema = makeSchema((data) => typeof data === "object" && data != null && data.note instanceof Note && typeof data.title === "string");
+/**
+* A {@link MessageQueue} that records what it was asked to enqueue and resolves
+* its `listen()` when the abort signal fires, so tests can inspect dispatch
+* without a real backend.
+*/
+var MockQueue = class {
+	nativeRetrial;
+	enqueued = [];
+	enqueuedMany = [];
+	listenCount = 0;
+	enqueueMany;
+	constructor(options = {}) {
+		this.nativeRetrial = options.nativeRetrial ?? false;
+		if (options.supportsEnqueueMany) this.enqueueMany = (messages, opts) => {
+			this.enqueuedMany.push({
+				messages,
+				options: opts
+			});
+			return Promise.resolve();
+		};
+	}
+	enqueue(message, options) {
+		this.enqueued.push({
+			message,
+			options
+		});
+		return Promise.resolve();
+	}
+	listen(_handler, options) {
+		this.listenCount++;
+		return new Promise((resolve) => {
+			options?.signal?.addEventListener("abort", () => resolve());
+		});
+	}
+};
+//#endregion
+export { stringSchema as a, numberSchema as i, envelopeSchema as n, makeSchema as r, MockQueue as t };

package/dist/utils/docloader.test.mjs

@@ -2,12 +2,12 @@ import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { t as esm_default } from "../esm-vrlUxr60.mjs";
-import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
-import "../std__assert-BBjXFNOb.mjs";
-import { t as assertRejects } from "../assert_rejects-DN60FHPX.mjs";
-import { l as verifyRequest } from "../http-Cm_e9dY7.mjs";
-import { i as rsaPrivateKey2 } from "../keys-DGu1NFwu.mjs";
-import { t as getAuthenticatedDocumentLoader } from "../docloader-Bu-Oecom.mjs";
+import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
+import "../std__assert-BTEgfoJo.mjs";
+import { t as assertRejects } from "../assert_rejects-DQP-q39h.mjs";
+import { l as verifyRequest } from "../http-GQoPA_YT.mjs";
+import { i as rsaPrivateKey2 } from "../keys-C3kae-6B.mjs";
+import { t as getAuthenticatedDocumentLoader } from "../docloader-B8AJowCx.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { UrlError } from "@fedify/vocab-runtime";
 //#region src/utils/docloader.test.ts

package/dist/utils/kv-cache.test.mjs

@@ -1,7 +1,7 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { URLPattern } from "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as kvCache, t as MockKvStore } from "../kv-cache-B3Na5DMI.mjs";
+import { n as kvCache, t as MockKvStore } from "../kv-cache-pw-kBdVz.mjs";
 import { deepStrictEqual, throws } from "node:assert";
 import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { preloadedContexts } from "@fedify/vocab-runtime";

package/dist/utils/mod.cjs

@@ -1,6 +1,6 @@
 const { Temporal } = require("@js-temporal/polyfill");
 const { URLPattern } = require("urlpattern-polyfill");
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_kv_cache = require("../kv-cache-QkLiue07.cjs");
+const require_kv_cache = require("../kv-cache-DXwu7BtY.cjs");
 exports.getAuthenticatedDocumentLoader = require_kv_cache.getAuthenticatedDocumentLoader;
 exports.kvCache = require_kv_cache.kvCache;

package/dist/utils/mod.js

@@ -1,4 +1,4 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { n as getAuthenticatedDocumentLoader, t as kvCache } from "../kv-cache-BQLjC1KN.js";
+import { n as getAuthenticatedDocumentLoader, t as kvCache } from "../kv-cache-CjEcb9qH.js";
 export { getAuthenticatedDocumentLoader, kvCache };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/fedify",
-  "version": "2.3.0",
+  "version": "2.4.0-dev.1422+7668da16",
   "description": "An ActivityPub server framework",
   "keywords": [
     "ActivityPub",
@@ -146,16 +146,18 @@
     "@opentelemetry/sdk-metrics": "2.7.1",
     "@opentelemetry/sdk-trace-base": "^2.7.1",
     "@opentelemetry/semantic-conventions": "^1.40.0",
+    "@standard-schema/spec": "^1.1.0",
     "byte-encodings": "^1.0.11",
+    "devalue": "^5.8.1",
     "es-toolkit": "1.46.1",
     "json-canon": "^1.0.1",
     "jsonld": "^9.0.0",
     "structured-field-values": "^2.0.4",
     "urlpattern-polyfill": "^10.1.0",
-    "@fedify/uri-template": "2.3.0",
-    "@fedify/vocab": "2.3.0",
-    "@fedify/vocab-runtime": "2.3.0",
-    "@fedify/webfinger": "2.3.0"
+    "@fedify/uri-template": "2.4.0-dev.1422+7668da16",
+    "@fedify/vocab-runtime": "2.4.0-dev.1422+7668da16",
+    "@fedify/vocab": "2.4.0-dev.1422+7668da16",
+    "@fedify/webfinger": "2.4.0-dev.1422+7668da16"
   },
   "devDependencies": {
     "@std/assert": "npm:@jsr/std__assert@^0.226.0",
@@ -168,7 +170,7 @@
     "typescript": "^6.0.0",
     "wrangler": "^4.17.0",
     "@fedify/fixture": "2.0.0",
-    "@fedify/vocab-tools": "^2.3.0"
+    "@fedify/vocab-tools": "^2.4.0-dev.1422+7668da16"
   },
   "scripts": {
     "build:self": "tsdown",