@workflow/world-local 5.0.0-beta.10 → 5.0.0-beta.11

package/dist/queue.d.ts

@@ -1,4 +1,11 @@
 import { type Queue } from '@workflow/world';
 import type { Config } from './config.js';
-export declare function createQueue(config: Partial<Config>): Queue;
+export type DirectHandler = (req: Request) => Promise<Response>;
+export type LocalQueue = Queue & {
+    /** Close the HTTP agent and release resources. */
+    close(): Promise<void>;
+    /** Register a direct in-process handler for a queue prefix, bypassing HTTP. */
+    registerHandler(prefix: '__wkf_step_' | '__wkf_workflow_', handler: DirectHandler): void;
+};
+export declare function createQueue(config: Partial<Config>): LocalQueue;
 //# sourceMappingURL=queue.d.ts.map

package/dist/queue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../src/queue.ts"],"names":[],"mappings":"AAEA,OAAO,EAAa,KAAK,KAAK,EAAkB,MAAM,iBAAiB,CAAC;AAIxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAc1C,wBAAgB,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,KAAK,CA2J1D"}
+{"version":3,"file":"queue.d.ts","sourceRoot":"","sources":["../src/queue.ts"],"names":[],"mappings":"AAEA,OAAO,EAAa,KAAK,KAAK,EAAkB,MAAM,iBAAiB,CAAC;AAKxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAiD1C,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEhE,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG;IAC/B,kDAAkD;IAClD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,+EAA+E;IAC/E,eAAe,CACb,MAAM,EAAE,aAAa,GAAG,iBAAiB,EACzC,OAAO,EAAE,aAAa,GACrB,IAAI,CAAC;CACT,CAAC;AAuCF,wBAAgB,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,UAAU,CAoQ/D"}

package/dist/queue.js

@@ -1,26 +1,96 @@
 import { setTimeout } from 'node:timers/promises';
-import { JsonTransport } from '@vercel/queue';
 import { MessageId, ValidQueueName } from '@workflow/world';
+import { Sema } from 'async-sema';
 import { monotonicFactory } from 'ulid';
 import { Agent } from 'undici';
-import z from 'zod';
+import { z } from 'zod/v4';
 import { resolveBaseUrl } from './config.js';
+import { jsonReplacer, jsonReviver } from './fs.js';
+import { getPackageInfo } from './init.js';
+/**
+ * JSON transport that preserves Uint8Array values using the same
+ * replacer/reviver that world-local uses for filesystem storage.
+ * Uint8Array → { __type: 'Uint8Array', data: '<base64>' } in JSON.
+ */
+class TypedJsonTransport {
+    contentType = 'application/json';
+    serialize(value) {
+        return Buffer.from(JSON.stringify(value, jsonReplacer));
+    }
+    async deserialize(stream) {
+        const chunks = [];
+        const reader = stream.getReader();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value)
+                chunks.push(value);
+        }
+        const text = Buffer.concat(chunks).toString();
+        return JSON.parse(text, jsonReviver);
+    }
+}
 // For local queue, there is no technical limit on the message visibility lifespan,
 // but the environment variable can be used for testing purposes to set a max visibility limit.
 const LOCAL_QUEUE_MAX_VISIBILITY = parseInt(process.env.WORKFLOW_LOCAL_QUEUE_MAX_VISIBILITY ?? '0', 10) ||
     Infinity;
