@sonamu-kit/tasks 0.0.1

package/dist/core/step.test.js

@@ -0,0 +1,356 @@
+import { describe, expect, test } from "vitest";
+import { ok } from "./result.js";
+import { addToStepAttemptCache, calculateSleepResumeAt, createSleepContext, createStepAttemptCacheFromAttempts, getCachedStepAttempt, hasCompletedStep, normalizeStepOutput } from "./step.js";
+describe("createStepAttemptCacheFromAttempts", ()=>{
+    test("creates empty cache from empty array", ()=>{
+        const cache = createStepAttemptCacheFromAttempts([]);
+        expect(cache.size).toBe(0);
+    });
+    test("includes completed attempts in cache", ()=>{
+        const attempt = createMockStepAttempt({
+            stepName: "step-a",
+            status: "completed",
+            output: "result"
+        });
+        const cache = createStepAttemptCacheFromAttempts([
+            attempt
+        ]);
+        expect(cache.size).toBe(1);
+        expect(cache.get("step-a")).toBe(attempt);
+    });
+    test("includes succeeded attempts in cache (deprecated status)", ()=>{
+        const attempt = createMockStepAttempt({
+            stepName: "step-b",
+            status: "succeeded",
+            output: "result"
+        });
+        const cache = createStepAttemptCacheFromAttempts([
+            attempt
+        ]);
+        expect(cache.size).toBe(1);
+        expect(cache.get("step-b")).toBe(attempt);
+    });
+    test("excludes running attempts from cache", ()=>{
+        const attempt = createMockStepAttempt({
+            stepName: "step-c",
+            status: "running"
+        });
+        const cache = createStepAttemptCacheFromAttempts([
+            attempt
+        ]);
+        expect(cache.size).toBe(0);
+    });
+    test("excludes failed attempts from cache", ()=>{
+        const attempt = createMockStepAttempt({
+            stepName: "step-d",
+            status: "failed",
+            error: {
+                message: "failed"
+            }
+        });
+        const cache = createStepAttemptCacheFromAttempts([
+            attempt
+        ]);
+        expect(cache.size).toBe(0);
+    });
+    test("filters mixed statuses correctly", ()=>{
+        const attempts = [
+            createMockStepAttempt({
+                stepName: "completed-step",
+                status: "completed"
+            }),
+            createMockStepAttempt({
+                stepName: "running-step",
+                status: "running"
+            }),
+            createMockStepAttempt({
+                stepName: "failed-step",
+                status: "failed"
+            }),
+            createMockStepAttempt({
+                stepName: "succeeded-step",
+                status: "succeeded"
+            })
+        ];
+        const cache = createStepAttemptCacheFromAttempts(attempts);
+        expect(cache.size).toBe(2);
+        expect(cache.has("completed-step")).toBe(true);
+        expect(cache.has("succeeded-step")).toBe(true);
+        expect(cache.has("running-step")).toBe(false);
+        expect(cache.has("failed-step")).toBe(false);
+    });
+    test("uses step name as cache key", ()=>{
+        const attempt = createMockStepAttempt({
+            stepName: "my-unique-step-name",
+            status: "completed"
+        });
+        const cache = createStepAttemptCacheFromAttempts([
+            attempt
+        ]);
+        expect(cache.get("my-unique-step-name")).toBe(attempt);
+        expect(cache.get("other-name")).toBeUndefined();
+    });
+});
+describe("getCachedStepAttempt", ()=>{
+    test("returns cached attempt when present", ()=>{
+        const attempt = createMockStepAttempt({
+            stepName: "cached-step"
+        });
+        const cache = new Map([
+            [
+                "cached-step",
+                attempt
+            ]
+        ]);
+        const result = getCachedStepAttempt(cache, "cached-step");
+        expect(result).toBe(attempt);
+    });
+    test("returns undefined when step not in cache", ()=>{
+        const cache = new Map();
+        const result = getCachedStepAttempt(cache, "missing-step");
+        expect(result).toBeUndefined();
+    });
+    test("returns undefined for similar but different step names", ()=>{
+        const attempt = createMockStepAttempt({
+            stepName: "step-1"
+        });
+        const cache = new Map([
+            [
+                "step-1",
+                attempt
+            ]
+        ]);
+        expect(getCachedStepAttempt(cache, "step-2")).toBeUndefined();
+        expect(getCachedStepAttempt(cache, "Step-1")).toBeUndefined();
+        expect(getCachedStepAttempt(cache, "step-1 ")).toBeUndefined();
+    });
+});
+describe("hasCompletedStep", ()=>{
+    test("returns true when step is in cache", ()=>{
+        const attempt = createMockStepAttempt({
+            stepName: "step-x"
+        });
+        const cache = new Map([
+            [
+                "step-x",
+                attempt
+            ]
+        ]);
+        expect(hasCompletedStep(cache, "step-x")).toBe(true);
+    });
+    test("returns false when step is not in cache", ()=>{
+        const cache = new Map();
+        expect(hasCompletedStep(cache, "step-y")).toBe(false);
+    });
+    test("returns false for empty cache", ()=>{
+        const cache = new Map();
+        expect(hasCompletedStep(cache, "any-step")).toBe(false);
+    });
+});
+describe("addToStepAttemptCache", ()=>{
+    test("adds attempt to empty cache", ()=>{
+        const cache = new Map();
+        const attempt = createMockStepAttempt({
+            stepName: "new-step"
+        });
+        const newCache = addToStepAttemptCache(cache, attempt);
+        expect(newCache.size).toBe(1);
+        expect(newCache.get("new-step")).toBe(attempt);
+    });
+    test("adds attempt to existing cache", ()=>{
+        const existing = createMockStepAttempt({
+            stepName: "existing-step"
+        });
+        const cache = new Map([
+            [
+                "existing-step",
+                existing
+            ]
+        ]);
+        const newAttempt = createMockStepAttempt({
+            stepName: "new-step"
+        });
+        const newCache = addToStepAttemptCache(cache, newAttempt);
+        expect(newCache.size).toBe(2);
+        expect(newCache.get("existing-step")).toBe(existing);
+        expect(newCache.get("new-step")).toBe(newAttempt);
+    });
+    test("does not mutate original cache (immutable)", ()=>{
+        const existing = createMockStepAttempt({
+            stepName: "existing-step"
+        });
+        const cache = new Map([
+            [
+                "existing-step",
+                existing
+            ]
+        ]);
+        const newAttempt = createMockStepAttempt({
+            stepName: "new-step"
+        });
+        const newCache = addToStepAttemptCache(cache, newAttempt);
+        expect(cache.size).toBe(1);
+        expect(cache.has("new-step")).toBe(false);
+        expect(newCache.size).toBe(2);
+    });
+    test("overwrites existing entry with same step name", ()=>{
+        const original = createMockStepAttempt({
+            stepName: "step",
+            output: "original"
+        });
+        const cache = new Map([
+            [
+                "step",
+                original
+            ]
+        ]);
+        const replacement = createMockStepAttempt({
+            stepName: "step",
+            output: "replacement"
+        });
+        const newCache = addToStepAttemptCache(cache, replacement);
+        expect(newCache.size).toBe(1);
+        expect(newCache.get("step")?.output).toBe("replacement");
+    });
+});
+describe("normalizeStepOutput", ()=>{
+    test("passes through string values", ()=>{
+        expect(normalizeStepOutput("hello")).toBe("hello");
+    });
+    test("passes through number values", ()=>{
+        expect(normalizeStepOutput(42)).toBe(42);
+        expect(normalizeStepOutput(3.14)).toBe(3.14);
+        expect(normalizeStepOutput(0)).toBe(0);
+        expect(normalizeStepOutput(-1)).toBe(-1);
+    });
+    test("passes through boolean values", ()=>{
+        expect(normalizeStepOutput(true)).toBe(true);
+        expect(normalizeStepOutput(false)).toBe(false);
+    });
+    test("passes through null", ()=>{
+        expect(normalizeStepOutput(null)).toBeNull();
+    });
+    test("converts undefined to null", ()=>{
+        // eslint-disable-next-line unicorn/no-useless-undefined
+        expect(normalizeStepOutput(undefined)).toBeNull();
+    });
+    test("passes through object values", ()=>{
+        const obj = {
+            foo: "bar",
+            nested: {
+                baz: 123
+            }
+        };
+        expect(normalizeStepOutput(obj)).toBe(obj);
+    });
+    test("passes through array values", ()=>{
+        const arr = [
+            1,
+            2,
+            3
+        ];
+        expect(normalizeStepOutput(arr)).toBe(arr);
+    });
+    test("passes through empty object", ()=>{
+        const obj = {};
+        expect(normalizeStepOutput(obj)).toBe(obj);
+    });
+    test("passes through empty array", ()=>{
+        const arr = [];
+        expect(normalizeStepOutput(arr)).toBe(arr);
+    });
+});
+describe("calculateSleepResumeAt", ()=>{
+    test("calculates resume time from duration string", ()=>{
+        const now = 1_000_000;
+        const result = calculateSleepResumeAt("5s", now);
+        expect(result).toEqual(ok(new Date(now + 5000)));
+    });
+    test("calculates resume time with milliseconds", ()=>{
+        const now = 1_000_000;
+        const result = calculateSleepResumeAt("500ms", now);
+        expect(result).toEqual(ok(new Date(now + 500)));
+    });
+    test("calculates resume time with minutes", ()=>{
+        const now = 1_000_000;
+        const result = calculateSleepResumeAt("2m", now);
+        expect(result).toEqual(ok(new Date(now + 2 * 60 * 1000)));
+    });
+    test("calculates resume time with hours", ()=>{
+        const now = 1_000_000;
+        const result = calculateSleepResumeAt("1h", now);
+        expect(result).toEqual(ok(new Date(now + 60 * 60 * 1000)));
+    });
+    test("uses Date.now() when now is not provided", ()=>{
+        const before = Date.now();
+        const result = calculateSleepResumeAt("1s");
+        const after = Date.now();
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+            const resumeTime = result.value.getTime();
+            expect(resumeTime).toBeGreaterThanOrEqual(before + 1000);
+            expect(resumeTime).toBeLessThanOrEqual(after + 1000);
+        }
+    });
+    test("returns error for invalid duration", ()=>{
+        // @ts-expect-error testing invalid input
+        const result = calculateSleepResumeAt("invalid");
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+            expect(result.error).toBeInstanceOf(Error);
+        }
+    });
+    test("returns error for empty duration", ()=>{
+        // @ts-expect-error testing invalid input
+        const result = calculateSleepResumeAt("");
+        expect(result.ok).toBe(false);
+    });
+});
+describe("createSleepContext", ()=>{
+    test("creates sleep context with ISO string timestamp", ()=>{
+        const resumeAt = new Date("2025-06-15T10:30:00.000Z");
+        const context = createSleepContext(resumeAt);
+        expect(context).toEqual({
+            kind: "sleep",
+            resumeAt: "2025-06-15T10:30:00.000Z"
+        });
+    });
+    test("preserves millisecond precision", ()=>{
+        const resumeAt = new Date("2025-01-01T00:00:00.123Z");
+        const context = createSleepContext(resumeAt);
+        expect(context.resumeAt).toBe("2025-01-01T00:00:00.123Z");
+    });
+    test("always has kind set to sleep", ()=>{
+        const resumeAt = new Date();
+        const context = createSleepContext(resumeAt);
+        expect(context.kind).toBe("sleep");
+    });
+    test("creates context from current date", ()=>{
+        const now = new Date();
+        const context = createSleepContext(now);
+        expect(context.resumeAt).toBe(now.toISOString());
+    });
+});
+function createMockStepAttempt(overrides = {}) {
+    return {
+        namespaceId: "default",
+        id: "step-1",
+        workflowRunId: "workflow-1",
+        stepName: "test-step",
+        kind: "function",
+        status: "completed",
+        config: {},
+        context: null,
+        output: null,
+        error: null,
+        childWorkflowRunNamespaceId: null,
+        childWorkflowRunId: null,
+        startedAt: new Date("2025-01-01T00:00:00Z"),
+        finishedAt: new Date("2025-01-01T00:00:01Z"),
+        createdAt: new Date("2025-01-01T00:00:00Z"),
+        updatedAt: new Date("2025-01-01T00:00:01Z"),
+        ...overrides
+    };
+}
+
+//# sourceMappingURL=step.test.js.map

