fix(core): accept IPC acks for void callbacks under zod 4.4+

FLUSH and CANCEL declare `callback: z.void()`, so the child acks with
`message: undefined`. Node's JSON IPC serialization drops that key, and
zod 4.4+ treats a `z.any()` key as required, so the ACK packet failed to
parse and `sendWithAck` waited out its full timeout: ~6s on every run
completion and ~31s on cancel. Make the ACK packet's `message` optional.

Fixes #4979

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: NERLOE

.changeset/void-ipc-acks.md

@@ -0,0 +1,5 @@
+---
+"@trigger.dev/core": patch
+---
+
+Fix a ~6 second delay between a task finishing and its run completing (and a ~31 second delay when cancelling a run) in projects that use zod 4.4 or newer.

packages/core/src/v3/zodIpc.ts

@@ -124,7 +124,9 @@ const Packet = discriminatedUnion("type", [
   }),
   z.object({
     type: z.literal("ACK"),
-    message: z.any(),
+    // Optional: a void callback acks with `message: undefined`, and `process.send`
+    // drops undefined keys when serializing, so the key is absent on arrival.
+    message: z.any().optional(),
     id: z.number(),
   }),
   z.object({

packages/core/test/zodIpc.test.ts

@@ -0,0 +1,83 @@
+import { EventEmitter } from "node:events";
+import { describe, expect, it } from "vitest";
+import { z } from "zod/v4";
+import { ZodIpcConnection } from "../src/v3/zodIpc.js";
+
+// A pair of in-memory endpoints that serialize packets the same way Node's default
+// ("json") IPC serialization does, so keys with `undefined` values are dropped in transit.
+function createIpcPair() {
+  const parentEvents = new EventEmitter();
+  const childEvents = new EventEmitter();
+
+  const endpoint = (inbox: EventEmitter, outbox: EventEmitter) => ({
+    connected: true,
+    send: (message: unknown) => {
+      const serialized = JSON.stringify(message);
+      setImmediate(() => outbox.emit("message", JSON.parse(serialized)));
+      return true;
+    },
+    on: (event: "message", listener: (message: any) => void) => {
+      inbox.on(event, listener);
+    },
+  });
+
+  return {
+    parent: endpoint(parentEvents, childEvents),
+    child: endpoint(childEvents, parentEvents),
+  };
+}
+
+const ParentToChild = {
+  FLUSH: {
+    message: z.object({ timeoutInMs: z.number() }),
+    callback: z.void(),
+  },
+  PING: {
+    message: z.object({ value: z.string() }),
+    callback: z.object({ echoed: z.string() }),
+  },
+};
+
+const ChildToParent = {};
+
+function createConnections() {
+  const { parent, child } = createIpcPair();
+
+  const parentConnection = new ZodIpcConnection({
+    listenSchema: ChildToParent,
+    emitSchema: ParentToChild,
+    process: parent,
+  });
+
+  new ZodIpcConnection({
+    listenSchema: ParentToChild,
+    emitSchema: ChildToParent,
+    process: child,
+    handlers: {
+      FLUSH: async () => {},
+      PING: async ({ value }) => ({ echoed: value }),
+    },
+  });
+
+  return parentConnection;
+}
+
+describe("ZodIpcConnection", () => {
+  it("resolves sendWithAck for a void callback after the ack crosses a JSON boundary", async () => {
+    const connection = createConnections();
+
+    const start = Date.now();
+    await expect(connection.sendWithAck("FLUSH", { timeoutInMs: 1000 }, 1000)).resolves.toBe(
+      undefined
+    );
+    expect(Date.now() - start).toBeLessThan(500);
+  });
+
+  it("resolves sendWithAck with the callback payload", async () => {
+    const connection = createConnections();
+
+    await expect(connection.sendWithAck("PING", { value: "hello" }, 1000)).resolves.toEqual({
+      echoed: "hello",
+    });
+  });
+});