@workflow/world-local 5.0.0-beta.6 → 5.0.0-beta.7

package/dist/storage/runs-storage.js

@@ -1,10 +1,43 @@
 import path from 'node:path';
 import { WorkflowRunNotFoundError } from '@workflow/errors';
-import { WorkflowRunSchema } from '@workflow/world';
+import { applyAttributeChanges, AttributeValidationError, validateAttributeChanges, WorkflowRunSchema, } from '@workflow/world';
 import { DEFAULT_RESOLVE_DATA_OPTION } from '../config.js';
-import { assertSafeEntityId, paginatedFileSystemQuery, readJSONWithFallback, } from '../fs.js';
+import { assertSafeEntityId, paginatedFileSystemQuery, readJSONWithFallback, taggedPath, writeJSON, } from '../fs.js';
 import { filterRunData } from './filters.js';
 import { getObjectCreatedAt } from './helpers.js';
+/**
+ * Per-run in-process async mutex. Serializes concurrent writes that
+ * touch the same run JSON file — both attribute writes via
+ * `experimentalSetAttributes` and run-lifecycle writes (run_started,
+ * run_completed, run_failed, run_cancelled) acquire it. Without the
+ * shared lock, an attribute write that lands between a lifecycle
+ * handler's read and write would be silently overwritten by the
+ * lifecycle write's stale attribute snapshot.
+ *
+ * Lifecycle writers acquire the lock and re-read the run file inside
+ * the critical section to pick up any attributes that landed since
+ * their pre-validation read.
+ */
+const runFileLocks = new Map();
+export function withRunFileLock(key, fn) {
+    const prev = runFileLocks.get(key);
+    const taskBox = {};
+    const task = (async () => {
+        if (prev)
+            await prev.catch(() => undefined);
+        try {
+            return await fn();
+        }
+        finally {
+            if (runFileLocks.get(key) === taskBox.task) {
+                runFileLocks.delete(key);
+            }
+        }
+    })();
+    taskBox.task = task;
+    runFileLocks.set(key, task);
+    return task;
+}
 /**
  * Creates the runs storage implementation using the filesystem.
  * Implements the Storage['runs'] interface with get and list operations,
@@ -56,6 +89,42 @@ export function createRunsStorage(basedir, tag) {
             }
             return result;
         }),
+        experimentalSetAttributes: async (runId, changes, options) => {
+            assertSafeEntityId('runId', runId);
+            return withRunFileLock(runId, async () => {
+                const run = await readJSONWithFallback(basedir, 'runs', runId, WorkflowRunSchema, tag);
+                if (!run) {
+                    throw new WorkflowRunNotFoundError(runId);
+                }
+                // Server-side validation. The SDK validates before sending, but
+                // the world is the final authority — re-check so direct callers
+                // (tests, other consumers) cannot bypass the limits.
+                try {
+                    validateAttributeChanges(changes, {
+                        existingKeys: Object.keys(run.attributes ?? {}),
+                        allowReservedAttributes: options?.allowReservedAttributes,
+                    });
+                }
+                catch (err) {
+                    if (err instanceof AttributeValidationError) {
+                        // Re-throw as a plain error; callers (the SDK) wrap as
+                        // FatalError on their side.
+                        throw err;
+                    }
+                    throw err;
+                }
+                const nextAttributes = applyAttributeChanges(run.attributes, changes);
+                const updatedRun = {
+                    ...run,
+                    attributes: nextAttributes,
+                    updatedAt: new Date(),
+                };
+                await writeJSON(taggedPath(basedir, 'runs', runId, tag), updatedRun, {
+                    overwrite: true,
+                });
+                return { attributes: nextAttributes };
+            });
+        },
     };
 }
-//# sourceMappingURL=runs-storage.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runs-storage.js","sourceRoot":"","sources":["../../src/storage/runs-storage.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'node:path';\nimport { WorkflowRunNotFoundError } from '@workflow/errors';\nimport type {\n  AttributeChange,\n  ExperimentalSetAttributesResult,\n  ListWorkflowRunsParams,\n  PaginatedResponse,\n  Storage,\n  WorkflowRun,\n  WorkflowRunWithoutData,\n} from '@workflow/world';\nimport {\n  applyAttributeChanges,\n  AttributeValidationError,\n  validateAttributeChanges,\n  WorkflowRunSchema,\n} from '@workflow/world';\nimport { DEFAULT_RESOLVE_DATA_OPTION } from '../config.js';\nimport {\n  assertSafeEntityId,\n  paginatedFileSystemQuery,\n  readJSONWithFallback,\n  taggedPath,\n  writeJSON,\n} from '../fs.js';\nimport { filterRunData } from './filters.js';\nimport { getObjectCreatedAt } from './helpers.js';\n\n/**\n * Internal extension of `ListWorkflowRunsParams` that adds a `fileIdFilter`\n * for scoping queries by raw filename (e.g., by tag suffix). Kept out of the\n * public `Storage['runs']['list']` surface — consumers of `@workflow/world`\n * must not see this option.\n */\nexport interface LocalListWorkflowRunsParams extends ListWorkflowRunsParams {\n  fileIdFilter?: (fileId: string) => boolean;\n}\n\nexport interface LocalRunsStorage {\n  get: Storage['runs']['get'];\n  list: {\n    (\n      params: LocalListWorkflowRunsParams & { resolveData: 'none' }\n    ): Promise<PaginatedResponse<WorkflowRunWithoutData>>;\n    (\n      params?: LocalListWorkflowRunsParams & { resolveData?: 'all' }\n    ): Promise<PaginatedResponse<WorkflowRun>>;\n    (\n      params?: LocalListWorkflowRunsParams\n    ): Promise<PaginatedResponse<WorkflowRun | WorkflowRunWithoutData>>;\n  };\n  experimentalSetAttributes(\n    runId: string,\n    changes: AttributeChange[],\n    options?: { allowReservedAttributes?: boolean }\n  ): Promise<ExperimentalSetAttributesResult>;\n}\n\n/**\n * Per-run in-process async mutex. Serializes concurrent writes that\n * touch the same run JSON file — both attribute writes via\n * `experimentalSetAttributes` and run-lifecycle writes (run_started,\n * run_completed, run_failed, run_cancelled) acquire it. Without the\n * shared lock, an attribute write that lands between a lifecycle\n * handler's read and write would be silently overwritten by the\n * lifecycle write's stale attribute snapshot.\n *\n * Lifecycle writers acquire the lock and re-read the run file inside\n * the critical section to pick up any attributes that landed since\n * their pre-validation read.\n */\nconst runFileLocks = new Map<string, Promise<unknown>>();\n\nexport function withRunFileLock<T>(\n  key: string,\n  fn: () => Promise<T>\n): Promise<T> {\n  const prev = runFileLocks.get(key);\n  const taskBox: { task?: Promise<T> } = {};\n  const task = (async () => {\n    if (prev) await prev.catch(() => undefined);\n    try {\n      return await fn();\n    } finally {\n      if (runFileLocks.get(key) === taskBox.task) {\n        runFileLocks.delete(key);\n      }\n    }\n  })();\n  taskBox.task = task;\n  runFileLocks.set(key, task);\n  return task;\n}\n\n/**\n * Creates the runs storage implementation using the filesystem.\n * Implements the Storage['runs'] interface with get and list operations,\n * plus an internal `fileIdFilter` on `list` for tag-scoped recovery queries.\n */\nexport function createRunsStorage(\n  basedir: string,\n  tag?: string\n): LocalRunsStorage {\n  return {\n    get: (async (id: string, params?: any) => {\n      assertSafeEntityId('runId', id);\n      const run = await readJSONWithFallback(\n        basedir,\n        'runs',\n        id,\n        WorkflowRunSchema,\n        tag\n      );\n      if (!run) {\n        throw new WorkflowRunNotFoundError(id);\n      }\n      const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;\n      return filterRunData(run, resolveData);\n    }) as Storage['runs']['get'],\n\n    list: (async (params?: LocalListWorkflowRunsParams) => {\n      const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;\n      const result = await paginatedFileSystemQuery({\n        directory: path.join(basedir, 'runs'),\n        schema: WorkflowRunSchema,\n        fileIdFilter: params?.fileIdFilter,\n        filter: (run) => {\n          if (\n            params?.workflowName &&\n            run.workflowName !== params.workflowName\n          ) {\n            return false;\n          }\n          if (params?.status && run.status !== params.status) {\n            return false;\n          }\n          return true;\n        },\n        sortOrder: params?.pagination?.sortOrder ?? 'desc',\n        limit: params?.pagination?.limit,\n        cursor: params?.pagination?.cursor,\n        getCreatedAt: getObjectCreatedAt('wrun'),\n        getId: (run) => run.runId,\n      });\n\n      // If resolveData is \"none\", replace input/output with undefined\n      if (resolveData === 'none') {\n        return {\n          ...result,\n          data: result.data.map((run) => ({\n            ...run,\n            input: undefined,\n            output: undefined,\n          })) as WorkflowRunWithoutData[],\n        };\n      }\n\n      return result;\n    }) as LocalRunsStorage['list'],\n\n    experimentalSetAttributes: async (runId, changes, options) => {\n      assertSafeEntityId('runId', runId);\n\n      return withRunFileLock(runId, async () => {\n        const run = await readJSONWithFallback(\n          basedir,\n          'runs',\n          runId,\n          WorkflowRunSchema,\n          tag\n        );\n        if (!run) {\n          throw new WorkflowRunNotFoundError(runId);\n        }\n\n        // Server-side validation. The SDK validates before sending, but\n        // the world is the final authority — re-check so direct callers\n        // (tests, other consumers) cannot bypass the limits.\n        try {\n          validateAttributeChanges(changes, {\n            existingKeys: Object.keys(run.attributes ?? {}),\n            allowReservedAttributes: options?.allowReservedAttributes,\n          });\n        } catch (err) {\n          if (err instanceof AttributeValidationError) {\n            // Re-throw as a plain error; callers (the SDK) wrap as\n            // FatalError on their side.\n            throw err;\n          }\n          throw err;\n        }\n\n        const nextAttributes = applyAttributeChanges(run.attributes, changes);\n        const updatedRun = {\n          ...run,\n          attributes: nextAttributes,\n          updatedAt: new Date(),\n        };\n\n        await writeJSON(taggedPath(basedir, 'runs', runId, tag), updatedRun, {\n          overwrite: true,\n        });\n\n        return { attributes: nextAttributes };\n      });\n    },\n  };\n}\n"]}

package/dist/storage/steps-storage.js

@@ -49,4 +49,4 @@ export function createStepsStorage(basedir, tag) {
         }),
     };
 }
-//# sourceMappingURL=steps-storage.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/dist/storage.js

@@ -8,4 +8,4 @@
  */
 // Re-export from the modular storage implementation
 export { createStorage } from './storage/index.js';
-//# sourceMappingURL=storage.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9zdG9yYWdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O0dBT0c7QUFFSCxvREFBb0Q7QUFDcEQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBGaWxlc3lzdGVtLWJhc2VkIHN0b3JhZ2UgaW1wbGVtZW50YXRpb24gZm9yIHdvcmtmbG93IGRhdGEuXG4gKlxuICogVGhpcyBtb2R1bGUgcHJvdmlkZXMgYSBjb21wbGV0ZSBTdG9yYWdlIGltcGxlbWVudGF0aW9uIHRoYXQgcGVyc2lzdHNcbiAqIHdvcmtmbG93IHJ1bnMsIHN0ZXBzLCBldmVudHMsIGFuZCBob29rcyB0byB0aGUgbG9jYWwgZmlsZXN5c3RlbS5cbiAqXG4gKiBAbW9kdWxlXG4gKi9cblxuLy8gUmUtZXhwb3J0IGZyb20gdGhlIG1vZHVsYXIgc3RvcmFnZSBpbXBsZW1lbnRhdGlvblxuZXhwb3J0IHsgY3JlYXRlU3RvcmFnZSB9IGZyb20gJy4vc3RvcmFnZS9pbmRleC5qcyc7XG4iXX0=

package/dist/streamer.js

@@ -480,4 +480,4 @@ export function createStreamer(basedir, tag) {
         },
     };
 }
