@workflow/world-local 4.2.0 → 4.2.1

package/dist/storage/helpers.d.ts

@@ -2,6 +2,19 @@
  * Hash a hook token to produce a filesystem-safe constraint filename.
  */
 export declare function hashToken(token: string): string;
+/**
+ * Compute the path of the recovery-marker sidecar for a specific
+ * `(token, runId, hookId)` triple. Identity is encoded in the
+ * filename hash so different token lifetimes (e.g. the same token
+ * reused by a later run after the first run was deleted) never
+ * contend on a single sidecar — without per-lifetime identity, a
+ * stale marker surviving prior-run cleanup could "leak" its
+ * eventId into the new lifetime's recovery and cause divergent
+ * publication.
+ *
+ * See `events-storage.ts` for the full recovery-marker rationale.
+ */
+export declare function hookRecoveryMarkerPath(basedir: string, token: string, runId: string, hookId: string): string;
 /**
  * Create a monotonic ULID factory that ensures ULIDs are always increasing
  * even when generated within the same millisecond.

package/dist/storage/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/storage/helpers.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,4BAAwC,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC5B,UAAU,MAAM,MAChB,UAAU,MAAM,KAAG,IAAI,GAAG,IAyB1B,CAAC"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/storage/helpers.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,MAAM,CAQR;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,4BAAwC,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC5B,UAAU,MAAM,MAChB,UAAU,MAAM,KAAG,IAAI,GAAG,IAyB1B,CAAC"}

package/dist/storage/helpers.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import path from 'node:path';
 import { monotonicFactory } from 'ulid';
 import { stripTag, ulidToDate } from '../fs.js';
 /**
@@ -7,6 +8,27 @@ import { stripTag, ulidToDate } from '../fs.js';
 export function hashToken(token) {
     return createHash('sha256').update(token).digest('hex');
 }
+/**
+ * Compute the path of the recovery-marker sidecar for a specific
+ * `(token, runId, hookId)` triple. Identity is encoded in the
+ * filename hash so different token lifetimes (e.g. the same token
+ * reused by a later run after the first run was deleted) never
+ * contend on a single sidecar — without per-lifetime identity, a
+ * stale marker surviving prior-run cleanup could "leak" its
+ * eventId into the new lifetime's recovery and cause divergent
+ * publication.
+ *
+ * See `events-storage.ts` for the full recovery-marker rationale.
+ */
+export function hookRecoveryMarkerPath(basedir, token, runId, hookId) {
+    // Distinct from `hashToken(token)` so a token's claim file and
+    // its recovery marker live at different paths AND a different
+    // lifetime's recovery marker never collides with this one.
+    const key = createHash('sha256')
+        .update(`${token}\x00${runId}\x00${hookId}`)
+        .digest('hex');
+    return path.join(basedir, 'hooks', 'tokens', `${key}.recovery.json`);
+}
 /**
  * Create a monotonic ULID factory that ensures ULIDs are always increasing
  * even when generated within the same millisecond.
@@ -41,4 +63,4 @@ export const getObjectCreatedAt = (idPrefix) => (filename) => {
     const ulid = id.replace(replaceRegex, '');
     return ulidToDate(ulid);
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,4 +1,5 @@
-import type { Storage } from '@workflow/world';
+import type { Hook, Storage } from '@workflow/world';
+export declare function rebuildLiveHookByTokenFromEventLog(basedir: string, token: string, tag?: string): Promise<Hook | null>;
 /**
  * Creates a hooks storage implementation using the filesystem.
  * Implements the Storage['hooks'] interface with hook CRUD operations.

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

@@ -1 +1 @@
-{"version":3,"file":"hooks-storage.d.ts","sourceRoot":"","sources":["../../src/storage/hooks-storage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAKV,OAAO,EACR,MAAM,iBAAiB,CAAC;AAczB;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CAiFlB;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAkBf"}
+{"version":3,"file":"hooks-storage.d.ts","sourceRoot":"","sources":["../../src/storage/hooks-storage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,IAAI,EAIJ,OAAO,EACR,MAAM,iBAAiB,CAAC;AA2KzB,wBAAsB,kCAAkC,CACtD,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAOtB;AAeD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CA+FlB;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CA0Bf"}

package/dist/storage/hooks-storage.js

@@ -1,10 +1,111 @@
 import path from 'node:path';
 import { HookNotFoundError } from '@workflow/errors';
-import { HookSchema } from '@workflow/world';
+import { EventSchema, HookSchema, isTerminalRunEventType, isTerminalWorkflowRunStatus, WorkflowRunSchema, } from '@workflow/world';
+import { z } from 'zod';
 import { DEFAULT_RESOLVE_DATA_OPTION } from '../config.js';
-import { assertSafeEntityId, deleteJSON, listJSONFiles, paginatedFileSystemQuery, readJSON, readJSONWithFallback, } from '../fs.js';
+import { assertSafeEntityId, deleteJSON, hasTag, isUntagged, jsonReplacer, listJSONFiles, paginatedFileSystemQuery, readJSON, readJSONWithFallback, taggedPath, writeExclusive, } from '../fs.js';
 import { filterHookData } from './filters.js';
-import { hashToken } from './helpers.js';
+import { hashToken, hookRecoveryMarkerPath } from './helpers.js';
+function isVisibleToTag(fileId, tag) {
+    return tag ? isUntagged(fileId) || hasTag(fileId, tag) : isUntagged(fileId);
+}
+function getHookCreatedToken(event) {
+    if (event.eventType !== 'hook_created')
+        return undefined;
+    const token = event.eventData.token;
+    return typeof token === 'string' ? token : undefined;
+}
+function hookFromCreatedEvent(event) {
+    const { token, metadata, isWebhook } = event.eventData;
+    return {
+        runId: event.runId,
+        hookId: event.correlationId,
+        token,
+        metadata,
+        ownerId: 'local-owner',
+        projectId: 'local-project',
+        environment: 'local',
+        createdAt: event.createdAt,
+        specVersion: event.specVersion,
+        isWebhook: isWebhook ?? true,
+    };
+}
+function isMatchingHookCreatedEvent(event, matches) {
+    return (event.eventType === 'hook_created' &&
+        typeof event.correlationId === 'string' &&
+        matches(event));
+}
+function closesLiveHook(event, liveEvent) {
+    if (event.runId !== liveEvent.runId)
+        return false;
+    return ((event.eventType === 'hook_disposed' &&
+        event.correlationId === liveEvent.correlationId) ||
+        isTerminalRunEventType(event.eventType));
+}
+async function readEventForHookScan(filePath) {
+    try {
+        return await readJSON(filePath, EventSchema);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError || error instanceof z.ZodError) {
+            return null;
+        }
+        throw error;
+    }
+}
+async function isTerminalRunCache(basedir, runId, tag) {
+    const run = await readJSONWithFallback(basedir, 'runs', runId, WorkflowRunSchema, tag);
+    return run ? isTerminalWorkflowRunStatus(run.status) : false;
+}
+async function findLiveHookCreatedEvent(basedir, matches, tag) {
+    const eventsDir = path.join(basedir, 'events');
+    const events = [];
+    for (const fileId of await listJSONFiles(eventsDir)) {
+        if (!isVisibleToTag(fileId, tag))
+            continue;
+        const event = await readEventForHookScan(path.join(eventsDir, `${fileId}.json`));
+        if (event)
+            events.push(event);
+    }
+    events.sort((a, b) => {
+        const byTime = a.createdAt.getTime() - b.createdAt.getTime();
+        return byTime === 0 ? a.eventId.localeCompare(b.eventId) : byTime;
+    });
+    let liveEvent = null;
+    for (const event of events) {
+        if (isMatchingHookCreatedEvent(event, matches)) {
+            liveEvent = event;
+            continue;
+        }
+        if (liveEvent && closesLiveHook(event, liveEvent)) {
+            liveEvent = null;
+        }
+    }
+    if (liveEvent && (await isTerminalRunCache(basedir, liveEvent.runId, tag))) {
+        return null;
+    }
+    return liveEvent;
+}
+async function restoreHookCachesFromEvent(basedir, event, tag) {
+    const hook = hookFromCreatedEvent(event);
+    const claimPath = path.join(basedir, 'hooks', 'tokens', `${hashToken(hook.token)}.json`);
+    await writeExclusive(claimPath, JSON.stringify({
+        token: hook.token,
+        hookId: hook.hookId,
+        runId: hook.runId,
+        eventId: event.eventId,
+    }));
+    await writeExclusive(taggedPath(basedir, 'hooks', hook.hookId, tag), JSON.stringify(hook, jsonReplacer, 2));
+    return hook;
+}
+export async function rebuildLiveHookByTokenFromEventLog(basedir, token, tag) {
+    const event = await findLiveHookCreatedEvent(basedir, (candidate) => getHookCreatedToken(candidate) === token, tag);
+    return event ? restoreHookCachesFromEvent(basedir, event, tag) : null;
+}
+async function rebuildLiveHookByIdFromEventLog(basedir, hookId, tag) {
+    const event = await findLiveHookCreatedEvent(basedir, (candidate) => candidate.correlationId === hookId, tag);
+    return event ? restoreHookCachesFromEvent(basedir, event, tag) : null;
+}
 /**
  * Creates a hooks storage implementation using the filesystem.
  * Implements the Storage['hooks'] interface with hook CRUD operations.
@@ -27,13 +128,19 @@ export function createHooksStorage(basedir, tag) {
         assertSafeEntityId('hookId', hookId);
         const hook = await readJSONWithFallback(basedir, 'hooks', hookId, HookSchema, tag);
         if (!hook) {
-            throw new HookNotFoundError(hookId);
+            const rebuilt = await rebuildLiveHookByIdFromEventLog(basedir, hookId, tag);
+            if (!rebuilt) {
+                throw new HookNotFoundError(hookId);
+            }
+            const resolveData = params?.resolveData || DEFAULT_RESOLVE_DATA_OPTION;
+            return filterHookData({ ...rebuilt, isWebhook: rebuilt.isWebhook ?? true }, resolveData);
         }
         const resolveData = params?.resolveData || DEFAULT_RESOLVE_DATA_OPTION;
         return filterHookData({ ...hook, isWebhook: hook.isWebhook ?? true }, resolveData);
     }
     async function getByToken(token) {
-        const hook = await findHookByToken(token);
+        const hook = (await findHookByToken(token)) ??
+            (await rebuildLiveHookByTokenFromEventLog(basedir, token, tag));
         if (!hook) {
             throw new HookNotFoundError(token);
         }
@@ -83,11 +190,17 @@ export async function deleteAllHooksForRun(basedir, runId) {
         const hookPath = path.join(hooksDir, `${file}.json`);
         const hook = await readJSON(hookPath, HookSchema);
         if (hook && hook.runId === runId) {
-            // Delete the token constraint file to free up the token
+            // Delete the token constraint file to free up the token, and
+            // delete the recovery marker (if any) for disk hygiene. The
+            // marker's filename hash includes `(token, runId, hookId)` so
+            // a leaked marker can never corrupt a different lifetime — but
+            // cleaning it up here keeps the tokens/ directory from
+            // accumulating recovered-hook sidecars over time.
             const constraintPath = path.join(hooksDir, 'tokens', `${hashToken(hook.token)}.json`);
             await deleteJSON(constraintPath);
+            await deleteJSON(hookRecoveryMarkerPath(basedir, hook.token, hook.runId, hook.hookId));
             await deleteJSON(hookPath);
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hooks-storage.js","sourceRoot":"","sources":["../../src/storage/hooks-storage.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'node:path';\nimport { HookNotFoundError } from '@workflow/errors';\nimport type {\n  GetHookParams,\n  Hook,\n  ListHooksParams,\n  PaginatedResponse,\n  Storage,\n} from '@workflow/world';\nimport { HookSchema } from '@workflow/world';\nimport { DEFAULT_RESOLVE_DATA_OPTION } from '../config.js';\nimport {\n  assertSafeEntityId,\n  deleteJSON,\n  listJSONFiles,\n  paginatedFileSystemQuery,\n  readJSON,\n  readJSONWithFallback,\n} from '../fs.js';\nimport { filterHookData } from './filters.js';\nimport { hashToken } from './helpers.js';\n\n/**\n * Creates a hooks storage implementation using the filesystem.\n * Implements the Storage['hooks'] interface with hook CRUD operations.\n */\nexport function createHooksStorage(\n  basedir: string,\n  tag?: string\n): Storage['hooks'] {\n  // Helper function to find a hook by token (shared between getByToken)\n  async function findHookByToken(token: string): Promise<Hook | null> {\n    const hooksDir = path.join(basedir, 'hooks');\n    const files = await listJSONFiles(hooksDir);\n\n    for (const file of files) {\n      const hookPath = path.join(hooksDir, `${file}.json`);\n      const hook = await readJSON(hookPath, HookSchema);\n      if (hook && hook.token === token) {\n        return { ...hook, isWebhook: hook.isWebhook ?? true };\n      }\n    }\n\n    return null;\n  }\n\n  async function get(hookId: string, params?: GetHookParams): Promise<Hook> {\n    assertSafeEntityId('hookId', hookId);\n    const hook = await readJSONWithFallback(\n      basedir,\n      'hooks',\n      hookId,\n      HookSchema,\n      tag\n    );\n    if (!hook) {\n      throw new HookNotFoundError(hookId);\n    }\n    const resolveData = params?.resolveData || DEFAULT_RESOLVE_DATA_OPTION;\n    return filterHookData(\n      { ...hook, isWebhook: hook.isWebhook ?? true },\n      resolveData\n    );\n  }\n\n  async function getByToken(token: string): Promise<Hook> {\n    const hook = await findHookByToken(token);\n    if (!hook) {\n      throw new HookNotFoundError(token);\n    }\n    return hook;\n  }\n\n  async function list(\n    params: ListHooksParams\n  ): Promise<PaginatedResponse<Hook>> {\n    const hooksDir = path.join(basedir, 'hooks');\n    const resolveData = params.resolveData || DEFAULT_RESOLVE_DATA_OPTION;\n\n    const result = await paginatedFileSystemQuery({\n      directory: hooksDir,\n      schema: HookSchema,\n      sortOrder: params.pagination?.sortOrder ?? 'asc',\n      limit: params.pagination?.limit,\n      cursor: params.pagination?.cursor,\n      filePrefix: undefined, // Hooks don't have ULIDs, so we can't optimize by filename\n      filter: (hook) => {\n        // Filter by runId if provided\n        if (params.runId && hook.runId !== params.runId) {\n          return false;\n        }\n        return true;\n      },\n      getCreatedAt: () => {\n        // Hook files don't have ULID timestamps in filename, so return null\n        // to skip the filename-based optimization and defer to JSON-based\n        // cursor filtering which uses the actual createdAt from the file.\n        return null;\n      },\n      getId: (hook) => hook.hookId,\n    });\n\n    // Transform the data after pagination\n    return {\n      ...result,\n      data: result.data.map((hook) => filterHookData(hook, resolveData)),\n    };\n  }\n\n  return { get, getByToken, list };\n}\n\n/**\n * Helper function to delete all hooks associated with a workflow run.\n * Called when a run reaches a terminal state.\n */\nexport async function deleteAllHooksForRun(\n  basedir: string,\n  runId: string\n): Promise<void> {\n  const hooksDir = path.join(basedir, 'hooks');\n  const files = await listJSONFiles(hooksDir);\n\n  for (const file of files) {\n    const hookPath = path.join(hooksDir, `${file}.json`);\n    const hook = await readJSON(hookPath, HookSchema);\n    if (hook && hook.runId === runId) {\n      // Delete the token constraint file to free up the token\n      const constraintPath = path.join(\n        hooksDir,\n        'tokens',\n        `${hashToken(hook.token)}.json`\n      );\n      await deleteJSON(constraintPath);\n      await deleteJSON(hookPath);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hooks-storage.js","sourceRoot":"","sources":["../../src/storage/hooks-storage.ts"],"names":[],"mappings":"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","sourcesContent":["import path from 'node:path';\nimport { HookNotFoundError } from '@workflow/errors';\nimport type {\n  Event,\n  GetHookParams,\n  Hook,\n  HookCreatedEvent,\n  ListHooksParams,\n  PaginatedResponse,\n  Storage,\n} from '@workflow/world';\nimport {\n  EventSchema,\n  HookSchema,\n  isTerminalRunEventType,\n  isTerminalWorkflowRunStatus,\n  WorkflowRunSchema,\n} from '@workflow/world';\nimport { z } from 'zod';\nimport { DEFAULT_RESOLVE_DATA_OPTION } from '../config.js';\nimport {\n  assertSafeEntityId,\n  deleteJSON,\n  hasTag,\n  isUntagged,\n  jsonReplacer,\n  listJSONFiles,\n  paginatedFileSystemQuery,\n  readJSON,\n  readJSONWithFallback,\n  taggedPath,\n  writeExclusive,\n} from '../fs.js';\nimport { filterHookData } from './filters.js';\nimport { hashToken, hookRecoveryMarkerPath } from './helpers.js';\n\nfunction isVisibleToTag(fileId: string, tag: string | undefined): boolean {\n  return tag ? isUntagged(fileId) || hasTag(fileId, tag) : isUntagged(fileId);\n}\n\nfunction getHookCreatedToken(event: Event): string | undefined {\n  if (event.eventType !== 'hook_created') return undefined;\n  const token = (event.eventData as { token?: unknown }).token;\n  return typeof token === 'string' ? token : undefined;\n}\n\nfunction hookFromCreatedEvent(event: Event & HookCreatedEvent): Hook {\n  const { token, metadata, isWebhook } = event.eventData;\n  return {\n    runId: event.runId,\n    hookId: event.correlationId,\n    token,\n    metadata,\n    ownerId: 'local-owner',\n    projectId: 'local-project',\n    environment: 'local',\n    createdAt: event.createdAt,\n    specVersion: event.specVersion,\n    isWebhook: isWebhook ?? true,\n  };\n}\n\nfunction isMatchingHookCreatedEvent(\n  event: Event,\n  matches: (event: Event) => boolean\n): event is Event & HookCreatedEvent {\n  return (\n    event.eventType === 'hook_created' &&\n    typeof event.correlationId === 'string' &&\n    matches(event)\n  );\n}\n\nfunction closesLiveHook(\n  event: Event,\n  liveEvent: Event & HookCreatedEvent\n): boolean {\n  if (event.runId !== liveEvent.runId) return false;\n  return (\n    (event.eventType === 'hook_disposed' &&\n      event.correlationId === liveEvent.correlationId) ||\n    isTerminalRunEventType(event.eventType)\n  );\n}\n\nasync function readEventForHookScan(filePath: string): Promise<Event | null> {\n  try {\n    return await readJSON(filePath, EventSchema);\n  } catch (error) {\n    if (error instanceof SyntaxError || error instanceof z.ZodError) {\n      return null;\n    }\n    throw error;\n  }\n}\n\nasync function isTerminalRunCache(\n  basedir: string,\n  runId: string,\n  tag?: string\n): Promise<boolean> {\n  const run = await readJSONWithFallback(\n    basedir,\n    'runs',\n    runId,\n    WorkflowRunSchema,\n    tag\n  );\n  return run ? isTerminalWorkflowRunStatus(run.status) : false;\n}\n\nasync function findLiveHookCreatedEvent(\n  basedir: string,\n  matches: (event: Event) => boolean,\n  tag?: string\n): Promise<(Event & HookCreatedEvent) | null> {\n  const eventsDir = path.join(basedir, 'events');\n  const events: Event[] = [];\n\n  for (const fileId of await listJSONFiles(eventsDir)) {\n    if (!isVisibleToTag(fileId, tag)) continue;\n    const event = await readEventForHookScan(\n      path.join(eventsDir, `${fileId}.json`)\n    );\n    if (event) events.push(event);\n  }\n\n  events.sort((a, b) => {\n    const byTime = a.createdAt.getTime() - b.createdAt.getTime();\n    return byTime === 0 ? a.eventId.localeCompare(b.eventId) : byTime;\n  });\n\n  let liveEvent: (Event & HookCreatedEvent) | null = null;\n  for (const event of events) {\n    if (isMatchingHookCreatedEvent(event, matches)) {\n      liveEvent = event;\n      continue;\n    }\n\n    if (liveEvent && closesLiveHook(event, liveEvent)) {\n      liveEvent = null;\n    }\n  }\n\n  if (liveEvent && (await isTerminalRunCache(basedir, liveEvent.runId, tag))) {\n    return null;\n  }\n\n  return liveEvent;\n}\n\nasync function restoreHookCachesFromEvent(\n  basedir: string,\n  event: Event & HookCreatedEvent,\n  tag?: string\n): Promise<Hook> {\n  const hook = hookFromCreatedEvent(event);\n\n  const claimPath = path.join(\n    basedir,\n    'hooks',\n    'tokens',\n    `${hashToken(hook.token)}.json`\n  );\n  await writeExclusive(\n    claimPath,\n    JSON.stringify({\n      token: hook.token,\n      hookId: hook.hookId,\n      runId: hook.runId,\n      eventId: event.eventId,\n    })\n  );\n  await writeExclusive(\n    taggedPath(basedir, 'hooks', hook.hookId, tag),\n    JSON.stringify(hook, jsonReplacer, 2)\n  );\n\n  return hook;\n}\n\nexport async function rebuildLiveHookByTokenFromEventLog(\n  basedir: string,\n  token: string,\n  tag?: string\n): Promise<Hook | null> {\n  const event = await findLiveHookCreatedEvent(\n    basedir,\n    (candidate) => getHookCreatedToken(candidate) === token,\n    tag\n  );\n  return event ? restoreHookCachesFromEvent(basedir, event, tag) : null;\n}\n\nasync function rebuildLiveHookByIdFromEventLog(\n  basedir: string,\n  hookId: string,\n  tag?: string\n): Promise<Hook | null> {\n  const event = await findLiveHookCreatedEvent(\n    basedir,\n    (candidate) => candidate.correlationId === hookId,\n    tag\n  );\n  return event ? restoreHookCachesFromEvent(basedir, event, tag) : null;\n}\n\n/**\n * Creates a hooks storage implementation using the filesystem.\n * Implements the Storage['hooks'] interface with hook CRUD operations.\n */\nexport function createHooksStorage(\n  basedir: string,\n  tag?: string\n): Storage['hooks'] {\n  // Helper function to find a hook by token (shared between getByToken)\n  async function findHookByToken(token: string): Promise<Hook | null> {\n    const hooksDir = path.join(basedir, 'hooks');\n    const files = await listJSONFiles(hooksDir);\n\n    for (const file of files) {\n      const hookPath = path.join(hooksDir, `${file}.json`);\n      const hook = await readJSON(hookPath, HookSchema);\n      if (hook && hook.token === token) {\n        return { ...hook, isWebhook: hook.isWebhook ?? true };\n      }\n    }\n\n    return null;\n  }\n\n  async function get(hookId: string, params?: GetHookParams): Promise<Hook> {\n    assertSafeEntityId('hookId', hookId);\n    const hook = await readJSONWithFallback(\n      basedir,\n      'hooks',\n      hookId,\n      HookSchema,\n      tag\n    );\n    if (!hook) {\n      const rebuilt = await rebuildLiveHookByIdFromEventLog(\n        basedir,\n        hookId,\n        tag\n      );\n      if (!rebuilt) {\n        throw new HookNotFoundError(hookId);\n      }\n      const resolveData = params?.resolveData || DEFAULT_RESOLVE_DATA_OPTION;\n      return filterHookData(\n        { ...rebuilt, isWebhook: rebuilt.isWebhook ?? true },\n        resolveData\n      );\n    }\n    const resolveData = params?.resolveData || DEFAULT_RESOLVE_DATA_OPTION;\n    return filterHookData(\n      { ...hook, isWebhook: hook.isWebhook ?? true },\n      resolveData\n    );\n  }\n\n  async function getByToken(token: string): Promise<Hook> {\n    const hook =\n      (await findHookByToken(token)) ??\n      (await rebuildLiveHookByTokenFromEventLog(basedir, token, tag));\n    if (!hook) {\n      throw new HookNotFoundError(token);\n    }\n    return hook;\n  }\n\n  async function list(\n    params: ListHooksParams\n  ): Promise<PaginatedResponse<Hook>> {\n    const hooksDir = path.join(basedir, 'hooks');\n    const resolveData = params.resolveData || DEFAULT_RESOLVE_DATA_OPTION;\n\n    const result = await paginatedFileSystemQuery({\n      directory: hooksDir,\n      schema: HookSchema,\n      sortOrder: params.pagination?.sortOrder ?? 'asc',\n      limit: params.pagination?.limit,\n      cursor: params.pagination?.cursor,\n      filePrefix: undefined, // Hooks don't have ULIDs, so we can't optimize by filename\n      filter: (hook) => {\n        // Filter by runId if provided\n        if (params.runId && hook.runId !== params.runId) {\n          return false;\n        }\n        return true;\n      },\n      getCreatedAt: () => {\n        // Hook files don't have ULID timestamps in filename, so return null\n        // to skip the filename-based optimization and defer to JSON-based\n        // cursor filtering which uses the actual createdAt from the file.\n        return null;\n      },\n      getId: (hook) => hook.hookId,\n    });\n\n    // Transform the data after pagination\n    return {\n      ...result,\n      data: result.data.map((hook) => filterHookData(hook, resolveData)),\n    };\n  }\n\n  return { get, getByToken, list };\n}\n\n/**\n * Helper function to delete all hooks associated with a workflow run.\n * Called when a run reaches a terminal state.\n */\nexport async function deleteAllHooksForRun(\n  basedir: string,\n  runId: string\n): Promise<void> {\n  const hooksDir = path.join(basedir, 'hooks');\n  const files = await listJSONFiles(hooksDir);\n\n  for (const file of files) {\n    const hookPath = path.join(hooksDir, `${file}.json`);\n    const hook = await readJSON(hookPath, HookSchema);\n    if (hook && hook.runId === runId) {\n      // Delete the token constraint file to free up the token, and\n      // delete the recovery marker (if any) for disk hygiene. The\n      // marker's filename hash includes `(token, runId, hookId)` so\n      // a leaked marker can never corrupt a different lifetime — but\n      // cleaning it up here keeps the tokens/ directory from\n      // accumulating recovered-hook sidecars over time.\n      const constraintPath = path.join(\n        hooksDir,\n        'tokens',\n        `${hashToken(hook.token)}.json`\n      );\n      await deleteJSON(constraintPath);\n      await deleteJSON(\n        hookRecoveryMarkerPath(basedir, hook.token, hook.runId, hook.hookId)\n      );\n      await deleteJSON(hookPath);\n    }\n  }\n}\n"]}

package/dist/telemetry.d.ts

@@ -25,4 +25,12 @@ export declare const RpcService: (value: string) => {
 export declare const RpcMethod: (value: string) => {
     [k: string]: string;
 };
+/** Unique identifier for a specific workflow run instance */
+export declare const WorkflowRunId: (value: string) => {
+    [k: string]: string;
+};
+/** Unique identifier for the step instance */
+export declare const StepId: (value: string) => {
+    [k: string]: string;
+};
 //# sourceMappingURL=telemetry.d.ts.map

package/dist/telemetry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAuBtE;;;GAGG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAC3B,QAAQ,EAAE,MAAM,EAChB,GAAG,IAAI,EACH,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,GACjC,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,GACvD,OAAO,CAAC,CAAC,CAAC,CA2BZ;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,MAAM,OAAO,QAAQ,GAC3B,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAI/B;AASD,wFAAwF;AACxF,eAAO,MAAM,WAAW;;CAA6C,CAAC;AAEtE,wDAAwD;AACxD,eAAO,MAAM,SAAS;;CAA2C,CAAC;AAElE,oDAAoD;AACpD,eAAO,MAAM,UAAU;;CAA4C,CAAC;AAEpE,kDAAkD;AAClD,eAAO,MAAM,SAAS;;CAA2C,CAAC"}
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAuBtE;;;GAGG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAC3B,QAAQ,EAAE,MAAM,EAChB,GAAG,IAAI,EACH,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,GACjC,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,GACvD,OAAO,CAAC,CAAC,CAAC,CA2BZ;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,MAAM,OAAO,QAAQ,GAC3B,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CAI/B;AASD,wFAAwF;AACxF,eAAO,MAAM,WAAW;;CAA6C,CAAC;AAEtE,wDAAwD;AACxD,eAAO,MAAM,SAAS;;CAA2C,CAAC;AAElE,oDAAoD;AACpD,eAAO,MAAM,UAAU;;CAA4C,CAAC;AAEpE,kDAAkD;AAClD,eAAO,MAAM,SAAS;;CAA2C,CAAC;AAElE,6DAA6D;AAC7D,eAAO,MAAM,aAAa;;CAAgD,CAAC;AAE3E,8CAA8C;AAC9C,eAAO,MAAM,MAAM;;CAAwC,CAAC"}

package/dist/telemetry.js

@@ -68,4 +68,8 @@ 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=data:application/json;base64,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
+/** Unique identifier for a specific workflow run instance */
+export const WorkflowRunId = SemanticConvention('workflow.run.id');
+/** Unique identifier for the step instance */
+export const StepId = SemanticConvention('step.id');
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"telemetry.js","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Minimal telemetry utilities for world-local package.\n *\n * NOTE: This module is a simplified version of world-vercel's telemetry.\n * It provides tracing capabilities for local development to match\n * the observability experience in production.\n *\n * IMPORTANT: This module uses the same tracer name 'workflow' as @workflow/core to ensure\n * all spans are reported under the parent application's service, not as a separate service.\n */\nimport type * as api from '@opentelemetry/api';\nimport type { Span, SpanKind, SpanOptions } from '@opentelemetry/api';\n\n// Lazy load OpenTelemetry API to make it optional\nlet otelApiPromise: Promise<typeof api | null> | null = null;\n\nasync function getOtelApi(): Promise<typeof api | null> {\n  if (!otelApiPromise) {\n    otelApiPromise = import('@opentelemetry/api').catch(() => null);\n  }\n  return otelApiPromise;\n}\n\nlet tracerPromise: Promise<api.Tracer | null> | null = null;\n\nasync function getTracer(): Promise<api.Tracer | null> {\n  if (!tracerPromise) {\n    tracerPromise = getOtelApi().then((otel) =>\n      otel ? otel.trace.getTracer('workflow') : null\n    );\n  }\n  return tracerPromise;\n}\n\n/**\n * Wrap an async function with a trace span.\n * No-op if OpenTelemetry is not available.\n */\nexport async function trace<T>(\n  spanName: string,\n  ...args:\n    | [fn: (span?: Span) => Promise<T>]\n    | [opts: SpanOptions, fn: (span?: Span) => Promise<T>]\n): Promise<T> {\n  const [tracer, otel] = await Promise.all([getTracer(), getOtelApi()]);\n  const { fn, opts } =\n    typeof args[0] === 'function'\n      ? { fn: args[0], opts: {} }\n      : { fn: args[1], opts: args[0] };\n  if (!fn) throw new Error('Function to trace must be provided');\n\n  if (!tracer || !otel) {\n    return await fn();\n  }\n\n  return tracer.startActiveSpan(spanName, opts, async (span) => {\n    try {\n      const result = await fn(span);\n      span.setStatus({ code: otel.SpanStatusCode.OK });\n      return result;\n    } catch (e) {\n      span.setStatus({\n        code: otel.SpanStatusCode.ERROR,\n        message: (e as Error).message,\n      });\n      throw e;\n    } finally {\n      span.end();\n    }\n  });\n}\n\n/**\n * Get SpanKind enum value by name.\n * Returns undefined if OpenTelemetry is not available.\n */\nexport async function getSpanKind(\n  field: keyof typeof SpanKind\n): Promise<SpanKind | undefined> {\n  const otel = await getOtelApi();\n  if (!otel) return undefined;\n  return otel.SpanKind[field];\n}\n\n// Semantic conventions for World/Storage tracing\n// Standard OTEL conventions for peer service mapping\nfunction SemanticConvention<T>(...names: string[]) {\n  return (value: T) =>\n    Object.fromEntries(names.map((name) => [name, value] as const));\n}\n\n/** The remote service name for Datadog service maps (Datadog-specific: peer.service) */\nexport const PeerService = SemanticConvention<string>('peer.service');\n\n/** RPC system identifier (standard OTEL: rpc.system) */\nexport const RpcSystem = SemanticConvention<string>('rpc.system');\n\n/** RPC service name (standard OTEL: rpc.service) */\nexport const RpcService = SemanticConvention<string>('rpc.service');\n\n/** RPC method name (standard OTEL: rpc.method) */\nexport const RpcMethod = SemanticConvention<string>('rpc.method');\n\n/** Unique identifier for a specific workflow run instance */\nexport const WorkflowRunId = SemanticConvention<string>('workflow.run.id');\n\n/** Unique identifier for the step instance */\nexport const StepId = SemanticConvention<string>('step.id');\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/world-local",
-  "version": "4.2.0",
+  "version": "4.2.1",
   "description": "Local development World implementation for Workflow SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -26,11 +26,11 @@
     "@vercel/queue": "0.3.1",
     "async-sema": "3.1.1",
     "ulid": "~3.0.1",
-    "undici": "7.26.0",
-    "zod": "4.3.6",
+    "undici": "7.28.0",
+    "zod": "~4.3.6",
     "@workflow/errors": "4.1.4",
     "@workflow/utils": "4.1.3",
-    "@workflow/world": "4.2.0"
+    "@workflow/world": "4.2.1"
   },
   "devDependencies": {
     "@opentelemetry/api": "1.9.0",