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

Closes #4979

Credit to @marcus-dk for finding and root-causing this in #4979,
including the zod version bisect and the end-to-end confirmation with a
patched worker.

## Summary

`FLUSH` and `CANCEL` declare `callback: z.void()`, so the task run
process acks them with `{ type: "ACK", id, message: undefined }`. Node's
JSON IPC serialization drops the undefined `message` key. Under zod 4.4+
a `z.any()` object key is required at parse time (it was optional under
zod 3 and 4.0–4.3), so `Packet.safeParse` rejects every such ack,
`#handlePacket` returns silently, and `sendWithAck` waits out its full
timeout.

Because `zodIpc.ts` imports `zod/v4` and `@trigger.dev/core` resolves
`zod` from the user's project, every project on zod ≥ 4.4 pays this on
every run: ~6 s between the task finishing and the completion reaching
the engine (FLUSH: 5 s + 1 s), and ~31 s on cancel.

The fix makes the ACK packet's `message` optional again
(`z.any().optional()`). Only the ACK packet can legitimately carry
`undefined`, so the other packets are unchanged.

## ✅ Checklist

- [x] I have followed every step in the [contributing
guide](https://github.com/triggerdotdev/trigger.dev/blob/main/CONTRIBUTING.md)
- [x] The PR title follows the convention.
- [x] I ran and tested the code works

---

## Testing

- Added `packages/core/test/zodIpc.test.ts`: forks a real child process
(`test/fixtures/zodIpcChild.ts`) and sends `FLUSH` (void callback) and
`PING` (payload callback) over Node's IPC channel, so the ack goes
through the same JSON serialization as between a worker and its task run
process. On `main` (zod 4.5.4 in this repo) the void-callback test fails
with `sendWithAck() timeout`; with the fix it resolves immediately.
- `pnpm run build --filter @trigger.dev/core` passes.
- Production evidence from our self-hosted instance (`completed_at -
started_at - usage_duration_ms` on successful runs):

| SDK | runs | p10 gap | p50 gap |
|---|---|---|---|
| 4.5.12 | 2.6M | 179 ms | 244 ms |
| 4.5.15 | 5.0M | 176 ms | 251 ms |
| 4.6.0 | 1.6M | 6,162 ms | 6,196 ms |
| 4.6.2 | 4.0M | 6,180 ms | 6,240 ms |

---

## Changelog

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.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Co-authored-by: Matt Aitken <matt@mattaitken.com>

Author: 3 people

.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. Run cost and billed usage was not impacted by this issue.

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/fixtures/zodIpcCatalog.ts

@@ -0,0 +1,14 @@
+import { z } from "zod/v4";
+
+export 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() }),
+  },
+};
+
+export const ChildToParent = {};

packages/core/test/fixtures/zodIpcChild.ts

@@ -0,0 +1,13 @@
+import { ZodIpcConnection } from "../../src/v3/zodIpc.js";
+import { ChildToParent, ParentToChild } from "./zodIpcCatalog.js";
+
+// Forked by zodIpc.test.ts: answers the parent's messages over the real IPC channel.
+new ZodIpcConnection({
+  listenSchema: ParentToChild,
+  emitSchema: ChildToParent,
+  process,
+  handlers: {
+    FLUSH: async () => {},
+    PING: async ({ value }) => ({ echoed: value }),
+  },
+});

packages/core/test/zodIpc.test.ts

@@ -0,0 +1,44 @@
+import { fork, type ChildProcess } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { afterEach, describe, expect, it } from "vitest";
+import { ZodIpcConnection } from "../src/v3/zodIpc.js";
+import { ChildToParent, ParentToChild } from "./fixtures/zodIpcCatalog.js";
+
+const childPath = fileURLToPath(new URL("./fixtures/zodIpcChild.ts", import.meta.url));
+
+let child: ChildProcess | undefined;
+
+afterEach(() => {
+  child?.kill();
+  child = undefined;
+});
+
+// Node's default IPC serialization is JSON, so an ack with `message: undefined`
+// arrives without the `message` key, exactly as it does between a worker and its task run process.
+function forkChild() {
+  child = fork(childPath, { execArgv: ["--import", "tsx"], stdio: "inherit" });
+
+  return new ZodIpcConnection({
+    listenSchema: ChildToParent,
+    emitSchema: ParentToChild,
+    process: child,
+  });
+}
+
+describe("ZodIpcConnection", () => {
+  it("resolves sendWithAck for a void callback", async () => {
+    const connection = forkChild();
+
+    await expect(connection.sendWithAck("FLUSH", { timeoutInMs: 1000 }, 2000)).resolves.toBe(
+      undefined
+    );
+  });
+
+  it("resolves sendWithAck with the callback payload", async () => {
+    const connection = forkChild();
+
+    await expect(connection.sendWithAck("PING", { value: "hello" }, 2000)).resolves.toEqual({
+      echoed: "hello",
+    });
+  });
+});