-//# sourceMappingURL=streamer.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"streamer.js","sourceRoot":"","sources":["../src/streamer.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter } from 'node:events';\nimport path from 'node:path';\nimport type {\n  GetChunksOptions,\n  StreamChunksResponse,\n  Streamer,\n  StreamInfoResponse,\n} from '@workflow/world';\nimport { monotonicFactory } from 'ulid';\nimport { z } from 'zod';\nimport {\n  assertSafeEntityId,\n  listFilesByExtension,\n  readBuffer,\n  readJSONWithFallback,\n  taggedPath,\n  write,\n  writeJSON,\n} from './fs.js';\n\n// Create a monotonic ULID factory that ensures ULIDs are always increasing\n// even when generated within the same millisecond\nconst monotonicUlid = monotonicFactory(() => Math.random());\n\n// Schema for the run-to-streams mapping file\nconst RunStreamsSchema = z.object({\n  streams: z.array(z.string()),\n});\n\n/**\n * A chunk consists of a boolean `eof` indicating if it's the last chunk,\n * and a `chunk` which is a Buffer of data.\n * The serialized format is:\n * - 1 byte for `eof` (0 or 1)\n * - and the rest is the chunk data.\n */\nexport interface Chunk {\n  eof: boolean;\n  chunk: Buffer;\n}\n\nexport function serializeChunk(chunk: Chunk) {\n  const eofByte = Buffer.from([chunk.eof ? 1 : 0]);\n  return Buffer.concat([eofByte, chunk.chunk]);\n}\n\n/** Check only the EOF flag byte without copying chunk payload. */\nexport function isEofChunk(serialized: Buffer): boolean {\n  return serialized[0] === 1;\n}\n\nexport function deserializeChunk(serialized: Buffer) {\n  const eof = serialized[0] === 1;\n  // Create a copy instead of a view to prevent ArrayBuffer detachment\n  const chunk = Buffer.from(serialized.subarray(1));\n  return { eof, chunk };\n}\n\n/**\n * List chunk files for a stream, sorted chronologically (ULID order).\n * Returns both the sorted file names and a map of file → extension for\n * resolving the full path. Handles tagged and legacy (.json) formats.\n */\nasync function listChunkFilesForStream(\n  chunksDir: string,\n  name: string,\n  tag?: string\n): Promise<{ files: string[]; extMap: Map<string, string> }> {\n  // Name is used as a filename prefix below; validate it can't escape chunksDir.\n  assertSafeEntityId('streamName', name);\n  const listPromises: Promise<string[]>[] = [\n    listFilesByExtension(chunksDir, '.bin'),\n    listFilesByExtension(chunksDir, '.json'),\n  ];\n  if (tag) {\n    listPromises.push(listFilesByExtension(chunksDir, `.${tag}.bin`));\n  }\n  const [binFiles, jsonFiles, ...taggedResults] =\n    await Promise.all(listPromises);\n  const taggedBinFiles = taggedResults[0] ?? [];\n\n  const extMap = new Map<string, string>();\n  for (const f of jsonFiles) extMap.set(f, '.json');\n  const tagSfx = tag ? `.${tag}` : '';\n  for (const f of binFiles) {\n    if (tag && f.endsWith(tagSfx)) continue;\n    extMap.set(f, '.bin');\n  }\n  for (const f of taggedBinFiles) extMap.set(f, `.${tag}.bin`);\n\n  const files = [...extMap.keys()]\n    .filter((file) => file.startsWith(`${name}-`))\n    .sort();\n\n  return { files, extMap };\n}\n\nexport function createStreamer(basedir: string, tag?: string): Streamer {\n  const tagSuffix = tag ? `.${tag}` : '';\n  const streamEmitter = new EventEmitter<{\n    [key: `chunk:${string}`]: [\n      {\n        streamName: string;\n        chunkData: Uint8Array;\n        chunkId: string;\n      },\n    ];\n    [key: `close:${string}`]: [\n      {\n        streamName: string;\n      },\n    ];\n  }>();\n\n  // Track which streams have already been registered for a run (in-memory cache)\n  const registeredStreams = new Set<string>();\n\n  // Helper to record the runId <> streamId association\n  async function registerStreamForRun(\n    runId: string,\n    streamName: string\n  ): Promise<void> {\n    assertSafeEntityId('runId', runId);\n    assertSafeEntityId('streamName', streamName);\n    const cacheKey = `${runId}:${streamName}`;\n    if (registeredStreams.has(cacheKey)) {\n      return; // Already registered in this session\n    }\n\n    const runStreamsPath = taggedPath(basedir, 'streams/runs', runId, tag);\n\n    // Read existing streams for this run (try tagged first, fall back to untagged)\n    const existing = await readJSONWithFallback(\n      basedir,\n      'streams/runs',\n      runId,\n      RunStreamsSchema,\n      tag\n    );\n    const streams = existing?.streams ?? [];\n\n    // Add stream if not already present\n    if (!streams.includes(streamName)) {\n      streams.push(streamName);\n      await writeJSON(runStreamsPath, { streams }, { overwrite: true });\n    }\n\n    registeredStreams.add(cacheKey);\n  }\n\n  // Helper to convert a chunk to a Buffer\n  function toBuffer(chunk: string | Uint8Array): Buffer {\n    if (typeof chunk === 'string') {\n      return Buffer.from(new TextEncoder().encode(chunk));\n    } else if (chunk instanceof Buffer) {\n      return chunk;\n    } else {\n      return Buffer.from(chunk);\n    }\n  }\n\n  return {\n    streams: {\n      async write(\n        _runId: string | Promise<string>,\n        name: string,\n        chunk: string | Uint8Array\n      ) {\n        // Generate ULID synchronously BEFORE any await to preserve call order.\n        // This ensures that chunks written in sequence maintain their order even\n        // when runId is a promise that multiple writes are waiting on.\n        const chunkId = `chnk_${monotonicUlid()}`;\n\n        // Await runId if it's a promise to ensure proper flushing\n        const runId = await _runId;\n\n        // Register this stream for the run\n        await registerStreamForRun(runId, name);\n\n        // Convert chunk to buffer for serialization\n        const chunkBuffer = toBuffer(chunk);\n\n        const serialized = serializeChunk({\n          chunk: chunkBuffer,\n          eof: false,\n        });\n\n        const chunkPath = path.join(\n          basedir,\n          'streams',\n          'chunks',\n          `${name}-${chunkId}${tagSuffix}.bin`\n        );\n\n        await write(chunkPath, serialized);\n\n        // Emit real-time event with Uint8Array (create copy to prevent ArrayBuffer detachment)\n        const chunkData = Uint8Array.from(chunkBuffer);\n\n        streamEmitter.emit(`chunk:${name}` as const, {\n          streamName: name,\n          chunkData,\n          chunkId,\n        });\n      },\n\n      async writeMulti(\n        _runId: string | Promise<string>,\n        name: string,\n        chunks: (string | Uint8Array)[]\n      ) {\n        if (chunks.length === 0) return;\n\n        // Generate all ULIDs synchronously BEFORE any await to preserve call order.\n        // This ensures that chunks maintain their order even when runId is a promise.\n        const chunkIds = chunks.map(() => `chnk_${monotonicUlid()}`);\n\n        // Await runId if it's a promise\n        const runId = await _runId;\n\n        // Register this stream for the run\n        await registerStreamForRun(runId, name);\n\n        // Prepare chunk data for parallel writes\n        const chunkBuffers = chunks.map((chunk) => toBuffer(chunk));\n\n        // Write all chunks in parallel for efficiency, but track individual completion\n        const writePromises = chunkBuffers.map(async (chunkBuffer, i) => {\n          const chunkId = chunkIds[i];\n\n          const serialized = serializeChunk({\n            chunk: chunkBuffer,\n            eof: false,\n          });\n\n          const chunkPath = path.join(\n            basedir,\n            'streams',\n            'chunks',\n            `${name}-${chunkId}${tagSuffix}.bin`\n          );\n\n          await write(chunkPath, serialized);\n\n          // Return data needed for event emission\n          return {\n            chunkId,\n            chunkData: Uint8Array.from(chunkBuffer),\n          };\n        });\n\n        // Emit events in order, waiting for each chunk's write to complete\n        // This ensures events are emitted in order while writes happen in parallel\n        for (const writePromise of writePromises) {\n          const { chunkId, chunkData } = await writePromise;\n\n          streamEmitter.emit(`chunk:${name}` as const, {\n            streamName: name,\n            chunkData,\n            chunkId,\n          });\n        }\n      },\n\n      async close(_runId: string | Promise<string>, name: string) {\n        // Generate ULID synchronously BEFORE any await to preserve call order.\n        const chunkId = `chnk_${monotonicUlid()}`;\n\n        // Await runId if it's a promise to ensure proper flushing\n        const runId = await _runId;\n\n        // Register this stream for the run (in case write wasn't called)\n        await registerStreamForRun(runId, name);\n        const chunkPath = path.join(\n          basedir,\n          'streams',\n          'chunks',\n          `${name}-${chunkId}${tagSuffix}.bin`\n        );\n\n        await write(\n          chunkPath,\n          serializeChunk({ chunk: Buffer.from([]), eof: true })\n        );\n\n        streamEmitter.emit(`close:${name}` as const, { streamName: name });\n      },\n\n      async list(runId: string) {\n        assertSafeEntityId('runId', runId);\n        const data = await readJSONWithFallback(\n          basedir,\n          'streams/runs',\n          runId,\n          RunStreamsSchema,\n          tag\n        );\n        return data?.streams ?? [];\n      },\n\n      async getChunks(\n        _runId: string,\n        name: string,\n        options?: GetChunksOptions\n      ): Promise<StreamChunksResponse> {\n        const limit = options?.limit ?? 100;\n        const chunksDir = path.join(basedir, 'streams', 'chunks');\n        const { files: chunkFiles, extMap: fileExtMap } =\n          await listChunkFilesForStream(chunksDir, name, tag);\n\n        // Decode cursor\n        let startIndex = 0;\n        if (options?.cursor) {\n          try {\n            const decoded = JSON.parse(\n              Buffer.from(options.cursor, 'base64').toString('utf-8')\n            );\n            startIndex = decoded.i;\n          } catch {\n            startIndex = 0;\n          }\n        }\n\n        // Walk from startIndex, reading only the files we need.\n        // Files before the cursor are skipped entirely.\n        let streamDone = false;\n        const resultChunks: { index: number; data: Uint8Array }[] = [];\n        let dataIndex = 0; // running count of data (non-EOF) files seen\n\n        for (const file of chunkFiles) {\n          const ext = fileExtMap.get(file) ?? '.bin';\n          const filePath = path.join(chunksDir, `${file}${ext}`);\n\n          // Before the cursor: only need to check EOF (1 byte), skip content\n          if (dataIndex < startIndex) {\n            if (isEofChunk(await readBuffer(filePath))) {\n              streamDone = true;\n              break;\n            }\n            dataIndex++;\n            continue;\n          }\n\n          // Collected enough data chunks — peek at the next file for EOF/hasMore\n          if (resultChunks.length >= limit) {\n            if (isEofChunk(await readBuffer(filePath))) {\n              streamDone = true;\n            } else {\n              // More data files exist beyond this page\n              dataIndex++;\n            }\n            break;\n          }\n\n          // In the page window: deserialize fully\n          const chunk = deserializeChunk(await readBuffer(filePath));\n          if (chunk.eof) {\n            streamDone = true;\n            break;\n          }\n          resultChunks.push({\n            index: dataIndex,\n            data: Uint8Array.from(chunk.chunk),\n          });\n          dataIndex++;\n        }\n\n        // hasMore = we know there are data files beyond this page\n        const hasMore =\n          !streamDone && dataIndex > startIndex + resultChunks.length;\n        const nextIndex = startIndex + resultChunks.length;\n        const nextCursor = hasMore\n          ? Buffer.from(JSON.stringify({ i: nextIndex })).toString('base64')\n          : null;\n\n        return {\n          data: resultChunks,\n          cursor: nextCursor,\n          hasMore,\n          done: streamDone,\n        };\n      },\n\n      async getInfo(_runId: string, name: string): Promise<StreamInfoResponse> {\n        const chunksDir = path.join(basedir, 'streams', 'chunks');\n        const { files: chunkFiles, extMap: fileExtMap } =\n          await listChunkFilesForStream(chunksDir, name, tag);\n\n        // Only read the first byte of each file to check EOF — no full\n        // deserialization needed since we just need a count.\n        let streamDone = false;\n        let dataCount = 0;\n        for (const file of chunkFiles) {\n          const ext = fileExtMap.get(file) ?? '.bin';\n          if (\n            isEofChunk(await readBuffer(path.join(chunksDir, `${file}${ext}`)))\n          ) {\n            streamDone = true;\n            break;\n          }\n          dataCount++;\n        }\n\n        return { tailIndex: dataCount - 1, done: streamDone };\n      },\n\n      async get(_runId: string, name: string, startIndex = 0) {\n        const chunksDir = path.join(basedir, 'streams', 'chunks');\n        let removeListeners = () => {};\n        let pollInterval: ReturnType<typeof setInterval> | null = null;\n\n        return new ReadableStream<Uint8Array>({\n          async start(controller) {\n            // Track chunks delivered via events to prevent duplicates and maintain order.\n            const deliveredChunkIds = new Set<string>();\n            // Buffer for chunks that arrive via events during disk reading\n            const bufferedEventChunks: Array<{\n              chunkId: string;\n              chunkData: Uint8Array;\n            }> = [];\n            let isReadingFromDisk = true;\n            // Buffer close event if it arrives during disk reading\n            let pendingClose = false;\n            // Set when the controller is closed; guards against enqueue-after-close\n            // in the polling callback when closeListener fires mid-iteration.\n            let streamClosed = false;\n\n            const chunkListener = (event: {\n              streamName: string;\n              chunkData: Uint8Array;\n              chunkId: string;\n            }) => {\n              // Skip empty chunks to maintain consistency with disk reading behavior\n              if (event.chunkData.byteLength === 0) {\n                deliveredChunkIds.add(event.chunkId);\n                return;\n              }\n\n              if (isReadingFromDisk) {\n                deliveredChunkIds.add(event.chunkId);\n                // Buffer chunks that arrive during disk reading to maintain order\n                // Create a copy to prevent ArrayBuffer detachment when enqueued later\n                bufferedEventChunks.push({\n                  chunkId: event.chunkId,\n                  chunkData: Uint8Array.from(event.chunkData),\n                });\n              } else if (!deliveredChunkIds.has(event.chunkId)) {\n                // Guard against duplicates: polling may have already claimed this\n                // chunk between its has() check and readBuffer() yield.\n                deliveredChunkIds.add(event.chunkId);\n                // After disk reading is complete, deliver chunks immediately\n                // Create a copy to prevent ArrayBuffer detachment\n                controller.enqueue(Uint8Array.from(event.chunkData));\n              }\n            };\n\n            const closeListener = () => {\n              // Buffer close event if disk reading is still in progress\n              if (isReadingFromDisk) {\n                pendingClose = true;\n                return;\n              }\n              // Remove listeners before closing\n              streamClosed = true;\n              streamEmitter.off(`chunk:${name}` as const, chunkListener);\n              streamEmitter.off(`close:${name}` as const, closeListener);\n              if (pollInterval) {\n                clearInterval(pollInterval);\n                pollInterval = null;\n              }\n              try {\n                controller.close();\n              } catch {\n                // Ignore if controller is already closed (e.g., from cancel() or EOF)\n              }\n            };\n            removeListeners = closeListener;\n\n            // Set up listeners FIRST to avoid missing events\n            streamEmitter.on(`chunk:${name}` as const, chunkListener);\n            streamEmitter.on(`close:${name}` as const, closeListener);\n\n            // Now load existing chunks from disk.\n            const { files: chunkFiles, extMap: fileExtMap } =\n              await listChunkFilesForStream(chunksDir, name, tag);\n\n            // Resolve negative startIndex relative to the number of data chunks\n            // (excluding the trailing EOF marker chunk, if present).\n            let dataChunkCount = chunkFiles.length;\n            if (\n              typeof startIndex === 'number' &&\n              startIndex < 0 &&\n              chunkFiles.length > 0\n            ) {\n              const lastFile = chunkFiles[chunkFiles.length - 1];\n              const lastExt = fileExtMap.get(lastFile) ?? '.bin';\n              // Note: this incurs an extra disk read to check the EOF marker.\n              // Acceptable since negative startIndex is not a hot path.\n              const lastChunk = deserializeChunk(\n                await readBuffer(path.join(chunksDir, `${lastFile}${lastExt}`))\n              );\n              if (lastChunk?.eof === true) {\n                dataChunkCount--;\n              }\n            }\n            const resolvedStartIndex =\n              typeof startIndex === 'number' && startIndex < 0\n                ? Math.max(0, dataChunkCount + startIndex)\n                : startIndex;\n\n            // Process existing chunks, skipping any already delivered via events\n            let isComplete = false;\n            for (let i = resolvedStartIndex; i < chunkFiles.length; i++) {\n              const file = chunkFiles[i];\n              // Extract chunk ID from filename: \"streamName-chunkId\" or \"streamName-chunkId.tag\"\n              const rawChunkId = file.substring(name.length + 1);\n              // Strip tag suffix (e.g., \"chnk_ULID.vitest-0\" → \"chnk_ULID\")\n              const chunkId = tag\n                ? rawChunkId.replace(`.${tag}`, '')\n                : rawChunkId;\n\n              // Skip if already delivered via event\n              if (deliveredChunkIds.has(chunkId)) {\n                continue;\n              }\n\n              const ext = fileExtMap.get(file) ?? '.bin';\n              const chunk = deserializeChunk(\n                await readBuffer(path.join(chunksDir, `${file}${ext}`))\n              );\n              if (chunk?.eof === true) {\n                isComplete = true;\n                break;\n              }\n              // Track as handled so polling doesn't re-deliver\n              deliveredChunkIds.add(chunkId);\n              if (chunk.chunk.byteLength) {\n                // Create a copy to prevent ArrayBuffer detachment\n                controller.enqueue(Uint8Array.from(chunk.chunk));\n              }\n            }\n\n            // Finished reading from disk - now deliver buffered event chunks in chronological order\n            isReadingFromDisk = false;\n\n            // Sort buffered chunks by ULID (chronological order)\n            bufferedEventChunks.sort((a, b) =>\n              a.chunkId.localeCompare(b.chunkId)\n            );\n            for (const buffered of bufferedEventChunks) {\n              // Create a copy for defense in depth (already copied at storage, but be extra safe)\n              controller.enqueue(Uint8Array.from(buffered.chunkData));\n            }\n\n            if (isComplete) {\n              removeListeners();\n              try {\n                controller.close();\n              } catch {\n                // Ignore if controller is already closed (e.g., from closeListener event)\n              }\n              return;\n            }\n\n            // Process any pending close event that arrived during disk reading\n            if (pendingClose) {\n              streamEmitter.off(`chunk:${name}` as const, chunkListener);\n              streamEmitter.off(`close:${name}` as const, closeListener);\n              try {\n                controller.close();\n              } catch {\n                // Ignore if controller is already closed\n              }\n              return;\n            }\n\n            // Track pre-startIndex chunks so polling doesn't re-deliver them\n            for (\n              let i = 0;\n              i < resolvedStartIndex && i < chunkFiles.length;\n              i++\n            ) {\n              const file = chunkFiles[i];\n              const rawChunkId = file.substring(name.length + 1);\n              const chunkId = tag\n                ? rawChunkId.replace(`.${tag}`, '')\n                : rawChunkId;\n              deliveredChunkIds.add(chunkId);\n            }\n\n            // Start filesystem polling for cross-process streaming support.\n            // The EventEmitter only works in-process; when the writer is in a\n            // separate process (e.g. e2e test runner ↔ workbench app), polling\n            // the shared filesystem is the fallback delivery mechanism.\n            let isPolling = false;\n            pollInterval = setInterval(async () => {\n              if (isPolling) return;\n              isPolling = true;\n              try {\n                const { files: currentFiles, extMap: currentExtMap } =\n                  await listChunkFilesForStream(chunksDir, name, tag);\n\n                for (const file of currentFiles) {\n                  const rawChunkId = file.substring(name.length + 1);\n                  const chunkId = tag\n                    ? rawChunkId.replace(`.${tag}`, '')\n                    : rawChunkId;\n\n                  if (deliveredChunkIds.has(chunkId)) continue;\n                  deliveredChunkIds.add(chunkId);\n\n                  const ext = currentExtMap.get(file) ?? '.bin';\n                  const chunk = deserializeChunk(\n                    await readBuffer(path.join(chunksDir, `${file}${ext}`))\n                  );\n\n                  if (chunk?.eof === true) {\n                    streamClosed = true;\n                    if (pollInterval) {\n                      clearInterval(pollInterval);\n                      pollInterval = null;\n                    }\n                    streamEmitter.off(`chunk:${name}` as const, chunkListener);\n                    streamEmitter.off(`close:${name}` as const, closeListener);\n                    try {\n                      controller.close();\n                    } catch {\n                      // Ignore if controller is already closed\n                    }\n                    return;\n                  }\n\n                  // Guard against enqueue-after-close: closeListener may have\n                  // fired between our readBuffer() yield and this point.\n                  if (streamClosed) return;\n\n                  if (chunk.chunk.byteLength) {\n                    controller.enqueue(Uint8Array.from(chunk.chunk));\n                  }\n                }\n              } catch (err: unknown) {\n                // Silently ignore transient filesystem errors (ENOENT, EACCES, etc.)\n                // Surface unexpected errors so bugs aren't hidden\n                if (!(err instanceof Error && 'code' in err)) {\n                  console.error('[world-local] Unexpected polling error:', err);\n                }\n              } finally {\n                isPolling = false;\n              }\n            }, 100);\n          },\n\n          cancel() {\n            removeListeners();\n            if (pollInterval) {\n              clearInterval(pollInterval);\n              pollInterval = null;\n            }\n          },\n        });\n      },\n    },\n  };\n}\n"]}

