Store task definitions in a prototype-safe Map

`FederationBuilderImpl.taskDefinitions` was a plain object, so the
duplicate check `name in this.taskDefinitions` and the lookups
`this.taskDefinitions[taskName]` consulted the prototype chain.  Task
names are arbitrary user-supplied strings, so a name such as
"constructor", "toString", or "__proto__" was wrongly reported as
already defined and resolved to an inherited method on lookup.

Switch the registry to a `Map`, which is immune to prototype keys by
construction and avoids the clone footgun where a later spread or
`Object.assign` would silently reintroduce the prototype.  Sibling
registries stay plain objects since they are keyed by controlled
values (type-id URLs).  Add a regression test covering names that
collide with `Object.prototype`.

#803 (comment)

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

Author: 2chanhaeng

packages/fedify/src/federation/builder.ts

@@ -188,7 +188,7 @@ export class FederationBuilderImpl<TContextData>
       TContextData
     >
   >;
-  taskDefinitions: Record<string, TaskDefinitionInternal<TContextData>>;
+  taskDefinitions: Map<string, TaskDefinitionInternal<TContextData>>;
 
   /**
    * Symbol registry for unique identification of unnamed symbols.
@@ -201,7 +201,7 @@ export class FederationBuilderImpl<TContextData>
     this.objectTypeIds = {};
     this.collectionCallbacks = {};
     this.collectionTypeIds = {};
-    this.taskDefinitions = {};
+    this.taskDefinitions = new Map();
   }
 
   /**
@@ -267,7 +267,7 @@ export class FederationBuilderImpl<TContextData>
     f.unverifiedActivityHandler = this.unverifiedActivityHandler;
     f.outboxPermanentFailureHandler = this.outboxPermanentFailureHandler;
     f.idempotencyStrategy = this.idempotencyStrategy;
-    f.taskDefinitions = { ...this.taskDefinitions };
+    f.taskDefinitions = new Map(this.taskDefinitions);
     return f;
   }
 
@@ -607,18 +607,18 @@ export class FederationBuilderImpl<TContextData>
     name: string,
     options: TaskDefinitionOptions<TContextData, TSchema>,
   ): TaskDefinition<TContextData, StandardSchemaV1.InferOutput<TSchema>> {
-    if (name in this.taskDefinitions) {
+    if (this.taskDefinitions.has(name)) {
       throw new TypeError(`Task ${JSON.stringify(name)} is already defined.`);
     }
-    this.taskDefinitions[name] = {
+    this.taskDefinitions.set(name, {
       name,
       schema: options.schema,
       handler: options.handler as TaskHandler<TContextData, unknown>,
       onError: options
         .onError as TaskDefinitionInternal<TContextData>["onError"],
       retryPolicy: options.retryPolicy,
       queue: options.queue,
-    };
+    });
     return { name, schema: options.schema };
   }
 

packages/fedify/src/federation/middleware.ts

@@ -957,7 +957,7 @@ export class FederationImpl<TContextData>
   }
 
   resolveTaskQueue(taskName: string): MessageQueue | undefined {
-    const def = this.taskDefinitions[taskName];
+    const def = this.taskDefinitions.get(taskName);
     const resolved = def?.queue ?? this.taskQueue;
     if (resolved != null) return resolved;
     return this.taskQueueResolution === "strict" ? undefined : this.outboxQueue;
@@ -2119,7 +2119,7 @@ export class FederationImpl<TContextData>
     message: TaskMessage,
   ): Promise<void> {
     const logger = getLogger(["fedify", "federation", "task"]);
-    const def = this.taskDefinitions[message.taskName];
+    const def = this.taskDefinitions.get(message.taskName);
     if (def == null) {
       // Unknown task: a handler won't appear by retrying.  Drop and log.
       logger.warn(

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

@@ -169,6 +169,33 @@ test("defineTask()", async (t) => {
     );
   });
 
+  await t.step("accepts names that collide with Object.prototype", () => {
+    const federation = createFederation<void>({
+      ...baseOptions,
+      queue: { task: new MockQueue() },
+    }) as FederationImpl<void>;
+    // These names exist on Object.prototype; a plain-object registry would
+    // mistake them for already-defined tasks (`name in {}`) and would return
+    // an inherited method on lookup.
+    for (const name of ["constructor", "toString", "hasOwnProperty"]) {
+      const task = federation.defineTask(name, {
+        schema: stringSchema,
+        handler: () => {},
+      });
+      strictEqual(task.name, name);
+      strictEqual(federation.taskDefinitions.get(name)?.name, name);
+    }
+    // A genuine duplicate still throws.
+    throws(
+      () =>
+        federation.defineTask("toString", {
+          schema: stringSchema,
+          handler: () => {},
+        }),
+      { name: "TypeError", message: /already defined/ },
+    );
+  });
+
   await t.step("build() clones the task registry", async () => {
     const builder = createFederationBuilder<void>();
     builder.defineTask("first", {
@@ -187,11 +214,11 @@ test("defineTask()", async (t) => {
       ...baseOptions,
       queue: { task: new MockQueue() },
     }) as FederationImpl<void>;
-    deepStrictEqual(Object.keys(f1.taskDefinitions), ["first"]);
-    deepStrictEqual(Object.keys(f2.taskDefinitions), ["first", "second"]);
+    deepStrictEqual([...f1.taskDefinitions.keys()], ["first"]);
+    deepStrictEqual([...f2.taskDefinitions.keys()], ["first", "second"]);
     // Defining on a built federation does not leak back into the builder:
     f1.defineTask("third", { schema: stringSchema, handler: () => {} });
-    deepStrictEqual(Object.keys(f2.taskDefinitions), ["first", "second"]);
+    deepStrictEqual([...f2.taskDefinitions.keys()], ["first", "second"]);
   });
 });