rexfect 0.0.7

package/dist/async/abortable.typeCheck.js

@@ -0,0 +1,138 @@
+/**
+ * Type check file for abortable functions and wrapper chaining.
+ * This file should compile without errors - no runtime tests needed.
+ *
+ * Run: npx tsc --noEmit src/async/abortable.typeCheck.ts
+ */
+import { abortable, } from "./abortable";
+// Note: wrappers are not yet implemented, so this file is disabled
+// import {
+//   retry,
+//   catchError,
+//   timeout,
+//   logging,
+//   debounce,
+//   throttle,
+// } from "./wrappers";
+// =============================================================================
+// Basic abortable creation
+// =============================================================================
+// Simple function with no args
+const noArgs = abortable(async () => "hello");
+noArgs;
+// Function with single arg
+const singleArg = abortable(async ({}, id) => ({ id, name: "test" }));
+singleArg;
+// Function with multiple args
+const multiArgs = abortable(async ({}, a, b, c) => a + b.length + (c ? 1 : 0));
+multiArgs;
+// Function using signal
+const withSignal = abortable(async ({ signal }, url) => {
+    const res = await fetch(url, { signal });
+    return res.json();
+});
+withSignal;
+// Function using safe
+const withSafe = abortable(async ({ safe }, id) => {
+    const result = await safe(Promise.resolve({ id }));
+    return result;
+});
+withSafe;
+// =============================================================================
+// Direct call and .withSignal() method
+// =============================================================================
+// Direct call - should accept the args
+void noArgs();
+void singleArg("123");
+void multiArgs(1, "test", true);
+// .withSignal() method - should accept signal + args
+const controller = new AbortController();
+void noArgs.withSignal(controller.signal);
+void singleArg.withSignal(controller.signal, "123");
+void multiArgs.withSignal(controller.signal, 1, "test", true);
+// =============================================================================
+// Single wrapper chaining
+// =============================================================================
+// Note: Wrapper functions are not yet implemented
+// These examples are commented out until wrappers are available
+// // retry() preserves types
+// const withRetry = singleArg.use(retry(3));
+// withRetry satisfies Abortable<[string], { id: string; name: string }>;
+// const _retryResult: Promise<{ id: string; name: string }> = withRetry("test");
+// =============================================================================
+// Multi-wrapper chaining
+// =============================================================================
+// Note: Wrapper chaining examples commented out until wrappers are available
+// =============================================================================
+// Custom wrapper creation
+// =============================================================================
+// Custom wrapper that doesn't change types
+const customPassThrough = (next) => async (ctx, ...args) => {
+    console.log("before");
+    const result = await next(ctx, ...args);
+    console.log("after");
+    return result;
+};
+const withCustom = singleArg.use(customPassThrough);
+withCustom;
+// API service with abortable methods (used in commented-out examples)
+const userApi = {
+    getUser: abortable(async ({ signal }, userId) => {
+        const res = await fetch(`/api/users/${userId}`, { signal });
+        return res.json();
+    }),
+    createUser: abortable(async ({ signal }, data) => {
+        const res = await fetch("/api/users", {
+            method: "POST",
+            body: JSON.stringify(data),
+            signal,
+        });
+        return res.json();
+    }),
+    getPost: abortable(async ({ signal }, postId) => {
+        const res = await fetch(`/api/posts/${postId}`, { signal });
+        return res.json();
+    }),
+};
+void userApi; // Mark as used for type checking
+// Wrap with retry and error handling (commented out until wrappers available)
+// const robustGetUser = userApi.getUser
+//   .use(retry({ retries: 3, delay: "backoff" }))
+//   .use(catchError((err) => console.error("Failed to get user:", err)))
+//   .use(timeout(10000));
+// Use the wrapped function (commented out)
+// async function fetchUserProfile(userId: string): Promise<User> {
+//   return robustGetUser(userId);
+// }
+// =============================================================================
+// Type preservation tests - ensure types are NOT widened to `any`
+// =============================================================================
+// Type error tests commented out until wrappers are available
+// =============================================================================
+// Edge cases
+// =============================================================================
+// Void return type (used in commented-out examples)
+const voidFn = abortable(async ({}, msg) => {
+    console.log(msg);
+});
+void voidFn; // Mark as used for type checking
+const complexFn = abortable(async ({}, page, _limit) => {
+    return {
+        users: [],
+        meta: { total: 0, page, hasMore: false },
+    };
+});
+void complexFn; // Mark as used for type checking
+// const wrappedComplex = complexFn
+//   .use(retry({ retries: 3, delay: 1000 }))
+//   .use(timeout(5000));
+// wrappedComplex satisfies Abortable<[number, number], ComplexData>;
+// Optional args (rest params style) - used in commented-out examples
+const optionalArgsFn = abortable(async ({}, required, optional) => {
+    return `${required}-${optional ?? 0}`;
+});
+void optionalArgsFn; // Mark as used for type checking
+// const wrappedOptional = optionalArgsFn.use(retry(3));
+// wrappedOptional satisfies Abortable<[string, (number | undefined)?], string>;
+console.log("All type checks passed!");
+//# sourceMappingURL=abortable.typeCheck.js.map