package/dist/telemetry.js

@@ -68,4 +68,4 @@ export const RpcSystem = SemanticConvention('rpc.system');
 export const RpcService = SemanticConvention('rpc.service');
 /** RPC method name (standard OTEL: rpc.method) */
 export const RpcMethod = SemanticConvention('rpc.method');
-//# sourceMappingURL=telemetry.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test-helpers.js

@@ -115,4 +115,4 @@ export async function completeWait(storage, runId, waitId) {
     }
     return result.wait;
 }
-//# sourceMappingURL=test-helpers.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-helpers.js","sourceRoot":"","sources":["../src/test-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  Hook,\n  SerializedData,\n  Step,\n  Storage,\n  Wait,\n  WorkflowRun,\n} from '@workflow/world';\nimport { SPEC_VERSION_CURRENT } from '@workflow/world';\n\n/**\n * Test helper functions for creating and updating storage entities through events.\n * These helpers simplify test setup by providing a convenient API for common operations.\n */\n\n/**\n * Create a new workflow run through the run_created event.\n */\nexport async function createRun(\n  storage: Storage,\n  data: {\n    deploymentId: string;\n    workflowName: string;\n    input: SerializedData;\n    executionContext?: Record<string, unknown>;\n  }\n): Promise<WorkflowRun> {\n  const result = await storage.events.create(null, {\n    eventType: 'run_created',\n    specVersion: SPEC_VERSION_CURRENT,\n    eventData: data,\n  });\n  if (!result.run) {\n    throw new Error('Expected run to be created');\n  }\n  return result.run;\n}\n\n/**\n * Update a workflow run's status through lifecycle events.\n */\nexport async function updateRun(\n  storage: Storage,\n  runId: string,\n  eventType: 'run_started' | 'run_completed' | 'run_failed' | 'run_cancelled',\n  eventData?: Record<string, unknown>\n): Promise<WorkflowRun> {\n  const result = await storage.events.create(runId, {\n    eventType,\n    specVersion: SPEC_VERSION_CURRENT,\n    eventData,\n  } as any);\n  if (!result.run) {\n    throw new Error('Expected run to be updated');\n  }\n  return result.run;\n}\n\n/**\n * Create a new step through the step_created event.\n */\nexport async function createStep(\n  storage: Storage,\n  runId: string,\n  data: {\n    stepId: string;\n    stepName: string;\n    input: SerializedData;\n  }\n): Promise<Step> {\n  const result = await storage.events.create(runId, {\n    eventType: 'step_created',\n    specVersion: SPEC_VERSION_CURRENT,\n    correlationId: data.stepId,\n    eventData: { stepName: data.stepName, input: data.input },\n  });\n  if (!result.step) {\n    throw new Error('Expected step to be created');\n  }\n  return result.step;\n}\n\n/**\n * Update a step's status through lifecycle events.\n */\nexport async function updateStep(\n  storage: Storage,\n  runId: string,\n  stepId: string,\n  eventType:\n    | 'step_started'\n    | 'step_completed'\n    | 'step_failed'\n    | 'step_retrying',\n  eventData?: Record<string, unknown>\n): Promise<Step> {\n  const result = await storage.events.create(runId, {\n    eventType,\n    specVersion: SPEC_VERSION_CURRENT,\n    correlationId: stepId,\n    eventData,\n  } as any);\n  if (!result.step) {\n    throw new Error('Expected step to be updated');\n  }\n  return result.step;\n}\n\n/**\n * Create a new hook through the hook_created event.\n */\nexport async function createHook(\n  storage: Storage,\n  runId: string,\n  data: {\n    hookId: string;\n    token: string;\n    metadata?: SerializedData;\n  }\n): Promise<Hook> {\n  const result = await storage.events.create(runId, {\n    eventType: 'hook_created',\n    specVersion: SPEC_VERSION_CURRENT,\n    correlationId: data.hookId,\n    eventData: { token: data.token, metadata: data.metadata },\n  });\n  if (!result.hook) {\n    throw new Error('Expected hook to be created');\n  }\n  return result.hook;\n}\n\n/**\n * Dispose a hook through the hook_disposed event.\n */\nexport async function disposeHook(\n  storage: Storage,\n  runId: string,\n  hookId: string\n): Promise<void> {\n  await storage.events.create(runId, {\n    eventType: 'hook_disposed',\n    specVersion: SPEC_VERSION_CURRENT,\n    correlationId: hookId,\n  });\n}\n\n/**\n * Create a new wait through the wait_created event.\n */\nexport async function createWait(\n  storage: Storage,\n  runId: string,\n  data: {\n    waitId: string;\n    resumeAt: Date;\n  }\n): Promise<Wait> {\n  const result = await storage.events.create(runId, {\n    eventType: 'wait_created',\n    specVersion: SPEC_VERSION_CURRENT,\n    correlationId: data.waitId,\n    eventData: { resumeAt: data.resumeAt },\n  });\n  if (!result.wait) {\n    throw new Error('Expected wait to be created');\n  }\n  return result.wait;\n}\n\n/**\n * Complete a wait through the wait_completed event.\n */\nexport async function completeWait(\n  storage: Storage,\n  runId: string,\n  waitId: string\n): Promise<Wait> {\n  const result = await storage.events.create(runId, {\n    eventType: 'wait_completed',\n    specVersion: SPEC_VERSION_CURRENT,\n    correlationId: waitId,\n  });\n  if (!result.wait) {\n    throw new Error('Expected wait to be completed');\n  }\n  return result.wait;\n}\n"]}