package/dist/core/step.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/step.test.ts"],"sourcesContent":["import { describe, expect, test } from \"vitest\";\nimport { ok } from \"./result\";\nimport type { StepAttempt, StepAttemptCache } from \"./step\";\nimport {\n  addToStepAttemptCache,\n  calculateSleepResumeAt,\n  createSleepContext,\n  createStepAttemptCacheFromAttempts,\n  getCachedStepAttempt,\n  hasCompletedStep,\n  normalizeStepOutput,\n} from \"./step\";\n\ndescribe(\"createStepAttemptCacheFromAttempts\", () => {\n  test(\"creates empty cache from empty array\", () => {\n    const cache = createStepAttemptCacheFromAttempts([]);\n\n    expect(cache.size).toBe(0);\n  });\n\n  test(\"includes completed attempts in cache\", () => {\n    const attempt = createMockStepAttempt({\n      stepName: \"step-a\",\n      status: \"completed\",\n      output: \"result\",\n    });\n    const cache = createStepAttemptCacheFromAttempts([attempt]);\n\n    expect(cache.size).toBe(1);\n    expect(cache.get(\"step-a\")).toBe(attempt);\n  });\n\n  test(\"includes succeeded attempts in cache (deprecated status)\", () => {\n    const attempt = createMockStepAttempt({\n      stepName: \"step-b\",\n      status: \"succeeded\",\n      output: \"result\",\n    });\n    const cache = createStepAttemptCacheFromAttempts([attempt]);\n\n    expect(cache.size).toBe(1);\n    expect(cache.get(\"step-b\")).toBe(attempt);\n  });\n\n  test(\"excludes running attempts from cache\", () => {\n    const attempt = createMockStepAttempt({\n      stepName: \"step-c\",\n      status: \"running\",\n    });\n    const cache = createStepAttemptCacheFromAttempts([attempt]);\n\n    expect(cache.size).toBe(0);\n  });\n\n  test(\"excludes failed attempts from cache\", () => {\n    const attempt = createMockStepAttempt({\n      stepName: \"step-d\",\n      status: \"failed\",\n      error: { message: \"failed\" },\n    });\n    const cache = createStepAttemptCacheFromAttempts([attempt]);\n\n    expect(cache.size).toBe(0);\n  });\n\n  test(\"filters mixed statuses correctly\", () => {\n    const attempts = [\n      createMockStepAttempt({\n        stepName: \"completed-step\",\n        status: \"completed\",\n      }),\n      createMockStepAttempt({ stepName: \"running-step\", status: \"running\" }),\n      createMockStepAttempt({ stepName: \"failed-step\", status: \"failed\" }),\n      createMockStepAttempt({\n        stepName: \"succeeded-step\",\n        status: \"succeeded\",\n      }),\n    ];\n    const cache = createStepAttemptCacheFromAttempts(attempts);\n\n    expect(cache.size).toBe(2);\n    expect(cache.has(\"completed-step\")).toBe(true);\n    expect(cache.has(\"succeeded-step\")).toBe(true);\n    expect(cache.has(\"running-step\")).toBe(false);\n    expect(cache.has(\"failed-step\")).toBe(false);\n  });\n\n  test(\"uses step name as cache key\", () => {\n    const attempt = createMockStepAttempt({\n      stepName: \"my-unique-step-name\",\n      status: \"completed\",\n    });\n    const cache = createStepAttemptCacheFromAttempts([attempt]);\n\n    expect(cache.get(\"my-unique-step-name\")).toBe(attempt);\n    expect(cache.get(\"other-name\")).toBeUndefined();\n  });\n});\n\ndescribe(\"getCachedStepAttempt\", () => {\n  test(\"returns cached attempt when present\", () => {\n    const attempt = createMockStepAttempt({ stepName: \"cached-step\" });\n    const cache: StepAttemptCache = new Map([[\"cached-step\", attempt]]);\n\n    const result = getCachedStepAttempt(cache, \"cached-step\");\n\n    expect(result).toBe(attempt);\n  });\n\n  test(\"returns undefined when step not in cache\", () => {\n    const cache: StepAttemptCache = new Map();\n\n    const result = getCachedStepAttempt(cache, \"missing-step\");\n\n    expect(result).toBeUndefined();\n  });\n\n  test(\"returns undefined for similar but different step names\", () => {\n    const attempt = createMockStepAttempt({ stepName: \"step-1\" });\n    const cache: StepAttemptCache = new Map([[\"step-1\", attempt]]);\n\n    expect(getCachedStepAttempt(cache, \"step-2\")).toBeUndefined();\n    expect(getCachedStepAttempt(cache, \"Step-1\")).toBeUndefined();\n    expect(getCachedStepAttempt(cache, \"step-1 \")).toBeUndefined();\n  });\n});\n\ndescribe(\"hasCompletedStep\", () => {\n  test(\"returns true when step is in cache\", () => {\n    const attempt = createMockStepAttempt({ stepName: \"step-x\" });\n    const cache: StepAttemptCache = new Map([[\"step-x\", attempt]]);\n\n    expect(hasCompletedStep(cache, \"step-x\")).toBe(true);\n  });\n\n  test(\"returns false when step is not in cache\", () => {\n    const cache: StepAttemptCache = new Map();\n\n    expect(hasCompletedStep(cache, \"step-y\")).toBe(false);\n  });\n\n  test(\"returns false for empty cache\", () => {\n    const cache: StepAttemptCache = new Map();\n\n    expect(hasCompletedStep(cache, \"any-step\")).toBe(false);\n  });\n});\n\ndescribe(\"addToStepAttemptCache\", () => {\n  test(\"adds attempt to empty cache\", () => {\n    const cache: StepAttemptCache = new Map();\n    const attempt = createMockStepAttempt({ stepName: \"new-step\" });\n\n    const newCache = addToStepAttemptCache(cache, attempt);\n\n    expect(newCache.size).toBe(1);\n    expect(newCache.get(\"new-step\")).toBe(attempt);\n  });\n\n  test(\"adds attempt to existing cache\", () => {\n    const existing = createMockStepAttempt({ stepName: \"existing-step\" });\n    const cache: StepAttemptCache = new Map([[\"existing-step\", existing]]);\n    const newAttempt = createMockStepAttempt({ stepName: \"new-step\" });\n\n    const newCache = addToStepAttemptCache(cache, newAttempt);\n\n    expect(newCache.size).toBe(2);\n    expect(newCache.get(\"existing-step\")).toBe(existing);\n    expect(newCache.get(\"new-step\")).toBe(newAttempt);\n  });\n\n  test(\"does not mutate original cache (immutable)\", () => {\n    const existing = createMockStepAttempt({ stepName: \"existing-step\" });\n    const cache: StepAttemptCache = new Map([[\"existing-step\", existing]]);\n    const newAttempt = createMockStepAttempt({ stepName: \"new-step\" });\n\n    const newCache = addToStepAttemptCache(cache, newAttempt);\n\n    expect(cache.size).toBe(1);\n    expect(cache.has(\"new-step\")).toBe(false);\n    expect(newCache.size).toBe(2);\n  });\n\n  test(\"overwrites existing entry with same step name\", () => {\n    const original = createMockStepAttempt({\n      stepName: \"step\",\n      output: \"original\",\n    });\n    const cache: StepAttemptCache = new Map([[\"step\", original]]);\n    const replacement = createMockStepAttempt({\n      stepName: \"step\",\n      output: \"replacement\",\n    });\n\n    const newCache = addToStepAttemptCache(cache, replacement);\n\n    expect(newCache.size).toBe(1);\n    expect(newCache.get(\"step\")?.output).toBe(\"replacement\");\n  });\n});\n\ndescribe(\"normalizeStepOutput\", () => {\n  test(\"passes through string values\", () => {\n    expect(normalizeStepOutput(\"hello\")).toBe(\"hello\");\n  });\n\n  test(\"passes through number values\", () => {\n    expect(normalizeStepOutput(42)).toBe(42);\n    expect(normalizeStepOutput(3.14)).toBe(3.14);\n    expect(normalizeStepOutput(0)).toBe(0);\n    expect(normalizeStepOutput(-1)).toBe(-1);\n  });\n\n  test(\"passes through boolean values\", () => {\n    expect(normalizeStepOutput(true)).toBe(true);\n    expect(normalizeStepOutput(false)).toBe(false);\n  });\n\n  test(\"passes through null\", () => {\n    expect(normalizeStepOutput(null)).toBeNull();\n  });\n\n  test(\"converts undefined to null\", () => {\n    // eslint-disable-next-line unicorn/no-useless-undefined\n    expect(normalizeStepOutput(undefined)).toBeNull();\n  });\n\n  test(\"passes through object values\", () => {\n    const obj = { foo: \"bar\", nested: { baz: 123 } };\n    expect(normalizeStepOutput(obj)).toBe(obj);\n  });\n\n  test(\"passes through array values\", () => {\n    const arr = [1, 2, 3];\n    expect(normalizeStepOutput(arr)).toBe(arr);\n  });\n\n  test(\"passes through empty object\", () => {\n    const obj = {};\n    expect(normalizeStepOutput(obj)).toBe(obj);\n  });\n\n  test(\"passes through empty array\", () => {\n    const arr: unknown[] = [];\n    expect(normalizeStepOutput(arr)).toBe(arr);\n  });\n});\n\ndescribe(\"calculateSleepResumeAt\", () => {\n  test(\"calculates resume time from duration string\", () => {\n    const now = 1_000_000;\n    const result = calculateSleepResumeAt(\"5s\", now);\n\n    expect(result).toEqual(ok(new Date(now + 5000)));\n  });\n\n  test(\"calculates resume time with milliseconds\", () => {\n    const now = 1_000_000;\n    const result = calculateSleepResumeAt(\"500ms\", now);\n\n    expect(result).toEqual(ok(new Date(now + 500)));\n  });\n\n  test(\"calculates resume time with minutes\", () => {\n    const now = 1_000_000;\n    const result = calculateSleepResumeAt(\"2m\", now);\n\n    expect(result).toEqual(ok(new Date(now + 2 * 60 * 1000)));\n  });\n\n  test(\"calculates resume time with hours\", () => {\n    const now = 1_000_000;\n    const result = calculateSleepResumeAt(\"1h\", now);\n\n    expect(result).toEqual(ok(new Date(now + 60 * 60 * 1000)));\n  });\n\n  test(\"uses Date.now() when now is not provided\", () => {\n    const before = Date.now();\n    const result = calculateSleepResumeAt(\"1s\");\n    const after = Date.now();\n\n    expect(result.ok).toBe(true);\n    if (result.ok) {\n      const resumeTime = result.value.getTime();\n      expect(resumeTime).toBeGreaterThanOrEqual(before + 1000);\n      expect(resumeTime).toBeLessThanOrEqual(after + 1000);\n    }\n  });\n\n  test(\"returns error for invalid duration\", () => {\n    // @ts-expect-error testing invalid input\n    const result = calculateSleepResumeAt(\"invalid\");\n\n    expect(result.ok).toBe(false);\n    if (!result.ok) {\n      expect(result.error).toBeInstanceOf(Error);\n    }\n  });\n\n  test(\"returns error for empty duration\", () => {\n    // @ts-expect-error testing invalid input\n    const result = calculateSleepResumeAt(\"\");\n\n    expect(result.ok).toBe(false);\n  });\n});\n\ndescribe(\"createSleepContext\", () => {\n  test(\"creates sleep context with ISO string timestamp\", () => {\n    const resumeAt = new Date(\"2025-06-15T10:30:00.000Z\");\n    const context = createSleepContext(resumeAt);\n\n    expect(context).toEqual({\n      kind: \"sleep\",\n      resumeAt: \"2025-06-15T10:30:00.000Z\",\n    });\n  });\n\n  test(\"preserves millisecond precision\", () => {\n    const resumeAt = new Date(\"2025-01-01T00:00:00.123Z\");\n    const context = createSleepContext(resumeAt);\n\n    expect(context.resumeAt).toBe(\"2025-01-01T00:00:00.123Z\");\n  });\n\n  test(\"always has kind set to sleep\", () => {\n    const resumeAt = new Date();\n    const context = createSleepContext(resumeAt);\n\n    expect(context.kind).toBe(\"sleep\");\n  });\n\n  test(\"creates context from current date\", () => {\n    const now = new Date();\n    const context = createSleepContext(now);\n\n    expect(context.resumeAt).toBe(now.toISOString());\n  });\n});\n\nfunction createMockStepAttempt(overrides: Partial<StepAttempt> = {}): StepAttempt {\n  return {\n    namespaceId: \"default\",\n    id: \"step-1\",\n    workflowRunId: \"workflow-1\",\n    stepName: \"test-step\",\n    kind: \"function\",\n    status: \"completed\",\n    config: {},\n    context: null,\n    output: null,\n    error: null,\n    childWorkflowRunNamespaceId: null,\n    childWorkflowRunId: null,\n    startedAt: new Date(\"2025-01-01T00:00:00Z\"),\n    finishedAt: new Date(\"2025-01-01T00:00:01Z\"),\n    createdAt: new Date(\"2025-01-01T00:00:00Z\"),\n    updatedAt: new Date(\"2025-01-01T00:00:01Z\"),\n    ...overrides,\n  };\n}\n"],"names":["describe","expect","test","ok","addToStepAttemptCache","calculateSleepResumeAt","createSleepContext","createStepAttemptCacheFromAttempts","getCachedStepAttempt","hasCompletedStep","normalizeStepOutput","cache","size","toBe","attempt","createMockStepAttempt","stepName","status","output","get","error","message","attempts","has","toBeUndefined","Map","result","newCache","existing","newAttempt","original","replacement","toBeNull","undefined","obj","foo","nested","baz","arr","now","toEqual","Date","before","after","resumeTime","value","getTime","toBeGreaterThanOrEqual","toBeLessThanOrEqual","toBeInstanceOf","Error","resumeAt","context","kind","toISOString","overrides","namespaceId","id","workflowRunId","config","childWorkflowRunNamespaceId","childWorkflowRunId","startedAt","finishedAt","createdAt","updatedAt"],"mappings":"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"}