package/dist/async/abortable.typeCheck.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abortable.typeCheck.js","sourceRoot":"","sources":["../../src/async/abortable.typeCheck.ts"],"names":[],"mappings":"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"}

package/dist/async/async.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Async utility functions.
+ * Re-exports from utils for convenience.
+ */
+import { toPromise } from "./utils";
+export { toPromise };
+/**
+ * Delay utility for async operations.
+ */
+export declare const delay: (ms: number) => Promise<void>;
+/**
+ * Async utilities object.
+ */
+export declare const async: {
+    delay: (ms: number) => Promise<void>;
+    toPromise: typeof toPromise;
+};
+//# sourceMappingURL=async.d.ts.map

package/dist/async/async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.d.ts","sourceRoot":"","sources":["../../src/async/async.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,CAAC;AAErB;;GAEG;AACH,eAAO,MAAM,KAAK,GAAI,IAAI,MAAM,KAAG,OAAO,CAAC,IAAI,CAE9C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,KAAK;gBAPQ,MAAM,KAAG,OAAO,CAAC,IAAI,CAAC;;CAU/C,CAAC"}

package/dist/async/async.js

@@ -0,0 +1,20 @@
+/**
+ * Async utility functions.
+ * Re-exports from utils for convenience.
+ */
+import { toPromise } from "./utils";
+export { toPromise };
+/**
+ * Delay utility for async operations.
+ */
+export const delay = (ms) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+};
+/**
+ * Async utilities object.
+ */
+export const async = {
+    delay,
+    toPromise,
+};
+//# sourceMappingURL=async.js.map

package/dist/async/async.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.js","sourceRoot":"","sources":["../../src/async/async.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,CAAC;AAErB;;GAEG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,EAAU,EAAiB,EAAE;IACjD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;AAC3D,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,KAAK;IACL,SAAS;CACV,CAAC"}

package/dist/async/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * rexfect/async - Async utilities
+ *
+ * - read: Suspense mode for Signals (throws promise)
+ * - wait: Promise mode for Promise/Action (returns Promise)
+ * - loadable: Extract async state from Promise-valued signals
+ * - abortable: Wrap functions with cancellation support
+ */
+export { read } from "./read";
+export { wait } from "./wait";
+export { loadable } from "./loadable";
+export { abortable, isAbortable } from "./abortable";
+export type { LoadableResult, LoadableReturn } from "./loadable";
+export type { Abortable, AbortableContext, AbortableResult } from "./abortable";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/async/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAGrD,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjE,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC"}

package/dist/async/index.js

@@ -0,0 +1,13 @@
+/**
+ * rexfect/async - Async utilities
+ *
+ * - read: Suspense mode for Signals (throws promise)
+ * - wait: Promise mode for Promise/Action (returns Promise)
+ * - loadable: Extract async state from Promise-valued signals
+ * - abortable: Wrap functions with cancellation support
+ */
+export { read } from "./read";
+export { wait } from "./wait";
+export { loadable } from "./loadable";
+export { abortable, isAbortable } from "./abortable";
+//# sourceMappingURL=index.js.map

