openworkflow 0.6.0 → 0.6.1

package/dist/core/duration.test.js

@@ -1,263 +0,0 @@
-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.test.d.ts

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

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

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

package/dist/core/error.test.js

@@ -1,60 +0,0 @@
-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/result.test.d.ts

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

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

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

package/dist/core/result.test.js

@@ -1,11 +0,0 @@
-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/step.test.d.ts

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

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

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

package/dist/core/step.test.js

@@ -1,266 +0,0 @@
-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.test.d.ts

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

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

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