@workflow/world-testing 5.0.0-beta.5 → 5.0.0-beta.51

package/dist/src/server.mjs

@@ -12,7 +12,7 @@ if (!process.env.WORKFLOW_TARGET_WORLD) {
     console.error('Error: WORKFLOW_TARGET_WORLD environment variable is not set.');
     process.exit(1);
 }
-const Invoke = z
+const Invoke = z.compile(z
     .object({
     file: z.enum(Object.keys(manifest.workflows)),
     workflow: z.string(),
@@ -21,21 +21,27 @@ const Invoke = z
     .transform((obj) => {
     const file = obj.file;
     const workflow = z
-        .enum(Object.keys(manifest.workflows[file]))
+        .compile(z.enum(Object.keys(manifest.workflows[file])))
         .parse(obj.workflow);
     return {
         args: obj.args,
         workflow: manifest.workflows[file][workflow],
     };
-});
+}));
 // Track flow handler invocations per run for testing inline execution
+// per-copy-ok: this file is a standalone test server entry (it calls `serve()`
+// below), so it runs as its own process with one module instance. There is no
+// host bundler to compile it into several layers.
 const flowInvocationCounts = new Map();
 const app = new Hono()
     .post('/.well-known/workflow/v1/flow', async (ctx) => {
-    // Clone the request to read the body for tracking without consuming it
+    // Clone the request to read the body for tracking without consuming it.
+    // We must increment the invocation counter *before* awaiting flowPOST,
+    // otherwise the workflow may complete (and the test may observe the
+    // completed status) before the counter is bumped, producing a flaky
+    // `expected 0 to be 1` failure when the test immediately queries
+    // /_flow-invocations after seeing the run as completed.
     const cloned = ctx.req.raw.clone();
-    const response = await flowPOST(ctx.req.raw);
-    // Extract runId from the request body (queue message payload)
     try {
         const body = (await cloned.json());
         const runId = typeof body?.runId === 'string'
@@ -51,7 +57,7 @@ const app = new Hono()
     catch {
         // Health check or non-JSON messages — ignore
     }
-    return response;
+    return flowPOST(ctx.req.raw);
 })
     .get('/_flow-invocations/:runId', (ctx) => {
     const count = flowInvocationCounts.get(ctx.req.param('runId')) ?? 0;
@@ -67,7 +73,8 @@ const app = new Hono()
     const hook = await getHookByToken(ctx.req.param('token'));
     const { runId } = await resumeHook(hook.token, {
         ...(await ctx.req.json()),
-        metadata: hook.metadata,
+        // `metadata` is a lazily-hydrated Promise; echo the resolved value.
+        metadata: await hook.metadata,
     });
     return ctx.json({ runId, hookId: hook.hookId });
 })
@@ -97,7 +104,7 @@ const app = new Hono()
     const runId = ctx.req.param('runId');
     const world = await getWorld();
     const allEvents = [];
-    let cursor = undefined;
+    let cursor;
     while (true) {
         const page = await world.events.list({
             runId,
@@ -105,6 +112,7 @@ const app = new Hono()
         });
         for (const e of page.data) {
             allEvents.push({
+                eventId: e.eventId,
                 eventType: e.eventType,
                 correlationId: e.correlationId,
             });
@@ -143,4 +151,4 @@ serve({
         control.end();
     }
 });
-//# sourceMappingURL=server.mjs.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.mjs","sourceRoot":"","sources":["../../src/server.mts"],"names":[],"mappings":"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","sourcesContent":["import fs from 'node:fs';\nimport { serve } from '@hono/node-server';\nimport { Hono } from 'hono';\nimport { getHookByToken, getRun, resumeHook, start } from 'workflow/api';\nimport { getWorld } from 'workflow/runtime';\nimport * as z from 'zod';\nimport { POST as flowPOST } from '../.well-known/workflow/v1/flow.mjs';\nimport manifest from '../.well-known/workflow/v1/manifest.json' with {\n  type: 'json',\n};\n\nif (!process.env.WORKFLOW_TARGET_WORLD) {\n  console.error(\n    'Error: WORKFLOW_TARGET_WORLD environment variable is not set.'\n  );\n  process.exit(1);\n}\n\ntype Files = keyof typeof manifest.workflows;\ntype Workflows<F extends Files> = keyof (typeof manifest.workflows)[F];\ntype NonEmptyArray<T> = [T, ...T[]];\n\nconst Invoke = z.compile(\n  z\n    .object({\n      file: z.enum(Object.keys(manifest.workflows) as NonEmptyArray<Files>),\n      workflow: z.string(),\n      args: z.unknown().array().default([]),\n    })\n    .transform((obj) => {\n      const file = obj.file as keyof typeof manifest.workflows;\n      const workflow = z\n        .compile(\n          z.enum(\n            Object.keys(manifest.workflows[file]) as NonEmptyArray<\n              Workflows<typeof file>\n            >\n          )\n        )\n        .parse(obj.workflow);\n      return {\n        args: obj.args,\n        workflow: manifest.workflows[file][workflow],\n      };\n    })\n);\n\n// Track flow handler invocations per run for testing inline execution\n// per-copy-ok: this file is a standalone test server entry (it calls `serve()`\n// below), so it runs as its own process with one module instance. There is no\n// host bundler to compile it into several layers.\nconst flowInvocationCounts = new Map<string, number>();\n\nconst app = new Hono()\n  .post('/.well-known/workflow/v1/flow', async (ctx) => {\n    // Clone the request to read the body for tracking without consuming it.\n    // We must increment the invocation counter *before* awaiting flowPOST,\n    // otherwise the workflow may complete (and the test may observe the\n    // completed status) before the counter is bumped, producing a flaky\n    // `expected 0 to be 1` failure when the test immediately queries\n    // /_flow-invocations after seeing the run as completed.\n    const cloned = ctx.req.raw.clone();\n    try {\n      const body = (await cloned.json()) as Record<string, unknown>;\n      const runId =\n        typeof body?.runId === 'string'\n          ? body.runId\n          : typeof (body.payload as Record<string, unknown> | undefined)\n                ?.runId === 'string'\n            ? ((body.payload as Record<string, unknown>).runId as string)\n            : undefined;\n      if (runId) {\n        flowInvocationCounts.set(\n          runId,\n          (flowInvocationCounts.get(runId) ?? 0) + 1\n        );\n      }\n    } catch {\n      // Health check or non-JSON messages — ignore\n    }\n    return flowPOST(ctx.req.raw);\n  })\n  .get('/_flow-invocations/:runId', (ctx) => {\n    const count = flowInvocationCounts.get(ctx.req.param('runId')) ?? 0;\n    return ctx.json({ count });\n  })\n  .get('/_manifest', (ctx) => ctx.json(manifest))\n  .post('/invoke', async (ctx) => {\n    const json = await ctx.req.json().then(Invoke.parse);\n    const handler = await start(json.workflow, json.args);\n\n    return ctx.json({ runId: handler.runId });\n  })\n  .post('/hooks/:token', async (ctx) => {\n    const hook = await getHookByToken(ctx.req.param('token'));\n    const { runId } = await resumeHook(hook.token, {\n      ...(await ctx.req.json()),\n      // `metadata` is a lazily-hydrated Promise; echo the resolved value.\n      metadata: await hook.metadata,\n    });\n    return ctx.json({ runId, hookId: hook.hookId });\n  })\n  .get('/runs/:runId', async (ctx) => {\n    const world = await getWorld();\n    const run = await world.runs.get(ctx.req.param('runId'));\n    // Custom JSON serialization to handle Uint8Array as base64\n    const json = JSON.stringify(run, (_key, value) => {\n      if (value instanceof Uint8Array) {\n        return {\n          __type: 'Uint8Array',\n          data: Buffer.from(value).toString('base64'),\n        };\n      }\n      return value;\n    });\n    return new Response(json, {\n      headers: { 'Content-Type': 'application/json' },\n    });\n  })\n  .get('/runs/:runId/readable', async (ctx) => {\n    const runId = ctx.req.param('runId');\n    const run = getRun(runId);\n    return new Response(run.getReadable());\n  })\n  .get('/runs/:runId/events', async (ctx) => {\n    const runId = ctx.req.param('runId');\n    const world = await getWorld();\n    const allEvents: {\n      eventId: string;\n      eventType: string;\n      correlationId?: string;\n    }[] = [];\n    let cursor: string | undefined;\n    while (true) {\n      const page = await world.events.list({\n        runId,\n        pagination: { sortOrder: 'asc', cursor },\n      });\n      for (const e of page.data) {\n        allEvents.push({\n          eventId: e.eventId,\n          eventType: e.eventType,\n          correlationId: e.correlationId,\n        });\n      }\n      if (!page.hasMore) break;\n      cursor = page.cursor ?? undefined;\n      if (!cursor) break;\n    }\n    return ctx.json({ events: allEvents });\n  });\n\nserve(\n  {\n    fetch: app.fetch,\n    port: Number(process.env.PORT) || 0,\n  },\n  async (info) => {\n    console.log(`👂 listening on http://${info.address}:${info.port}`);\n    console.log('');\n\n    process.env.PORT = info.port.toString();\n\n    for (const [filename, workflows] of Object.entries(manifest.workflows)) {\n      for (const workflowName of Object.keys(\n        workflows as Record<string, unknown>\n      )) {\n        console.log(\n          `$ curl -X POST http://localhost:${info.port}/invoke -d '${JSON.stringify(\n            {\n              file: filename,\n              workflow: workflowName,\n            }\n          )}'`\n        );\n      }\n    }\n\n    const world = await getWorld();\n    if (world.start) {\n      console.log(`starting background tasks...`);\n      await world.start().then(\n        () => console.log('background tasks started.'),\n        (err) => console.error('❗ error starting background tasks:', err)\n      );\n    }\n\n    if (process.env.CONTROL_FD === '3') {\n      const control = fs.createWriteStream('', { fd: 3 });\n      control.write(`${JSON.stringify({ state: 'listening', info })}\\n`);\n      control.end();\n    }\n  }\n);\n"]}

package/dist/src/util.d.mts

@@ -24,18 +24,32 @@ export declare function createFetcher(control: Control): {
     invoke<F extends Files, W extends Workflows<F>>(file: F, workflow: W, args: unknown[]): Promise<{
         runId: string;
     }>;
+    /**
+     * Every event of a run, oldest first, as the World stored it.
+     *
+     * Ids included on purpose: they are the one part of the storage contract a
+     * World can get wrong while every workflow still appears to work, right
+     * up until a replay reads one (see `eventIds`).
+     */
+    getEvents(runId: string): Promise<{
+        eventId: string;
+        eventType: string;
+        correlationId?: string;
+    }[]>;
     getFlowInvocationCount(runId: string): Promise<number>;
     getRun(id: string): Promise<{
         runId: string;
         deploymentId: string;
         workflowName: string;
-        input: unknown;
+        attributes: Record<string, string>;
         createdAt: Date;
         updatedAt: Date;
         status: "pending" | "running";
         specVersion?: number | undefined;
         executionContext?: Record<string, any> | undefined;
+        input?: unknown;
         errorCode?: string | undefined;
+        encryptionPublicKey?: string | undefined;
         expiredAt?: Date | undefined;
         startedAt?: Date | undefined;
         output?: undefined;
@@ -45,14 +59,16 @@ export declare function createFetcher(control: Control): {
         runId: string;
         deploymentId: string;
         workflowName: string;
-        input: unknown;
+        attributes: Record<string, string>;
         createdAt: Date;
         updatedAt: Date;
         status: "cancelled";
         completedAt: Date;
         specVersion?: number | undefined;
         executionContext?: Record<string, any> | undefined;
+        input?: unknown;
         errorCode?: string | undefined;
+        encryptionPublicKey?: string | undefined;
         expiredAt?: Date | undefined;
         startedAt?: Date | undefined;
         output?: undefined;
@@ -61,34 +77,38 @@ export declare function createFetcher(control: Control): {
         runId: string;
         deploymentId: string;
         workflowName: string;
-        input: unknown;
+        attributes: Record<string, string>;
         createdAt: Date;
         updatedAt: Date;
         status: "completed";
-        output: unknown;
         completedAt: Date;
         specVersion?: number | undefined;
         executionContext?: Record<string, any> | undefined;
+        input?: unknown;
         errorCode?: string | undefined;
+        encryptionPublicKey?: string | undefined;
         expiredAt?: Date | undefined;
         startedAt?: Date | undefined;
+        output?: unknown;
         error?: undefined;
     } | {
         runId: string;
         deploymentId: string;
         workflowName: string;
-        input: unknown;
+        attributes: Record<string, string>;
         createdAt: Date;
         updatedAt: Date;
         status: "failed";
-        error: unknown;
         completedAt: Date;
         specVersion?: number | undefined;
         executionContext?: Record<string, any> | undefined;
+        input?: unknown;
         errorCode?: string | undefined;
+        encryptionPublicKey?: string | undefined;
         expiredAt?: Date | undefined;
         startedAt?: Date | undefined;
         output?: undefined;
+        error?: unknown;
     }>;
     getReadable(id: string): Promise<ReadableStream<Uint8Array>>;
     resumeHook<T extends TypedHook<any, any>>(token: string, payload: Omit<NoInfer<TypedHook.Input<T>>, "metadata">): Promise<void>;

package/dist/src/util.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"util.d.mts","sourceRoot":"","sources":["../../src/util.mts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,QAAQ,MAAM,0CAA0C,CAAC;AAErE,eAAO,MAAM,OAAO;;;;;iBAKlB,CAAC;AACH,KAAK,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAC;AAEvC,KAAK,KAAK,GAAG,MAAM,OAAO,QAAQ,CAAC,SAAS,CAAC;AAC7C,KAAK,SAAS,CAAC,CAAC,SAAS,KAAK,IAAI,MAAM,CAAC,OAAO,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AAEvE,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC1C;;;;;;GAwDA;AAID,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO;WAE7B,CAAC,SAAS,KAAK,EAAE,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,QAC5C,CAAC,YACG,CAAC,QACL,OAAO,EAAE;;;kCAemB,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;eAO3C,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAmBD,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;eAcjD,CAAC,SAAS,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,SACrC,MAAM,WACJ,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC;EAoB3D"}
+{"version":3,"file":"util.d.mts","sourceRoot":"","sources":["../../src/util.mts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,KAAK,QAAQ,MAAM,0CAA0C,CAAC;AAErE,eAAO,MAAM,OAAO;;;;;iBAOnB,CAAC;AACF,KAAK,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAC;AAEvC,KAAK,KAAK,GAAG,MAAM,OAAO,QAAQ,CAAC,SAAS,CAAC;AAC7C,KAAK,SAAS,CAAC,CAAC,SAAS,KAAK,IAAI,MAAM,CAAC,OAAO,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AAEvE,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC1C;;;;;;GA2FA;AAID,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO;WAE7B,CAAC,SAAS,KAAK,EAAE,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,QAC5C,CAAC,YACG,CAAC,QACL,OAAO,EAAE;;;IAejB;;;;;;OAMG;qBACoB,MAAM,GAAG,OAAO,CACrC;QACE,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,EAAE,CACJ;kCAamC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;eAO3C,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAmBD,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;eAcjD,CAAC,SAAS,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,SACrC,MAAM,WACJ,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC;EAoB3D"}

package/dist/src/util.mjs

@@ -1,33 +1,69 @@
 import cp from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
+import { rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { setTimeout } from 'node:timers/promises';
 import { fileURLToPath } from 'node:url';
 import { WorkflowRunSchema } from '@workflow/world';
 import chalk from 'chalk';
 import jsonlines from 'jsonlines';
 import { assert, onTestFailed, onTestFinished } from 'vitest';
 import * as z from 'zod';
-export const Control = z.object({
+export const Control = z.compile(z.object({
     state: z.literal('listening'),
     info: z.object({
         port: z.number(),
     }),
-});
+}));
 export async function startServer(opts) {
     let serverPath = new URL('./server.mts', import.meta.url);
     if (!existsSync(serverPath)) {
         serverPath = new URL('./server.mjs', import.meta.url);
     }
+    // Give each spawned server its own data directory. The Local World's default
+    // (untagged) `.workflow-data` dir is otherwise shared by every concurrently
+    // running test file's server, and its startup recovery sweep re-enqueues
+    // every untagged run it finds — including runs still mid-flight in another
+    // test's server — dispatching them against the same on-disk event log and
+    // racing the run's actual owner into spurious `ReplayDivergenceError`s.
+    const dataDir = join(tmpdir(), `workflow-world-testing-${process.pid}-${randomUUID()}`);
     const proc = cp.spawn('node', [fileURLToPath(serverPath)], {
         stdio: ['ignore', 'pipe', 'pipe', 'pipe'],
         env: {
             ...process.env,
             WORKFLOW_TARGET_WORLD: opts.world,
             CONTROL_FD: '3',
+            WORKFLOW_LOCAL_DATA_DIR: dataDir,
             ...(opts.env ?? {}),
         },
     });
-    onTestFinished(() => {
-        proc.kill();
+    onTestFinished(async () => {
+        // Wait for the child to actually exit before removing its data directory:
+        // `kill()` only requests termination, and on Windows `rm()` fails with
+        // EPERM/EBUSY while the server still holds file handles in `dataDir`.
+        if (proc.exitCode === null && proc.signalCode === null) {
+            const exited = new Promise((resolve) => {
+                proc.once('exit', () => resolve());
+            });
+            proc.kill();
+            // Bounded, so a child that refuses to die can't hang test teardown.
+            await Promise.race([
+                exited,
+                setTimeout(5_000, undefined, { ref: false }),
+            ]);
+        }
+        // Windows can hold the handles for a moment past exit, hence the retries.
+        // A leaked temp dir is not worth failing an otherwise passing test over.
+        await rm(dataDir, {
+            recursive: true,
+            force: true,
+            maxRetries: 10,
+            retryDelay: 100,
+        }).catch((err) => {
+            console.warn(`Failed to remove test data dir ${dataDir}:`, err);
+        });
     });
     const stdio = [];
     // Accumulated raw server output — used by tests that want to inspect
@@ -62,7 +98,7 @@ export async function startServer(opts) {
     }
     throw new Error('Server did not start correctly');
 }
-const Invoke = z.object({ runId: z.coerce.string() });
+const Invoke = z.compile(z.object({ runId: z.coerce.string() }));
 export function createFetcher(control) {
     return {
         async invoke(file, workflow, args) {
@@ -79,6 +115,18 @@ export function createFetcher(control) {
             });
             return data;
         },
+        /**
+         * Every event of a run, oldest first, as the World stored it.
+         *
+         * Ids included on purpose: they are the one part of the storage contract a
+         * World can get wrong while every workflow still appears to work, right
+         * up until a replay reads one (see `eventIds`).
+         */
+        async getEvents(runId) {
+            const x = await fetch(`http://localhost:${control.info.port}/runs/${encodeURIComponent(runId)}/events`);
+            const data = (await x.json());
+            return data.events;
+        },
         async getFlowInvocationCount(runId) {
             const x = await fetch(`http://localhost:${control.info.port}/_flow-invocations/${encodeURIComponent(runId)}`);
             const data = (await x.json());
@@ -124,4 +172,4 @@ export function createFetcher(control) {
         },
     };
 }
-//# sourceMappingURL=util.mjs.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.mjs","sourceRoot":"","sources":["../../src/util.mts"],"names":[],"mappings":"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","sourcesContent":["import cp from 'node:child_process';\nimport { randomUUID } from 'node:crypto';\nimport { existsSync } from 'node:fs';\nimport { rm } from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport { setTimeout } from 'node:timers/promises';\nimport { fileURLToPath } from 'node:url';\nimport { WorkflowRunSchema } from '@workflow/world';\nimport chalk, { type ChalkInstance } from 'chalk';\nimport jsonlines from 'jsonlines';\nimport { assert, onTestFailed, onTestFinished } from 'vitest';\nimport type { TypedHook } from 'workflow';\nimport * as z from 'zod';\nimport type manifest from '../.well-known/workflow/v1/manifest.json';\n\nexport const Control = z.compile(\n  z.object({\n    state: z.literal('listening'),\n    info: z.object({\n      port: z.number(),\n    }),\n  })\n);\ntype Control = z.infer<typeof Control>;\n\ntype Files = keyof typeof manifest.workflows;\ntype Workflows<F extends Files> = keyof (typeof manifest.workflows)[F];\n\nexport async function startServer(opts: {\n  world: string;\n  env?: Record<string, string | undefined>;\n}) {\n  let serverPath = new URL('./server.mts', import.meta.url);\n\n  if (!existsSync(serverPath)) {\n    serverPath = new URL('./server.mjs', import.meta.url);\n  }\n\n  // Give each spawned server its own data directory. The Local World's default\n  // (untagged) `.workflow-data` dir is otherwise shared by every concurrently\n  // running test file's server, and its startup recovery sweep re-enqueues\n  // every untagged run it finds — including runs still mid-flight in another\n  // test's server — dispatching them against the same on-disk event log and\n  // racing the run's actual owner into spurious `ReplayDivergenceError`s.\n  const dataDir = join(\n    tmpdir(),\n    `workflow-world-testing-${process.pid}-${randomUUID()}`\n  );\n\n  const proc = cp.spawn('node', [fileURLToPath(serverPath)], {\n    stdio: ['ignore', 'pipe', 'pipe', 'pipe'],\n    env: {\n      ...process.env,\n      WORKFLOW_TARGET_WORLD: opts.world,\n      CONTROL_FD: '3',\n      WORKFLOW_LOCAL_DATA_DIR: dataDir,\n      ...(opts.env ?? {}),\n    },\n  });\n  onTestFinished(async () => {\n    // Wait for the child to actually exit before removing its data directory:\n    // `kill()` only requests termination, and on Windows `rm()` fails with\n    // EPERM/EBUSY while the server still holds file handles in `dataDir`.\n    if (proc.exitCode === null && proc.signalCode === null) {\n      const exited = new Promise<void>((resolve) => {\n        proc.once('exit', () => resolve());\n      });\n      proc.kill();\n      // Bounded, so a child that refuses to die can't hang test teardown.\n      await Promise.race([\n        exited,\n        setTimeout(5_000, undefined, { ref: false }),\n      ]);\n    }\n    // Windows can hold the handles for a moment past exit, hence the retries.\n    // A leaked temp dir is not worth failing an otherwise passing test over.\n    await rm(dataDir, {\n      recursive: true,\n      force: true,\n      maxRetries: 10,\n      retryDelay: 100,\n    }).catch((err) => {\n      console.warn(`Failed to remove test data dir ${dataDir}:`, err);\n    });\n  });\n\n  const stdio = [] as { stream: ChalkInstance; chunk: string }[];\n  // Accumulated raw server output — used by tests that want to inspect\n  // debug logs (e.g., count runtime iterations, event loads, etc.).\n  const outputBuffer: string[] = [];\n  proc.stdout?.on('data', (chunk) => {\n    const str = chunk.toString();\n    stdio.push({ stream: chalk.white, chunk: str });\n    outputBuffer.push(str);\n  });\n  proc.stderr?.on('data', (chunk) => {\n    const str = chunk.toString();\n    stdio.push({ stream: chalk.red, chunk: str });\n    outputBuffer.push(str);\n  });\n\n  onTestFailed(() => {\n    console.log('=== SERVER STDIO ===');\n    let buffer = '';\n    for (const { stream, chunk } of stdio) {\n      buffer += stream.inverse(chunk);\n    }\n    console.log(buffer);\n  });\n\n  const fd3 = proc.stdio[3];\n  assert(fd3, 'fd3 should be defined');\n\n  for await (const chunk of fd3.pipe(jsonlines.parse())) {\n    const control = Control.parse(chunk);\n    return {\n      ...control,\n      getOutput: () => outputBuffer.join(''),\n    };\n  }\n\n  throw new Error('Server did not start correctly');\n}\n\nconst Invoke = z.compile(z.object({ runId: z.coerce.string() }));\n\nexport function createFetcher(control: Control) {\n  return {\n    async invoke<F extends Files, W extends Workflows<F>>(\n      file: F,\n      workflow: W,\n      args: unknown[]\n    ) {\n      const x = await fetch(`http://localhost:${control.info.port}/invoke`, {\n        method: 'POST',\n        headers: {\n          'content-type': 'application/json',\n        },\n        body: JSON.stringify({ file, workflow, args }),\n      });\n      const data = await x.json().then(Invoke.parse);\n      onTestFailed(() => {\n        console.error('Workflow run:', data.runId);\n      });\n      return data;\n    },\n    /**\n     * Every event of a run, oldest first, as the World stored it.\n     *\n     * Ids included on purpose: they are the one part of the storage contract a\n     * World can get wrong while every workflow still appears to work, right\n     * up until a replay reads one (see `eventIds`).\n     */\n    async getEvents(runId: string): Promise<\n      {\n        eventId: string;\n        eventType: string;\n        correlationId?: string;\n      }[]\n    > {\n      const x = await fetch(\n        `http://localhost:${control.info.port}/runs/${encodeURIComponent(runId)}/events`\n      );\n      const data = (await x.json()) as {\n        events: {\n          eventId: string;\n          eventType: string;\n          correlationId?: string;\n        }[];\n      };\n      return data.events;\n    },\n    async getFlowInvocationCount(runId: string): Promise<number> {\n      const x = await fetch(\n        `http://localhost:${control.info.port}/_flow-invocations/${encodeURIComponent(runId)}`\n      );\n      const data = (await x.json()) as { count: number };\n      return data.count;\n    },\n    async getRun(id: string) {\n      const x = await fetch(\n        `http://localhost:${control.info.port}/runs/${encodeURIComponent(id)}`\n      );\n      const text = await x.text();\n      // Custom JSON reviver to decode base64 back to Uint8Array\n      const data = JSON.parse(text, (_key, value) => {\n        if (\n          value !== null &&\n          typeof value === 'object' &&\n          (value as any).__type === 'Uint8Array' &&\n          typeof (value as any).data === 'string'\n        ) {\n          return new Uint8Array(Buffer.from((value as any).data, 'base64'));\n        }\n        return value;\n      });\n      return WorkflowRunSchema.parseAsync(data);\n    },\n    async getReadable(id: string): Promise<ReadableStream<Uint8Array>> {\n      const x = await fetch(\n        `http://localhost:${control.info.port}/runs/${encodeURIComponent(id)}/readable`\n      );\n      if (!x.ok) {\n        throw new Error(\n          `Failed to get readable stream: ${x.status} ${x.statusText}`\n        );\n      }\n      if (!x.body) {\n        throw new Error('No body in response');\n      }\n      return x.body;\n    },\n    async resumeHook<T extends TypedHook<any, any>>(\n      token: string,\n      payload: Omit<NoInfer<TypedHook.Input<T>>, 'metadata'>\n    ) {\n      const res = await fetch(\n        `http://localhost:${control.info.port}/hooks/${token}`,\n        {\n          method: 'POST',\n          headers: {\n            'content-type': 'application/json',\n          },\n          body: JSON.stringify(payload),\n        }\n      );\n      res.arrayBuffer().catch(() => {}); // Drain the body to avoid resource leaks\n      if (!res.ok) {\n        throw new Error(\n          `Failed to resume hook: ${res.status} ${res.statusText}`\n        );\n      }\n    },\n  };\n}\n"]}

package/dist/workflows/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../workflows/hooks.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,IAAI;;;;;;;;EAMf,CAAC;AAEH,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;;;;;;GActE"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../workflows/hooks.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,IAAI;;;;;;;;EAQf,CAAC;AAEH,wBAAsB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;;;;;;GActE"}

package/dist/workflows/hooks.js

@@ -38,11 +38,11 @@ exports.collectWithHook = collectWithHook;
 const core_1 = require("@workflow/core");
 const z = __importStar(require("zod"));
 exports.Hook = (0, core_1.defineHook)({
-    schema: z.object({
+    schema: z.compile(z.object({
         data: z.string(),
         done: z.boolean().optional(),
         metadata: z.unknown(),
-    }),
+    })),
 });
 async function collectWithHook(token, customData) {
     'use workflow';
@@ -67,4 +67,4 @@ async function writeEvent(writable, event, payload) {
         payload,
     })}\r\n`));
 }
-//# sourceMappingURL=hooks.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/world-testing",
-  "version": "5.0.0-beta.5",
+  "version": "5.0.0-beta.51",
   "description": "Testing utilities and World implementation for Workflow SDK",
   "main": "dist/src/index.mjs",
   "files": [
@@ -16,24 +16,25 @@
     "directory": "packages/world-testing"
   },
   "dependencies": {
-    "@hono/node-server": "1.19.9",
+    "@hono/node-server": "1.19.13",
+    "@workflow/cli": "5.0.0-beta.51",
+    "@workflow/core": "5.0.0-beta.51",
+    "@workflow/world": "5.0.0-beta.35",
     "chalk": "5.6.2",
-    "hono": "4.12.3",
+    "hono": "4.12.25",
     "jsonlines": "0.1.1",
-    "zod": "4.3.6",
-    "@workflow/core": "5.0.0-beta.5",
-    "@workflow/cli": "5.0.0-beta.5",
-    "workflow": "5.0.0-beta.5",
-    "@workflow/world": "5.0.0-beta.2"
+    "workflow": "5.0.0-beta.51",
+    "zod": "~4.5.4"
   },
   "devDependencies": {
-    "@types/node": "22.19.0",
     "@types/jsonlines": "0.1.5",
-    "vitest": "^4.0.18",
-    "@workflow/tsconfig": "5.0.0-beta.0"
+    "@types/node": "22.19.0",
+    "@workflow/tsconfig": "5.0.0-beta.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10"
   },
   "peerDependencies": {
-    "vitest": "^4.0.18"
+    "vitest": "^4.1.10"
   },
   "keywords": [],
   "author": "",
@@ -41,6 +42,6 @@
     "build": "wf build && node scripts/generate-well-known-dts.mjs && tsc && cp .well-known/workflow/v1/*.mjs dist/.well-known/workflow/v1/",
     "clean": "tsc --build --clean && rm -rf dist .well-known* .workflow-data",
     "start": "node --watch src/server.mts",
-    "test": "vitest"
+    "test": "vitest run"
   }
 }