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

package/dist/storage/filters.d.ts

@@ -0,0 +1,22 @@
+import type { Hook, Step, StepWithoutData, WorkflowRun, WorkflowRunWithoutData } from '@workflow/world';
+export { stripEventDataRefs } from '@workflow/world';
+/**
+ * Filter run data based on resolveData setting.
+ * When resolveData is 'none', strips input/output to reduce payload size.
+ */
+export declare function filterRunData(run: WorkflowRun, resolveData: 'none'): WorkflowRunWithoutData;
+export declare function filterRunData(run: WorkflowRun, resolveData: 'all'): WorkflowRun;
+export declare function filterRunData(run: WorkflowRun, resolveData: 'none' | 'all'): WorkflowRun | WorkflowRunWithoutData;
+/**
+ * Filter step data based on resolveData setting.
+ * When resolveData is 'none', strips input/output to reduce payload size.
+ */
+export declare function filterStepData(step: Step, resolveData: 'none'): StepWithoutData;
+export declare function filterStepData(step: Step, resolveData: 'all'): Step;
+export declare function filterStepData(step: Step, resolveData: 'none' | 'all'): Step | StepWithoutData;
+/**
+ * Filter hook data based on resolveData setting.
+ * When resolveData is 'none', strips metadata to reduce payload size.
+ */
+export declare function filterHookData(hook: Hook, resolveData: 'none' | 'all'): Hook;
+//# sourceMappingURL=filters.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filters.d.ts","sourceRoot":"","sources":["../../src/storage/filters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,IAAI,EACJ,eAAe,EACf,WAAW,EACX,sBAAsB,EACvB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,WAAW,EAChB,WAAW,EAAE,MAAM,GAClB,sBAAsB,CAAC;AAC1B,wBAAgB,aAAa,CAC3B,GAAG,EAAE,WAAW,EAChB,WAAW,EAAE,KAAK,GACjB,WAAW,CAAC;AACf,wBAAgB,aAAa,CAC3B,GAAG,EAAE,WAAW,EAChB,WAAW,EAAE,MAAM,GAAG,KAAK,GAC1B,WAAW,GAAG,sBAAsB,CAAC;AAexC;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,GAClB,eAAe,CAAC;AACnB,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,GAAG,IAAI,CAAC;AACrE,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,MAAM,GAAG,KAAK,GAC1B,IAAI,GAAG,eAAe,CAAC;AAe1B;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,CAM5E"}

package/dist/storage/filters.js

