@workflow/world-testing 5.0.0-beta.4 → 5.0.0-beta.41

package/dist/src/lineage.mjs

@@ -0,0 +1,48 @@
+import { hydrateWorkflowReturnValue } from '@workflow/core/serialization';
+import { expect, test, vi } from 'vitest';
+import { createFetcher, startServer } from './util.mjs';
+const awaitCompleted = (server, runId) => vi.waitFor(async () => {
+    const run = await server.getRun(runId);
+    expect(run.status).toBe('completed');
+    return run;
+}, { interval: 200, timeout: 10_000 });
+// The runId a run spawned, read from its return value.
+const spawnedRunId = (run) => hydrateWorkflowReturnValue(run.output, run.runId, undefined);
+/**
+ * Proves end-to-end that `start()` called from a workflow *body* (the canonical
+ * child-workflow spawn, not from inside a step) records cross-run lineage. The
+ * spawned child must carry `$parentRunId`/`$rootRunId` pointing at the parent,
+ * while the top-level parent itself carries none.
+ */
+export function lineage(world) {
+    test('body-level start() records lineage on the child', { timeout: 30_000 }, async () => {
+        const server = await startServer({ world }).then(createFetcher);
+        const { runId: parentRunId } = await server.invoke('workflows/lineage.ts', 'bodyStartsChild', []);
+        const parent = await awaitCompleted(server, parentRunId);
+        const child = await awaitCompleted(server, await spawnedRunId(parent));
+        // The child started from the parent's body inherits the lineage; the
+        // parent is top-level, so it anchors the root to itself.
+        expect(child.attributes?.$parentRunId).toBe(parentRunId);
+        expect(child.attributes?.$rootRunId).toBe(parentRunId);
+        expect(parent.attributes?.$parentRunId).toBeUndefined();
+    });
+    test('a three-level chain groups every run under the same root', { timeout: 30_000 }, async () => {
+        const server = await startServer({ world }).then(createFetcher);
+        // Each run returns the id of the one it spawned.
+        const { runId: rootRunId } = await server.invoke('workflows/lineage.ts', 'chainRoot', []);
+        const root = await awaitCompleted(server, rootRunId);
+        const middleRunId = await spawnedRunId(root);
+        const middle = await awaitCompleted(server, middleRunId);
+        const leaf = await awaitCompleted(server, await spawnedRunId(middle));
+        // Root is top-level.
+        expect(root.attributes?.$parentRunId).toBeUndefined();
+        expect(root.attributes?.$rootRunId).toBeUndefined();
+        // Middle: root and parent coincide at depth two.
+        expect(middle.attributes?.$parentRunId).toBe(rootRunId);
+        expect(middle.attributes?.$rootRunId).toBe(rootRunId);
+        // Leaf: parent is the middle, but root is still the chain root.
+        expect(leaf.attributes?.$parentRunId).toBe(middleRunId);
+        expect(leaf.attributes?.$rootRunId).toBe(rootRunId);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/null-byte.mjs

@@ -1,5 +1,5 @@
-import { expect, test, vi } from 'vitest';
 import { hydrateWorkflowReturnValue } from '@workflow/core/serialization';
+import { expect, test, vi } from 'vitest';
 import { createFetcher, startServer } from './util.mjs';
 export function nullByte(world) {
     test('supports null bytes in step results', { timeout: 12_000 }, async () => {
@@ -19,4 +19,4 @@ export function nullByte(world) {
         expect(output).toEqual('null byte \0');
     });
 }
-//# sourceMappingURL=null-byte.mjs.map
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/server.mjs

@@ -8,7 +8,6 @@ import { POST as flowPOST } from '../.well-known/workflow/v1/flow.mjs';
 import manifest from '../.well-known/workflow/v1/manifest.json' with {
     type: 'json'
 };
-import { POST as stepPOST } from '../.well-known/workflow/v1/step.mjs';
 if (!process.env.WORKFLOW_TARGET_WORLD) {
     console.error('Error: WORKFLOW_TARGET_WORLD environment variable is not set.');
     process.exit(1);
@@ -29,12 +28,37 @@ const Invoke = z
         workflow: manifest.workflows[file][workflow],
     };
 });
+// Track flow handler invocations per run for testing inline execution
+const flowInvocationCounts = new Map();
 const app = new Hono()
-    .post('/.well-known/workflow/v1/flow', (ctx) => {
+    .post('/.well-known/workflow/v1/flow', async (ctx) => {
+    // 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();
+    try {
+        const body = (await cloned.json());
+        const runId = typeof body?.runId === 'string'
+            ? body.runId
+            : typeof body.payload
+                ?.runId === 'string'
+                ? body.payload.runId
+                : undefined;
+        if (runId) {
+            flowInvocationCounts.set(runId, (flowInvocationCounts.get(runId) ?? 0) + 1);
+        }
+    }
+    catch {
+        // Health check or non-JSON messages — ignore
+    }
     return flowPOST(ctx.req.raw);
 })
-    .post('/.well-known/workflow/v1/step', (ctx) => {
-    return stepPOST(ctx.req.raw);
+    .get('/_flow-invocations/:runId', (ctx) => {
+    const count = flowInvocationCounts.get(ctx.req.param('runId')) ?? 0;
+    return ctx.json({ count });
 })
     .get('/_manifest', (ctx) => ctx.json(manifest))
     .post('/invoke', async (ctx) => {
@@ -71,6 +95,30 @@ const app = new Hono()
     const runId = ctx.req.param('runId');
     const run = getRun(runId);
     return new Response(run.getReadable());
+})
+    .get('/runs/:runId/events', async (ctx) => {
+    const runId = ctx.req.param('runId');
+    const world = await getWorld();
+    const allEvents = [];
+    let cursor;
+    while (true) {
+        const page = await world.events.list({
+            runId,
+            pagination: { sortOrder: 'asc', cursor },
+        });
+        for (const e of page.data) {
+            allEvents.push({
+                eventType: e.eventType,
+                correlationId: e.correlationId,
+            });
+        }
+        if (!page.hasMore)
+            break;
+        cursor = page.cursor ?? undefined;
+        if (!cursor)
+            break;
+    }
+    return ctx.json({ events: allEvents });
 });
 serve({
     fetch: app.fetch,
@@ -98,4 +146,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\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      .enum(\n        Object.keys(manifest.workflows[file]) as NonEmptyArray<\n          Workflows<typeof file>\n        >\n      )\n      .parse(obj.workflow);\n    return {\n      args: obj.args,\n      workflow: manifest.workflows[file][workflow],\n    };\n  });\n\n// Track flow handler invocations per run for testing inline execution\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: 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: { eventType: string; correlationId?: string }[] = [];\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          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

@@ -12,7 +12,9 @@ type Files = keyof typeof manifest.workflows;
 type Workflows<F extends Files> = keyof (typeof manifest.workflows)[F];
 export declare function startServer(opts: {
     world: string;
+    env?: Record<string, string | undefined>;
 }): Promise<{
+    getOutput: () => string;
     state: "listening";
     info: {
         port: number;
@@ -22,70 +24,79 @@ export declare function createFetcher(control: Control): {
     invoke<F extends Files, W extends Workflows<F>>(file: F, workflow: W, args: unknown[]): Promise<{
         runId: 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";
-        output: undefined;
-        error: undefined;
-        completedAt: undefined;
         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?: undefined;
+        completedAt?: undefined;
     } | {
         runId: string;
         deploymentId: string;
         workflowName: string;
-        input: unknown;
+        attributes: Record<string, string>;
         createdAt: Date;
         updatedAt: Date;
         status: "cancelled";
-        output: undefined;
-        error: undefined;
         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?: undefined;
     } | {
         runId: string;
         deploymentId: string;
         workflowName: string;
-        input: unknown;
+        attributes: Record<string, string>;
         createdAt: Date;
         updatedAt: Date;
         status: "completed";
         output: unknown;
-        error: undefined;
         completedAt: Date;
         specVersion?: number | undefined;
         executionContext?: Record<string, any> | undefined;
+        input?: unknown;
+        errorCode?: string | undefined;
+        encryptionPublicKey?: string | undefined;
         expiredAt?: Date | undefined;
         startedAt?: Date | undefined;
+        error?: undefined;
     } | {
         runId: string;
         deploymentId: string;
         workflowName: string;
-        input: unknown;
+        attributes: Record<string, string>;
         createdAt: Date;
         updatedAt: Date;
         status: "failed";
-        output: undefined;
-        error: {
-            message: string;
-            stack?: string | undefined;
-            code?: string | undefined;
-        };
+        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;
     }>;
     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;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE;;;;;GA4CxD;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;;;eAeA,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;;;;;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;;;;;;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;;;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"}

package/dist/src/util.mjs

@@ -1,5 +1,10 @@
 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';
@@ -17,23 +22,62 @@ export async function startServer(opts) {
     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
+    // debug logs (e.g., count runtime iterations, event loads, etc.).
+    const outputBuffer = [];
     proc.stdout?.on('data', (chunk) => {
-        stdio.push({ stream: chalk.white, chunk: chunk.toString() });
+        const str = chunk.toString();
+        stdio.push({ stream: chalk.white, chunk: str });
+        outputBuffer.push(str);
     });
     proc.stderr?.on('data', (chunk) => {
-        stdio.push({ stream: chalk.red, chunk: chunk.toString() });
+        const str = chunk.toString();
+        stdio.push({ stream: chalk.red, chunk: str });
+        outputBuffer.push(str);
     });
     onTestFailed(() => {
         console.log('=== SERVER STDIO ===');
@@ -46,7 +90,11 @@ export async function startServer(opts) {
     const fd3 = proc.stdio[3];
     assert(fd3, 'fd3 should be defined');
     for await (const chunk of fd3.pipe(jsonlines.parse())) {
-        return Control.parse(chunk);
+        const control = Control.parse(chunk);
+        return {
+            ...control,
+            getOutput: () => outputBuffer.join(''),
+        };
     }
     throw new Error('Server did not start correctly');
 }
@@ -67,6 +115,11 @@ export function createFetcher(control) {
             });
             return data;
         },
+        async getFlowInvocationCount(runId) {
+            const x = await fetch(`http://localhost:${control.info.port}/_flow-invocations/${encodeURIComponent(runId)}`);
+            const data = (await x.json());
+            return data.count;
+        },
         async getRun(id) {
             const x = await fetch(`http://localhost:${control.info.port}/runs/${encodeURIComponent(id)}`);
             const text = await x.text();
@@ -107,4 +160,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.object({\n  state: z.literal('listening'),\n  info: z.object({\n    port: z.number(),\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.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    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.js

@@ -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.4",
+  "version": "5.0.0-beta.41",
   "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",
     "chalk": "5.6.2",
-    "hono": "4.12.3",
+    "hono": "4.12.25",
     "jsonlines": "0.1.1",
-    "zod": "4.3.6",
-    "@workflow/cli": "5.0.0-beta.4",
-    "@workflow/core": "5.0.0-beta.4",
-    "workflow": "5.0.0-beta.4",
-    "@workflow/world": "5.0.0-beta.1"
+    "zod": "~4.3.6",
+    "@workflow/cli": "5.0.0-beta.41",
+    "@workflow/core": "5.0.0-beta.41",
+    "@workflow/world": "5.0.0-beta.26",
+    "workflow": "5.0.0-beta.41"
   },
   "devDependencies": {
-    "@types/node": "22.19.0",
     "@types/jsonlines": "0.1.5",
-    "vitest": "^4.0.18",
+    "@types/node": "22.19.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10",
     "@workflow/tsconfig": "5.0.0-beta.0"
   },
   "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"
   }
 }