-// Create a custom agent with unlimited headers timeout for long-running steps
-const httpAgent = new Agent({
-    headersTimeout: 0,
-});
+// Maximum safe delay for setTimeout in Node.js (2^31 - 1 milliseconds ≈ 24.85 days)
+// Larger values cause "TimeoutOverflowWarning: X does not fit into a 32-bit signed integer"
+// When the clamped timeout fires, the handler will recalculate remaining time from
+// persistent state and return another timeoutSeconds if needed.
+const MAX_SAFE_TIMEOUT_MS = 2147483647;
+// The local workers share the same Node.js process and event loop,
+// so we need to limit concurrency to avoid overwhelming the system.
+const DEFAULT_CONCURRENCY_LIMIT = 1000;
+const WORKFLOW_LOCAL_QUEUE_CONCURRENCY = parseInt(process.env.WORKFLOW_LOCAL_QUEUE_CONCURRENCY ?? '0', 10) ||
+    DEFAULT_CONCURRENCY_LIMIT;
+const DETACHED_ARRAYBUFFER_ERROR = 'Cannot perform ArrayBuffer.prototype.slice on a detached ArrayBuffer';
+const PROXY_HANDLER_DOCS_URL = 'https://workflow-sdk.dev/docs/getting-started/next#configure-proxy-handler';
+function isDetachedArrayBufferQueueError(error) {
+    let current = error;
+    const visited = new Set();
+    while (current && typeof current === 'object' && !visited.has(current)) {
+        visited.add(current);
+        if ('message' in current &&
+            typeof current.message === 'string' &&
+            current.message.includes(DETACHED_ARRAYBUFFER_ERROR)) {
+            return true;
+        }
+        current = 'cause' in current ? current.cause : undefined;
+    }
+    return false;
+}
+function getQueueRoute(queueName) {
+    if (queueName.startsWith('__wkf_step_')) {
+        return { pathname: 'step', prefix: '__wkf_step_' };
+    }
+    if (queueName.startsWith('__wkf_workflow_')) {
+        return { pathname: 'flow', prefix: '__wkf_workflow_' };
+    }
+    throw new Error('Unknown queue name prefix');
+}
 export function createQueue(config) {
-    const transport = new JsonTransport();
+    // Create a custom agent optimized for high-concurrency local workflows:
+    // - headersTimeout: 0 allows long-running steps
+    // - connections: 1000 allows many parallel connections to the same host
+    // - pipelining: 1 (default) for HTTP/1.1 compatibility
+    // - keepAliveTimeout: 30s keeps connections warm for rapid step execution
+    const httpAgent = new Agent({
+        headersTimeout: 0,
+        connections: 1000,
+        keepAliveTimeout: 30_000,
+    });
+    const transport = new TypedJsonTransport();
     const generateId = monotonicFactory();
+    const semaphore = new Sema(WORKFLOW_LOCAL_QUEUE_CONCURRENCY);
     /**
      * holds inflight messages by idempotency key to ensure
      * that we don't queue the same message multiple times
      */
     const inflightMessages = new Map();
+    /** Direct in-process handlers by queue prefix, bypassing HTTP when set. */
+    const directHandlers = new Map();
     const queue = async (queueName, message, opts) => {
         const cleanup = [];
         if (opts?.idempotencyKey) {
@@ -30,17 +100,13 @@ export function createQueue(config) {
             }
         }
         const body = transport.serialize(message);
-        let pathname;
-        if (queueName.startsWith('__wkf_step_')) {
-            pathname = `step`;
-        }
-        else if (queueName.startsWith('__wkf_workflow_')) {
-            pathname = `flow`;
-        }
-        else {
-            throw new Error('Unknown queue name prefix');
-        }
+        const { pathname, prefix } = getQueueRoute(queueName);
         const messageId = MessageId.parse(`msg_${generateId()}`);
+        // Extract identifiers from the message for structured logging.
+        // Workflow messages have `runId`, step messages have `workflowRunId` + `stepId`.
+        const msg = message;
+        const runId = (msg.runId ?? msg.workflowRunId ?? undefined);
+        const stepId = (msg.stepId ?? undefined);
         if (opts?.idempotencyKey) {
             const key = opts.idempotencyKey;
             inflightMessages.set(key, messageId);
@@ -49,46 +115,110 @@ export function createQueue(config) {
             });
         }
         (async () => {
-            let defaultRetriesLeft = 3;
-            const baseUrl = await resolveBaseUrl(config);
-            for (let attempt = 0; defaultRetriesLeft > 0; attempt++) {
-                defaultRetriesLeft--;
-                const response = await fetch(`${baseUrl}/.well-known/workflow/v1/${pathname}`, {
-                    method: 'POST',
-                    duplex: 'half',
-                    // @ts-expect-error undici type differences
-                    dispatcher: httpAgent,
-                    headers: {
+            const token = semaphore.tryAcquire();
+            if (!token) {
+                console.warn(`[world-local]: concurrency limit (${WORKFLOW_LOCAL_QUEUE_CONCURRENCY}) reached, waiting for queue to free up`);
+                await semaphore.acquire();
+            }
+            // Safety limit to prevent infinite loops in the local queue.
+            // The actual max delivery enforcement happens in the workflow/step handlers
+            // (at MAX_QUEUE_DELIVERIES = 48), so this just needs to be comfortably higher.
+            const MAX_LOCAL_SAFETY_LIMIT = 256;
+            try {
+                for (let attempt = 0; attempt < MAX_LOCAL_SAFETY_LIMIT; attempt++) {
+                    const headers = {
+                        ...opts?.headers,
                         'content-type': 'application/json',
                         'x-vqs-queue-name': queueName,
                         'x-vqs-message-id': messageId,
                         'x-vqs-message-attempt': String(attempt + 1),
-                    },
-                    body,
-                });
-                if (response.ok) {
-                    return;
-                }
-                const text = await response.text();
-                if (response.status === 503) {
-                    try {
-                        const timeoutSeconds = Number(JSON.parse(text).timeoutSeconds);
-                        await setTimeout(timeoutSeconds * 1000);
-                        defaultRetriesLeft++;
-                        continue;
+                    };
+                    const directHandler = directHandlers.get(prefix);
+                    let response;
+                    if (directHandler) {
+                        const req = new Request(`http://localhost/.well-known/workflow/v1/${pathname}`, {
+                            method: 'POST',
+                            headers,
+                            body,
+                        });
+                        response = await directHandler(req);
+                    }
+                    else {
+                        const baseUrl = await resolveBaseUrl(config);
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- undici v7 dispatcher types don't match @types/node's RequestInit
+                        response = await fetch(`${baseUrl}/.well-known/workflow/v1/${pathname}`, {
+                            method: 'POST',
+                            duplex: 'half',
+                            dispatcher: httpAgent,
+                            headers,
+                            body,
+                        });
+                    }
+                    const text = await response.text();
+                    if (response.ok) {
+                        try {
+                            const timeoutSeconds = Number(JSON.parse(text).timeoutSeconds);
+                            if (Number.isFinite(timeoutSeconds) && timeoutSeconds >= 0) {
+                                // Clamp to MAX_SAFE_TIMEOUT_MS to avoid Node.js setTimeout overflow warning.
+                                // When this fires early, the handler recalculates remaining time from
+                                // persistent state and returns another timeoutSeconds if needed.
+                                if (timeoutSeconds > 0) {
+                                    const timeoutMs = Math.min(timeoutSeconds * 1000, MAX_SAFE_TIMEOUT_MS);
+                                    await setTimeout(timeoutMs);
+                                }
+                                continue;
+                            }
+                        }
+                        catch { }
+                        return;
                     }
-                    catch { }
+                    console.error(`[world-local] Queue message failed (attempt ${attempt + 1}, HTTP ${response.status})`, {
+                        queueName,
+                        messageId,
+                        ...(runId && { runId }),
+                        ...(stepId && { stepId }),
+                        handlerError: text,
+                    });
+                    // 5s linear backoff to approximate VQS retry timing in local dev.
+                    // VQS uses 5s linear for attempts 1–32, then exponential, but for
+                    // local dev linear 5s is sufficient — the handler enforces the real
+                    // cap at MAX_QUEUE_DELIVERIES (48) which keeps total time under ~4min.
+                    await setTimeout(5000);
                 }
-                console.error(`[embedded world] Failed to queue message`, {
+                console.error(`[world-local] Queue message exhausted safety limit (${MAX_LOCAL_SAFETY_LIMIT} attempts)`, {
                     queueName,
-                    text,
-                    status: response.status,
-                    headers: Object.fromEntries(response.headers.entries()),
-                    body: body.toString(),
+                    messageId,
+                    ...(runId && { runId }),
+                    ...(stepId && { stepId }),
                 });
             }
-            console.error(`[embedded world] Reached max retries of embedded world queue implementation`);
-        })().finally(() => {
+            finally {
+                semaphore.release();
+            }
+        })()
+            .catch((err) => {
+            // Silently ignore client disconnect errors (e.g., browser refresh during streaming)
+            // These are expected and should not cause unhandled rejection warnings
+            const isAbortError = err?.name === 'AbortError' || err?.name === 'ResponseAborted';
+            if (!isAbortError) {
+                if (isDetachedArrayBufferQueueError(err)) {
+                    console.error(`[local world] Queue operation failed: detected "${DETACHED_ARRAYBUFFER_ERROR}". ` +
+                        "This usually means a Next.js proxy/middleware consumed Workflow's internal " +
+                        'request before the executor could read it. Exclude `/.well-known/workflow/*` ' +
+                        `from your matcher. See ${PROXY_HANDLER_DOCS_URL}`, {
+                        queueName,
+                        messageId,
+                        ...(runId && { runId }),
+                        ...(stepId && { stepId }),
+                        originalError: err,
+                    });
+                }
+                else {
+                    console.error('[local world] Queue operation failed:', err);
+                }
+            }
+        })
+            .finally(() => {
             for (const fn of cleanup) {
                 fn();
             }
@@ -116,15 +246,15 @@ export function createQueue(config) {
             if (!queueName.startsWith(prefix)) {
                 return Response.json({ error: 'Unhandled queue' }, { status: 400 });
             }
-            const body = await new JsonTransport().deserialize(req.body);
+            const body = await new TypedJsonTransport().deserialize(req.body);
             try {
                 const result = await handler(body, { attempt, queueName, messageId });
                 let timeoutSeconds = null;
                 if (typeof result?.timeoutSeconds === 'number') {
                     timeoutSeconds = Math.min(result.timeoutSeconds, LOCAL_QUEUE_MAX_VISIBILITY);
                 }
-                if (timeoutSeconds) {
-                    return Response.json({ timeoutSeconds }, { status: 503 });
+                if (timeoutSeconds != null) {
+                    return Response.json({ timeoutSeconds });
                 }
                 return Response.json({ ok: true });
             }
@@ -134,8 +264,19 @@ export function createQueue(config) {
         };
     };
     const getDeploymentId = async () => {
-        return 'dpl_embedded';
+        const packageInfo = await getPackageInfo();
+        return `dpl_local@${packageInfo.version}`;
+    };
+    return {
+        queue,
+        createQueueHandler,
+        getDeploymentId,
+        registerHandler(prefix, handler) {
+            directHandlers.set(prefix, handler);
+        },
+        async close() {
+            await httpAgent.close();
+        },
     };
-    return { queue, createQueueHandler, getDeploymentId };
 }
-//# sourceMappingURL=queue.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queue.js","sourceRoot":"","sources":["../src/queue.ts"],"names":[],"mappings":"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","sourcesContent":["import { setTimeout } from 'node:timers/promises';\nimport type { Transport } from '@vercel/queue';\nimport { MessageId, type Queue, ValidQueueName } from '@workflow/world';\nimport { Sema } from 'async-sema';\nimport { monotonicFactory } from 'ulid';\nimport { Agent } from 'undici';\nimport { z } from 'zod/v4';\nimport type { Config } from './config.js';\nimport { resolveBaseUrl } from './config.js';\nimport { jsonReplacer, jsonReviver } from './fs.js';\nimport { getPackageInfo } from './init.js';\n\n/**\n * JSON transport that preserves Uint8Array values using the same\n * replacer/reviver that world-local uses for filesystem storage.\n * Uint8Array → { __type: 'Uint8Array', data: '<base64>' } in JSON.\n */\nclass TypedJsonTransport implements Transport<unknown> {\n  readonly contentType = 'application/json';\n\n  serialize(value: unknown): Buffer {\n    return Buffer.from(JSON.stringify(value, jsonReplacer));\n  }\n\n  async deserialize(stream: ReadableStream<Uint8Array>): Promise<unknown> {\n    const chunks: Uint8Array[] = [];\n    const reader = stream.getReader();\n    while (true) {\n      const { done, value } = await reader.read();\n      if (done) break;\n      if (value) chunks.push(value);\n    }\n    const text = Buffer.concat(chunks).toString();\n    return JSON.parse(text, jsonReviver);\n  }\n}\n\n// For local queue, there is no technical limit on the message visibility lifespan,\n// but the environment variable can be used for testing purposes to set a max visibility limit.\nconst LOCAL_QUEUE_MAX_VISIBILITY =\n  parseInt(process.env.WORKFLOW_LOCAL_QUEUE_MAX_VISIBILITY ?? '0', 10) ||\n  Infinity;\n\n// Maximum safe delay for setTimeout in Node.js (2^31 - 1 milliseconds ≈ 24.85 days)\n// Larger values cause \"TimeoutOverflowWarning: X does not fit into a 32-bit signed integer\"\n// When the clamped timeout fires, the handler will recalculate remaining time from\n// persistent state and return another timeoutSeconds if needed.\nconst MAX_SAFE_TIMEOUT_MS = 2147483647;\n\n// The local workers share the same Node.js process and event loop,\n// so we need to limit concurrency to avoid overwhelming the system.\nconst DEFAULT_CONCURRENCY_LIMIT = 1000;\nconst WORKFLOW_LOCAL_QUEUE_CONCURRENCY =\n  parseInt(process.env.WORKFLOW_LOCAL_QUEUE_CONCURRENCY ?? '0', 10) ||\n  DEFAULT_CONCURRENCY_LIMIT;\n\nexport type DirectHandler = (req: Request) => Promise<Response>;\n\nexport type LocalQueue = Queue & {\n  /** Close the HTTP agent and release resources. */\n  close(): Promise<void>;\n  /** Register a direct in-process handler for a queue prefix, bypassing HTTP. */\n  registerHandler(\n    prefix: '__wkf_step_' | '__wkf_workflow_',\n    handler: DirectHandler\n  ): void;\n};\n\nconst DETACHED_ARRAYBUFFER_ERROR =\n  'Cannot perform ArrayBuffer.prototype.slice on a detached ArrayBuffer';\nconst PROXY_HANDLER_DOCS_URL =\n  'https://workflow-sdk.dev/docs/getting-started/next#configure-proxy-handler';\n\nfunction isDetachedArrayBufferQueueError(error: unknown): boolean {\n  let current = error;\n  const visited = new Set<unknown>();\n\n  while (current && typeof current === 'object' && !visited.has(current)) {\n    visited.add(current);\n    if (\n      'message' in current &&\n      typeof current.message === 'string' &&\n      current.message.includes(DETACHED_ARRAYBUFFER_ERROR)\n    ) {\n      return true;\n    }\n    current = 'cause' in current ? current.cause : undefined;\n  }\n\n  return false;\n}\n\nfunction getQueueRoute(queueName: ValidQueueName): {\n  pathname: 'flow' | 'step';\n  prefix: '__wkf_step_' | '__wkf_workflow_';\n} {\n  if (queueName.startsWith('__wkf_step_')) {\n    return { pathname: 'step', prefix: '__wkf_step_' };\n  }\n  if (queueName.startsWith('__wkf_workflow_')) {\n    return { pathname: 'flow', prefix: '__wkf_workflow_' };\n  }\n  throw new Error('Unknown queue name prefix');\n}\n\nexport function createQueue(config: Partial<Config>): LocalQueue {\n  // Create a custom agent optimized for high-concurrency local workflows:\n  // - headersTimeout: 0 allows long-running steps\n  // - connections: 1000 allows many parallel connections to the same host\n  // - pipelining: 1 (default) for HTTP/1.1 compatibility\n  // - keepAliveTimeout: 30s keeps connections warm for rapid step execution\n  const httpAgent = new Agent({\n    headersTimeout: 0,\n    connections: 1000,\n    keepAliveTimeout: 30_000,\n  });\n  const transport = new TypedJsonTransport();\n  const generateId = monotonicFactory();\n  const semaphore = new Sema(WORKFLOW_LOCAL_QUEUE_CONCURRENCY);\n\n  /**\n   * holds inflight messages by idempotency key to ensure\n   * that we don't queue the same message multiple times\n   */\n  const inflightMessages = new Map<string, MessageId>();\n  /** Direct in-process handlers by queue prefix, bypassing HTTP when set. */\n  const directHandlers = new Map<string, DirectHandler>();\n\n  const queue: Queue['queue'] = async (queueName, message, opts) => {\n    const cleanup = [] as (() => void)[];\n\n    if (opts?.idempotencyKey) {\n      const existing = inflightMessages.get(opts.idempotencyKey);\n      if (existing) {\n        return { messageId: existing };\n      }\n    }\n\n    const body = transport.serialize(message);\n    const { pathname, prefix } = getQueueRoute(queueName);\n    const messageId = MessageId.parse(`msg_${generateId()}`);\n\n    // Extract identifiers from the message for structured logging.\n    // Workflow messages have `runId`, step messages have `workflowRunId` + `stepId`.\n    const msg = message as Record<string, unknown>;\n    const runId = (msg.runId ?? msg.workflowRunId ?? undefined) as\n      | string\n      | undefined;\n    const stepId = (msg.stepId ?? undefined) as string | undefined;\n\n    if (opts?.idempotencyKey) {\n      const key = opts.idempotencyKey;\n      inflightMessages.set(key, messageId);\n      cleanup.push(() => {\n        inflightMessages.delete(key);\n      });\n    }\n\n    (async () => {\n      const token = semaphore.tryAcquire();\n      if (!token) {\n        console.warn(\n          `[world-local]: concurrency limit (${WORKFLOW_LOCAL_QUEUE_CONCURRENCY}) reached, waiting for queue to free up`\n        );\n        await semaphore.acquire();\n      }\n      // Safety limit to prevent infinite loops in the local queue.\n      // The actual max delivery enforcement happens in the workflow/step handlers\n      // (at MAX_QUEUE_DELIVERIES = 48), so this just needs to be comfortably higher.\n      const MAX_LOCAL_SAFETY_LIMIT = 256;\n      try {\n        for (let attempt = 0; attempt < MAX_LOCAL_SAFETY_LIMIT; attempt++) {\n          const headers: Record<string, string> = {\n            ...opts?.headers,\n            'content-type': 'application/json',\n            'x-vqs-queue-name': queueName,\n            'x-vqs-message-id': messageId,\n            'x-vqs-message-attempt': String(attempt + 1),\n          };\n          const directHandler = directHandlers.get(prefix);\n          let response: Response;\n\n          if (directHandler) {\n            const req = new Request(\n              `http://localhost/.well-known/workflow/v1/${pathname}`,\n              {\n                method: 'POST',\n                headers,\n                body,\n              }\n            );\n            response = await directHandler(req);\n          } else {\n            const baseUrl = await resolveBaseUrl(config);\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- undici v7 dispatcher types don't match @types/node's RequestInit\n            response = await fetch(\n              `${baseUrl}/.well-known/workflow/v1/${pathname}`,\n              {\n                method: 'POST',\n                duplex: 'half',\n                dispatcher: httpAgent,\n                headers,\n                body,\n              } as any\n            );\n          }\n\n          const text = await response.text();\n\n          if (response.ok) {\n            try {\n              const timeoutSeconds = Number(JSON.parse(text).timeoutSeconds);\n              if (Number.isFinite(timeoutSeconds) && timeoutSeconds >= 0) {\n                // Clamp to MAX_SAFE_TIMEOUT_MS to avoid Node.js setTimeout overflow warning.\n                // When this fires early, the handler recalculates remaining time from\n                // persistent state and returns another timeoutSeconds if needed.\n                if (timeoutSeconds > 0) {\n                  const timeoutMs = Math.min(\n                    timeoutSeconds * 1000,\n                    MAX_SAFE_TIMEOUT_MS\n                  );\n                  await setTimeout(timeoutMs);\n                }\n                continue;\n              }\n            } catch {}\n            return;\n          }\n\n          console.error(\n            `[world-local] Queue message failed (attempt ${attempt + 1}, HTTP ${response.status})`,\n            {\n              queueName,\n              messageId,\n              ...(runId && { runId }),\n              ...(stepId && { stepId }),\n              handlerError: text,\n            }\n          );\n\n          // 5s linear backoff to approximate VQS retry timing in local dev.\n          // VQS uses 5s linear for attempts 1–32, then exponential, but for\n          // local dev linear 5s is sufficient — the handler enforces the real\n          // cap at MAX_QUEUE_DELIVERIES (48) which keeps total time under ~4min.\n          await setTimeout(5000);\n        }\n\n        console.error(\n          `[world-local] Queue message exhausted safety limit (${MAX_LOCAL_SAFETY_LIMIT} attempts)`,\n          {\n            queueName,\n            messageId,\n            ...(runId && { runId }),\n            ...(stepId && { stepId }),\n          }\n        );\n      } finally {\n        semaphore.release();\n      }\n    })()\n      .catch((err) => {\n        // Silently ignore client disconnect errors (e.g., browser refresh during streaming)\n        // These are expected and should not cause unhandled rejection warnings\n        const isAbortError =\n          err?.name === 'AbortError' || err?.name === 'ResponseAborted';\n        if (!isAbortError) {\n          if (isDetachedArrayBufferQueueError(err)) {\n            console.error(\n              `[local world] Queue operation failed: detected \"${DETACHED_ARRAYBUFFER_ERROR}\". ` +\n                \"This usually means a Next.js proxy/middleware consumed Workflow's internal \" +\n                'request before the executor could read it. Exclude `/.well-known/workflow/*` ' +\n                `from your matcher. See ${PROXY_HANDLER_DOCS_URL}`,\n              {\n                queueName,\n                messageId,\n                ...(runId && { runId }),\n                ...(stepId && { stepId }),\n                originalError: err,\n              }\n            );\n          } else {\n            console.error('[local world] Queue operation failed:', err);\n          }\n        }\n      })\n      .finally(() => {\n        for (const fn of cleanup) {\n          fn();\n        }\n      });\n\n    return { messageId };\n  };\n\n  const HeaderParser = z.object({\n    'x-vqs-queue-name': ValidQueueName,\n    'x-vqs-message-id': MessageId,\n    'x-vqs-message-attempt': z.coerce.number(),\n  });\n\n  const createQueueHandler: Queue['createQueueHandler'] = (prefix, handler) => {\n    return async (req) => {\n      const headers = HeaderParser.safeParse(Object.fromEntries(req.headers));\n\n      if (!headers.success || !req.body) {\n        return Response.json(\n          {\n            error: !req.body\n              ? 'Missing request body'\n              : 'Missing required headers',\n          },\n          { status: 400 }\n        );\n      }\n\n      const queueName = headers.data['x-vqs-queue-name'];\n      const messageId = headers.data['x-vqs-message-id'];\n      const attempt = headers.data['x-vqs-message-attempt'];\n\n      if (!queueName.startsWith(prefix)) {\n        return Response.json({ error: 'Unhandled queue' }, { status: 400 });\n      }\n\n      const body = await new TypedJsonTransport().deserialize(req.body);\n      try {\n        const result = await handler(body, { attempt, queueName, messageId });\n\n        let timeoutSeconds: number | null = null;\n        if (typeof result?.timeoutSeconds === 'number') {\n          timeoutSeconds = Math.min(\n            result.timeoutSeconds,\n            LOCAL_QUEUE_MAX_VISIBILITY\n          );\n        }\n\n        if (timeoutSeconds != null) {\n          return Response.json({ timeoutSeconds });\n        }\n\n        return Response.json({ ok: true });\n      } catch (error) {\n        return Response.json(String(error), { status: 500 });\n      }\n    };\n  };\n\n  const getDeploymentId: Queue['getDeploymentId'] = async () => {\n    const packageInfo = await getPackageInfo();\n    return `dpl_local@${packageInfo.version}`;\n  };\n\n  return {\n    queue,\n    createQueueHandler,\n    getDeploymentId,\n    registerHandler(\n      prefix: '__wkf_step_' | '__wkf_workflow_',\n      handler: DirectHandler\n    ) {\n      directHandlers.set(prefix, handler);\n    },\n    async close() {\n      await httpAgent.close();\n    },\n  };\n}\n"]}

package/dist/storage/events-storage.d.ts

@@ -0,0 +1,7 @@
+import type { Storage } from '@workflow/world';
+/**
+ * Creates the events storage implementation using the filesystem.
+ * Implements the Storage['events'] interface with create, list, and listByCorrelationId operations.
+ */
+export declare function createEventsStorage(basedir: string, tag?: string): Storage['events'];
+//# sourceMappingURL=events-storage.d.ts.map

package/dist/storage/events-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events-storage.d.ts","sourceRoot":"","sources":["../../src/storage/events-storage.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAMV,OAAO,EAGR,MAAM,iBAAiB,CAAC;AA8IzB;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,QAAQ,CAAC,CAukCnB"}