openworkflow 0.5.0 → 0.6.0

package/dist/core/duration.test.js

@@ -0,0 +1,263 @@
+import { parseDuration } from "./duration.js";
+import { ok, err } from "./result.js";
+import { describe, expect, test } from "vitest";
+describe("parseDuration", () => {
+    describe("milliseconds", () => {
+        test("parses integer milliseconds", () => {
+            expect(parseDuration("100ms")).toEqual(ok(100));
+            expect(parseDuration("1ms")).toEqual(ok(1));
+            expect(parseDuration("5000ms")).toEqual(ok(5000));
+        });
+        test("parses decimal milliseconds", () => {
+            expect(parseDuration("1.5ms")).toEqual(ok(1.5));
+            expect(parseDuration("10.25ms")).toEqual(ok(10.25));
+        });
+        test("parses milliseconds with long format", () => {
+            expect(parseDuration("53 milliseconds")).toEqual(ok(53));
+            expect(parseDuration("17 msecs")).toEqual(ok(17));
+            expect(parseDuration("100 millisecond")).toEqual(ok(100));
+        });
+        test("parses numbers without unit as milliseconds", () => {
+            expect(parseDuration("100")).toEqual(ok(100));
+            expect(parseDuration("1000")).toEqual(ok(1000));
+        });
+        test("parses negative milliseconds", () => {
+            expect(parseDuration("-100ms")).toEqual(ok(-100));
+            expect(parseDuration("-100 milliseconds")).toEqual(ok(-100));
+        });
+    });
+    describe("seconds", () => {
+        test("parses integer seconds", () => {
+            expect(parseDuration("1s")).toEqual(ok(1000));
+            expect(parseDuration("5s")).toEqual(ok(5000));
+            expect(parseDuration("60s")).toEqual(ok(60_000));
+        });
+        test("parses decimal seconds", () => {
+            expect(parseDuration("1.5s")).toEqual(ok(1500));
+            expect(parseDuration("0.1s")).toEqual(ok(100));
+            expect(parseDuration("2.5s")).toEqual(ok(2500));
+            expect(parseDuration("0.001s")).toEqual(ok(1));
+        });
+        test("parses seconds with long format", () => {
+            expect(parseDuration("1 sec")).toEqual(ok(1000));
+            expect(parseDuration("5 seconds")).toEqual(ok(5000));
+            expect(parseDuration("10 secs")).toEqual(ok(10_000));
+        });
+        test("parses seconds with leading decimal", () => {
+            expect(parseDuration(".5s")).toEqual(ok(500));
+            expect(parseDuration(".5ms")).toEqual(ok(0.5));
+        });
+        test("parses negative seconds", () => {
+            expect(parseDuration("-5s")).toEqual(ok(-5000));
+            expect(parseDuration("-.5s")).toEqual(ok(-500));
+        });
+    });
+    describe("minutes", () => {
+        test("parses integer minutes", () => {
+            expect(parseDuration("1m")).toEqual(ok(60 * 1000));
+            expect(parseDuration("5m")).toEqual(ok(5 * 60 * 1000));
+            expect(parseDuration("30m")).toEqual(ok(30 * 60 * 1000));
+        });
+        test("parses decimal minutes", () => {
+            expect(parseDuration("1.5m")).toEqual(ok(1.5 * 60 * 1000));
+            expect(parseDuration("0.5m")).toEqual(ok(30 * 1000));
+        });
+        test("parses minutes with long format", () => {
+            expect(parseDuration("1 min")).toEqual(ok(60_000));
+            expect(parseDuration("5 minutes")).toEqual(ok(5 * 60 * 1000));
+            expect(parseDuration("10 mins")).toEqual(ok(10 * 60 * 1000));
+        });
+    });
+    describe("hours", () => {
+        test("parses integer hours", () => {
+            expect(parseDuration("1h")).toEqual(ok(60 * 60 * 1000));
+            expect(parseDuration("2h")).toEqual(ok(2 * 60 * 60 * 1000));
+            expect(parseDuration("24h")).toEqual(ok(24 * 60 * 60 * 1000));
+        });
+        test("parses decimal hours", () => {
+            expect(parseDuration("1.5h")).toEqual(ok(1.5 * 60 * 60 * 1000));
+            expect(parseDuration("0.25h")).toEqual(ok(15 * 60 * 1000));
+        });
+        test("parses hours with long format", () => {
+            expect(parseDuration("1 hr")).toEqual(ok(3_600_000));
+            expect(parseDuration("2 hours")).toEqual(ok(2 * 60 * 60 * 1000));
+            expect(parseDuration("3 hrs")).toEqual(ok(3 * 60 * 60 * 1000));
+            expect(parseDuration("1.5 hours")).toEqual(ok(5_400_000));
+        });
+        test("parses negative hours", () => {
+            expect(parseDuration("-1.5h")).toEqual(ok(-5_400_000));
+            expect(parseDuration("-10.5h")).toEqual(ok(-37_800_000));
+            expect(parseDuration("-.5h")).toEqual(ok(-1_800_000));
+            expect(parseDuration("-1.5 hours")).toEqual(ok(-5_400_000));
+            expect(parseDuration("-.5 hr")).toEqual(ok(-1_800_000));
+        });
+    });
+    describe("days", () => {
+        test("parses integer days", () => {
+            expect(parseDuration("1d")).toEqual(ok(24 * 60 * 60 * 1000));
+            expect(parseDuration("7d")).toEqual(ok(7 * 24 * 60 * 60 * 1000));
+            expect(parseDuration("30d")).toEqual(ok(30 * 24 * 60 * 60 * 1000));
+        });
+        test("parses decimal days", () => {
+            expect(parseDuration("1.5d")).toEqual(ok(1.5 * 24 * 60 * 60 * 1000));
+            expect(parseDuration("0.5d")).toEqual(ok(12 * 60 * 60 * 1000));
+        });
+        test("parses days with long format", () => {
+            expect(parseDuration("2 days")).toEqual(ok(172_800_000));
+            expect(parseDuration("1 day")).toEqual(ok(24 * 60 * 60 * 1000));
+        });
+    });
+    describe("weeks", () => {
+        test("parses integer weeks", () => {
+            expect(parseDuration("1w")).toEqual(ok(7 * 24 * 60 * 60 * 1000));
+            expect(parseDuration("2w")).toEqual(ok(2 * 7 * 24 * 60 * 60 * 1000));
+            expect(parseDuration("3w")).toEqual(ok(1_814_400_000));
+        });
+        test("parses decimal weeks", () => {
+            expect(parseDuration("1.5w")).toEqual(ok(1.5 * 7 * 24 * 60 * 60 * 1000));
+            expect(parseDuration("0.5w")).toEqual(ok(3.5 * 24 * 60 * 60 * 1000));
+        });
+        test("parses weeks with long format", () => {
+            expect(parseDuration("1 week")).toEqual(ok(604_800_000));
+            expect(parseDuration("2 weeks")).toEqual(ok(2 * 7 * 24 * 60 * 60 * 1000));
+        });
+    });
+    describe("months", () => {
+        test("parses integer months", () => {
+            expect(parseDuration("1mo")).toEqual(ok(2_629_800_000));
+            expect(parseDuration("2mo")).toEqual(ok(2 * 2_629_800_000));
+            expect(parseDuration("6mo")).toEqual(ok(6 * 2_629_800_000));
+        });
+        test("parses decimal months", () => {
+            expect(parseDuration("1.5mo")).toEqual(ok(1.5 * 2_629_800_000));
+            expect(parseDuration("0.5mo")).toEqual(ok(0.5 * 2_629_800_000));
+        });
+        test("parses months with long format", () => {
+            expect(parseDuration("1 month")).toEqual(ok(2_629_800_000));
+            expect(parseDuration("2 months")).toEqual(ok(2 * 2_629_800_000));
+        });
+    });
+    describe("years", () => {
+        test("parses integer years", () => {
+            expect(parseDuration("1y")).toEqual(ok(31_557_600_000));
+            expect(parseDuration("2y")).toEqual(ok(2 * 31_557_600_000));
+            expect(parseDuration("5y")).toEqual(ok(5 * 31_557_600_000));
+        });
+        test("parses decimal years", () => {
+            expect(parseDuration("1.5y")).toEqual(ok(1.5 * 31_557_600_000));
+            expect(parseDuration("0.5y")).toEqual(ok(0.5 * 31_557_600_000));
+        });
+        test("parses years with long format", () => {
+            expect(parseDuration("1 year")).toEqual(ok(31_557_600_000));
+            expect(parseDuration("2 years")).toEqual(ok(2 * 31_557_600_000));
+            expect(parseDuration("1 yr")).toEqual(ok(31_557_600_000));
+            expect(parseDuration("2 yrs")).toEqual(ok(2 * 31_557_600_000));
+        });
+    });
+    describe("case insensitivity", () => {
+        test("parses case-insensitive units", () => {
+            expect(parseDuration("5S")).toEqual(ok(5000));
+            expect(parseDuration("5M")).toEqual(ok(5 * 60 * 1000));
+            expect(parseDuration("5H")).toEqual(ok(5 * 60 * 60 * 1000));
+            expect(parseDuration("5D")).toEqual(ok(5 * 24 * 60 * 60 * 1000));
+            expect(parseDuration("5W")).toEqual(ok(5 * 7 * 24 * 60 * 60 * 1000));
+        });
+        test("parses case-insensitive long format", () => {
+            // @ts-expect-error - mixed-case (not in type but accepted at runtime)
+            expect(parseDuration("53 YeArS")).toEqual(ok(1_672_552_800_000));
+            // @ts-expect-error - mixed-case (not in type but accepted at runtime)
+            expect(parseDuration("53 WeEkS")).toEqual(ok(32_054_400_000));
+            // @ts-expect-error - mixed-case (not in type but accepted at runtime)
+            expect(parseDuration("53 DaYS")).toEqual(ok(4_579_200_000));
+            // @ts-expect-error - mixed-case (not in type but accepted at runtime)
+            expect(parseDuration("53 HoUrs")).toEqual(ok(190_800_000));
+            // @ts-expect-error - mixed-case (not in type but accepted at runtime)
+            expect(parseDuration("53 MiLliSeCondS")).toEqual(ok(53));
+        });
+    });
+    describe("whitespace handling", () => {
+        test("parses with single space", () => {
+            expect(parseDuration("1 s")).toEqual(ok(1000));
+            expect(parseDuration("5 m")).toEqual(ok(5 * 60 * 1000));
+            expect(parseDuration("2 h")).toEqual(ok(2 * 60 * 60 * 1000));
+        });
+        test("parses with multiple spaces", () => {
+            expect(parseDuration("1   s")).toEqual(ok(1000));
+            expect(parseDuration("5   m")).toEqual(ok(5 * 60 * 1000));
+        });
+    });
+    describe("edge cases", () => {
+        test("parses zero values", () => {
+            expect(parseDuration("0ms")).toEqual(ok(0));
+            expect(parseDuration("0s")).toEqual(ok(0));
+            expect(parseDuration("0m")).toEqual(ok(0));
+            expect(parseDuration("0h")).toEqual(ok(0));
+            expect(parseDuration("0d")).toEqual(ok(0));
+            expect(parseDuration("0")).toEqual(ok(0));
+        });
+        test("parses very small decimals", () => {
+            expect(parseDuration("0.001s")).toEqual(ok(1));
+            expect(parseDuration("0.1ms")).toEqual(ok(0.1));
+        });
+        test("parses large numbers", () => {
+            expect(parseDuration("999999ms")).toEqual(ok(999_999));
+            expect(parseDuration("1000s")).toEqual(ok(1_000_000));
+        });
+    });
+    describe("error cases", () => {
+        test("returns error on invalid format", () => {
+            // @ts-expect-error - invalid format
+            expect(parseDuration("invalid")).toEqual(err(new Error('Invalid duration format: "invalid"')));
+            // @ts-expect-error - invalid format
+            expect(parseDuration("10-.5")).toEqual(err(new Error('Invalid duration format: "10-.5"')));
+            // @ts-expect-error - invalid format
+            expect(parseDuration("foo")).toEqual(err(new Error('Invalid duration format: "foo"')));
+        });
+        test("returns error on empty string", () => {
+            // @ts-expect-error - empty string
+            expect(parseDuration("")).toEqual(err(new Error('Invalid duration format: ""')));
+        });
+        test("returns error on missing number", () => {
+            // @ts-expect-error - unit without number
+            expect(parseDuration("ms")).toEqual(err(new Error('Invalid duration format: "ms"')));
+            // @ts-expect-error - unit without number
+            expect(parseDuration("s")).toEqual(err(new Error('Invalid duration format: "s"')));
+            // @ts-expect-error - unit without number
+            expect(parseDuration("m")).toEqual(err(new Error('Invalid duration format: "m"')));
+            // @ts-expect-error - unit without number
+            expect(parseDuration("h")).toEqual(err(new Error('Invalid duration format: "h"')));
+        });
+        test("returns error on unknown unit", () => {
+            // @ts-expect-error - unknown unit
+            expect(parseDuration("100x")).toEqual(err(new Error('Invalid duration format: "100x"')));
+            // @ts-expect-error - unknown unit
+            expect(parseDuration("5z")).toEqual(err(new Error('Invalid duration format: "5z"')));
+        });
+        test("returns error on multiple units", () => {
+            // @ts-expect-error - multiple units
+            expect(parseDuration("1h30m")).toEqual(err(new Error('Invalid duration format: "1h30m"')));
+            // @ts-expect-error - multiple units
+            expect(parseDuration("5s100ms")).toEqual(err(new Error('Invalid duration format: "5s100ms"')));
+        });
+        test("returns error on leading/trailing spaces", () => {
+            expect(parseDuration(" 5s")).toEqual(err(new Error('Invalid duration format: " 5s"')));
+            // @ts-expect-error - trailing space
+            expect(parseDuration("5s ")).toEqual(err(new Error('Invalid duration format: "5s "')));
+        });
+        test("returns error on special characters", () => {
+            // @ts-expect-error - special characters
+            expect(parseDuration("5s!")).toEqual(err(new Error('Invalid duration format: "5s!"')));
+            // @ts-expect-error - special characters
+            expect(parseDuration("@5s")).toEqual(err(new Error('Invalid duration format: "@5s"')));
+        });
+        test("returns error on non-string types", () => {
+            expect(parseDuration(undefined)).toEqual(err(new TypeError("Invalid duration format: expected a string but received undefined")));
+            expect(parseDuration(null)).toEqual(err(new TypeError("Invalid duration format: expected a string but received object")));
+            expect(parseDuration([])).toEqual(err(new TypeError("Invalid duration format: expected a string but received object")));
+            expect(parseDuration({})).toEqual(err(new TypeError("Invalid duration format: expected a string but received object")));
+            expect(parseDuration(Number.NaN)).toEqual(err(new TypeError("Invalid duration format: expected a string but received number")));
+            expect(parseDuration(Number.POSITIVE_INFINITY)).toEqual(err(new TypeError("Invalid duration format: expected a string but received number")));
+            expect(parseDuration(Number.NEGATIVE_INFINITY)).toEqual(err(new TypeError("Invalid duration format: expected a string but received number")));
+        });
+    });
+});