package/dist/util.js

@@ -18,4 +18,4 @@ export function once(fn) {
     };
     return result;
 }
-//# sourceMappingURL=util.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy91dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7R0FTRztBQUNILE1BQU0sVUFBVSxJQUFJLENBQUksRUFBVztJQUNqQyxNQUFNLE1BQU0sR0FBRztRQUNiLElBQUksS0FBSztZQUNQLE1BQU0sS0FBSyxHQUFHLEVBQUUsRUFBRSxDQUFDO1lBQ25CLE1BQU0sQ0FBQyxjQUFjLENBQUMsTUFBTSxFQUFFLE9BQU8sRUFBRSxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUM7WUFDbEQsT0FBTyxLQUFLLENBQUM7UUFDZixDQUFDO0tBQ0YsQ0FBQztJQUNGLE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENyZWF0ZXMgYSBsYXppbHktZXZhbHVhdGVkLCBtZW1vaXplZCB2ZXJzaW9uIG9mIHRoZSBwcm92aWRlZCBmdW5jdGlvbi5cbiAqXG4gKiBUaGUgcmV0dXJuZWQgb2JqZWN0IGV4cG9zZXMgYSBgdmFsdWVgIGdldHRlciB0aGF0IGNhbGxzIGBmbmAgb25seSBvbmNlLFxuICogY2FjaGVzIGl0cyByZXN1bHQsIGFuZCByZXR1cm5zIHRoZSBjYWNoZWQgdmFsdWUgb24gc3Vic2VxdWVudCBhY2Nlc3Nlcy5cbiAqXG4gKiBAdHlwZVBhcmFtIFQgLSBUaGUgcmV0dXJuIHR5cGUgb2YgdGhlIHByb3ZpZGVkIGZ1bmN0aW9uLlxuICogQHBhcmFtIGZuIC0gVGhlIGZ1bmN0aW9uIHRvIGJlIGNhbGxlZCBvbmNlIGFuZCB3aG9zZSByZXN1bHQgd2lsbCBiZSBjYWNoZWQuXG4gKiBAcmV0dXJucyBBbiBvYmplY3Qgd2l0aCBhIGB2YWx1ZWAgcHJvcGVydHkgdGhhdCByZXR1cm5zIHRoZSBtZW1vaXplZCByZXN1bHQgb2YgYGZuYC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIG9uY2U8VD4oZm46ICgpID0+IFQpIHtcbiAgY29uc3QgcmVzdWx0ID0ge1xuICAgIGdldCB2YWx1ZSgpIHtcbiAgICAgIGNvbnN0IHZhbHVlID0gZm4oKTtcbiAgICAgIE9iamVjdC5kZWZpbmVQcm9wZXJ0eShyZXN1bHQsICd2YWx1ZScsIHsgdmFsdWUgfSk7XG4gICAgICByZXR1cm4gdmFsdWU7XG4gICAgfSxcbiAgfTtcbiAgcmV0dXJuIHJlc3VsdDtcbn1cbiJdfQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/world-local",
-  "version": "5.0.0-beta.6",
+  "version": "5.0.0-beta.7",
   "description": "Local development World implementation for Workflow SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -28,9 +28,9 @@
     "ulid": "~3.0.1",
     "undici": "7.22.0",
     "zod": "4.3.6",