package/dist/async/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/async/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}

package/dist/async/loadable.d.ts

@@ -0,0 +1,7 @@
+import type { Signal, LoadableResult, LoadableReturn } from "../types";
+/**
+ * Extracts async state from a Promise-valued signal.
+ */
+export declare function loadable<TValue extends Promise<any> | null | undefined>(signal: Signal<TValue>): LoadableReturn<TValue>;
+export type { LoadableResult, LoadableReturn };
+//# sourceMappingURL=loadable.d.ts.map

package/dist/async/loadable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadable.d.ts","sourceRoot":"","sources":["../../src/async/loadable.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAgBvE;;GAEG;AACH,wBAAgB,QAAQ,CAAC,MAAM,SAAS,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,SAAS,EACrE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,GACrB,cAAc,CAAC,MAAM,CAAC,CAoCxB;AAGD,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,CAAC"}

package/dist/async/loadable.js

@@ -0,0 +1,52 @@
+import { atomInstance } from "../atom";
+import { getHooks } from "../hooks";
+import { trackPromise } from "./promiseCache";
+function getPromiseState(promise) {
+    const entry = trackPromise(promise);
+    switch (entry.status) {
+        case "pending":
+            return { loading: true, data: undefined, error: undefined };
+        case "fulfilled":
+            return { loading: false, data: entry.value, error: undefined };
+        case "rejected":
+            return { loading: false, data: undefined, error: entry.error };
+    }
+}
+/**
+ * Extracts async state from a Promise-valued signal.
+ */
+export function loadable(signal) {
+    const value = signal();
+    if (value === null || value === undefined) {
+        return null;
+    }
+    const promise = value;
+    const state = getPromiseState(promise);
+    // If pending, set up reactivity to re-run when promise settles
+    if (state.loading) {
+        const track = getHooks().track;
+        let onFinally;
+        if (track) {
+            let disposed = false;
+            const { signal, setter, dispose } = atomInstance({});
+            track(signal, () => {
+                disposed = true;
+                dispose();
+            });
+            onFinally = () => {
+                if (disposed)
+                    return;
+                // trigger re-run
+                setter({});
+            };
+        }
+        // Force re-evaluation when promise settles
+        // Use .then with both handlers to avoid unhandled rejection warnings
+        promise.then(onFinally, () => {
+            // Call onFinally but also suppress the unhandled rejection
+            onFinally?.();
+        });
+    }
+    return state;
+}
+//# sourceMappingURL=loadable.js.map

package/dist/async/loadable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadable.js","sourceRoot":"","sources":["../../src/async/loadable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,SAAS,eAAe,CAAI,OAAmB;IAC7C,MAAM,KAAK,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;IAEpC,QAAQ,KAAK,CAAC,MAAM,EAAE,CAAC;QACrB,KAAK,SAAS;YACZ,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;QAC9D,KAAK,WAAW;YACd,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;QACjE,KAAK,UAAU;YACb,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IACnE,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,QAAQ,CACtB,MAAsB;IAEtB,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC;IAEvB,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QAC1C,OAAO,IAA8B,CAAC;IACxC,CAAC;IAED,MAAM,OAAO,GAAG,KAAqB,CAAC;IACtC,MAAM,KAAK,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC;IAEvC,+DAA+D;IAC/D,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;QAClB,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC,KAAK,CAAC;QAC/B,IAAI,SAAmC,CAAC;QACxC,IAAI,KAAK,EAAE,CAAC;YACV,IAAI,QAAQ,GAAG,KAAK,CAAC;YACrB,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,YAAY,CAAC,EAAE,CAAC,CAAC;YACrD,KAAK,CAAC,MAAM,EAAE,GAAG,EAAE;gBACjB,QAAQ,GAAG,IAAI,CAAC;gBAChB,OAAO,EAAE,CAAC;YACZ,CAAC,CAAC,CAAC;YACH,SAAS,GAAG,GAAG,EAAE;gBACf,IAAI,QAAQ;oBAAE,OAAO;gBACrB,iBAAiB;gBACjB,MAAM,CAAC,EAAE,CAAC,CAAC;YACb,CAAC,CAAC;QACJ,CAAC;QACD,2CAA2C;QAC3C,qEAAqE;QACrE,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE;YAC3B,2DAA2D;YAC3D,SAAS,EAAE,EAAE,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,OAAO,KAA+B,CAAC;AACzC,CAAC"}