package/dist/core/error.js

@@ -15,4 +15,3 @@ export function serializeError(error) {
         message: String(error),
     };
 }
-//# sourceMappingURL=error.js.map

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

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

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

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

package/dist/core/error.test.js

@@ -0,0 +1,60 @@
+import { serializeError } from "./error.js";
+import { describe, expect, test } from "vitest";
+describe("serializeError", () => {
+    test("serializes Error instance with name, message, and stack", () => {
+        const error = new Error("Something went wrong");
+        const result = serializeError(error);
+        expect(result.name).toBe("Error");
+        expect(result.message).toBe("Something went wrong");
+        expect(result.stack).toBeDefined();
+        expect(typeof result.stack).toBe("string");
+    });
+    test("serializes TypeError with correct name", () => {
+        const error = new TypeError("Invalid type");
+        const result = serializeError(error);
+        expect(result.name).toBe("TypeError");
+        expect(result.message).toBe("Invalid type");
+    });
+    test("serializes custom Error subclass", () => {
+        class CustomError extends Error {
+            constructor(message) {
+                super(message);
+                this.name = "CustomError";
+            }
+        }
+        const error = new CustomError("Custom error message");
+        const result = serializeError(error);
+        expect(result.name).toBe("CustomError");
+        expect(result.message).toBe("Custom error message");
+    });
+    test("serializes Error without stack as undefined", () => {
+        const error = new Error("No stack");
+        // @ts-expect-error testing edge case
+        error.stack = undefined;
+        const result = serializeError(error);
+        expect(result.stack).toBeUndefined();
+    });
+    test("serializes string to message", () => {
+        const result = serializeError("string error");
+        expect(result.message).toBe("string error");
+        expect(result.name).toBeUndefined();
+        expect(result.stack).toBeUndefined();
+    });
+    test("serializes number to message", () => {
+        const result = serializeError(42);
+        expect(result.message).toBe("42");
+    });
+    test("serializes null to message", () => {
+        const result = serializeError(null);
+        expect(result.message).toBe("null");
+    });
+    test("serializes undefined to message", () => {
+        // eslint-disable-next-line unicorn/no-useless-undefined
+        const result = serializeError(undefined);
+        expect(result.message).toBe("undefined");
+    });
+    test("serializes object to message using String()", () => {
+        const result = serializeError({ foo: "bar" });
+        expect(result.message).toBe("[object Object]");
+    });
+});