-    "@workflow/errors": "5.0.0-beta.4",
-    "@workflow/utils": "5.0.0-beta.2",
-    "@workflow/world": "5.0.0-beta.4"
+    "@workflow/utils": "5.0.0-beta.3",
+    "@workflow/world": "5.0.0-beta.5",
+    "@workflow/errors": "5.0.0-beta.5"
   },
   "devDependencies": {
     "@opentelemetry/api": "1.9.0",

package/dist/config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,MAAM,iBAAiB,GAAG,GAAG,EAAE;IAC7B,OAAO,OAAO,CAAC,GAAG,CAAC,uBAAuB,IAAI,gBAAgB,CAAC;AACjE,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,2BAA2B,GAAG,KAAK,CAAC;AAEjD,MAAM,iBAAiB,GAAG,GAAG,EAAE;IAC7B,OAAO,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC;AAC7C,CAAC,CAAC;AA0BF,MAAM,CAAC,MAAM,MAAM,GAAG,IAAI,CAAS,GAAG,EAAE;IACtC,MAAM,OAAO,GAAG,iBAAiB,EAAE,CAAC;IACpC,MAAM,OAAO,GAAG,iBAAiB,EAAE,CAAC;IAEpC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;AAC9B,CAAC,CAAC,CAAC;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,MAAuB;IAC1D,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,OAAO,MAAM,CAAC,OAAO,CAAC;IACxB,CAAC;IAED,wEAAwE;IACxE,2EAA2E;IAC3E,IAAI,OAAO,CAAC,GAAG,CAAC,uBAAuB,EAAE,CAAC;QACxC,OAAO,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC;IAC7C,CAAC;IAED,IAAI,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QACpC,OAAO,oBAAoB,MAAM,CAAC,IAAI,EAAE,CAAC;IAC3C,CAAC;IAED,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QACrB,OAAO,oBAAoB,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;IAChD,CAAC;IAED,MAAM,YAAY,GAAG,MAAM,eAAe,EAAE,CAAC;IAC7C,IAAI,YAAY,EAAE,CAAC;QACjB,OAAO,oBAAoB,YAAY,EAAE,CAAC;IAC5C,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;AACpE,CAAC","sourcesContent":["import { getWorkflowPort } from '@workflow/utils/get-port';\nimport { once } from './util.js';\n\nconst getDataDirFromEnv = () => {\n  return process.env.WORKFLOW_LOCAL_DATA_DIR || '.workflow-data';\n};\n\nexport const DEFAULT_RESOLVE_DATA_OPTION = 'all';\n\nconst getBaseUrlFromEnv = () => {\n  return process.env.WORKFLOW_LOCAL_BASE_URL;\n};\n\nexport type Config = {\n  dataDir: string;\n  port?: number;\n  baseUrl?: string;\n  /**\n   * Whether start() should re-enqueue pending/running runs from storage.\n   * Defaults to true. Test harnesses that always start from a clean slate can\n   * disable recovery to avoid replaying stale runs.\n   */\n  recoverActiveRuns?: boolean;\n  /**\n   * Optional tag to scope filesystem operations.\n   * When set, files are written as `{id}.{tag}.json` and `clear()` only deletes\n   * files matching this tag. Used by vitest to isolate test data in the shared\n   * `.workflow-data` directory.\n   */\n  tag?: string;\n  /**\n   * Override the flush interval (in ms) for buffered stream writes.\n   * Default is 10ms. Set to 0 for immediate flushing.\n   */\n  streamFlushIntervalMs?: number;\n};\n\nexport const config = once<Config>(() => {\n  const dataDir = getDataDirFromEnv();\n  const baseUrl = getBaseUrlFromEnv();\n\n  return { dataDir, baseUrl };\n});\n\n/**\n * Resolves the base URL for queue requests following the priority order:\n * 1. config.baseUrl (highest priority - full override from args)\n * 2. WORKFLOW_LOCAL_BASE_URL env var (checked directly to handle late env var setting)\n * 3. config.port (explicit port override from args)\n * 4. PORT env var (explicit configuration)\n * 5. Auto-detected port via getPort (detect actual listening port)\n */\nexport async function resolveBaseUrl(config: Partial<Config>): Promise<string> {\n  if (config.baseUrl) {\n    return config.baseUrl;\n  }\n\n  // Check env var directly in case it was set after the config was cached\n  // This is important for CLI tools that set the env var after module import\n  if (process.env.WORKFLOW_LOCAL_BASE_URL) {\n    return process.env.WORKFLOW_LOCAL_BASE_URL;\n  }\n\n  if (typeof config.port === 'number') {\n    return `http://localhost:${config.port}`;\n  }\n\n  if (process.env.PORT) {\n    return `http://localhost:${process.env.PORT}`;\n  }\n\n  const detectedPort = await getWorkflowPort();\n  if (detectedPort) {\n    return `http://localhost:${detectedPort}`;\n  }\n\n  throw new Error('Unable to resolve base URL for workflow queue.');\n}\n"]}

package/dist/fs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fs.js","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":"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","sourcesContent":["import { promises as fs } from 'node:fs';\nimport path from 'node:path';\nimport { EntityConflictError, WorkflowWorldError } from '@workflow/errors';\nimport type { PaginatedResponse } from '@workflow/world';\nimport { monotonicFactory } from 'ulid';\nimport { z } from 'zod';\n\nconst ulid = monotonicFactory(() => Math.random());\n\n/**\n * Truncate a possibly-untrusted value for inclusion in an error message.\n * Keeps error output actionable for developers in dev mode while limiting\n * the amount of attacker-controlled data reflected back if a `world-local`\n * backend is ever run in a context that surfaces these messages to clients.\n */\nfunction truncateForError(value: unknown): string {\n  const s = typeof value === 'string' ? value : String(value);\n  const MAX = 48;\n  return s.length > MAX ? `${s.slice(0, MAX)}…` : s;\n}\n\n/**\n * Thrown when a caller-supplied entity ID contains characters that would\n * escape the storage root (path traversal) or otherwise produce an unsafe\n * filename. Extends {@link WorkflowWorldError} so the platform's standard\n * error-to-HTTP mapping handles it alongside other world-layer errors.\n */\nexport class UnsafeEntityIdError extends WorkflowWorldError {\n  constructor(kind: string, value: string) {\n    super(\n      `Unsafe ${kind} \"${truncateForError(value)}\": must not be empty, start with \".\", or contain path separators or null bytes`\n    );\n    this.name = 'UnsafeEntityIdError';\n  }\n\n  static is(value: unknown): value is UnsafeEntityIdError {\n    return value instanceof Error && value.name === 'UnsafeEntityIdError';\n  }\n}\n\n/**\n * Validate that a string is safe to embed in a filesystem path as a single\n * path component. Rejects values that are:\n *   - empty\n *   - starting with `.` (blocks `.`, `..`, `.locks`, `.tmp`, and other\n *     hidden or reserved filenames)\n *   - containing `/`, `\\`, or a NUL byte\n *\n * This is the primary defense against path-traversal attacks where a\n * request body supplies a `runId` / `stepId` / `correlationId` containing\n * `../` sequences to read or write files outside the storage root.\n * {@link resolveWithinBase} provides a belt-and-suspenders containment\n * check at the point of `path.join` for defense in depth.\n *\n * @param kind - Human-readable label used in the error message (e.g. \"runId\")\n * @param value - The value to validate; throws {@link UnsafeEntityIdError}\n *   if the value is not safe.\n */\nexport function assertSafeEntityId(kind: string, value: string): void {\n  if (\n    value.length === 0 ||\n    value.startsWith('.') ||\n    value.includes('/') ||\n    value.includes('\\\\') ||\n    value.includes('\\0')\n  ) {\n    throw new UnsafeEntityIdError(kind, value);\n  }\n}\n\n/**\n * Join `basedir` with an entity-relative path and assert the result stays\n * inside `basedir`. Complements {@link assertSafeEntityId}: per-entry-point\n * validation is the primary defense, and this final check catches any path\n * escape that slipped past (e.g. a new call site that forgot to validate,\n * or an unusual character combination on a future filesystem). Throws\n * {@link UnsafeEntityIdError} if the joined path escapes `basedir`.\n */\nexport function resolveWithinBase(\n  basedir: string,\n  ...segments: string[]\n): string {\n  const resolvedBase = path.resolve(basedir);\n  const joined = path.resolve(basedir, ...segments);\n  if (joined !== resolvedBase && !joined.startsWith(resolvedBase + path.sep)) {\n    throw new UnsafeEntityIdError('path', segments.join('/'));\n  }\n  return joined;\n}\n\nconst isWindows = process.platform === 'win32';\n\n/**\n * Execute a filesystem operation with retry logic on Windows.\n * On Windows, file operations can fail with EPERM/EBUSY/EACCES when files\n * are briefly locked by another process or antivirus. This wrapper adds\n * exponential backoff retry logic. On non-Windows platforms, executes directly.\n */\nasync function withWindowsRetry<T>(\n  fn: () => Promise<T>,\n  maxRetries = 5\n): Promise<T> {\n  if (!isWindows) return fn();\n\n  const retryableErrors = ['EPERM', 'EBUSY', 'EACCES'];\n  const baseDelayMs = 10;\n\n  for (let attempt = 0; attempt <= maxRetries; attempt++) {\n    try {\n      return await fn();\n    } catch (error: any) {\n      const isRetryable =\n        attempt < maxRetries && retryableErrors.includes(error.code);\n      if (!isRetryable) throw error;\n      // Exponential backoff with jitter\n      const delay = baseDelayMs * 2 ** attempt + Math.random() * baseDelayMs;\n      await new Promise((resolve) => setTimeout(resolve, delay));\n    }\n  }\n  // TypeScript: unreachable, but satisfies return type\n  throw new Error('Retry loop exited unexpectedly');\n}\n\n// In-memory cache of created files to avoid expensive fs.access() calls\n// This is safe because we only write once per file path (no overwrites without explicit flag)\nconst createdFilesCache = new Set<string>();\n\n/**\n * Clear the created files cache. Useful for testing or when files are deleted externally.\n */\nexport function clearCreatedFilesCache(): void {\n  createdFilesCache.clear();\n}\n\nexport { ulidToDate } from '@workflow/world';\n\n/**\n * Regex matching a tag suffix on a fileId (after `.json` has been stripped).\n * E.g., `wrun_ABC.vitest-0` → the `.vitest-0` part.\n * Tags start with a letter and contain alphanumeric chars and hyphens.\n * Entity IDs (ULIDs, step_N, etc.) never contain dots, so the first dot\n * always marks the tag boundary.\n */\nconst TAG_PATTERN = /\\.[a-zA-Z][a-zA-Z0-9-]*$/;\n\n/**\n * Strip a tag suffix from a fileId.\n * `wrun_ABC.vitest-0` → `wrun_ABC`\n * `wrun_ABC` → `wrun_ABC` (no-op if no tag)\n */\nexport function stripTag(fileId: string): string {\n  return fileId.replace(TAG_PATTERN, '');\n}\n\n/**\n * Check whether a fileId belongs to a specific tag.\n * `wrun_ABC.vitest-0` belongs to `vitest-0`.\n * Untagged fileIds never match a tag-scoped lookup.\n */\nexport function hasTag(fileId: string, tag: string): boolean {\n  return fileId.endsWith(`.${tag}`);\n}\n\n/**\n * Build the file path for an entity, with optional tag embedded in the filename.\n * `taggedPath('/data', 'runs', 'wrun_ABC', 'vitest-0')` → `/data/runs/wrun_ABC.vitest-0.json`\n * `taggedPath('/data', 'runs', 'wrun_ABC')` → `/data/runs/wrun_ABC.json`\n *\n * The `fileId` and `tag` are validated with {@link assertSafeEntityId} and\n * the result is containment-checked with {@link resolveWithinBase} to\n * prevent path-traversal attacks when values are derived from untrusted\n * request input.\n */\nexport function taggedPath(\n  basedir: string,\n  entityDir: string,\n  fileId: string,\n  tag?: string\n): string {\n  assertSafeEntityId('fileId', fileId);\n  if (tag !== undefined) assertSafeEntityId('tag', tag);\n  const filename = tag ? `${fileId}.${tag}.json` : `${fileId}.json`;\n  return resolveWithinBase(basedir, entityDir, filename);\n}\n\n/**\n * Read a JSON entity with tagged fallback.\n * When a tag is set, tries the tagged path first, then falls back to the\n * untagged path (so a tagged world can read entities written without a tag).\n */\nexport async function readJSONWithFallback<T>(\n  basedir: string,\n  entityDir: string,\n  fileId: string,\n  schema: z.ZodType<T>,\n  tag?: string\n): Promise<T | null> {\n  assertSafeEntityId('fileId', fileId);\n  if (tag !== undefined) assertSafeEntityId('tag', tag);\n  if (tag) {\n    const result = await readJSON(\n      resolveWithinBase(basedir, entityDir, `${fileId}.${tag}.json`),\n      schema\n    );\n    if (result !== null) return result;\n  }\n  return readJSON(\n    resolveWithinBase(basedir, entityDir, `${fileId}.json`),\n    schema\n  );\n}\n\n/**\n * List all filenames in a directory that have a specific tag.\n * Returns full filenames (e.g., `wrun_ABC.vitest-0.json`).\n */\nexport async function listTaggedFiles(\n  dirPath: string,\n  tag: string\n): Promise<string[]> {\n  const suffix = `.${tag}.json`;\n  try {\n    const files = await fs.readdir(dirPath);\n    return files.filter((f) => f.endsWith(suffix));\n  } catch (error) {\n    if ((error as any).code === 'ENOENT') return [];\n    throw error;\n  }\n}\n\n/**\n * List all filenames in a directory that have a specific tag and extension.\n * Returns full filenames (e.g., `stream-chnk_ABC.vitest-0.bin`).\n */\nexport async function listTaggedFilesByExtension(\n  dirPath: string,\n  tag: string,\n  extension: string\n): Promise<string[]> {\n  const suffix = `.${tag}${extension}`;\n  try {\n    const files = await fs.readdir(dirPath);\n    return files.filter((f) => f.endsWith(suffix));\n  } catch (error) {\n    if ((error as any).code === 'ENOENT') return [];\n    throw error;\n  }\n}\n\nexport async function ensureDir(dirPath: string): Promise<void> {\n  try {\n    await fs.mkdir(dirPath, { recursive: true });\n  } catch (_error) {\n    // Ignore if already exists\n  }\n}\n\ninterface WriteOptions {\n  overwrite?: boolean;\n}\n\n/**\n * Custom JSON replacer that encodes Uint8Array as base64 strings.\n * Format: { __type: 'Uint8Array', data: '<base64>' }\n */\nexport function jsonReplacer(_key: string, value: unknown): unknown {\n  if (value instanceof Uint8Array) {\n    return {\n      __type: 'Uint8Array',\n      data: Buffer.from(value).toString('base64'),\n    };\n  }\n  return value;\n}\n\n/**\n * Custom JSON reviver that decodes base64 strings back to Uint8Array.\n */\nexport function jsonReviver(_key: string, value: unknown): unknown {\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\nexport async function writeJSON(\n  filePath: string,\n  data: any,\n  opts?: WriteOptions\n): Promise<void> {\n  return write(filePath, JSON.stringify(data, jsonReplacer, 2), opts);\n}\n\n/**\n * Writes data to a file using atomic write-rename pattern.\n *\n * Note: While this function uses temp files to avoid partial writes,\n * it does not provide protection against concurrent writes from multiple\n * processes. In a multi-writer scenario, the last writer wins.\n * For production use with multiple writers, consider using a proper\n * database or locking mechanism.\n */\nexport async function write(\n  filePath: string,\n  data: string | Buffer,\n  opts?: WriteOptions\n): Promise<void> {\n  if (!opts?.overwrite) {\n    // Fast path: check in-memory cache first to avoid expensive fs.access() calls\n    // This provides significant performance improvement when creating many files\n    if (createdFilesCache.has(filePath)) {\n      throw new EntityConflictError(\n        `File ${filePath} already exists and 'overwrite' is false`\n      );\n    }\n\n    // Slow path: check filesystem for files created before this process started\n    try {\n      await fs.access(filePath);\n      // File exists on disk, add to cache for future checks\n      createdFilesCache.add(filePath);\n      throw new EntityConflictError(\n        `File ${filePath} already exists and 'overwrite' is false`\n      );\n    } catch (error: any) {\n      // If file doesn't exist (ENOENT), continue with write\n      if (error.code !== 'ENOENT') {\n        throw error;\n      }\n    }\n  }\n\n  const tempPath = `${filePath}.tmp.${ulid()}`;\n  let tempFileCreated = false;\n  try {\n    await ensureDir(path.dirname(filePath));\n    await fs.writeFile(tempPath, data);\n    tempFileCreated = true;\n    await withWindowsRetry(() => fs.rename(tempPath, filePath));\n    // Track this file in cache so future writes know it exists\n    createdFilesCache.add(filePath);\n  } catch (error) {\n    // Only try to clean up temp file if it was actually created\n    if (tempFileCreated) {\n      await withWindowsRetry(() => fs.unlink(tempPath), 3).catch(() => {});\n    }\n    throw error;\n  }\n}\n\nexport async function readJSON<T>(\n  filePath: string,\n  decoder: z.ZodType<T>\n): Promise<T | null> {\n  try {\n    const content = await fs.readFile(filePath, 'utf-8');\n    return decoder.parse(JSON.parse(content, jsonReviver));\n  } catch (error) {\n    if ((error as any).code === 'ENOENT') return null;\n    throw error;\n  }\n}\n\nexport async function readBuffer(filePath: string): Promise<Buffer> {\n  const content = await fs.readFile(filePath);\n  return content;\n}\n\nexport async function deleteJSON(filePath: string): Promise<void> {\n  try {\n    await fs.unlink(filePath);\n  } catch (error) {\n    if ((error as any).code !== 'ENOENT') throw error;\n  }\n}\n\n/**\n * Atomically create a file using O_CREAT | O_EXCL flags.\n * Returns true if the file was created, false if it already exists.\n * This is atomic at the OS level, safe for concurrent access.\n */\nexport async function writeExclusive(\n  filePath: string,\n  data: string\n): Promise<boolean> {\n  await ensureDir(path.dirname(filePath));\n  try {\n    await fs.writeFile(filePath, data, { flag: 'wx' });\n    return true;\n  } catch (error: any) {\n    if (error.code === 'EEXIST') {\n      return false;\n    }\n    throw error;\n  }\n}\n\nexport async function listJSONFiles(dirPath: string): Promise<string[]> {\n  return listFilesByExtension(dirPath, '.json');\n}\n\nexport async function listFilesByExtension(\n  dirPath: string,\n  extension: string\n): Promise<string[]> {\n  try {\n    const files = await fs.readdir(dirPath);\n    return files\n      .filter((f) => f.endsWith(extension))\n      .map((f) => f.slice(0, -extension.length));\n  } catch (error) {\n    if ((error as any).code === 'ENOENT') return [];\n    throw error;\n  }\n}\n\ninterface PaginatedFileSystemQueryConfig<T> {\n  directory: string;\n  schema: z.ZodType<T>;\n  filePrefix?: string;\n  fileIdFilter?: (fileId: string) => boolean;\n  filter?: (item: T) => boolean;\n  sortOrder?: 'asc' | 'desc';\n  limit?: number;\n  cursor?: string;\n  getCreatedAt(filename: string): Date | null;\n  getId?(item: T): string;\n}\n// Cursor format: \"timestamp|id\" for tie-breaking\ninterface ParsedCursor {\n  timestamp: Date;\n  id: string | null;\n}\n\nfunction parseCursor(cursor: string | undefined): ParsedCursor | null {\n  if (!cursor) return null;\n\n  const parts = cursor.split('|');\n  return {\n    timestamp: new Date(parts[0]),\n    id: parts[1] || null,\n  };\n}\n\nfunction createCursor(timestamp: Date, id: string | undefined): string {\n  return id ? `${timestamp.toISOString()}|${id}` : timestamp.toISOString();\n}\n\nexport async function paginatedFileSystemQuery<T extends { createdAt: Date }>(\n  config: PaginatedFileSystemQueryConfig<T>\n): Promise<PaginatedResponse<T>> {\n  const {\n    directory,\n    schema,\n    filePrefix,\n    fileIdFilter,\n    filter,\n    sortOrder = 'desc',\n    limit = 20,\n    cursor,\n    getCreatedAt,\n    getId,\n  } = config;\n\n  // Validate filePrefix (typically `${runId}-`) so request-derived prefixes\n  // consistently reject unsafe characters. filePrefix is only used below to\n  // filter readdir() results by prefix — it doesn't participate in path\n  // construction — but keeping the validation rule uniform across the\n  // storage layer avoids special cases and catches bad values earlier.\n  if (filePrefix !== undefined) {\n    assertSafeEntityId('filePrefix', filePrefix);\n  }\n\n  // 1. Get all JSON files in directory\n  const fileIds = await listJSONFiles(directory);\n\n  // 2. Filter by prefix if provided\n  const relevantFileIds = filePrefix\n    ? fileIds.filter((fileId) => fileId.startsWith(filePrefix))\n    : fileIds;\n  const filteredFileIds = fileIdFilter\n    ? relevantFileIds.filter(fileIdFilter)\n    : relevantFileIds;\n\n  // 3. ULID Optimization: Filter by cursor using filename timestamps before loading JSON\n  const parsedCursor = parseCursor(cursor);\n  let candidateFileIds = filteredFileIds;\n\n  if (parsedCursor) {\n    candidateFileIds = filteredFileIds.filter((fileId) => {\n      const filenameDate = getCreatedAt(`${fileId}.json`);\n      if (filenameDate) {\n        // Use filename timestamp for cursor filtering\n        // We need to be careful here: if parsedCursor has an ID (for tie-breaking),\n        // we need to include items with the same timestamp for later ID-based filtering.\n        // If no ID, we can use strict inequality for optimization.\n        const cursorTime = parsedCursor.timestamp.getTime();\n        const fileTime = filenameDate.getTime();\n\n        if (parsedCursor.id) {\n          // Tie-breaking mode: include items at or near cursor timestamp\n          return sortOrder === 'desc'\n            ? fileTime <= cursorTime\n            : fileTime >= cursorTime;\n        } else {\n          // No tie-breaking: strict inequality\n          return sortOrder === 'desc'\n            ? fileTime < cursorTime\n            : fileTime > cursorTime;\n        }\n      }\n      // Can't extract timestamp from filename (e.g., steps use sequential IDs).\n      // Include the file and defer to JSON-based filtering below.\n      return true;\n    });\n  }\n\n  // 4. Load files individually and collect valid items\n  const validItems: T[] = [];\n\n  for (const fileId of candidateFileIds) {\n    const filePath = path.join(directory, `${fileId}.json`);\n    let item: T | null = null;\n    try {\n      item = await readJSON(filePath, schema);\n    } catch (error: unknown) {\n      // We don't expect zod errors to happen, but if the JSON does get malformed,\n      // we skip the item. Preferably, we'd have a way to mark items as malformed,\n      // so that the UI can display them as such, with richer messaging. In the meantime,\n      // we just log a warning and skip the item.\n      if (error instanceof z.ZodError) {\n        console.warn(\n          `Skipping item ${fileId} due to malformed JSON: ${error.message}`\n        );\n        continue;\n      }\n      throw error;\n    }\n\n    if (item) {\n      // Apply custom filter early if provided\n      if (filter && !filter(item)) continue;\n\n      // Double-check cursor filtering with actual createdAt from JSON\n      // (in case ULID timestamp differs from stored createdAt)\n      if (parsedCursor) {\n        const itemTime = item.createdAt.getTime();\n        const cursorTime = parsedCursor.timestamp.getTime();\n\n        if (sortOrder === 'desc') {\n          // For descending order, skip items >= cursor\n          if (itemTime > cursorTime) continue;\n          // If timestamps are equal, use ID for tie-breaking (skip if ID >= cursorId)\n          if (itemTime === cursorTime && parsedCursor.id && getId) {\n            const itemId = getId(item);\n            if (itemId >= parsedCursor.id) continue;\n          }\n        } else {\n          // For ascending order, skip items <= cursor\n          if (itemTime < cursorTime) continue;\n          // If timestamps are equal, use ID for tie-breaking (skip if ID <= cursorId)\n          if (itemTime === cursorTime && parsedCursor.id && getId) {\n            const itemId = getId(item);\n            if (itemId <= parsedCursor.id) continue;\n          }\n        }\n      }\n\n      validItems.push(item);\n    }\n  }\n\n  // 5. Sort by createdAt (and by ID for tie-breaking if getId is provided)\n  validItems.sort((a, b) => {\n    const aTime = a.createdAt.getTime();\n    const bTime = b.createdAt.getTime();\n    const timeComparison = sortOrder === 'asc' ? aTime - bTime : bTime - aTime;\n\n    // If timestamps are equal and we have getId, use ID for stable sorting\n    if (timeComparison === 0 && getId) {\n      const aId = getId(a);\n      const bId = getId(b);\n      return sortOrder === 'asc'\n        ? aId.localeCompare(bId)\n        : bId.localeCompare(aId);\n    }\n\n    return timeComparison;\n  });\n\n  // 6. Apply pagination\n  const hasMore = validItems.length > limit;\n  const items = hasMore ? validItems.slice(0, limit) : validItems;\n  const nextCursor =\n    items.length > 0\n      ? createCursor(\n          items[items.length - 1].createdAt,\n          getId?.(items[items.length - 1])\n        )\n      : null;\n\n  return {\n    data: items,\n    cursor: nextCursor,\n    hasMore,\n  };\n}\n"]}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,EAAE,EAAE,MAAM,kBAAkB,CAAC;AACtC,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE5E,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EACL,sBAAsB,EACtB,UAAU,EACV,MAAM,EACN,eAAe,EACf,0BAA0B,EAC1B,QAAQ,GACT,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,WAAW,EAAsB,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,mDAAmD;AACnD,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,EACb,WAAW,EAEX,YAAY,GACb,MAAM,WAAW,CAAC;AAcnB;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAsB;IACrD,MAAM,WAAW,GAAG,IAAI;QACtB,CAAC,CAAC,MAAM,CAAC,WAAW,CAChB,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC,CAChE;QACH,CAAC,CAAC,EAAE,CAAC;IACP,MAAM,YAAY,GAAG,EAAE,GAAG,MAAM,CAAC,KAAK,EAAE,GAAG,WAAW,EAAE,CAAC;IACzD,MAAM,GAAG,GAAG,YAAY,CAAC,GAAG,CAAC;IAC7B,MAAM,KAAK,GAAG,WAAW,CAAC,YAAY,CAAC,CAAC;IACxC,MAAM,OAAO,GAAG,aAAa,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;IACzD,MAAM,iBAAiB,GAAG,YAAY,CAAC,iBAAiB,IAAI,IAAI,CAAC;IACjE,OAAO;QACL,WAAW,EAAE,oBAAoB;QACjC,GAAG,KAAK;QACR,GAAG,OAAO;QACV,GAAG,gBAAgB,CAAC,eAAe,EAAE;YACnC,GAAG,cAAc,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,CAAC;YAC5C,GAAG,CAAC,YAAY,CAAC,qBAAqB,KAAK,SAAS,IAAI;gBACtD,qBAAqB,EAAE,YAAY,CAAC,qBAAqB;aAC1D,CAAC;SACH,CAAC;QACF,KAAK,CAAC,KAAK;YACT,MAAM,WAAW,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;YACxC,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACvB,OAAO;YACT,CAAC;YACD,MAAM,YAAY,GAAG,GAAG;gBACtB,CAAC,CAAC;oBACE,GAAG,OAAO,CAAC,IAAI;oBACf,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAChB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC;wBAChB,GAAG,MAAM;wBACT,YAAY,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAC9C,CAAC,CAA6B;iBAClC;gBACH,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC;YACjB,MAAM,mBAAmB,CAAC,YAAY,EAAE,KAAK,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;QACtE,CAAC;QACD,KAAK,CAAC,KAAK;YACT,MAAM,KAAK,CAAC,KAAK,EAAE,CAAC;QACtB,CAAC;QACD,KAAK,CAAC,KAAK;YACT,IAAI,GAAG,EAAE,CAAC;gBACR,kDAAkD;gBAClD,MAAM,OAAO,GAAG,YAAY,CAAC,OAAO,CAAC;gBAErC,gEAAgE;gBAChE,6DAA6D;gBAC7D,mEAAmE;gBACnE,4DAA4D;gBAC5D,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;gBAC7C,MAAM,eAAe,GAAG,MAAM,eAAe,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;gBAC7D,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,MAAM,CAAC,iBAAiB,CAAC,CAAC;gBACvD,MAAM,OAAO,CAAC,GAAG,CACf,eAAe,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE;oBACrC,MAAM,IAAI,GAAG,MAAM,QAAQ,CACzB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAC7B,UAAU,CACX,CAAC;oBACF,IAAI,IAAI,EAAE,KAAK,EAAE,CAAC;wBAChB,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAC/D,CAAC;oBACJ,CAAC;gBACH,CAAC,CAAC,CACH,CAAC;gBAEF,oDAAoD;gBACpD,MAAM,UAAU,GAAG;oBACjB,MAAM;oBACN,OAAO;oBACP,QAAQ;oBACR,OAAO;oBACP,OAAO;oBACP,cAAc;iBACf,CAAC;gBACF,MAAM,OAAO,CAAC,GAAG,CACf,UAAU,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;oBAC3B,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;oBACxC,MAAM,KAAK,GAAG,MAAM,eAAe,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;oBAClD,MAAM,OAAO,CAAC,GAAG,CACf,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CACpD,CAAC;gBACJ,CAAC,CAAC,CACH,CAAC;gBACF,4DAA4D;gBAC5D,MAAM,EAAE;qBACL,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;qBAClE,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;gBACnB,iDAAiD;gBACjD,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;gBAC1D,MAAM,cAAc,GAAG,MAAM,0BAA0B,CACrD,SAAS,EACT,GAAG,EACH,MAAM,CACP,CAAC;gBACF,MAAM,OAAO,CAAC,GAAG,CACf,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACvB,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CACnD,CACF,CAAC;gBACF,iEAAiE;gBACjE,sBAAsB,EAAE,CAAC;YAC3B,CAAC;iBAAM,CAAC;gBACN,MAAM,EAAE,CAAC,YAAY,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;gBACjE,MAAM,WAAW,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;YAC1C,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import { promises as fs } from 'node:fs';\nimport { rm } from 'node:fs/promises';\nimport path from 'node:path';\nimport type { World } from '@workflow/world';\nimport { reenqueueActiveRuns, SPEC_VERSION_CURRENT } from '@workflow/world';\nimport type { Config } from './config.js';\nimport { config } from './config.js';\nimport {\n  clearCreatedFilesCache,\n  deleteJSON,\n  hasTag,\n  listTaggedFiles,\n  listTaggedFilesByExtension,\n  readJSON,\n} from './fs.js';\nimport { initDataDir } from './init.js';\nimport { instrumentObject } from './instrumentObject.js';\nimport { createQueue, type DirectHandler } from './queue.js';\nimport { hashToken } from './storage/helpers.js';\nimport { createStorage } from './storage.js';\nimport { createStreamer } from './streamer.js';\n\n// Re-export init types and utilities for consumers\nexport {\n  DataDirAccessError,\n  DataDirVersionError,\n  ensureDataDir,\n  initDataDir,\n  type ParsedVersion,\n  parseVersion,\n} from './init.js';\n\nexport type { DirectHandler } from './queue.js';\n\nexport type LocalWorld = World & {\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  /** Clear all workflow data (runs, steps, events, hooks, streams). */\n  clear(): Promise<void>;\n};\n\n/**\n * Creates a local world instance that combines queue, storage, and streamer functionalities.\n *\n * @param args - Optional configuration object\n * @param args.dataDir - Directory for storing workflow data (default: `.workflow-data/`)\n * @param args.port - Port override for queue transport (default: auto-detected)\n * @param args.baseUrl - Full base URL override for queue transport (default: `http://localhost:{port}`)\n * @param args.recoverActiveRuns - Whether `start()` should re-enqueue pending/running runs from storage (default: `true`)\n * @param args.tag - Optional tag to scope files (e.g., `vitest-0`). When set, files are written\n *   as `{id}.{tag}.json` and `clear()` only deletes files matching this tag.\n * @throws {DataDirAccessError} If the data directory cannot be created or accessed\n * @throws {DataDirVersionError} If the data directory version is incompatible\n */\nexport function createLocalWorld(args?: Partial<Config>): LocalWorld {\n  const definedArgs = args\n    ? Object.fromEntries(\n        Object.entries(args).filter(([, value]) => value !== undefined)\n      )\n    : {};\n  const mergedConfig = { ...config.value, ...definedArgs };\n  const tag = mergedConfig.tag;\n  const queue = createQueue(mergedConfig);\n  const storage = createStorage(mergedConfig.dataDir, tag);\n  const recoverActiveRuns = mergedConfig.recoverActiveRuns ?? true;\n  return {\n    specVersion: SPEC_VERSION_CURRENT,\n    ...queue,\n    ...storage,\n    ...instrumentObject('world.streams', {\n      ...createStreamer(mergedConfig.dataDir, tag),\n      ...(mergedConfig.streamFlushIntervalMs !== undefined && {\n        streamFlushIntervalMs: mergedConfig.streamFlushIntervalMs,\n      }),\n    }),\n    async start() {\n      await initDataDir(mergedConfig.dataDir);\n      if (!recoverActiveRuns) {\n        return;\n      }\n      const recoveryRuns = tag\n        ? {\n            ...storage.runs,\n            list: ((params) =>\n              storage.runs.list({\n                ...params,\n                fileIdFilter: (fileId) => hasTag(fileId, tag),\n              })) as typeof storage.runs.list,\n          }\n        : storage.runs;\n      await reenqueueActiveRuns(recoveryRuns, queue.queue, 'world-local');\n    },\n    async close() {\n      await queue.close();\n    },\n    async clear() {\n      if (tag) {\n        // Selectively delete only files matching this tag\n        const basedir = mergedConfig.dataDir;\n\n        // Delete hook token constraint files BEFORE deleting the hooks,\n        // since we need to read each hook to extract its token hash.\n        // Constraint files are untagged ({sha256}.json) so listTaggedFiles\n        // won't find them — we must resolve them via the hook data.\n        const hooksDir = path.join(basedir, 'hooks');\n        const taggedHookFiles = await listTaggedFiles(hooksDir, tag);\n        const { HookSchema } = await import('@workflow/world');\n        await Promise.all(\n          taggedHookFiles.map(async (hookFile) => {\n            const hook = await readJSON(\n              path.join(hooksDir, hookFile),\n              HookSchema\n            );\n            if (hook?.token) {\n              await deleteJSON(\n                path.join(hooksDir, 'tokens', `${hashToken(hook.token)}.json`)\n              );\n            }\n          })\n        );\n\n        // Delete tagged entity files across all directories\n        const entityDirs = [\n          'runs',\n          'steps',\n          'events',\n          'hooks',\n          'waits',\n          'streams/runs',\n        ];\n        await Promise.all(\n          entityDirs.map(async (dir) => {\n            const fullDir = path.join(basedir, dir);\n            const files = await listTaggedFiles(fullDir, tag);\n            await Promise.all(\n              files.map((f) => deleteJSON(path.join(fullDir, f)))\n            );\n          })\n        );\n        // Clean up lock files used for atomic terminal-state guards\n        await fs\n          .rm(path.join(basedir, '.locks'), { recursive: true, force: true })\n          .catch(() => {});\n        // Delete tagged stream chunks (.{tag}.bin files)\n        const chunksDir = path.join(basedir, 'streams', 'chunks');\n        const taggedBinFiles = await listTaggedFilesByExtension(\n          chunksDir,\n          tag,\n          '.bin'\n        );\n        await Promise.all(\n          taggedBinFiles.map((f) =>\n            fs.unlink(path.join(chunksDir, f)).catch(() => {})\n          )\n        );\n        // Clear the in-memory write cache so deleted paths are forgotten\n        clearCreatedFilesCache();\n      } else {\n        await rm(mergedConfig.dataDir, { recursive: true, force: true });\n        await initDataDir(mergedConfig.dataDir);\n      }\n    },\n  };\n}\n"]}

package/dist/init.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"init.js","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,SAAS,EACT,KAAK,EACL,QAAQ,EACR,MAAM,EACN,SAAS,GACV,MAAM,kBAAkB,CAAC;AAC1B,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,uDAAuD;AACvD,MAAM,YAAY,GAAG,uBAAuB,CAAC;AAO7C,IAAI,iBAAiB,GAAuB,IAAI,CAAC;AAEjD;;;GAGG;AACH,SAAS,YAAY;IACnB,qEAAqE;IACrE,IAAI,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;QAC3D,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACtD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc;IAClC,IAAI,iBAAiB,EAAE,CAAC;QACtB,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAED,MAAM,SAAS,GAAG,YAAY,EAAE,CAAC;IACjC,IAAI,SAAS,EAAE,CAAC;QACd,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,MAAM,QAAQ,CAC5B,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,iBAAiB,CAAC,EACvC,OAAO,CACR,CAAC;YACF,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAgB,CAAC;YACvD,OAAO,iBAAiB,CAAC;QAC3B,CAAC;QAAC,MAAM,CAAC;YACP,mCAAmC;QACrC,CAAC;IACH,CAAC;IAED,gDAAgD;IAChD,iBAAiB,GAAG;QAClB,IAAI,EAAE,YAAY;QAClB,OAAO,EAAE,SAAS;KACnB,CAAC;IACF,OAAO,iBAAiB,CAAC;AAC3B,CAAC;AAED,qEAAqE;AACrE,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAavC;;GAEG;AACH,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAClC,OAAO,CAAS;IAChB,IAAI,CAAU;IAEvB,YAAY,OAAe,EAAE,OAAe,EAAE,IAAa;QACzD,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;QACjC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IACnC,UAAU,CAAgB;IAC1B,UAAU,CAAgB;IAC1B,gBAAgB,CAAU;IAEnC,YACE,OAAe,EACf,UAAyB,EACzB,UAAyB,EACzB,gBAAyB;QAEzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;QAClC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;IAC3C,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,aAAqB;IAChD,oDAAoD;IACpD,MAAM,KAAK,GAAG,aAAa,CAAC,KAAK,CAAC,iCAAiC,CAAC,CAAC;IAErE,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CAAC,4BAA4B,aAAa,GAAG,CAAC,CAAC;IAChE,CAAC;IAED,OAAO;QACL,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;QAC7B,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;QAC7B,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;QAC7B,UAAU,EAAE,KAAK,CAAC,CAAC,CAAC;QACpB,GAAG,EAAE,aAAa;KACnB,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,OAAsB;IAClD,MAAM,IAAI,GAAG,GAAG,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;IAClE,OAAO,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AACrE,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAAe;IAI9C,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IAC/B,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAE7C,IAAI,WAAW,IAAI,CAAC,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CAAC,kCAAkC,OAAO,GAAG,CAAC,CAAC;IAChE,CAAC;IAED,MAAM,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;IACtD,MAAM,aAAa,GAAG,OAAO,CAAC,SAAS,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC;IAEzD,OAAO;QACL,WAAW;QACX,OAAO,EAAE,YAAY,CAAC,aAAa,CAAC;KACrC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAC/B,WAAmB,EACnB,OAAsB;IAEtB,OAAO,GAAG,WAAW,IAAI,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC;AACpD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAC5B,UAAyB,EACzB,UAAyB;IAEzB,OAAO,CAAC,GAAG,CACT,wCAAwC,aAAa,CAAC,UAAU,CAAC,OAAO,aAAa,CAAC,UAAU,CAAC,EAAE,CACpG,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,OAAe;IACjD,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAE3C,kDAAkD;IAClD,IAAI,CAAC;QACH,MAAM,KAAK,CAAC,YAAY,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACjD,CAAC;IAAC,OAAO,KAAc,EAAE,CAAC;QACxB,MAAM,SAAS,GAAG,KAA8B,CAAC;QACjD,4CAA4C;QAC5C,IAAI,SAAS,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAChC,MAAM,IAAI,kBAAkB,CAC1B,oCAAoC,YAAY,MAAM,SAAS,CAAC,OAAO,EAAE,EACzE,YAAY,EACZ,SAAS,CAAC,IAAI,CACf,CAAC;QACJ,CAAC;IACH,CAAC;IAED,gDAAgD;IAChD,IAAI,CAAC;QACH,MAAM,MAAM,CAAC,YAAY,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;IAC7C,CAAC;IAAC,OAAO,KAAc,EAAE,CAAC;QACxB,MAAM,SAAS,GAAG,KAA8B,CAAC;QACjD,MAAM,IAAI,kBAAkB,CAC1B,mBAAmB,YAAY,sBAAsB,SAAS,CAAC,OAAO,EAAE,EACxE,YAAY,EACZ,SAAS,CAAC,IAAI,CACf,CAAC;IACJ,CAAC;IAED,sEAAsE;IACtE,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CACxB,YAAY,EACZ,wBAAwB,IAAI,CAAC,GAAG,EAAE,EAAE,CACrC,CAAC;IACF,IAAI,CAAC;QACH,MAAM,SAAS,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QAC9B,mEAAmE;QACnE,+DAA+D;QAC/D,MAAM,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,CAAwB,EAAE,EAAE;YACxD,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ;gBAAE,MAAM,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,KAAc,EAAE,CAAC;QACxB,MAAM,SAAS,GAAG,KAA8B,CAAC;QACjD,MAAM,IAAI,kBAAkB,CAC1B,mBAAmB,YAAY,sBAAsB,SAAS,CAAC,OAAO,EAAE,EACxE,YAAY,EACZ,SAAS,CAAC,IAAI,CACf,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,KAAK,UAAU,eAAe,CAAC,OAAe;IAI5C,MAAM,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAC,CAAC;IAE3E,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;QACzD,OAAO,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;IAAC,OAAO,KAAc,EAAE,CAAC;QACxB,MAAM,SAAS,GAAG,KAA8B,CAAC;QACjD,IAAI,SAAS,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAChC,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,KAAK,UAAU,gBAAgB,CAC7B,OAAe,EACf,OAAsB;IAEtB,MAAM,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAC,CAAC;IAC3E,MAAM,WAAW,GAAG,MAAM,cAAc,EAAE,CAAC;IAC3C,MAAM,OAAO,GAAG,iBAAiB,CAAC,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC7D,MAAM,SAAS,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;GAKG;AACH,SAAS,4BAA4B,CACnC,UAAyB,EACzB,gBAAyB;IAEzB,IAAI,gBAAgB,EAAE,CAAC;QACrB,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED,kDAAkD;IAClD,OAAO,aAAa,CAAC,UAAU,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,OAAe;IAC/C,sDAAsD;IACtD,MAAM,aAAa,CAAC,OAAO,CAAC,CAAC;IAE7B,MAAM,WAAW,GAAG,MAAM,cAAc,EAAE,CAAC;IAC3C,MAAM,cAAc,GAAG,YAAY,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IAEzD,6BAA6B;IAC7B,MAAM,mBAAmB,GAAG,MAAM,eAAe,CAAC,OAAO,CAAC,CAAC;IAE3D,IAAI,mBAAmB,KAAK,IAAI,EAAE,CAAC;QACjC,iDAAiD;QACjD,MAAM,gBAAgB,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;QAChD,OAAO;IACT,CAAC;IAED,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,mBAAmB,CAAC;IAEpD,qDAAqD;IACrD,IAAI,aAAa,CAAC,UAAU,CAAC,KAAK,aAAa,CAAC,cAAc,CAAC,EAAE,CAAC;QAChE,OAAO;IACT,CAAC;IAED,kBAAkB;IAClB,IAAI,CAAC;QACH,cAAc,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;QAC3C,4CAA4C;QAC5C,MAAM,gBAAgB,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;IAClD,CAAC;IAAC,OAAO,KAAc,EAAE,CAAC;QACxB,MAAM,gBAAgB,GACpB,KAAK,YAAY,mBAAmB,CAAC,CAAC,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS,CAAC;QAE5E,MAAM,eAAe,GAAG,4BAA4B,CAClD,UAAU,EACV,gBAAgB,CACjB,CAAC;QAEF,OAAO,CAAC,KAAK,CACX,+DAA+D,aAAa,CAAC,UAAU,CAAC,OAAO,aAAa,CAAC,cAAc,CAAC,GAAG,EAC/H,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAC/C,CAAC;QACF,OAAO,CAAC,KAAK,CACX,iEAAiE;YAC/D,uBAAuB,WAAW,CAAC,IAAI,IAAI,eAAe,EAAE,CAC/D,CAAC;QAEF,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC","sourcesContent":["import {\n  access,\n  constants,\n  mkdir,\n  readFile,\n  unlink,\n  writeFile,\n} from 'node:fs/promises';\nimport path from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\n/** Package name - hardcoded since it doesn't change */\nconst PACKAGE_NAME = '@workflow/world-local';\n\ninterface PackageInfo {\n  name: string;\n  version: string;\n}\n\nlet cachedPackageInfo: PackageInfo | null = null;\n\n/**\n * Get the directory path for this module.\n * Works in ESM and falls back to a constant in CJS contexts (which shouldn't happen)\n */\nfunction getModuleDir(): string | null {\n  // In bundled CJS contexts, import.meta.url may be undefined or empty\n  if (typeof import.meta.url === 'string' && import.meta.url) {\n    return path.dirname(fileURLToPath(import.meta.url));\n  }\n  return null;\n}\n\n/**\n * Returns the package name and version from package.json.\n * The result is cached after the first read.\n *\n * In bundled contexts where package.json cannot be read,\n * returns 'bundled' as the version.\n */\nexport async function getPackageInfo(): Promise<PackageInfo> {\n  if (cachedPackageInfo) {\n    return cachedPackageInfo;\n  }\n\n  const moduleDir = getModuleDir();\n  if (moduleDir) {\n    try {\n      const content = await readFile(\n        path.join(moduleDir, '../package.json'),\n        'utf-8'\n      );\n      cachedPackageInfo = JSON.parse(content) as PackageInfo;\n      return cachedPackageInfo;\n    } catch {\n      // Fall through to bundled fallback\n    }\n  }\n\n  // Bundled context - package.json not accessible\n  cachedPackageInfo = {\n    name: PACKAGE_NAME,\n    version: 'bundled',\n  };\n  return cachedPackageInfo;\n}\n\n/** Filename for storing version information in the data directory */\nconst VERSION_FILENAME = 'version.txt';\n\n/**\n * Represents a parsed semantic version with optional prerelease tag.\n */\nexport interface ParsedVersion {\n  major: number;\n  minor: number;\n  patch: number;\n  prerelease?: string;\n  raw: string;\n}\n\n/**\n * Error thrown when the data directory cannot be accessed or created.\n */\nexport class DataDirAccessError extends Error {\n  readonly dataDir: string;\n  readonly code?: string;\n\n  constructor(message: string, dataDir: string, code?: string) {\n    super(message);\n    this.name = 'DataDirAccessError';\n    this.dataDir = dataDir;\n    this.code = code;\n  }\n}\n\n/**\n * Error thrown when data directory version is incompatible.\n */\nexport class DataDirVersionError extends Error {\n  readonly oldVersion: ParsedVersion;\n  readonly newVersion: ParsedVersion;\n  readonly suggestedVersion?: string;\n\n  constructor(\n    message: string,\n    oldVersion: ParsedVersion,\n    newVersion: ParsedVersion,\n    suggestedVersion?: string\n  ) {\n    super(message);\n    this.name = 'DataDirVersionError';\n    this.oldVersion = oldVersion;\n    this.newVersion = newVersion;\n    this.suggestedVersion = suggestedVersion;\n  }\n}\n\n/**\n * Parses a version string into its components.\n *\n * @param versionString - Version string like \"4.0.1\" or \"4.0.1-beta.20\"\n * @returns Parsed version object with major, minor, patch, and optional prerelease\n */\nexport function parseVersion(versionString: string): ParsedVersion {\n  // Match: major.minor.patch with optional prerelease\n  const match = versionString.match(/^(\\d+)\\.(\\d+)\\.(\\d+)(?:-(.+))?$/);\n\n  if (!match) {\n    throw new Error(`Invalid version string: \"${versionString}\"`);\n  }\n\n  return {\n    major: parseInt(match[1], 10),\n    minor: parseInt(match[2], 10),\n    patch: parseInt(match[3], 10),\n    prerelease: match[4],\n    raw: versionString,\n  };\n}\n\n/**\n * Formats a parsed version back to a string.\n */\nexport function formatVersion(version: ParsedVersion): string {\n  const base = `${version.major}.${version.minor}.${version.patch}`;\n  return version.prerelease ? `${base}-${version.prerelease}` : base;\n}\n\n/**\n * Parses the version file content to extract package name and version.\n *\n * @param content - Content like \"@workflow/world-local@4.0.1-beta.20\"\n * @returns Object with packageName and version\n */\nexport function parseVersionFile(content: string): {\n  packageName: string;\n  version: ParsedVersion;\n} {\n  const trimmed = content.trim();\n  const lastAtIndex = trimmed.lastIndexOf('@');\n\n  if (lastAtIndex <= 0) {\n    throw new Error(`Invalid version file content: \"${content}\"`);\n  }\n\n  const packageName = trimmed.substring(0, lastAtIndex);\n  const versionString = trimmed.substring(lastAtIndex + 1);\n\n  return {\n    packageName,\n    version: parseVersion(versionString),\n  };\n}\n\n/**\n * Formats the version file content.\n */\nexport function formatVersionFile(\n  packageName: string,\n  version: ParsedVersion\n): string {\n  return `${packageName}@${formatVersion(version)}`;\n}\n\n/**\n * Handles version upgrades between old and new versions.\n * This function is called when the data directory was created with a different version.\n *\n * @param oldVersion - The version that created the data directory\n * @param newVersion - The current package version\n * @throws {DataDirVersionError} If the versions are incompatible\n */\nexport function upgradeVersion(\n  oldVersion: ParsedVersion,\n  newVersion: ParsedVersion\n): void {\n  console.log(\n    `[world-local] Upgrading from version ${formatVersion(oldVersion)} to ${formatVersion(newVersion)}`\n  );\n}\n\n/**\n * Ensures the data directory exists and is writable.\n * Creates the directory if it doesn't exist.\n *\n * @param dataDir - The path to the data directory\n * @throws {DataDirAccessError} If the directory cannot be created or accessed\n */\nexport async function ensureDataDir(dataDir: string): Promise<void> {\n  const absolutePath = path.resolve(dataDir);\n\n  // Try to create the directory if it doesn't exist\n  try {\n    await mkdir(absolutePath, { recursive: true });\n  } catch (error: unknown) {\n    const nodeError = error as NodeJS.ErrnoException;\n    // EEXIST is fine - directory already exists\n    if (nodeError.code !== 'EEXIST') {\n      throw new DataDirAccessError(\n        `Failed to create data directory \"${absolutePath}\": ${nodeError.message}`,\n        absolutePath,\n        nodeError.code\n      );\n    }\n  }\n\n  // Verify the directory is accessible (readable)\n  try {\n    await access(absolutePath, constants.R_OK);\n  } catch (error: unknown) {\n    const nodeError = error as NodeJS.ErrnoException;\n    throw new DataDirAccessError(\n      `Data directory \"${absolutePath}\" is not readable: ${nodeError.message}`,\n      absolutePath,\n      nodeError.code\n    );\n  }\n\n  // Verify the directory is writable by attempting to write a temp file\n  const testFile = path.join(\n    absolutePath,\n    `.workflow-write-test-${Date.now()}`\n  );\n  try {\n    await writeFile(testFile, '');\n    // Clean up test file — ENOENT during cleanup is harmless (may race\n    // with another process performing the same check concurrently)\n    await unlink(testFile).catch((e: NodeJS.ErrnoException) => {\n      if (e.code !== 'ENOENT') throw e;\n    });\n  } catch (error: unknown) {\n    const nodeError = error as NodeJS.ErrnoException;\n    throw new DataDirAccessError(\n      `Data directory \"${absolutePath}\" is not writable: ${nodeError.message}`,\n      absolutePath,\n      nodeError.code\n    );\n  }\n}\n\n/**\n * Reads the version from the data directory's version file.\n *\n * @param dataDir - Path to the data directory\n * @returns The parsed version info, or null if the file doesn't exist\n */\nasync function readVersionFile(dataDir: string): Promise<{\n  packageName: string;\n  version: ParsedVersion;\n} | null> {\n  const versionFilePath = path.join(path.resolve(dataDir), VERSION_FILENAME);\n\n  try {\n    const content = await readFile(versionFilePath, 'utf-8');\n    return parseVersionFile(content);\n  } catch (error: unknown) {\n    const nodeError = error as NodeJS.ErrnoException;\n    if (nodeError.code === 'ENOENT') {\n      return null;\n    }\n    throw error;\n  }\n}\n\n/**\n * Writes the current version to the data directory's version file.\n *\n * @param dataDir - Path to the data directory\n * @param version - The version to write\n */\nasync function writeVersionFile(\n  dataDir: string,\n  version: ParsedVersion\n): Promise<void> {\n  const versionFilePath = path.join(path.resolve(dataDir), VERSION_FILENAME);\n  const packageInfo = await getPackageInfo();\n  const content = formatVersionFile(packageInfo.name, version);\n  await writeFile(versionFilePath, content);\n}\n\n/**\n * Gets the suggested downgrade version based on the old version.\n * If a specific version is suggested in the error, use that.\n * Otherwise, suggest the previous minor version if patch is 0,\n * or previous major version if minor is also 0.\n */\nfunction getSuggestedDowngradeVersion(\n  oldVersion: ParsedVersion,\n  suggestedVersion?: string\n): string {\n  if (suggestedVersion) {\n    return suggestedVersion;\n  }\n\n  // Suggest the old version as the downgrade target\n  return formatVersion(oldVersion);\n}\n\n/**\n * Initializes the data directory, ensuring it exists, is accessible,\n * and handles version compatibility.\n *\n * @param dataDir - The path to the data directory\n * @throws {DataDirAccessError} If the directory cannot be created or accessed\n */\nexport async function initDataDir(dataDir: string): Promise<void> {\n  // First ensure the directory exists and is accessible\n  await ensureDataDir(dataDir);\n\n  const packageInfo = await getPackageInfo();\n  const currentVersion = parseVersion(packageInfo.version);\n\n  // Read existing version file\n  const existingVersionInfo = await readVersionFile(dataDir);\n\n  if (existingVersionInfo === null) {\n    // New data directory - write the current version\n    await writeVersionFile(dataDir, currentVersion);\n    return;\n  }\n\n  const { version: oldVersion } = existingVersionInfo;\n\n  // Check if versions are the same (no upgrade needed)\n  if (formatVersion(oldVersion) === formatVersion(currentVersion)) {\n    return;\n  }\n\n  // Attempt upgrade\n  try {\n    upgradeVersion(oldVersion, currentVersion);\n    // Upgrade succeeded - write the new version\n    await writeVersionFile(dataDir, currentVersion);\n  } catch (error: unknown) {\n    const suggestedVersion =\n      error instanceof DataDirVersionError ? error.suggestedVersion : undefined;\n\n    const downgradeTarget = getSuggestedDowngradeVersion(\n      oldVersion,\n      suggestedVersion\n    );\n\n    console.error(\n      `[world-local] Failed to upgrade data directory from version ${formatVersion(oldVersion)} to ${formatVersion(currentVersion)}:`,\n      error instanceof Error ? error.message : error\n    );\n    console.error(\n      `[world-local] Data is not compatible with the current version. ` +\n        `Please downgrade to ${packageInfo.name}@${downgradeTarget}`\n    );\n\n    throw error;\n  }\n}\n"]}

package/dist/instrumentObject.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"instrumentObject.js","sourceRoot":"","sources":["../src/instrumentObject.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACL,KAAK,EACL,WAAW,EACX,WAAW,EACX,SAAS,EACT,UAAU,EACV,SAAS,GACV,MAAM,gBAAgB,CAAC;AAExB,iDAAiD;AACjD,MAAM,mBAAmB,GAAG;IAC1B,WAAW,EAAE,aAAa;IAC1B,SAAS,EAAE,OAAO;IAClB,UAAU,EAAE,aAAa;CAC1B,CAAC;AAEF;;;GAGG;AACH,SAAS,gBAAgB,CAAC,IAAe;IACvC,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,QAAQ,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;QACxE,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAA4B,CAAC;QAChD,IAAI,OAAO,IAAI,CAAC,SAAS,KAAK,QAAQ,EAAE,CAAC;YACvC,OAAO,IAAI,CAAC,SAAS,CAAC;QACxB,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAmB,MAAc,EAAE,CAAI;IACrE,MAAM,QAAQ,GAAG,EAAO,CAAC;IACzB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAgB,EAAE,CAAC;QAChD,IAAI,OAAO,CAAC,CAAC,GAAG,CAAC,KAAK,UAAU,EAAE,CAAC;YACjC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QACzB,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;YACjB,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YAC/B,+CAA+C;YAC/C,QAAQ,CAAC,GAAG,CAAC,GAAG,KAAK,EAAE,GAAG,IAAe,EAAE,EAAE;gBAC3C,8DAA8D;gBAC9D,IAAI,QAAQ,GAAG,GAAG,MAAM,IAAI,UAAU,EAAE,CAAC;gBACzC,IAAI,MAAM,KAAK,cAAc,IAAI,UAAU,KAAK,QAAQ,EAAE,CAAC;oBACzD,MAAM,SAAS,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;oBACzC,IAAI,SAAS,EAAE,CAAC;wBACd,QAAQ,GAAG,GAAG,MAAM,IAAI,UAAU,IAAI,SAAS,EAAE,CAAC;oBACpD,CAAC;gBACH,CAAC;gBAED,OAAO,KAAK,CACV,QAAQ,EACR,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC,UAAU,CAAC,EAAE,EACvC,KAAK,EAAE,IAAI,EAAE,EAAE;oBACb,+CAA+C;oBAC/C,sEAAsE;oBACtE,IAAI,EAAE,aAAa,CAAC;wBAClB,GAAG,WAAW,CAAC,mBAAmB,CAAC,WAAW,CAAC;wBAC/C,GAAG,SAAS,CAAC,mBAAmB,CAAC,SAAS,CAAC;wBAC3C,GAAG,UAAU,CAAC,mBAAmB,CAAC,UAAU,CAAC;wBAC7C,GAAG,SAAS,CAAC,QAAQ,CAAC;qBACvB,CAAC,CAAC;oBACH,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;gBACpB,CAAC,CACF,CAAC;YACJ,CAAC,CAAC;QACJ,CAAC;IACH,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC","sourcesContent":["/**\n * Utility to instrument object methods with tracing.\n * This mirrors world-vercel's implementation for consistent observability.\n */\nimport {\n  trace,\n  getSpanKind,\n  PeerService,\n  RpcSystem,\n  RpcService,\n  RpcMethod,\n} from './telemetry.js';\n\n/** Configuration for peer service attribution */\nconst WORLD_LOCAL_SERVICE = {\n  peerService: 'world-local',\n  rpcSystem: 'local',\n  rpcService: 'world-local',\n};\n\n/**\n * Extracts the event type from arguments for events.create calls.\n * The event data is the second argument and contains eventType.\n */\nfunction extractEventType(args: unknown[]): string | undefined {\n  if (args.length >= 2 && typeof args[1] === 'object' && args[1] !== null) {\n    const data = args[1] as Record<string, unknown>;\n    if (typeof data.eventType === 'string') {\n      return data.eventType;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Wraps all methods of an object with tracing spans.\n * @param prefix - Prefix for span names (e.g., \"world.runs\")\n * @param o - Object with methods to instrument\n * @returns Instrumented object with same interface\n */\nexport function instrumentObject<T extends object>(prefix: string, o: T): T {\n  const handlers = {} as T;\n  for (const key of Object.keys(o) as (keyof T)[]) {\n    if (typeof o[key] !== 'function') {\n      handlers[key] = o[key];\n    } else {\n      const f = o[key];\n      const methodName = String(key);\n      // @ts-expect-error - dynamic function wrapping\n      handlers[key] = async (...args: unknown[]) => {\n        // Build span name - for events.create, include the event type\n        let spanName = `${prefix}.${methodName}`;\n        if (prefix === 'world.events' && methodName === 'create') {\n          const eventType = extractEventType(args);\n          if (eventType) {\n            spanName = `${prefix}.${methodName} ${eventType}`;\n          }\n        }\n\n        return trace(\n          spanName,\n          { kind: await getSpanKind('INTERNAL') },\n          async (span) => {\n            // Add peer service attributes for service maps\n            // Use spanName for rpc.method so Datadog shows event type in resource\n            span?.setAttributes({\n              ...PeerService(WORLD_LOCAL_SERVICE.peerService),\n              ...RpcSystem(WORLD_LOCAL_SERVICE.rpcSystem),\n              ...RpcService(WORLD_LOCAL_SERVICE.rpcService),\n              ...RpcMethod(spanName),\n            });\n            return f(...args);\n          }\n        );\n      };\n    }\n  }\n  return handlers;\n}\n"]}

package/dist/queue.js.map

@@ -1 +0,0 @@
-{"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"]}