package/dist/async/loadable.test.d.ts

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

package/dist/async/loadable.test.d.ts.map

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

package/dist/async/loadable.test.js

@@ -0,0 +1,322 @@
+import { describe, it, expect, vi } from "vitest";
+import { atom } from "../atom";
+import { effect } from "../effect";
+import { loadable } from "./loadable";
+// Helper to create rejected promise without unhandled rejection warning
+function rejectedPromise(error) {
+    const p = Promise.reject(error);
+    p.catch(() => { }); // Suppress warning
+    return p;
+}
+describe("loadable", () => {
+    it("should return null for null signal value", () => {
+        const [promise] = atom(null);
+        const result = loadable(promise);
+        expect(result).toBeNull();
+    });
+    it("should return null for undefined signal value", () => {
+        const [promise] = atom(undefined);
+        const result = loadable(promise);
+        expect(result).toBeNull();
+    });
+    it("should return loading state for pending promise", () => {
+        const [promise] = atom(new Promise(() => { })); // never resolves
+        const result = loadable(promise);
+        expect(result).not.toBeNull();
+        expect(result.loading).toBe(true);
+        expect(result.data).toBeUndefined();
+        expect(result.error).toBeUndefined();
+    });
+    it("should return data for resolved promise", async () => {
+        const [promise] = atom(Promise.resolve("hello"));
+        // First call to initialize tracking
+        loadable(promise);
+        // Wait for promise to settle and tracking to update
+        await new Promise((r) => setTimeout(r, 10));
+        const result = loadable(promise);
+        expect(result).not.toBeNull();
+        expect(result.loading).toBe(false);
+        expect(result.data).toBe("hello");
+        expect(result.error).toBeUndefined();
+    });
+    it("should return error for rejected promise", async () => {
+        const error = new Error("test error");
+        const [promise] = atom(rejectedPromise(error));
+        // First call to initialize tracking
+        loadable(promise);
+        // Wait for promise to settle and tracking to update
+        await new Promise((r) => setTimeout(r, 10));
+        const result = loadable(promise);
+        expect(result).not.toBeNull();
+        expect(result.loading).toBe(false);
+        expect(result.data).toBeUndefined();
+        expect(result.error).toBe(error);
+    });
+    it("should handle promise that resolves later", async () => {
+        let resolve;
+        const [promise] = atom(new Promise((r) => {
+            resolve = r;
+        }));
+        // Initially loading
+        let result = loadable(promise);
+        expect(result.loading).toBe(true);
+        // Resolve the promise
+        resolve("resolved");
+        await new Promise((r) => setTimeout(r, 10));
+        // Now should have data
+        result = loadable(promise);
+        expect(result.loading).toBe(false);
+        expect(result.data).toBe("resolved");
+    });
+    it("should cache promise state", async () => {
+        const [promise] = atom(Promise.resolve(42));
+        // First call to initialize tracking
+        loadable(promise);
+        // Wait for promise to settle
+        await new Promise((r) => setTimeout(r, 10));
+        // Multiple calls should return same cached state
+        const result1 = loadable(promise);
+        const result2 = loadable(promise);
+        expect(result1.data).toBe(42);
+        expect(result2.data).toBe(42);
+    });
+    it("should handle signal value change", async () => {
+        const [promise, setPromise] = atom(null);
+        // Initial null
+        expect(loadable(promise)).toBeNull();
+        // Set to pending promise
+        setPromise(Promise.resolve(1));
+        // First call to initialize tracking
+        loadable(promise);
+        // Wait for promise
+        await new Promise((r) => setTimeout(r, 10));
+        expect(loadable(promise).data).toBe(1);
+        // Change to new promise
+        setPromise(Promise.resolve(2));
+        // Initialize tracking for new promise
+        loadable(promise);
+        await new Promise((r) => setTimeout(r, 10));
+        expect(loadable(promise).data).toBe(2);
+    });
+    describe("reactive tracking", () => {
+        it("should re-run effect when promise resolves", async () => {
+            // Create a promise that we control
+            let resolve;
+            const [promise] = atom(new Promise((r) => {
+                resolve = r;
+            }));
+            // Track effect runs
+            const states = [];
+            const dispose = effect(() => {
+                const state = loadable(promise);
+                if (state) {
+                    states.push({ loading: state.loading, data: state.data });
+                }
+            });
+            // First run should be loading
+            expect(states.length).toBe(1);
+            expect(states[0].loading).toBe(true);
+            expect(states[0].data).toBeUndefined();
+            // Resolve the promise
+            resolve("hello world");
+            // Wait for promise to settle and effect to re-run
+            await new Promise((r) => setTimeout(r, 10));
+            // Effect should have re-run with resolved data
+            expect(states.length).toBe(2);
+            expect(states[1].loading).toBe(false);
+            expect(states[1].data).toBe("hello world");
+            dispose();
+        });
+        it("should re-run effect when promise rejects", async () => {
+            // Create a promise that we control
+            let reject;
+            const p = new Promise((_, r) => {
+                reject = r;
+            });
+            // Suppress unhandled rejection warning
+            p.catch(() => { });
+            const [promise] = atom(p);
+            // Track effect runs
+            const states = [];
+            const dispose = effect(() => {
+                const state = loadable(promise);
+                if (state) {
+                    states.push({ loading: state.loading, error: state.error });
+                }
+            });
+            // First run should be loading
+            expect(states.length).toBe(1);
+            expect(states[0].loading).toBe(true);
+            // Reject the promise
+            const error = new Error("loadable test rejection");
+            reject(error);
+            // Wait for promise to settle and effect to re-run
+            await new Promise((r) => setTimeout(r, 10));
+            // Effect should have re-run with error
+            expect(states.length).toBe(2);
+            expect(states[1].loading).toBe(false);
+            expect(states[1].error).toBe(error);
+            dispose();
+        });
+        it("should not trigger re-run after effect is disposed", async () => {
+            // Create a promise that we control
+            let resolve;
+            const [promise] = atom(new Promise((r) => {
+                resolve = r;
+            }));
+            // Track effect runs
+            const fn = vi.fn();
+            const dispose = effect(() => {
+                const state = loadable(promise);
+                fn(state);
+            });
+            // First run
+            expect(fn).toHaveBeenCalledTimes(1);
+            // Dispose the effect BEFORE promise resolves
+            dispose();
+            // Resolve the promise
+            resolve("hello");
+            // Wait for promise to settle
+            await new Promise((r) => setTimeout(r, 10));
+            // Effect should NOT have re-run (was disposed)
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it("should handle multiple promises in same effect", async () => {
+            // Create two promises we control
+            let resolve1;
+            let resolve2;
+            const [promise1] = atom(new Promise((r) => {
+                resolve1 = r;
+            }));
+            const [promise2] = atom(new Promise((r) => {
+                resolve2 = r;
+            }));
+            // Track effect runs
+            let runCount = 0;
+            let state1;
+            let state2;
+            const dispose = effect(() => {
+                runCount++;
+                state1 = loadable(promise1);
+                state2 = loadable(promise2);
+            });
+            // Initial run - both loading
+            expect(runCount).toBe(1);
+            expect(state1.loading).toBe(true);
+            expect(state2.loading).toBe(true);
+            // Resolve first promise
+            resolve1(100);
+            await new Promise((r) => setTimeout(r, 10));
+            // Effect should re-run, first resolved, second still loading
+            expect(runCount).toBe(2);
+            expect(state1.loading).toBe(false);
+            expect(state1.data).toBe(100);
+            expect(state2.loading).toBe(true);
+            // Resolve second promise
+            resolve2(200);
+            await new Promise((r) => setTimeout(r, 10));
+            // Effect should re-run again, both resolved
+            expect(runCount).toBe(3);
+            expect(state1.data).toBe(100);
+            expect(state2.loading).toBe(false);
+            expect(state2.data).toBe(200);
+            dispose();
+        });
+        it("should handle promise signal change during loading", async () => {
+            // Create first promise (never resolves)
+            const [promise, setPromise] = atom(new Promise(() => { }));
+            let runCount = 0;
+            let lastData;
+            const dispose = effect(() => {
+                runCount++;
+                const state = loadable(promise);
+                if (state && !state.loading) {
+                    lastData = state.data;
+                }
+            });
+            // Initial run - loading
+            expect(runCount).toBe(1);
+            // Change to a new promise that resolves immediately
+            setPromise(Promise.resolve("new value"));
+            // Effect should re-run due to signal change
+            await new Promise((r) => setTimeout(r, 10));
+            // Should have the new resolved value
+            expect(lastData).toBe("new value");
+            dispose();
+        });
+        it("should not re-run for already resolved promise", async () => {
+            // Use an already-resolved promise
+            const [promise] = atom(Promise.resolve("already done"));
+            // Wait for cache to be populated
+            loadable(promise);
+            await new Promise((r) => setTimeout(r, 10));
+            // Now track effect runs
+            const fn = vi.fn();
+            const dispose = effect(() => {
+                const state = loadable(promise);
+                fn(state);
+            });
+            // Should only run once (data already available)
+            expect(fn).toHaveBeenCalledTimes(1);
+            expect(fn).toHaveBeenCalledWith(expect.objectContaining({
+                loading: false,
+                data: "already done",
+            }));
+            // Wait a bit to ensure no extra runs
+            await new Promise((r) => setTimeout(r, 20));
+            expect(fn).toHaveBeenCalledTimes(1);
+            dispose();
+        });
+        it("should not trigger update after disposal when promise resolves", async () => {
+            // Create a promise that we control
+            let resolve;
+            const [promise] = atom(new Promise((r) => {
+                resolve = r;
+            }));
+            // Track effect runs
+            const fn = vi.fn();
+            const dispose = effect(() => {
+                const state = loadable(promise);
+                fn(state?.loading);
+            });
+            // First run should be loading
+            expect(fn).toHaveBeenCalledTimes(1);
+            expect(fn).toHaveBeenLastCalledWith(true);
+            // Dispose BEFORE promise resolves - this tests the disposed check in onFinally (lines 80-81)
+            dispose();
+            // Now resolve the promise
+            resolve("resolved after dispose");
+            // Wait for promise to settle
+            await new Promise((r) => setTimeout(r, 20));
+            // Effect should NOT have re-run since it was disposed
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it("should not trigger update after disposal when promise rejects", async () => {
+            // Create a promise that we control
+            let reject;
+            const p = new Promise((_, r) => {
+                reject = r;
+            });
+            // Suppress unhandled rejection warning
+            p.catch(() => { });
+            const [promise] = atom(p);
+            // Track effect runs
+            const fn = vi.fn();
+            const dispose = effect(() => {
+                const state = loadable(promise);
+                fn(state?.loading);
+            });
+            // First run should be loading
+            expect(fn).toHaveBeenCalledTimes(1);
+            // Dispose BEFORE promise rejects
+            dispose();
+            // Now reject the promise
+            reject(new Error("rejected after dispose"));
+            // Wait for promise to settle
+            await new Promise((r) => setTimeout(r, 20));
+            // Effect should NOT have re-run since it was disposed
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+    });
+});
+//# sourceMappingURL=loadable.test.js.map