package/dist/core/json.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=json.js.map

package/dist/core/result.js

@@ -14,4 +14,3 @@ export function ok(value) {
 export function err(error) {
     return { ok: false, error };
 }
-//# sourceMappingURL=result.js.map

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

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

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

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

package/dist/core/result.test.js

@@ -0,0 +1,11 @@
+import { ok, err } from "./result.js";
+import { describe, expect, test } from "vitest";
+describe("Result helpers", () => {
+    test("ok creates success result", () => {
+        expect(ok(123)).toEqual({ ok: true, value: 123 });
+    });
+    test("err creates error result", () => {
+        const error = new Error("oops");
+        expect(err(error)).toEqual({ ok: false, error });
+    });
+});

package/dist/core/retry.js

@@ -4,4 +4,3 @@ export const DEFAULT_RETRY_POLICY = {
     maximumIntervalMs: 100 * 1000, // 100s
     maximumAttempts: Infinity, // unlimited
 };
-//# sourceMappingURL=retry.js.map

package/dist/core/schema.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=schema.js.map

package/dist/core/step.js

@@ -63,4 +63,3 @@ export function createSleepContext(resumeAt) {
         resumeAt: resumeAt.toISOString(),
     };
 }
-//# sourceMappingURL=step.js.map

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

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

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

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

package/dist/core/step.test.js

@@ -0,0 +1,266 @@
+import { ok } from "./result.js";
+import { createStepAttemptCacheFromAttempts, getCachedStepAttempt, addToStepAttemptCache, normalizeStepOutput, calculateSleepResumeAt, createSleepContext, } from "./step.js";
+import { describe, expect, test } from "vitest";
+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("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,
+    };
+}

package/dist/core/workflow.js

@@ -32,4 +32,3 @@ export async function validateInput(schema, input) {
         value: resolved.value,
     };
 }
-//# sourceMappingURL=workflow.js.map