Polish task payload docs and cover Temporal

Three documentation points raised on the task API review, plus a
regression test backing the Temporal claim:

 -  The payload codec round-trips devalue's built-in Temporal types
    with no extra code, but the supported-payload list omitted them.
    List `Temporal` (with `Temporal.Instant` / `Temporal.Duration`
    examples) and add a serialize/deserialize round-trip test so the
    documented support stays covered.

 -  The vocab import example used the compatibility path
    `@fedify/fedify/vocab`.  Switch it to `@fedify/vocab`, matching the
    surrounding docs and the current package boundary so copied code
    does not bind to a path slated for removal.

 -  Task payloads now cross durable queue storage and can hold arbitrary
    application data.  Add a trust-boundary security note to the queue
    isolation section: treat the backend and payloads as internal
    trusted storage, pass identifiers the worker resolves rather than
    long-lived secrets, and use a dedicated task queue with
    `taskQueueResolution: "strict"` when isolation is required.

#803 (comment)
#803 (comment)
#803 (comment)

Assisted-by: Claude Code:claude-opus-4-8

Author: 2chanhaeng

docs/manual/tasks.md

@@ -57,16 +57,17 @@ Task payloads cross a message queue, so they are serialized on enqueue and
 deserialized on dispatch.  Fedify owns this codec—applications never encode
 payloads themselves.  The codec is built on [devalue], which means payloads
 are not limited to JSON: `Date`, `Map`, `Set`, `URL`, `RegExp`, `bigint`,
-typed arrays, circular references, and repeated references all round-trip
-faithfully.
+typed arrays, `Temporal` values (e.g., `Temporal.Instant`,
+`Temporal.Duration`), circular references, and repeated references all
+round-trip faithfully.
 
 Activity Vocabulary objects (`Note`, `Create`, `Person`, `Link`, and so on)
 are also supported as payload values.  Each vocabulary object is bridged
 through expanded JSON-LD on the wire and comes back as a real instance, so
 the handler can call its methods and getters as usual:
 
 ~~~~ typescript
-import { Note } from "@fedify/fedify/vocab";
+import { Note } from "@fedify/vocab";
 import { z } from "zod";
 
 const indexNote = federation.defineTask("indexNote", {
@@ -247,6 +248,14 @@ A task that falls back to the outbox queue needs no dedicated worker; the
 outbox worker dispatches every message by its type regardless of which queue
 delivered it.
 
+> [!CAUTION]
+> Task payloads cross durable queue storage, so treat the queue backend and
+> its payloads as internal, trusted storage.  Do not place long-lived secrets
+> or credentials directly in a task payload; pass an identifier that the
+> worker resolves from your application storage instead.  When task workloads
+> must stay isolated from ActivityPub delivery, give them a dedicated task
+> queue and set `taskQueueResolution: "strict"`.
+
 
 Limitations
 -----------

packages/fedify/src/federation/tasks/codec.test.ts

@@ -210,6 +210,22 @@ test("TaskCodec.serialize() / deserialize()", async (t) => {
       strictEqual(decoded.big[length - 1], length - 1);
     },
   );
+
+  await t.step("round-trips Temporal values", async () => {
+    const payload = {
+      instant: Temporal.Instant.from("2026-01-02T03:04:05Z"),
+      duration: Temporal.Duration.from({ hours: 1, minutes: 30 }),
+    };
+    const encoded = await codec.serialize(payload);
+    const decoded = await codec.deserialize(encoded) as {
+      instant: Temporal.Instant;
+      duration: Temporal.Duration;
+    };
+    ok(decoded.instant instanceof Temporal.Instant);
+    ok(decoded.instant.equals(payload.instant));
+    ok(decoded.duration instanceof Temporal.Duration);
+    strictEqual(decoded.duration.toString(), payload.duration.toString());
+  });
 });
 
 test("TaskCodec (one instance reused across decodes)", async (t) => {