@@ -0,0 +1,33 @@
+export { stripEventDataRefs } from '@workflow/world';
+export function filterRunData(run, resolveData) {
+    if (resolveData === 'none') {
+        return {
+            ...run,
+            input: undefined,
+            output: undefined,
+        };
+    }
+    return run;
+}
+export function filterStepData(step, resolveData) {
+    if (resolveData === 'none') {
+        return {
+            ...step,
+            input: undefined,
+            output: undefined,
+        };
+    }
+    return step;
+}
+/**
+ * Filter hook data based on resolveData setting.
+ * When resolveData is 'none', strips metadata to reduce payload size.
+ */
+export function filterHookData(hook, resolveData) {
+    if (resolveData === 'none') {
+        const { metadata: _metadata, ...rest } = hook;
+        return rest;
+    }
+    return hook;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/storage/helpers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Hash a hook token to produce a filesystem-safe constraint filename.
+ */
+export declare function hashToken(token: string): string;
+/**
+ * Create a monotonic ULID factory that ensures ULIDs are always increasing
+ * even when generated within the same millisecond.
+ */
+export declare const monotonicUlid: import("ulid").ULIDFactory;
+/**
+ * Creates a function to extract createdAt date from a filename based on ULID.
+ * Used for efficient pagination without reading file contents.
+ *
+ * @param idPrefix - The prefix to strip from filenames (e.g., 'wrun', 'evnt', 'step')
+ * @returns A function that extracts Date from filename, or null if not extractable
+ */
+export declare const getObjectCreatedAt: (idPrefix: string) => (filename: string) => Date | null;
+//# sourceMappingURL=helpers.d.ts.map

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

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

package/dist/storage/helpers.js

@@ -0,0 +1,44 @@
+import { createHash } from 'node:crypto';
+import { monotonicFactory } from 'ulid';
+import { stripTag, ulidToDate } from '../fs.js';
+/**
+ * Hash a hook token to produce a filesystem-safe constraint filename.
+ */
+export function hashToken(token) {
+    return createHash('sha256').update(token).digest('hex');
+}
+/**
+ * Create a monotonic ULID factory that ensures ULIDs are always increasing
+ * even when generated within the same millisecond.
+ */
+export const monotonicUlid = monotonicFactory(() => Math.random());
+/**
+ * Creates a function to extract createdAt date from a filename based on ULID.
+ * Used for efficient pagination without reading file contents.
+ *
+ * @param idPrefix - The prefix to strip from filenames (e.g., 'wrun', 'evnt', 'step')
+ * @returns A function that extracts Date from filename, or null if not extractable
+ */
+export const getObjectCreatedAt = (idPrefix) => (filename) => {
+    // Strip tag suffix before ULID extraction
+    // e.g., "wrun_ABC.vitest-0.json" → "wrun_ABC.json"
+    const cleanName = stripTag(filename.replace(/\.json$/, '')) + '.json';
+    const replaceRegex = new RegExp(`^${idPrefix}_`, 'g');
+    const dashIndex = cleanName.indexOf('-');
+    if (dashIndex === -1) {
+        // No dash - extract ULID from the filename (e.g., wrun_ULID.json, evnt_ULID.json)
+        const ulid = cleanName.replace(/\.json$/, '').replace(replaceRegex, '');
+        return ulidToDate(ulid);
+    }
+    // For composite keys like {runId}-{stepId}, extract from the appropriate part
+    if (idPrefix === 'step') {
+        // Steps use sequential IDs (step_0, step_1, etc.) - no timestamp in filename.
+        // Return null to skip filename-based optimization and defer to JSON-based filtering.
+        return null;
+    }
+    // For events: wrun_ULID-evnt_ULID.json - extract from the eventId part
+    const id = cleanName.substring(dashIndex + 1).replace(/\.json$/, '');
+    const ulid = id.replace(replaceRegex, '');
+    return ulidToDate(ulid);
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,12 @@
+import type { Storage } from '@workflow/world';
+/**
+ * Creates a hooks storage implementation using the filesystem.
+ * Implements the Storage['hooks'] interface with hook CRUD operations.
+ */
+export declare function createHooksStorage(basedir: string, tag?: string): Storage['hooks'];
+/**
+ * Helper function to delete all hooks associated with a workflow run.
+ * Called when a run reaches a terminal state.
+ */
+export declare function deleteAllHooksForRun(basedir: string, runId: string): Promise<void>;
+//# sourceMappingURL=hooks-storage.d.ts.map

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

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

package/dist/storage/hooks-storage.js

@@ -0,0 +1,93 @@
+import path from 'node:path';
+import { HookNotFoundError } from '@workflow/errors';
+import { HookSchema } from '@workflow/world';
+import { DEFAULT_RESOLVE_DATA_OPTION } from '../config.js';
+import { assertSafeEntityId, deleteJSON, listJSONFiles, paginatedFileSystemQuery, readJSON, readJSONWithFallback, } from '../fs.js';
+import { filterHookData } from './filters.js';
+import { hashToken } from './helpers.js';
+/**
+ * Creates a hooks storage implementation using the filesystem.
+ * Implements the Storage['hooks'] interface with hook CRUD operations.
+ */
+export function createHooksStorage(basedir, tag) {
+    // Helper function to find a hook by token (shared between getByToken)
+    async function findHookByToken(token) {
+        const hooksDir = path.join(basedir, 'hooks');
+        const files = await listJSONFiles(hooksDir);
+        for (const file of files) {
+            const hookPath = path.join(hooksDir, `${file}.json`);
+            const hook = await readJSON(hookPath, HookSchema);
+            if (hook && hook.token === token) {
+                return { ...hook, isWebhook: hook.isWebhook ?? true };
+            }
+        }
+        return null;
+    }
+    async function get(hookId, params) {
+        assertSafeEntityId('hookId', hookId);
+        const hook = await readJSONWithFallback(basedir, 'hooks', hookId, HookSchema, tag);
+        if (!hook) {
+            throw new HookNotFoundError(hookId);
+        }
+        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);
+        if (!hook) {
+            throw new HookNotFoundError(token);
+        }
+        return hook;
+    }
+    async function list(params) {
+        const hooksDir = path.join(basedir, 'hooks');
+        const resolveData = params.resolveData || DEFAULT_RESOLVE_DATA_OPTION;
+        const result = await paginatedFileSystemQuery({
+            directory: hooksDir,
+            schema: HookSchema,
+            sortOrder: params.pagination?.sortOrder ?? 'asc',
+            limit: params.pagination?.limit,
+            cursor: params.pagination?.cursor,
+            filePrefix: undefined, // Hooks don't have ULIDs, so we can't optimize by filename
+            filter: (hook) => {
+                // Filter by runId if provided
+                if (params.runId && hook.runId !== params.runId) {
+                    return false;
+                }
+                return true;
+            },
+            getCreatedAt: () => {
+                // Hook files don't have ULID timestamps in filename, so return null
+                // to skip the filename-based optimization and defer to JSON-based
+                // cursor filtering which uses the actual createdAt from the file.
+                return null;
+            },
+            getId: (hook) => hook.hookId,
+        });
+        // Transform the data after pagination
+        return {
+            ...result,
+            data: result.data.map((hook) => filterHookData(hook, resolveData)),
+        };
+    }
+    return { get, getByToken, list };
+}
+/**
+ * Helper function to delete all hooks associated with a workflow run.
+ * Called when a run reaches a terminal state.
+ */
+export async function deleteAllHooksForRun(basedir, runId) {
+    const hooksDir = path.join(basedir, 'hooks');
+    const files = await listJSONFiles(hooksDir);
+    for (const file of files) {
+        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
+            const constraintPath = path.join(hooksDir, 'tokens', `${hashToken(hook.token)}.json`);
+            await deleteJSON(constraintPath);
+            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"]}

package/dist/storage/index.d.ts

@@ -0,0 +1,21 @@
+import type { Storage } from '@workflow/world';
+import { type LocalRunsStorage } from './runs-storage.js';
+/**
+ * Storage shape used inside world-local: identical to `Storage`, but `runs`
+ * exposes the internal `fileIdFilter` option on `list()`. Structurally
+ * assignable to `Storage` at public boundaries (e.g., `reenqueueActiveRuns`).
+ */
+export type LocalStorage = Omit<Storage, 'runs'> & {
+    runs: LocalRunsStorage;
+};
+/**
+ * Creates a complete storage implementation using the filesystem.
+ * This is the main entry point that composes all storage implementations.
+ *
+ * All storage methods are instrumented with tracing spans for observability.
+ *
+ * @param basedir - The base directory for storing workflow data
+ * @returns A complete Storage implementation with tracing
+ */
+export declare function createStorage(basedir: string, tag?: string): LocalStorage;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAI/C,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAG7E;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAE9E;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,YAAY,CAezE"}

package/dist/storage/index.js

@@ -0,0 +1,30 @@
+import { instrumentObject } from '../instrumentObject.js';
+import { createEventsStorage } from './events-storage.js';
+import { createHooksStorage } from './hooks-storage.js';
+import { createRunsStorage } from './runs-storage.js';
+import { createStepsStorage } from './steps-storage.js';
+/**
+ * Creates a complete storage implementation using the filesystem.
+ * This is the main entry point that composes all storage implementations.
+ *
+ * All storage methods are instrumented with tracing spans for observability.
+ *
+ * @param basedir - The base directory for storing workflow data
+ * @returns A complete Storage implementation with tracing
+ */
+export function createStorage(basedir, tag) {
+    // Create raw storage implementations
+    const runs = createRunsStorage(basedir, tag);
+    const steps = createStepsStorage(basedir, tag);
+    const events = createEventsStorage(basedir, tag);
+    const hooks = createHooksStorage(basedir, tag);
+    // Instrument all storage methods with tracing
+    // NOTE: Span names are lowercase per OTEL semantic conventions
+    return {
+        runs: instrumentObject('world.runs', runs),
+        steps: instrumentObject('world.steps', steps),
+        events: instrumentObject('world.events', events),
+        hooks: instrumentObject('world.hooks', hooks),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/storage/legacy.d.ts

@@ -0,0 +1,13 @@
+import type { EventResult, WorkflowRun } from '@workflow/world';
+/**
+ * Handle events for legacy runs (pre-event-sourcing, specVersion < 2).
+ * Legacy runs use different behavior:
+ * - run_cancelled: Skip event storage, directly update run
+ * - wait_completed: Store event only (no entity mutation)
+ * - hook_received: Store event only (hooks exist via old system, no entity mutation)
+ * - Other events: Throw error (not supported for legacy runs)
+ */
+export declare function handleLegacyEvent(basedir: string, runId: string, data: any, currentRun: WorkflowRun, params?: {
+    resolveData?: 'none' | 'all';
+}): Promise<EventResult>;
+//# sourceMappingURL=legacy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"legacy.d.ts","sourceRoot":"","sources":["../../src/storage/legacy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,WAAW,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAQvE;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,GAAG,EACT,UAAU,EAAE,WAAW,EACvB,MAAM,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,GAAG,KAAK,CAAA;CAAE,GACxC,OAAO,CAAC,WAAW,CAAC,CAwEtB"}

package/dist/storage/legacy.js

@@ -0,0 +1,78 @@
+import { SPEC_VERSION_CURRENT } from '@workflow/world';
+import { DEFAULT_RESOLVE_DATA_OPTION } from '../config.js';
+import { assertSafeEntityId, resolveWithinBase, writeJSON } from '../fs.js';
+import { filterRunData, stripEventDataRefs } from './filters.js';
+import { monotonicUlid } from './helpers.js';
+import { deleteAllHooksForRun } from './hooks-storage.js';
+/**
+ * Handle events for legacy runs (pre-event-sourcing, specVersion < 2).
+ * Legacy runs use different behavior:
+ * - run_cancelled: Skip event storage, directly update run
+ * - wait_completed: Store event only (no entity mutation)
+ * - hook_received: Store event only (hooks exist via old system, no entity mutation)
+ * - Other events: Throw error (not supported for legacy runs)
+ */
+export async function handleLegacyEvent(basedir, runId, data, currentRun, params) {
+    // Defense in depth: events.create already validates runId before routing
+    // here, but handleLegacyEvent is exported and its signature doesn't
+    // document that invariant. Validating locally keeps the guarantee in this
+    // file.
+    assertSafeEntityId('runId', runId);
+    const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+    switch (data.eventType) {
+        case 'run_cancelled': {
+            // Legacy: Skip event storage, directly update run to cancelled
+            const now = new Date();
+            const run = {
+                runId: currentRun.runId,
+                deploymentId: currentRun.deploymentId,
+                workflowName: currentRun.workflowName,
+                specVersion: currentRun.specVersion,
+                executionContext: currentRun.executionContext,
+                input: currentRun.input,
+                createdAt: currentRun.createdAt,
+                expiredAt: currentRun.expiredAt,
+                startedAt: currentRun.startedAt,
+                status: 'cancelled',
+                output: undefined,
+                error: undefined,
+                completedAt: now,
+                updatedAt: now,
+                attributes: currentRun.attributes,
+            };
+            const runPath = resolveWithinBase(basedir, 'runs', `${runId}.json`);
+            await writeJSON(runPath, run, { overwrite: true });
+            await deleteAllHooksForRun(basedir, runId);
+            // Return without event (legacy behavior skips event storage)
+            // Type assertion: EventResult expects WorkflowRun, filterRunData may return WorkflowRunWithoutData
+            return {
+                event: undefined,
+                run: filterRunData(run, resolveData),
+            };
+        }
+        case 'wait_completed':
+        case 'hook_received': {
+            // Legacy: Store event only (no entity mutation)
+            // - wait_completed: for replay purposes
+            // - hook_received: hooks exist via old system, just record the event
+            const eventId = `evnt_${monotonicUlid()}`;
+            const now = new Date();
+            const event = {
+                ...data,
+                runId,
+                eventId,
+                createdAt: now,
+                specVersion: SPEC_VERSION_CURRENT,
+            };
+            const compositeKey = `${runId}-${eventId}`;
+            const eventPath = resolveWithinBase(basedir, 'events', `${compositeKey}.json`);
+            await writeJSON(eventPath, event);
+            return { event: stripEventDataRefs(event, resolveData) };
+        }
+        default:
+            throw new Error(`Event type '${data.eventType}' not supported for legacy runs ` +
+                `(specVersion: ${currentRun.specVersion || 'undefined'}). ` +
+                `Please upgrade 'workflow' package.`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,33 @@
+import type { AttributeChange, ExperimentalSetAttributesResult, ListWorkflowRunsParams, PaginatedResponse, Storage, WorkflowRun, WorkflowRunWithoutData } from '@workflow/world';
+/**
+ * Internal extension of `ListWorkflowRunsParams` that adds a `fileIdFilter`
+ * for scoping queries by raw filename (e.g., by tag suffix). Kept out of the
+ * public `Storage['runs']['list']` surface — consumers of `@workflow/world`
+ * must not see this option.
+ */
+export interface LocalListWorkflowRunsParams extends ListWorkflowRunsParams {
+    fileIdFilter?: (fileId: string) => boolean;
+}
+export interface LocalRunsStorage {
+    get: Storage['runs']['get'];
+    list: {
+        (params: LocalListWorkflowRunsParams & {
+            resolveData: 'none';
+        }): Promise<PaginatedResponse<WorkflowRunWithoutData>>;
+        (params?: LocalListWorkflowRunsParams & {
+            resolveData?: 'all';
+        }): Promise<PaginatedResponse<WorkflowRun>>;
+        (params?: LocalListWorkflowRunsParams): Promise<PaginatedResponse<WorkflowRun | WorkflowRunWithoutData>>;
+    };
+    experimentalSetAttributes(runId: string, changes: AttributeChange[], options?: {
+        allowReservedAttributes?: boolean;
+    }): Promise<ExperimentalSetAttributesResult>;
+}
+export declare function withRunFileLock<T>(key: string, fn: () => Promise<T>): Promise<T>;
+/**
+ * Creates the runs storage implementation using the filesystem.
+ * Implements the Storage['runs'] interface with get and list operations,
+ * plus an internal `fileIdFilter` on `list` for tag-scoped recovery queries.
+ */
+export declare function createRunsStorage(basedir: string, tag?: string): LocalRunsStorage;
+//# sourceMappingURL=runs-storage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runs-storage.d.ts","sourceRoot":"","sources":["../../src/storage/runs-storage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,eAAe,EACf,+BAA+B,EAC/B,sBAAsB,EACtB,iBAAiB,EACjB,OAAO,EACP,WAAW,EACX,sBAAsB,EACvB,MAAM,iBAAiB,CAAC;AAkBzB;;;;;GAKG;AACH,MAAM,WAAW,2BAA4B,SAAQ,sBAAsB;IACzE,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5C;AAED,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC;IAC5B,IAAI,EAAE;QACJ,CACE,MAAM,EAAE,2BAA2B,GAAG;YAAE,WAAW,EAAE,MAAM,CAAA;SAAE,GAC5D,OAAO,CAAC,iBAAiB,CAAC,sBAAsB,CAAC,CAAC,CAAC;QACtD,CACE,MAAM,CAAC,EAAE,2BAA2B,GAAG;YAAE,WAAW,CAAC,EAAE,KAAK,CAAA;SAAE,GAC7D,OAAO,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC,CAAC;QAC3C,CACE,MAAM,CAAC,EAAE,2BAA2B,GACnC,OAAO,CAAC,iBAAiB,CAAC,WAAW,GAAG,sBAAsB,CAAC,CAAC,CAAC;KACrE,CAAC;IACF,yBAAyB,CACvB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,eAAe,EAAE,EAC1B,OAAO,CAAC,EAAE;QAAE,uBAAuB,CAAC,EAAE,OAAO,CAAA;KAAE,GAC9C,OAAO,CAAC,+BAA+B,CAAC,CAAC;CAC7C;AAiBD,wBAAgB,eAAe,CAAC,CAAC,EAC/B,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAgBZ;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,MAAM,GACX,gBAAgB,CAyGlB"}