package/dist/core/workflow.d.ts

@@ -0,0 +1,78 @@
+import type { SerializedError } from "./error";
+import type { JsonValue } from "./json";
+import type { StandardSchemaV1 } from "./schema";
+/**
+ * Status of a workflow run through its lifecycle.
+ */
+export type WorkflowRunStatus = "pending" | "running" | "sleeping" | "succeeded" | "completed" | "failed" | "canceled";
+/**
+ * WorkflowRun represents a single execution instance of a workflow.
+ */
+export interface WorkflowRun {
+    namespaceId: string;
+    id: string;
+    workflowName: string;
+    version: string | null;
+    status: WorkflowRunStatus;
+    idempotencyKey: string | null;
+    config: JsonValue;
+    context: JsonValue | null;
+    input: JsonValue | null;
+    output: JsonValue | null;
+    error: SerializedError | null;
+    attempts: number;
+    parentStepAttemptNamespaceId: string | null;
+    parentStepAttemptId: string | null;
+    workerId: string | null;
+    availableAt: Date | null;
+    deadlineAt: Date | null;
+    startedAt: Date | null;
+    finishedAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Infers the input type from a Standard Schema.
+ */
+export type SchemaInput<TSchema, Fallback> = TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferInput<TSchema> : Fallback;
+/**
+ * Infers the output type from a Standard Schema.
+ */
+export type SchemaOutput<TSchema, Fallback> = TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : Fallback;
+/**
+ * Result of input validation - either success with a value or failure with an
+ * error message.
+ */
+export type ValidationResult<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Default configuration for result polling when awaiting workflow completion.
+ */
+export declare const DEFAULT_WORKFLOW_RESULT_CONFIG: {
+    /** Polling interval in milliseconds (1 second) */
+    readonly pollIntervalMs: 1000;
+    /** Timeout in milliseconds (5 minutes) */
+    readonly timeoutMs: number;
+};
+/**
+ * Validate input against a Standard Schema. Pure async function that validates
+ * input and returns a ValidationResult.
+ * @param schema - The Standard Schema to validate against (or null/undefined
+ * for no validation)
+ * @param input - The input value to validate
+ * @returns A ValidationResult containing either the validated value or an error
+ * message
+ */
+export declare function validateInput<RunInput, Input>(schema: StandardSchemaV1<RunInput, Input> | null | undefined, input: RunInput | undefined): Promise<ValidationResult<Input>>;
+/**
+ * Check if a workflow run status represents a terminal state.
+ * @param status - The workflow run status
+ * @returns True if the status is terminal (completed, failed, or canceled)
+ */
+export declare function isTerminalStatus(status: string): status is "succeeded" | "completed" | "failed" | "canceled";
+//# sourceMappingURL=workflow.d.ts.map

package/dist/core/workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../src/core/workflow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GACzB,SAAS,GACT,SAAS,GACT,UAAU,GACV,WAAW,GACX,WAAW,GACX,QAAQ,GACR,UAAU,CAAC;AAEf;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,MAAM,EAAE,SAAS,CAAC;IAClB,OAAO,EAAE,SAAS,GAAG,IAAI,CAAC;IAC1B,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IACzB,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,4BAA4B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,WAAW,EAAE,IAAI,GAAG,IAAI,CAAC;IACzB,UAAU,EAAE,IAAI,GAAG,IAAI,CAAC;IACxB,SAAS,EAAE,IAAI,GAAG,IAAI,CAAC;IACvB,UAAU,EAAE,IAAI,GAAG,IAAI,CAAC;IACxB,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,OAAO,EAAE,QAAQ,IAAI,OAAO,SAAS,gBAAgB,GACzE,gBAAgB,CAAC,UAAU,CAAC,OAAO,CAAC,GACpC,QAAQ,CAAC;AAEb;;GAEG;AACH,MAAM,MAAM,YAAY,CAAC,OAAO,EAAE,QAAQ,IAAI,OAAO,SAAS,gBAAgB,GAC1E,gBAAgB,CAAC,WAAW,CAAC,OAAO,CAAC,GACrC,QAAQ,CAAC;AAEb;;;GAGG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAElG;;GAEG;AACH,eAAO,MAAM,8BAA8B;IACzC,kDAAkD;;IAElD,0CAA0C;;CAElC,CAAC;AAEX;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,KAAK,EACjD,MAAM,EAAE,gBAAgB,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,IAAI,GAAG,SAAS,EAC5D,KAAK,EAAE,QAAQ,GAAG,SAAS,GAC1B,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CA4BlC;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,GACb,MAAM,IAAI,WAAW,GAAG,WAAW,GAAG,QAAQ,GAAG,UAAU,CAI7D"}

package/dist/core/workflow.js

@@ -0,0 +1,46 @@
+/**
+ * Default configuration for result polling when awaiting workflow completion.
+ */ export const DEFAULT_WORKFLOW_RESULT_CONFIG = {
+    /** Polling interval in milliseconds (1 second) */ pollIntervalMs: 1000,
+    /** Timeout in milliseconds (5 minutes) */ timeoutMs: 5 * 60 * 1000
+};
+/**
+ * Validate input against a Standard Schema. Pure async function that validates
+ * input and returns a ValidationResult.
+ * @param schema - The Standard Schema to validate against (or null/undefined
+ * for no validation)
+ * @param input - The input value to validate
+ * @returns A ValidationResult containing either the validated value or an error
+ * message
+ */ export async function validateInput(schema, input) {
+    // No schema means no validation - pass through as-is
+    if (!schema) {
+        return {
+            success: true,
+            value: input
+        };
+    }
+    // Validate using Standard Schema v1 protocol https://standardschema.dev
+    const result = schema["~standard"].validate(input);
+    const resolved = await Promise.resolve(result);
+    if (resolved.issues) {
+        const messages = resolved.issues.length > 0 ? resolved.issues.map((issue)=>issue.message).join("; ") : "Validation failed";
+        return {
+            success: false,
+            error: messages
+        };
+    }
+    return {
+        success: true,
+        value: resolved.value
+    };
+}
+/**
+ * Check if a workflow run status represents a terminal state.
+ * @param status - The workflow run status
+ * @returns True if the status is terminal (completed, failed, or canceled)
+ */ export function isTerminalStatus(status) {
+    return status === "succeeded" || status === "completed" || status === "failed" || status === "canceled";
+}
+
+//# sourceMappingURL=workflow.js.map

package/dist/core/workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/workflow.ts"],"sourcesContent":["import type { SerializedError } from \"./error\";\nimport type { JsonValue } from \"./json\";\nimport type { StandardSchemaV1 } from \"./schema\";\n\n/**\n * Status of a workflow run through its lifecycle.\n */\nexport type WorkflowRunStatus =\n  | \"pending\"\n  | \"running\"\n  | \"sleeping\"\n  | \"succeeded\" // deprecated in favor of 'completed'\n  | \"completed\"\n  | \"failed\"\n  | \"canceled\";\n\n/**\n * WorkflowRun represents a single execution instance of a workflow.\n */\nexport interface WorkflowRun {\n  namespaceId: string;\n  id: string;\n  workflowName: string;\n  version: string | null;\n  status: WorkflowRunStatus;\n  idempotencyKey: string | null;\n  config: JsonValue; // user-defined config\n  context: JsonValue | null; // runtime execution metadata\n  input: JsonValue | null;\n  output: JsonValue | null;\n  error: SerializedError | null;\n  attempts: number;\n  parentStepAttemptNamespaceId: string | null;\n  parentStepAttemptId: string | null;\n  workerId: string | null;\n  availableAt: Date | null;\n  deadlineAt: Date | null;\n  startedAt: Date | null;\n  finishedAt: Date | null;\n  createdAt: Date;\n  updatedAt: Date;\n}\n\n/**\n * Infers the input type from a Standard Schema.\n */\nexport type SchemaInput<TSchema, Fallback> = TSchema extends StandardSchemaV1\n  ? StandardSchemaV1.InferInput<TSchema>\n  : Fallback;\n\n/**\n * Infers the output type from a Standard Schema.\n */\nexport type SchemaOutput<TSchema, Fallback> = TSchema extends StandardSchemaV1\n  ? StandardSchemaV1.InferOutput<TSchema>\n  : Fallback;\n\n/**\n * Result of input validation - either success with a value or failure with an\n * error message.\n */\nexport type ValidationResult<T> = { success: true; value: T } | { success: false; error: string };\n\n/**\n * Default configuration for result polling when awaiting workflow completion.\n */\nexport const DEFAULT_WORKFLOW_RESULT_CONFIG = {\n  /** Polling interval in milliseconds (1 second) */\n  pollIntervalMs: 1000,\n  /** Timeout in milliseconds (5 minutes) */\n  timeoutMs: 5 * 60 * 1000,\n} as const;\n\n/**\n * Validate input against a Standard Schema. Pure async function that validates\n * input and returns a ValidationResult.\n * @param schema - The Standard Schema to validate against (or null/undefined\n * for no validation)\n * @param input - The input value to validate\n * @returns A ValidationResult containing either the validated value or an error\n * message\n */\nexport async function validateInput<RunInput, Input>(\n  schema: StandardSchemaV1<RunInput, Input> | null | undefined,\n  input: RunInput | undefined,\n): Promise<ValidationResult<Input>> {\n  // No schema means no validation - pass through as-is\n  if (!schema) {\n    return {\n      success: true,\n      value: input as unknown as Input,\n    };\n  }\n\n  // Validate using Standard Schema v1 protocol https://standardschema.dev\n  const result = schema[\"~standard\"].validate(input);\n  const resolved = await Promise.resolve(result);\n\n  if (resolved.issues) {\n    const messages =\n      resolved.issues.length > 0\n        ? resolved.issues.map((issue) => issue.message).join(\"; \")\n        : \"Validation failed\";\n    return {\n      success: false,\n      error: messages,\n    };\n  }\n\n  return {\n    success: true,\n    value: resolved.value,\n  };\n}\n\n/**\n * Check if a workflow run status represents a terminal state.\n * @param status - The workflow run status\n * @returns True if the status is terminal (completed, failed, or canceled)\n */\nexport function isTerminalStatus(\n  status: string,\n): status is \"succeeded\" | \"completed\" | \"failed\" | \"canceled\" {\n  return (\n    status === \"succeeded\" || status === \"completed\" || status === \"failed\" || status === \"canceled\"\n  );\n}\n"],"names":["DEFAULT_WORKFLOW_RESULT_CONFIG","pollIntervalMs","timeoutMs","validateInput","schema","input","success","value","result","validate","resolved","Promise","resolve","issues","messages","length","map","issue","message","join","error","isTerminalStatus","status"],"mappings":"AA+DA;;CAEC,GACD,OAAO,MAAMA,iCAAiC;IAC5C,gDAAgD,GAChDC,gBAAgB;IAChB,wCAAwC,GACxCC,WAAW,IAAI,KAAK;AACtB,EAAW;AAEX;;;;;;;;CAQC,GACD,OAAO,eAAeC,cACpBC,MAA4D,EAC5DC,KAA2B;IAE3B,qDAAqD;IACrD,IAAI,CAACD,QAAQ;QACX,OAAO;YACLE,SAAS;YACTC,OAAOF;QACT;IACF;IAEA,wEAAwE;IACxE,MAAMG,SAASJ,MAAM,CAAC,YAAY,CAACK,QAAQ,CAACJ;IAC5C,MAAMK,WAAW,MAAMC,QAAQC,OAAO,CAACJ;IAEvC,IAAIE,SAASG,MAAM,EAAE;QACnB,MAAMC,WACJJ,SAASG,MAAM,CAACE,MAAM,GAAG,IACrBL,SAASG,MAAM,CAACG,GAAG,CAAC,CAACC,QAAUA,MAAMC,OAAO,EAAEC,IAAI,CAAC,QACnD;QACN,OAAO;YACLb,SAAS;YACTc,OAAON;QACT;IACF;IAEA,OAAO;QACLR,SAAS;QACTC,OAAOG,SAASH,KAAK;IACvB;AACF;AAEA;;;;CAIC,GACD,OAAO,SAASc,iBACdC,MAAc;IAEd,OACEA,WAAW,eAAeA,WAAW,eAAeA,WAAW,YAAYA,WAAW;AAE1F"}

package/dist/core/workflow.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=workflow.test.d.ts.map

package/dist/core/workflow.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.test.d.ts","sourceRoot":"","sources":["../../src/core/workflow.test.ts"],"names":[],"mappings":""}