@adviser/cement 0.5.2 → 0.5.4

package/cjs/timeouted.test.cjs

@@ -33,79 +33,79 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-const promise_sleep_js_1 = require("./promise-sleep.cjs");
-const runtime_js_1 = require("./runtime.cjs");
+const vitest_1 = require("vitest");
+const cement_1 = require("@adviser/cement");
 const timeouted_js_1 = require("./timeouted.cjs");
-describe("timeoutAction - Success Cases", () => {
-    it("should return success for a fast promise", async () => {
+(0, vitest_1.describe)("timeoutAction - Success Cases", () => {
+    (0, vitest_1.it)("should return success for a fast promise", async () => {
         const result = await (0, timeouted_js_1.timeouted)(Promise.resolve("hello"), { timeout: 1000 });
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
-        expect(result.state).toBe("success");
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)(result.state).toBe("success");
         if ((0, timeouted_js_1.isSuccess)(result)) {
-            expect(result.value).toBe("hello");
+            (0, vitest_1.expect)(result.value).toBe("hello");
         }
-        expect(result.duration).toBeLessThan(100);
+        (0, vitest_1.expect)(result.duration).toBeLessThan(100);
     });
-    it("should return success for a fast action function", async () => {
+    (0, vitest_1.it)("should return success for a fast action function", async () => {
         const result = await (0, timeouted_js_1.timeouted)((ctrl) => {
-            expect(ctrl).toBeInstanceOf(AbortController);
+            (0, vitest_1.expect)(ctrl).toBeInstanceOf(AbortController);
             return Promise.resolve("world");
         }, { timeout: 1000 });
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
         if ((0, timeouted_js_1.isSuccess)(result)) {
-            expect(result.value).toBe("world");
+            (0, vitest_1.expect)(result.value).toBe("world");
         }
     });
-    it("should return success with custom context", async () => {
+    (0, vitest_1.it)("should return success with custom context", async () => {
         const ctx = { userId: "user123", requestId: 42 };
         const result = await (0, timeouted_js_1.timeouted)(Promise.resolve("data"), { timeout: 1000, ctx });
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
-        expect(result.ctx).toEqual(ctx);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)(result.ctx).toEqual(ctx);
     });
-    it("should not call onAbortAction on success", async () => {
-        const onAbort = vi.fn();
+    (0, vitest_1.it)("should not call onAbortAction on success", async () => {
+        const onAbort = vitest_1.vi.fn();
         const result = await (0, timeouted_js_1.timeouted)(Promise.resolve("success"), { timeout: 1000, onAbort });
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
-        expect(onAbort).not.toHaveBeenCalled();
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)(onAbort).not.toHaveBeenCalled();
     });
-    it("should cleanup event listeners on success", async () => {
+    (0, vitest_1.it)("should cleanup event listeners on success", async () => {
         const controller = new AbortController();
         const result = await (0, timeouted_js_1.timeouted)(Promise.resolve("success"), { timeout: 1000, signal: controller.signal });
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
         controller.abort();
-        expect(controller.signal.aborted).toBe(true);
+        (0, vitest_1.expect)(controller.signal.aborted).toBe(true);
     });
 });
-describe("timeoutAction - Timeout Cases", () => {
-    it("should timeout when action takes too long", async () => {
+(0, vitest_1.describe)("timeoutAction - Timeout Cases", () => {
+    (0, vitest_1.it)("should timeout when action takes too long", async () => {
         const result = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("too slow"), 200)), { timeout: 50 });
-        expect((0, timeouted_js_1.isTimeout)(result)).toBe(true);
-        expect(result.state).toBe("timeout");
-        expect(result.duration).toBeGreaterThanOrEqual(45);
-        expect(result.duration).toBeLessThan(100);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(result)).toBe(true);
+        (0, vitest_1.expect)(result.state).toBe("timeout");
+        (0, vitest_1.expect)(result.duration).toBeGreaterThanOrEqual(45);
+        (0, vitest_1.expect)(result.duration).toBeLessThan(100);
     });
-    it("should call onTimeout callback on timeout", async () => {
-        const onTimeout = vi.fn();
+    (0, vitest_1.it)("should call onTimeout callback on timeout", async () => {
+        const onTimeout = vitest_1.vi.fn();
         const result = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("slow"), 200)), { timeout: 50, onTimeout });
-        expect((0, timeouted_js_1.isTimeout)(result)).toBe(true);
-        expect(onTimeout).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(result)).toBe(true);
+        (0, vitest_1.expect)(onTimeout).toHaveBeenCalledTimes(1);
     });
-    it("should call onAbortAction on timeout", async () => {
-        const onAbort = vi.fn();
+    (0, vitest_1.it)("should call onAbortAction on timeout", async () => {
+        const onAbort = vitest_1.vi.fn();
         const result = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("slow"), 200)), {
             timeout: 50,
             onAbort,
         });
-        expect((0, timeouted_js_1.isTimeout)(result)).toBe(true);
-        expect(onAbort).toHaveBeenCalledTimes(0);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(result)).toBe(true);
+        (0, vitest_1.expect)(onAbort).toHaveBeenCalledTimes(0);
     });
-    it("should abort the controller on timeout", async () => {
+    (0, vitest_1.it)("should abort the controller on timeout", async () => {
         const controller = new AbortController();
         const result = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("slow"), 200)), { timeout: 50, controller });
-        expect((0, timeouted_js_1.isTimeout)(result)).toBe(true);
-        expect(controller.signal.aborted).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(result)).toBe(true);
+        (0, vitest_1.expect)(controller.signal.aborted).toBe(false);
     });
-    it("should allow action to use abort signal on timeout", async () => {
+    (0, vitest_1.it)("should allow action to use abort signal on timeout", async () => {
         let wasAborted = false;
         const result = await (0, timeouted_js_1.timeouted)(async (ctrl) => {
             return new Promise((resolve) => {
@@ -115,13 +115,13 @@ describe("timeoutAction - Timeout Cases", () => {
                 setTimeout(() => resolve("done"), 200);
             });
         }, { timeout: 50 });
-        expect((0, timeouted_js_1.isTimeout)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(result)).toBe(true);
         await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(wasAborted).toBe(false);
+        (0, vitest_1.expect)(wasAborted).toBe(false);
     });
 });
-describe("timeoutAction - Abort Cases", () => {
-    it("should abort when external signal is triggered", async () => {
+(0, vitest_1.describe)("timeoutAction - Abort Cases", () => {
+    (0, vitest_1.it)("should abort when external signal is triggered", async () => {
         const controller = new AbortController();
         const promise = (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("data"), 200)), {
             timeout: 1000,
@@ -129,14 +129,14 @@ describe("timeoutAction - Abort Cases", () => {
         });
         setTimeout(() => controller.abort("user cancelled"), 50);
         const result = await promise;
-        expect((0, timeouted_js_1.isAborted)(result)).toBe(true);
-        expect(result.state).toBe("aborted");
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(result)).toBe(true);
+        (0, vitest_1.expect)(result.state).toBe("aborted");
         if ((0, timeouted_js_1.isAborted)(result)) {
-            expect(result.reason).toBe("user cancelled");
+            (0, vitest_1.expect)(result.reason).toBe("user cancelled");
         }
     });
-    it("should call onAbort callback with reason", async () => {
-        const onAbort = vi.fn();
+    (0, vitest_1.it)("should call onAbort callback with reason", async () => {
+        const onAbort = vitest_1.vi.fn();
         const controller = new AbortController();
         const abortReason = new Error("User initiated abort");
         const promise = (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("data"), 200)), {
@@ -146,15 +146,15 @@ describe("timeoutAction - Abort Cases", () => {
         });
         setTimeout(() => controller.abort(abortReason), 50);
         const result = await promise;
-        expect((0, timeouted_js_1.isAborted)(result)).toBe(true);
-        expect(onAbort).toHaveBeenCalledTimes(1);
-        expect(onAbort).toHaveBeenCalledWith(abortReason);
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(result)).toBe(true);
+        (0, vitest_1.expect)(onAbort).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(onAbort).toHaveBeenCalledWith(abortReason);
     });
-    it("should propagate abort to internal controller", async () => {
+    (0, vitest_1.it)("should propagate abort to internal controller", async () => {
         const externalController = new AbortController();
         const internalController = new AbortController();
         const promise = (0, timeouted_js_1.timeouted)(async (ctrl) => {
-            expect(ctrl).toBe(internalController);
+            (0, vitest_1.expect)(ctrl).toBe(internalController);
             return new Promise((resolve) => {
                 setTimeout(() => resolve("data"), 200);
             });
@@ -165,10 +165,10 @@ describe("timeoutAction - Abort Cases", () => {
         });
         setTimeout(() => externalController.abort("cancelled"), 50);
         const result = await promise;
-        expect((0, timeouted_js_1.isAborted)(result)).toBe(true);
-        expect(internalController.signal.aborted).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(result)).toBe(true);
+        (0, vitest_1.expect)(internalController.signal.aborted).toBe(true);
     });
-    it("should cleanup event listeners on abort", async () => {
+    (0, vitest_1.it)("should cleanup event listeners on abort", async () => {
         const controller = new AbortController();
         const promise = (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("data"), 200)), {
             timeout: 1000,
@@ -176,11 +176,11 @@ describe("timeoutAction - Abort Cases", () => {
         });
         setTimeout(() => controller.abort(), 50);
         const result = await promise;
-        expect((0, timeouted_js_1.isAborted)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(result)).toBe(true);
     });
-    it("should handle abort with undefined reason", async () => {
+    (0, vitest_1.it)("should handle abort with undefined reason", async () => {
         const controller = new AbortController();
-        const onAbort = vi.fn();
+        const onAbort = vitest_1.vi.fn();
         const promise = (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("data"), 200)), {
             timeout: 1000,
             signal: controller.signal,
@@ -188,87 +188,87 @@ describe("timeoutAction - Abort Cases", () => {
         });
         setTimeout(() => controller.abort(), 50);
         const result = await promise;
-        expect((0, timeouted_js_1.isAborted)(result)).toBe(true);
-        expect(onAbort.mock.calls[0][0].message).toContain("aborted");
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(result)).toBe(true);
+        (0, vitest_1.expect)(onAbort.mock.calls[0][0].message).toContain("aborted");
     });
 });
-describe("timeoutAction - Error Cases", () => {
-    it("should handle promise rejection", async () => {
+(0, vitest_1.describe)("timeoutAction - Error Cases", () => {
+    (0, vitest_1.it)("should handle promise rejection", async () => {
         const testError = new Error("Something went wrong");
         const result = await (0, timeouted_js_1.timeouted)(Promise.reject(testError), { timeout: 1000 });
-        expect((0, timeouted_js_1.isError)(result)).toBe(true);
-        expect(result.state).toBe("error");
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(result)).toBe(true);
+        (0, vitest_1.expect)(result.state).toBe("error");
         if ((0, timeouted_js_1.isError)(result)) {
-            expect(result.error).toBe(testError);
+            (0, vitest_1.expect)(result.error).toBe(testError);
         }
     });
-    it("should handle action function throwing synchronously", async () => {
+    (0, vitest_1.it)("should handle action function throwing synchronously", async () => {
         const testError = new Error("Sync error");
         const result = await (0, timeouted_js_1.timeouted)(() => {
             throw testError;
         }, { timeout: 1000 });
-        expect((0, timeouted_js_1.isError)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(result)).toBe(true);
         if ((0, timeouted_js_1.isError)(result)) {
-            expect(result.error).toBe(testError);
+            (0, vitest_1.expect)(result.error).toBe(testError);
         }
     });
-    it("should handle action function rejecting asynchronously", async () => {
+    (0, vitest_1.it)("should handle action function rejecting asynchronously", async () => {
         const testError = new Error("Async error");
         const result = await (0, timeouted_js_1.timeouted)(() => {
             throw testError;
         }, { timeout: 1000 });
-        expect((0, timeouted_js_1.isError)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(result)).toBe(true);
         if ((0, timeouted_js_1.isError)(result)) {
-            expect(result.error).toBe(testError);
+            (0, vitest_1.expect)(result.error).toBe(testError);
         }
     });
-    it("should call onError callback on error", async () => {
-        const onError = vi.fn();
+    (0, vitest_1.it)("should call onError callback on error", async () => {
+        const onError = vitest_1.vi.fn();
         const testError = new Error("Test error");
         const result = await (0, timeouted_js_1.timeouted)(Promise.reject(testError), { timeout: 1000, onError });
-        expect((0, timeouted_js_1.isError)(result)).toBe(true);
-        expect(onError).toHaveBeenCalledTimes(1);
-        expect(onError).toHaveBeenCalledWith(testError);
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(result)).toBe(true);
+        (0, vitest_1.expect)(onError).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(onError).toHaveBeenCalledWith(testError);
     });
-    it("should call onAbortAction on error", async () => {
+    (0, vitest_1.it)("should call onAbortAction on error", async () => {
         const testError = new Error("Test error");
-        const onAbort = vi.fn();
+        const onAbort = vitest_1.vi.fn();
         const result = await (0, timeouted_js_1.timeouted)(Promise.reject(testError), { timeout: 1000, onAbort });
-        expect((0, timeouted_js_1.isError)(result)).toBe(true);
-        expect(onAbort).toHaveBeenCalledTimes(0);
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(result)).toBe(true);
+        (0, vitest_1.expect)(onAbort).toHaveBeenCalledTimes(0);
     });
-    it("should convert non-Error rejection to Error", async () => {
+    (0, vitest_1.it)("should convert non-Error rejection to Error", async () => {
         const result = await (0, timeouted_js_1.timeouted)(Promise.reject(new Error("string error")), { timeout: 1000 });
-        expect((0, timeouted_js_1.isError)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(result)).toBe(true);
         if ((0, timeouted_js_1.isError)(result)) {
-            expect(result.error).toBeInstanceOf(Error);
+            (0, vitest_1.expect)(result.error).toBeInstanceOf(Error);
         }
     });
-    it("should handle synchronous throw of non-Error value", async () => {
+    (0, vitest_1.it)("should handle synchronous throw of non-Error value", async () => {
         const result = await (0, timeouted_js_1.timeouted)(() => {
             throw new Error("string throw");
         }, { timeout: 1000 });
-        expect((0, timeouted_js_1.isError)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(result)).toBe(true);
         if ((0, timeouted_js_1.isError)(result)) {
-            expect(result.error).toBeInstanceOf(Error);
-            expect(result.error.message).toBe("string throw");
+            (0, vitest_1.expect)(result.error).toBeInstanceOf(Error);
+            (0, vitest_1.expect)(result.error.message).toBe("string throw");
         }
     });
 });
-describe("Type Guards", () => {
-    it("isSuccess should work correctly", async () => {
+(0, vitest_1.describe)("Type Guards", () => {
+    (0, vitest_1.it)("isSuccess should work correctly", async () => {
         const successResult = await (0, timeouted_js_1.timeouted)(Promise.resolve(42), { timeout: 1000 });
         const timeoutResult = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve(42), 200)), { timeout: 50 });
-        expect((0, timeouted_js_1.isSuccess)(successResult)).toBe(true);
-        expect((0, timeouted_js_1.isSuccess)(timeoutResult)).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(successResult)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(timeoutResult)).toBe(false);
     });
-    it("isTimeout should work correctly", async () => {
+    (0, vitest_1.it)("isTimeout should work correctly", async () => {
         const successResult = await (0, timeouted_js_1.timeouted)(Promise.resolve(42), { timeout: 1000 });
         const timeoutResult = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve(42), 200)), { timeout: 50 });
-        expect((0, timeouted_js_1.isTimeout)(successResult)).toBe(false);
-        expect((0, timeouted_js_1.isTimeout)(timeoutResult)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(successResult)).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(timeoutResult)).toBe(true);
     });
-    it("isAborted should work correctly", async () => {
+    (0, vitest_1.it)("isAborted should work correctly", async () => {
         const controller = new AbortController();
         const promise = (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve(42), 200)), {
             timeout: 1000,
@@ -277,27 +277,27 @@ describe("Type Guards", () => {
         setTimeout(() => controller.abort(), 50);
         const abortedResult = await promise;
         const successResult = await (0, timeouted_js_1.timeouted)(Promise.resolve(42), { timeout: 1000 });
-        expect((0, timeouted_js_1.isAborted)(successResult)).toBe(false);
-        expect((0, timeouted_js_1.isAborted)(abortedResult)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(successResult)).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(abortedResult)).toBe(true);
     });
-    it("isError should work correctly", async () => {
+    (0, vitest_1.it)("isError should work correctly", async () => {
         const successResult = await (0, timeouted_js_1.timeouted)(Promise.resolve(42), { timeout: 1000 });
         const errorResult = await (0, timeouted_js_1.timeouted)(Promise.reject(new Error("fail")), { timeout: 1000 });
-        expect((0, timeouted_js_1.isError)(successResult)).toBe(false);
-        expect((0, timeouted_js_1.isError)(errorResult)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(successResult)).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(errorResult)).toBe(true);
     });
 });
-describe("Helper Functions", () => {
-    describe("unwrap", () => {
-        it("should return value on success", async () => {
+(0, vitest_1.describe)("Helper Functions", () => {
+    (0, vitest_1.describe)("unwrap", () => {
+        (0, vitest_1.it)("should return value on success", async () => {
             const result = await (0, timeouted_js_1.timeouted)(Promise.resolve(42), { timeout: 1000 });
-            expect((0, timeouted_js_1.unwrap)(result)).toBe(42);
+            (0, vitest_1.expect)((0, timeouted_js_1.unwrap)(result)).toBe(42);
         });
-        it("should throw on timeout", async () => {
+        (0, vitest_1.it)("should throw on timeout", async () => {
             const result = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve(42), 200)), { timeout: 50 });
-            expect(() => (0, timeouted_js_1.unwrap)(result)).toThrow("TimeoutResult is not success: timeout");
+            (0, vitest_1.expect)(() => (0, timeouted_js_1.unwrap)(result)).toThrow("TimeoutResult is not success: timeout");
         });
-        it("should throw on abort", async () => {
+        (0, vitest_1.it)("should throw on abort", async () => {
             const controller = new AbortController();
             const promise = (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve(42), 200)), {
                 timeout: 1000,
@@ -305,23 +305,23 @@ describe("Helper Functions", () => {
             });
             setTimeout(() => controller.abort(), 50);
             const result = await promise;
-            expect(() => (0, timeouted_js_1.unwrap)(result)).toThrow("TimeoutResult is not success: aborted");
+            (0, vitest_1.expect)(() => (0, timeouted_js_1.unwrap)(result)).toThrow("TimeoutResult is not success: aborted");
         });
-        it("should throw on error", async () => {
+        (0, vitest_1.it)("should throw on error", async () => {
             const result = await (0, timeouted_js_1.timeouted)(Promise.reject(new Error("fail")), { timeout: 1000 });
-            expect(() => (0, timeouted_js_1.unwrap)(result)).toThrow("TimeoutResult is not success: error");
+            (0, vitest_1.expect)(() => (0, timeouted_js_1.unwrap)(result)).toThrow("TimeoutResult is not success: error");
         });
     });
-    describe("unwrapOr", () => {
-        it("should return value on success", async () => {
+    (0, vitest_1.describe)("unwrapOr", () => {
+        (0, vitest_1.it)("should return value on success", async () => {
             const result = await (0, timeouted_js_1.timeouted)(Promise.resolve(42), { timeout: 1000 });
-            expect((0, timeouted_js_1.unwrapOr)(result, 0)).toBe(42);
+            (0, vitest_1.expect)((0, timeouted_js_1.unwrapOr)(result, 0)).toBe(42);
         });
-        it("should return default on timeout", async () => {
+        (0, vitest_1.it)("should return default on timeout", async () => {
             const result = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve(42), 200)), { timeout: 50 });
-            expect((0, timeouted_js_1.unwrapOr)(result, 999)).toBe(999);
+            (0, vitest_1.expect)((0, timeouted_js_1.unwrapOr)(result, 999)).toBe(999);
         });
-        it("should return default on abort", async () => {
+        (0, vitest_1.it)("should return default on abort", async () => {
             const controller = new AbortController();
             const promise = (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve(42), 200)), {
                 timeout: 1000,
@@ -329,87 +329,87 @@ describe("Helper Functions", () => {
             });
             setTimeout(() => controller.abort(), 50);
             const result = await promise;
-            expect((0, timeouted_js_1.unwrapOr)(result, -1)).toBe(-1);
+            (0, vitest_1.expect)((0, timeouted_js_1.unwrapOr)(result, -1)).toBe(-1);
         });
-        it("should return default on error", async () => {
+        (0, vitest_1.it)("should return default on error", async () => {
             const result = await (0, timeouted_js_1.timeouted)(Promise.reject(new Error("fail")), { timeout: 1000 });
-            expect((0, timeouted_js_1.unwrapOr)(result, 100)).toBe(100);
+            (0, vitest_1.expect)((0, timeouted_js_1.unwrapOr)(result, 100)).toBe(100);
         });
     });
 });
-describe("Edge Cases", () => {
-    it("should handle zero timeout", async () => {
+(0, vitest_1.describe)("Edge Cases", () => {
+    (0, vitest_1.it)("should handle zero timeout", async () => {
         const result = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("data"), 10)), { timeout: 0 });
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
-        expect((0, timeouted_js_1.unwrap)(result)).toBe("data");
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.unwrap)(result)).toBe("data");
     });
-    it("should handle very short timeout", async () => {
+    (0, vitest_1.it)("should handle very short timeout", async () => {
         const result = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("data"), 100)), { timeout: 1 });
-        expect((0, timeouted_js_1.isTimeout)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(result)).toBe(true);
     });
-    it("should handle action that completes exactly at timeout", async () => {
+    (0, vitest_1.it)("should handle action that completes exactly at timeout", async () => {
         const result = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("data"), 50)), { timeout: 50 });
-        expect(["success", "timeout"]).toContain(result.state);
+        (0, vitest_1.expect)(["success", "timeout"]).toContain(result.state);
     });
-    it("should track duration accurately", async () => {
+    (0, vitest_1.it)("should track duration accurately", async () => {
         const start = Date.now();
         const result = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("data"), 100)), { timeout: 1000 });
         const actualDuration = Date.now() - start;
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
-        expect(result.duration).toBeGreaterThanOrEqual(95);
-        expect(result.duration).toBeLessThan(150);
-        expect(Math.abs(result.duration - actualDuration)).toBeLessThan(10);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)(result.duration).toBeGreaterThanOrEqual(95);
+        (0, vitest_1.expect)(result.duration).toBeLessThan(150);
+        (0, vitest_1.expect)(Math.abs(result.duration - actualDuration)).toBeLessThan(10);
     });
-    it("should handle default timeout value (30000ms)", async () => {
+    (0, vitest_1.it)("should handle default timeout value (30000ms)", async () => {
         const result = await (0, timeouted_js_1.timeouted)(Promise.resolve("data"));
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
     });
-    it("should handle undefined context", async () => {
+    (0, vitest_1.it)("should handle undefined context", async () => {
         const result = await (0, timeouted_js_1.timeouted)(Promise.resolve("data"), { timeout: 1000 });
-        expect(result.ctx).toBeUndefined();
+        (0, vitest_1.expect)(result.ctx).toBeUndefined();
     });
-    it("should pass abort controller to action function", async () => {
+    (0, vitest_1.it)("should pass abort controller to action function", async () => {
         let receivedController = null;
         const result = await (0, timeouted_js_1.timeouted)((ctrl) => {
             receivedController = ctrl;
             return Promise.resolve("data");
         }, { timeout: 1000 });
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
-        expect(receivedController).toBeInstanceOf(AbortController);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)(receivedController).toBeInstanceOf(AbortController);
     });
-    it("should use external controller when provided", async () => {
+    (0, vitest_1.it)("should use external controller when provided", async () => {
         const externalController = new AbortController();
         const result = await (0, timeouted_js_1.timeouted)((ctrl) => {
-            expect(ctrl).toBe(externalController);
+            (0, vitest_1.expect)(ctrl).toBe(externalController);
             return Promise.resolve("data");
         }, { timeout: 1000, controller: externalController });
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
     });
-    it("should handle negative timeout (treated as 30000ms default)", async () => {
+    (0, vitest_1.it)("should handle negative timeout (treated as 30000ms default)", async () => {
         const result = await (0, timeouted_js_1.timeouted)(Promise.resolve("data"), { timeout: -100 });
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
     });
 });
-describe("Callback Interactions", () => {
-    it("should call all appropriate callbacks on timeout", async () => {
-        const onTimeout = vi.fn();
-        const onAbort = vi.fn();
-        const onError = vi.fn();
+(0, vitest_1.describe)("Callback Interactions", () => {
+    (0, vitest_1.it)("should call all appropriate callbacks on timeout", async () => {
+        const onTimeout = vitest_1.vi.fn();
+        const onAbort = vitest_1.vi.fn();
+        const onError = vitest_1.vi.fn();
         const result = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("slow"), 200)), {
             timeout: 50,
             onTimeout,
             onAbort,
             onError,
         });
-        expect((0, timeouted_js_1.isTimeout)(result)).toBe(true);
-        expect(onTimeout).toHaveBeenCalledTimes(1);
-        expect(onAbort).not.toHaveBeenCalled();
-        expect(onError).not.toHaveBeenCalled();
-    });
-    it("should call all appropriate callbacks on abort", async () => {
-        const onTimeout = vi.fn();
-        const onAbort = vi.fn();
-        const onError = vi.fn();
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(result)).toBe(true);
+        (0, vitest_1.expect)(onTimeout).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(onAbort).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(onError).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)("should call all appropriate callbacks on abort", async () => {
+        const onTimeout = vitest_1.vi.fn();
+        const onAbort = vitest_1.vi.fn();
+        const onError = vitest_1.vi.fn();
         const controller = new AbortController();
         const promise = (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("data"), 200)), {
             timeout: 1000,
@@ -420,106 +420,106 @@ describe("Callback Interactions", () => {
         });
         setTimeout(() => controller.abort("user action"), 50);
         const result = await promise;
-        expect((0, timeouted_js_1.isAborted)(result)).toBe(true);
-        expect(onTimeout).not.toHaveBeenCalled();
-        expect(onAbort).toHaveBeenCalledTimes(1);
-        expect(onAbort).toHaveBeenCalledWith("user action");
-        expect(onError).not.toHaveBeenCalled();
-    });
-    it("should call all appropriate callbacks on error", async () => {
-        const onTimeout = vi.fn();
-        const onAbort = vi.fn();
-        const onError = vi.fn();
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(result)).toBe(true);
+        (0, vitest_1.expect)(onTimeout).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(onAbort).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(onAbort).toHaveBeenCalledWith("user action");
+        (0, vitest_1.expect)(onError).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)("should call all appropriate callbacks on error", async () => {
+        const onTimeout = vitest_1.vi.fn();
+        const onAbort = vitest_1.vi.fn();
+        const onError = vitest_1.vi.fn();
         const testError = new Error("test");
         const result = await (0, timeouted_js_1.timeouted)(Promise.reject(testError), { timeout: 1000, onTimeout, onAbort, onError });
-        expect((0, timeouted_js_1.isError)(result)).toBe(true);
-        expect(onTimeout).not.toHaveBeenCalled();
-        expect(onAbort).not.toHaveBeenCalled();
-        expect(onError).toHaveBeenCalledTimes(1);
-        expect(onError).toHaveBeenCalledWith(testError);
-    });
-    it("should not call any error callbacks on success", async () => {
-        const onTimeout = vi.fn();
-        const onAbort = vi.fn();
-        const onError = vi.fn();
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(result)).toBe(true);
+        (0, vitest_1.expect)(onTimeout).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(onAbort).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(onError).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(onError).toHaveBeenCalledWith(testError);
+    });
+    (0, vitest_1.it)("should not call any error callbacks on success", async () => {
+        const onTimeout = vitest_1.vi.fn();
+        const onAbort = vitest_1.vi.fn();
+        const onError = vitest_1.vi.fn();
         const result = await (0, timeouted_js_1.timeouted)(Promise.resolve("success"), { timeout: 1000, onTimeout, onAbort, onError });
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
-        expect(onTimeout).not.toHaveBeenCalled();
-        expect(onAbort).not.toHaveBeenCalled();
-        expect(onError).not.toHaveBeenCalled();
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)(onTimeout).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(onAbort).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(onError).not.toHaveBeenCalled();
     });
 });
-describe("isTimeouted isTypeGuard Consistency", () => {
-    it("isSuccess", async () => {
+(0, vitest_1.describe)("isTimeouted isTypeGuard Consistency", () => {
+    (0, vitest_1.it)("isSuccess", async () => {
         const timed = await (0, timeouted_js_1.timeouted)(Promise.resolve("data"), { timeout: 1000 });
-        expect((0, timeouted_js_1.isSuccess)(timed)).toBe(true);
-        expect(timed.isSuccess()).toBe(true);
-        expect((0, timeouted_js_1.isTimeout)(timed)).toBe(false);
-        expect(timed.isTimeout()).toBe(false);
-        expect((0, timeouted_js_1.isAborted)(timed)).toBe(false);
-        expect(timed.isAborted()).toBe(false);
-        expect((0, timeouted_js_1.isError)(timed)).toBe(false);
-        expect(timed.isError()).toBe(false);
-    });
-    it("isTimeout", async () => {
-        const timed = await (0, timeouted_js_1.timeouted)((0, promise_sleep_js_1.sleep)(10000), { timeout: 10 });
-        expect((0, timeouted_js_1.isSuccess)(timed)).toBe(false);
-        expect(timed.isSuccess()).toBe(false);
-        expect((0, timeouted_js_1.isTimeout)(timed)).toBe(true);
-        expect(timed.isTimeout()).toBe(true);
-        expect((0, timeouted_js_1.isAborted)(timed)).toBe(false);
-        expect(timed.isAborted()).toBe(false);
-        expect((0, timeouted_js_1.isError)(timed)).toBe(false);
-        expect(timed.isError()).toBe(false);
-    });
-    it("isAbort controller", async () => {
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(timed)).toBe(true);
+        (0, vitest_1.expect)(timed.isSuccess()).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isTimeout()).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isAborted()).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isError()).toBe(false);
+    });
+    (0, vitest_1.it)("isTimeout", async () => {
+        const timed = await (0, timeouted_js_1.timeouted)((0, cement_1.sleep)(10000), { timeout: 10 });
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isSuccess()).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(timed)).toBe(true);
+        (0, vitest_1.expect)(timed.isTimeout()).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isAborted()).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isError()).toBe(false);
+    });
+    (0, vitest_1.it)("isAbort controller", async () => {
         const controller = new AbortController();
         setTimeout(() => controller.abort(), 10);
-        const timed = await (0, timeouted_js_1.timeouted)((0, promise_sleep_js_1.sleep)(10000), { timeout: 100000, controller: controller });
-        expect((0, timeouted_js_1.isSuccess)(timed)).toBe(false);
-        expect(timed.isSuccess()).toBe(false);
-        expect((0, timeouted_js_1.isTimeout)(timed)).toBe(false);
-        expect(timed.isTimeout()).toBe(false);
-        expect((0, timeouted_js_1.isAborted)(timed)).toBe(true);
-        expect(timed.isAborted()).toBe(true);
-        expect((0, timeouted_js_1.isError)(timed)).toBe(false);
-        expect(timed.isError()).toBe(false);
-    });
-    it("isAbort signal", async () => {
+        const timed = await (0, timeouted_js_1.timeouted)((0, cement_1.sleep)(10000), { timeout: 100000, controller: controller });
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isSuccess()).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isTimeout()).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(timed)).toBe(true);
+        (0, vitest_1.expect)(timed.isAborted()).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isError()).toBe(false);
+    });
+    (0, vitest_1.it)("isAbort signal", async () => {
         const controller = new AbortController();
         setTimeout(() => controller.abort(), 10);
-        const timed = await (0, timeouted_js_1.timeouted)((0, promise_sleep_js_1.sleep)(10000), { timeout: 100000, signal: controller.signal });
-        expect((0, timeouted_js_1.isSuccess)(timed)).toBe(false);
-        expect(timed.isSuccess()).toBe(false);
-        expect((0, timeouted_js_1.isTimeout)(timed)).toBe(false);
-        expect(timed.isTimeout()).toBe(false);
-        expect((0, timeouted_js_1.isAborted)(timed)).toBe(true);
-        expect(timed.isAborted()).toBe(true);
-        expect((0, timeouted_js_1.isError)(timed)).toBe(false);
-        expect(timed.isError()).toBe(false);
-    });
-    it("isError", async () => {
+        const timed = await (0, timeouted_js_1.timeouted)((0, cement_1.sleep)(10000), { timeout: 100000, signal: controller.signal });
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isSuccess()).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isTimeout()).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(timed)).toBe(true);
+        (0, vitest_1.expect)(timed.isAborted()).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isError()).toBe(false);
+    });
+    (0, vitest_1.it)("isError", async () => {
         const timed = await (0, timeouted_js_1.timeouted)(Promise.reject(new Error("data")), { timeout: 1000 });
-        expect((0, timeouted_js_1.isSuccess)(timed)).toBe(false);
-        expect(timed.isSuccess()).toBe(false);
-        expect((0, timeouted_js_1.isTimeout)(timed)).toBe(false);
-        expect(timed.isTimeout()).toBe(false);
-        expect((0, timeouted_js_1.isAborted)(timed)).toBe(false);
-        expect(timed.isAborted()).toBe(false);
-        expect((0, timeouted_js_1.isError)(timed)).toBe(true);
-        expect(timed.isError()).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isSuccess()).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isTimeout()).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(timed)).toBe(false);
+        (0, vitest_1.expect)(timed.isAborted()).toBe(false);
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(timed)).toBe(true);
+        (0, vitest_1.expect)(timed.isError()).toBe(true);
     });
 });
-describe("Race Conditions", () => {
-    it("should handle success that wins race against timeout", async () => {
+(0, vitest_1.describe)("Race Conditions", () => {
+    (0, vitest_1.it)("should handle success that wins race against timeout", async () => {
         const result = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("fast"), 10)), { timeout: 100 });
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
     });
-    it("should handle timeout that wins race against slow promise", async () => {
+    (0, vitest_1.it)("should handle timeout that wins race against slow promise", async () => {
         const result = await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("slow"), 100)), { timeout: 10 });
-        expect((0, timeouted_js_1.isTimeout)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(result)).toBe(true);
     });
-    it("should handle abort that wins race against slow promise", async () => {
+    (0, vitest_1.it)("should handle abort that wins race against slow promise", async () => {
         const controller = new AbortController();
         const promise = (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("slow"), 200)), {
             timeout: 1000,
@@ -527,15 +527,15 @@ describe("Race Conditions", () => {
         });
         setTimeout(() => controller.abort(), 10);
         const result = await promise;
-        expect((0, timeouted_js_1.isAborted)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(result)).toBe(true);
     });
-    it("should handle error that wins race against timeout", async () => {
+    (0, vitest_1.it)("should handle error that wins race against timeout", async () => {
         const result = await (0, timeouted_js_1.timeouted)(new Promise((_, reject) => setTimeout(() => reject(new Error("fast error")), 10)), {
             timeout: 100,
         });
-        expect((0, timeouted_js_1.isError)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isError)(result)).toBe(true);
     });
-    it("should handle abort that wins race against timeout", async () => {
+    (0, vitest_1.it)("should handle abort that wins race against timeout", async () => {
         const controller = new AbortController();
         const promise = (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("data"), 500)), {
             timeout: 100,
@@ -543,15 +543,15 @@ describe("Race Conditions", () => {
         });
         setTimeout(() => controller.abort("quick abort"), 20);
         const result = await promise;
-        expect((0, timeouted_js_1.isAborted)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(result)).toBe(true);
         if ((0, timeouted_js_1.isAborted)(result)) {
-            expect(result.reason).toBe("quick abort");
+            (0, vitest_1.expect)(result.reason).toBe("quick abort");
         }
-        expect(result.duration).toBeLessThan(50);
+        (0, vitest_1.expect)(result.duration).toBeLessThan(50);
     });
 });
-describe("Real-World Scenarios", () => {
-    it("should handle fetch-like operation with timeout", async () => {
+(0, vitest_1.describe)("Real-World Scenarios", () => {
+    (0, vitest_1.it)("should handle fetch-like operation with timeout", async () => {
         const mockFetch = async (ctrl) => {
             return new Promise((resolve, reject) => {
                 const timeoutId = setTimeout(() => resolve({ data: "response" }), 100);
@@ -562,22 +562,22 @@ describe("Real-World Scenarios", () => {
             });
         };
         const result = await (0, timeouted_js_1.timeouted)(mockFetch, { timeout: 200 });
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
         if ((0, timeouted_js_1.isSuccess)(result)) {
-            expect(result.value.data).toBe("response");
+            (0, vitest_1.expect)(result.value.data).toBe("response");
         }
     });
-    it("should handle fetch timeout scenario", async () => {
+    (0, vitest_1.it)("should handle fetch timeout scenario", async () => {
         const mockSlowFetch = async () => {
             await new Promise((resolve) => setTimeout(resolve, 200));
             return { data: "slow response" };
         };
         const result = await (0, timeouted_js_1.timeouted)(mockSlowFetch, { timeout: 50 });
-        expect((0, timeouted_js_1.isTimeout)(result)).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(result)).toBe(true);
     });
-    it("should handle user cancellation during long operation", async () => {
+    (0, vitest_1.it)("should handle user cancellation during long operation", async () => {
         const controller = new AbortController();
-        const onAbort = vi.fn();
+        const onAbort = vitest_1.vi.fn();
         const promise = (0, timeouted_js_1.timeouted)(async (ctrl) => {
             for (let i = 0; i < 10; i++) {
                 if (ctrl.signal.aborted) {
@@ -589,10 +589,10 @@ describe("Real-World Scenarios", () => {
         }, { timeout: 10000, signal: controller.signal, onAbort });
         setTimeout(() => controller.abort("User clicked cancel"), 100);
         const result = await promise;
-        expect((0, timeouted_js_1.isAborted)(result)).toBe(true);
-        expect(onAbort).toHaveBeenCalledWith("User clicked cancel");
+        (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(result)).toBe(true);
+        (0, vitest_1.expect)(onAbort).toHaveBeenCalledWith("User clicked cancel");
     });
-    it("should track request context throughout operation", async () => {
+    (0, vitest_1.it)("should track request context throughout operation", async () => {
         const ctx = {
             requestId: "req-123",
             userId: "user-456",
@@ -602,11 +602,11 @@ describe("Real-World Scenarios", () => {
             await new Promise((resolve) => setTimeout(resolve, 50));
             return { status: "ok" };
         }, { timeout: 1000, ctx });
-        expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
-        expect(result.ctx).toEqual(ctx);
-        expect(result.duration).toBeGreaterThan(0);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+        (0, vitest_1.expect)(result.ctx).toEqual(ctx);
+        (0, vitest_1.expect)(result.duration).toBeGreaterThan(0);
     });
-    it("should handle retry logic pattern", async () => {
+    (0, vitest_1.it)("should handle retry logic pattern", async () => {
         let attempts = 0;
         const maxAttempts = 3;
         async function attemptOperation() {
@@ -624,31 +624,31 @@ describe("Real-World Scenarios", () => {
             return (0, timeouted_js_1.unwrapOr)(result, "failed");
         }
         const finalResult = await attemptOperation();
-        expect(finalResult).toBe("success");
-        expect(attempts).toBe(3);
+        (0, vitest_1.expect)(finalResult).toBe("success");
+        (0, vitest_1.expect)(attempts).toBe(3);
     });
-    it("should handle parallel operations with different timeouts", async () => {
+    (0, vitest_1.it)("should handle parallel operations with different timeouts", async () => {
         const results = await Promise.all([
             (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("fast"), 50)), { timeout: 100 }),
             (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("medium"), 150)), { timeout: 200 }),
             (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("slow"), 300)), { timeout: 100 }),
         ]);
-        expect((0, timeouted_js_1.isSuccess)(results[0])).toBe(true);
-        expect((0, timeouted_js_1.isSuccess)(results[1])).toBe(true);
-        expect((0, timeouted_js_1.isTimeout)(results[2])).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(results[0])).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(results[1])).toBe(true);
+        (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(results[2])).toBe(true);
     });
 });
-describe("Memory Leak Prevention", () => {
-    it("should not leak event listeners on success", async () => {
+(0, vitest_1.describe)("Memory Leak Prevention", () => {
+    (0, vitest_1.it)("should not leak event listeners on success", async () => {
         const controller = new AbortController();
         await (0, timeouted_js_1.timeouted)(Promise.resolve("data"), { timeout: 1000, signal: controller.signal });
-        expect(controller.signal.aborted).toBe(false);
+        (0, vitest_1.expect)(controller.signal.aborted).toBe(false);
     });
-    it("should not leak event listeners on timeout", async () => {
+    (0, vitest_1.it)("should not leak event listeners on timeout", async () => {
         const controller = new AbortController();
         await (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("slow"), 200)), { timeout: 50, signal: controller.signal });
     });
-    it("should not leak event listeners on abort", async () => {
+    (0, vitest_1.it)("should not leak event listeners on abort", async () => {
         const controller = new AbortController();
         const promise = (0, timeouted_js_1.timeouted)(new Promise((resolve) => setTimeout(() => resolve("data"), 200)), {
             timeout: 1000,
@@ -657,103 +657,133 @@ describe("Memory Leak Prevention", () => {
         setTimeout(() => controller.abort(), 50);
         await promise;
     });
-    it("should cleanup on multiple rapid calls", async () => {
+    (0, vitest_1.it)("should cleanup on multiple rapid calls", async () => {
         const controller = new AbortController();
         const promises = Array.from({ length: 10 }, (_, i) => (0, timeouted_js_1.timeouted)(Promise.resolve(i), { timeout: 100, signal: controller.signal }));
         const results = await Promise.all(promises);
-        expect(results.every(timeouted_js_1.isSuccess)).toBe(true);
+        (0, vitest_1.expect)(results.every(timeouted_js_1.isSuccess)).toBe(true);
     });
 });
-describe("Node.js Exit Prevention", () => {
+(0, vitest_1.describe)("Node.js Exit Prevention", () => {
     let runtime = undefined;
-    if ((0, runtime_js_1.runtimeFn)().isNodeIsh) {
+    if ((0, cement_1.runtimeFn)().isNodeIsh) {
         runtime = ["tsx", "-e"];
     }
-    if ((0, runtime_js_1.runtimeFn)().isDeno) {
+    if ((0, cement_1.runtimeFn)().isDeno) {
         runtime = ["deno", "eval"];
     }
-    it("not block node from exiting on success", async () => {
+    (0, vitest_1.it)("not block node from exiting on success", async () => {
         if (runtime) {
             const { $ } = await Promise.resolve().then(() => __importStar(require("zx")));
             const start = Date.now();
             await $ `${runtime} "import { timeouted } from './src/timeouted.ts'; import { sleep } from './src/promise-sleep.ts'; timeouted(sleep(200), { timeout: 10000 })"`;
             const duration = Date.now() - start;
-            expect(duration).toBeLessThan(2000);
+            (0, vitest_1.expect)(duration).toBeLessThan(2000);
         }
     });
-    it("block node from exiting on error", async () => {
+    (0, vitest_1.it)("block node from exiting on error", async () => {
         if (runtime) {
             const { $ } = await Promise.resolve().then(() => __importStar(require("zx")));
             const start = Date.now();
             await $ `${runtime} "import { timeouted } from './src/timeouted.ts'; timeouted(Promise.reject(new Error('fail')), { timeout: 10000 })"`;
             const duration = Date.now() - start;
-            expect(duration).toBeLessThan(2000);
+            (0, vitest_1.expect)(duration).toBeLessThan(2000);
         }
     });
-    it("block node from exiting on timeout", async () => {
+    (0, vitest_1.it)("block node from exiting on timeout", async () => {
         if (runtime) {
             const { $ } = await Promise.resolve().then(() => __importStar(require("zx")));
             const start = Date.now();
             await $ `${runtime} "import { timeouted } from './src/timeouted.ts'; timeouted(new Promise(() => {}), { timeout: 10 })"`;
             const duration = Date.now() - start;
-            expect(duration).toBeLessThan(2000);
+            (0, vitest_1.expect)(duration).toBeLessThan(2000);
         }
     });
 });
-describe("createTimeoutResult", () => {
-    it("should create success result", () => {
+(0, vitest_1.describe)("createTimeoutResult", () => {
+    (0, vitest_1.it)("should create success result", () => {
         const result = (0, timeouted_js_1.createTimeoutResult)({
             state: "success",
             value: "data",
+            duration: 100,
+            ctx: undefined,
         });
         if ((0, timeouted_js_1.isSuccess)(result)) {
-            expect((0, timeouted_js_1.isSuccess)(result)).toBe(true);
-            expect(result.value).toBe("data");
-            expect(result.duration).toBeGreaterThanOrEqual(0);
+            (0, vitest_1.expect)((0, timeouted_js_1.isSuccess)(result)).toBe(true);
+            (0, vitest_1.expect)(result.value).toBe("data");
+            (0, vitest_1.expect)(result.duration).toBeGreaterThanOrEqual(0);
         }
         else {
-            assert.fail("Result should be success");
+            vitest_1.assert.fail("Result should be success");
         }
     });
-    it("should create abort result", () => {
+    (0, vitest_1.it)("should create abort result", () => {
         const result = (0, timeouted_js_1.createTimeoutResult)({
             state: "aborted",
             reason: "user abort",
+            duration: 100,
+            ctx: undefined,
         });
         if ((0, timeouted_js_1.isAborted)(result)) {
-            expect((0, timeouted_js_1.isAborted)(result)).toBe(true);
-            expect(result.reason).toBe("user abort");
-            expect(result.duration).toBeGreaterThanOrEqual(0);
+            (0, vitest_1.expect)((0, timeouted_js_1.isAborted)(result)).toBe(true);
+            (0, vitest_1.expect)(result.reason).toBe("user abort");
+            (0, vitest_1.expect)(result.duration).toBeGreaterThanOrEqual(0);
         }
         else {
-            assert.fail("Result should be aborted");
+            vitest_1.assert.fail("Result should be aborted");
         }
     });
-    it("should create error result", () => {
+    (0, vitest_1.it)("should create error result", () => {
         const result = (0, timeouted_js_1.createTimeoutResult)({
             state: "error",
             error: new Error("user abort"),
+            duration: 100,
+            ctx: undefined,
         });
         if ((0, timeouted_js_1.isError)(result)) {
-            expect((0, timeouted_js_1.isError)(result)).toBe(true);
-            expect(result.error.message).toBe("user abort");
-            expect(result.duration).toBeGreaterThanOrEqual(0);
+            (0, vitest_1.expect)((0, timeouted_js_1.isError)(result)).toBe(true);
+            (0, vitest_1.expect)(result.error.message).toBe("user abort");
+            (0, vitest_1.expect)(result.duration).toBeGreaterThanOrEqual(0);
         }
         else {
-            assert.fail("Result should be error");
+            vitest_1.assert.fail("Result should be error");
         }
     });
-    it("should create timeout result", () => {
+    (0, vitest_1.it)("should create timeout result", () => {
         const result = (0, timeouted_js_1.createTimeoutResult)({
             state: "timeout",
+            duration: 100,
+            ctx: undefined,
         });
         if ((0, timeouted_js_1.isTimeout)(result)) {
-            expect((0, timeouted_js_1.isTimeout)(result)).toBe(true);
-            expect(result.duration).toBeGreaterThanOrEqual(0);
+            (0, vitest_1.expect)((0, timeouted_js_1.isTimeout)(result)).toBe(true);
+            (0, vitest_1.expect)(result.duration).toBeGreaterThanOrEqual(0);
         }
         else {
-            assert.fail("Result should be timeout");
+            vitest_1.assert.fail("Result should be timeout");
         }
     });
+    (0, vitest_1.it)("timeoutd return isTimeouted", async () => {
+        const result = await (0, timeouted_js_1.timeouted)(Promise.resolve("data"), { timeout: 1000 });
+        switch (true) {
+            case result.isSuccess(): {
+                (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+                break;
+            }
+            case result.isTimeout(): {
+                (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+                break;
+            }
+            case result.isAborted(): {
+                (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+                break;
+            }
+            case result.isError(): {
+                (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+                break;
+            }
+        }
+        (0, vitest_1.expectTypeOf)(result).toEqualTypeOf();
+    });
 });
 //# sourceMappingURL=timeouted.test.js.map