@polyphron/viper-react 0.1.2 → 0.3.0

package/dist/db.js

@@ -0,0 +1,329 @@
+import { createCollection } from "@tanstack/db";
+import { useLiveQuery } from "@tanstack/react-db";
+import { toViperFilter, toViperSort, toWindow } from "./db-query.js";
+import { useViper } from "./provider.js";
+export { toViperFilter, toViperSort } from "./db-query.js";
+export { useLivePage, viperPage, viperPageOptions, } from "./db-page.js";
+export { pageComparator, planPage, } from "./page-plan.js";
+export { fetchCollectionOptions, fetched, forgetFetched, refetchFetched, useFetched, useFetchedAll, } from "./db-fetch.js";
+export { useLiveQuery };
+/**
+ * Options for `createCollection()`: a TanStack DB collection that holds every
+ * record the signed-in user's list rule allows (or, in `on-demand` mode, the
+ * ones live queries ask for), and keeps it fresh from
+ * realtime events without asking the server again. Inserts, updates and
+ * deletes show at once and are rolled back if the server says no.
+ *
+ * Insert with your own `id` (15 characters, like Viper's), since the row
+ * needs a key before the server has answered.
+ */
+export function viperCollectionOptions(options) {
+    const { viper, collection } = options;
+    const onDemand = options.syncMode === "on-demand";
+    const records = viper.collection(collection).records;
+    // Set while the sync is running, so a mutation can write the server's
+    // answer into the collection.
+    let sink = null;
+    const sync = (params) => {
+        const { begin, write, commit, truncate, markReady, markError } = params;
+        // The `updated` we hold for each synced row: what makes an old realtime
+        // event (our own write coming back, say) unable to undo a newer one.
+        const versions = new Map();
+        let closed = false;
+        let loading = false;
+        let again = false;
+        // Events that arrive while a load is in flight, replayed after it.
+        let buffered = [];
+        // On-demand: subset loads in flight (they buffer events too), and the
+        // subsets live queries hold now, so a reload can fetch them again.
+        let pending = 0;
+        const subsets = new Map();
+        const stamp = (record) => Date.parse(record.updated) || 0;
+        const put = (record) => {
+            const seen = versions.get(record.id);
+            if (seen !== undefined && stamp(record) < seen)
+                return;
+            write({ type: seen === undefined ? "insert" : "update", value: record });
+            versions.set(record.id, stamp(record));
+        };
+        const remove = (id) => {
+            const seen = versions.get(id);
+            if (seen === undefined)
+                return;
+            write({ type: "delete", key: id });
+            versions.delete(id);
+        };
+        const apply = (event) => {
+            if (event.action === "delete")
+                remove(event.record.id);
+            else if (event.action !== "refresh")
+                put(event.record);
+        };
+        // A subset is held once per load; it is let go when each is unloaded.
+        const release = (subset) => {
+            const count = subsets.get(subset) ?? 0;
+            if (count > 1)
+                subsets.set(subset, count - 1);
+            else
+                subsets.delete(subset);
+        };
+        // Every row the held subsets want, or the whole collection when eager.
+        const fetchAll = async () => {
+            if (!onDemand)
+                return records.listAll();
+            const found = await Promise.all([...subsets.keys()].map(fetchSubset));
+            const byId = new Map();
+            for (const item of found.flat())
+                byId.set(item.id, item);
+            return [...byId.values()];
+        };
+        // One subset: the rows its `where` names, sorted, and its window when it
+        // has a limit. A `where` we could only half say loads wider and never
+        // takes a window, since the window would be cut from the wrong rows.
+        const fetchSubset = async (subset) => {
+            const { filter, exact } = toViperFilter(subset.where);
+            const sort = toViperSort(subset.orderBy);
+            const window = exact && sort && subset.limit !== undefined
+                ? toWindow(subset.offset ?? 0, subset.limit)
+                : null;
+            // Core always sends `offset` along with `cursor`, so the cursor
+            // expressions are left alone and the offset does the paging. Only the
+            // rows are wanted, so `skipTotal` spares the server its COUNT (see
+            // toWindow for why this is not a keyset cursor).
+            if (!window) {
+                return records.listAll({
+                    filter: filter || undefined,
+                    sort: sort || undefined,
+                });
+            }
+            const result = await records.list({
+                filter: filter || undefined,
+                sort: sort || undefined,
+                skipTotal: true,
+                ...window,
+            });
+            return result.items;
+        };
+        const load = async () => {
+            // One load at a time; a request during a load runs another after it.
+            if (loading) {
+                again = true;
+                return;
+            }
+            loading = true;
+            try {
+                do {
+                    again = false;
+                    const items = await fetchAll();
+                    if (closed)
+                        return;
+                    // Truncate and rewrite in one transaction, so a reload never
+                    // shows an empty list in between.
+                    begin();
+                    truncate();
+                    versions.clear();
+                    items.forEach(put);
+                    const missed = buffered;
+                    if (pending === 0)
+                        buffered = [];
+                    missed.forEach(apply);
+                    commit();
+                    markReady();
+                } while (again);
+            }
+            catch (error) {
+                markError(error);
+            }
+            finally {
+                loading = false;
+            }
+        };
+        sink = {
+            put,
+            remove,
+            write: (fn) => {
+                begin();
+                fn();
+                commit();
+            },
+        };
+        // Subscribe before loading, so nothing that happens in between is lost.
+        const off = viper.realtime.subscribe(collection, (event) => {
+            if (event.action === "refresh") {
+                void load();
+            }
+            else if (loading || pending > 0) {
+                buffered.push(event);
+            }
+            else {
+                begin();
+                apply(event);
+                commit();
+            }
+        });
+        const offResync = viper.realtime.onResync(() => void load());
+        const cleanup = () => {
+            closed = true;
+            sink = null;
+            off();
+            offResync();
+        };
+        if (!onDemand) {
+            void load();
+            return cleanup;
+        }
+        // Nothing to load until a query asks. Every realtime event is applied,
+        // not only those matching a held subset: the list rule already decided
+        // this user may see the row, and a live query drops what does not match
+        // it. Skipping non-matching events would need the where evaluated here,
+        // and would miss a new row that a query should show.
+        markReady();
+        return {
+            cleanup,
+            loadSubset: async (subset) => {
+                pending++;
+                subsets.set(subset, (subsets.get(subset) ?? 0) + 1);
+                try {
+                    const items = await fetchSubset(subset);
+                    if (closed)
+                        return;
+                    begin();
+                    items.forEach(put);
+                    buffered.forEach(apply);
+                    await commit();
+                }
+                catch (error) {
+                    release(subset);
+                    throw error;
+                }
+                finally {
+                    pending--;
+                    if (pending === 0 && !loading)
+                        buffered = [];
+                }
+            },
+            unloadSubset: release,
+        };
+    };
+    // Puts what the server answered into the collection, in place of our guess.
+    // A write the user may make on a row they may not see afterwards (the view
+    // rule now hides it) answers with only ids, so that row is dropped rather
+    // than kept as the partial guess.
+    const store = (saved) => {
+        sink?.write(() => {
+            for (const record of saved) {
+                if (!record)
+                    continue;
+                if (hiddenAnswer(record))
+                    sink?.remove(record.id);
+                else
+                    sink?.put(record);
+            }
+        });
+    };
+    return {
+        getKey: (record) => record.id,
+        // Records are whole rows, so an update replaces rather than merges.
+        sync: { sync, rowUpdateMode: "full" },
+        syncMode: onDemand ? "on-demand" : "eager",
+        onInsert: async ({ transaction }) => {
+            const saved = await save(viper, records, collection, transaction.mutations);
+            store(saved);
+        },
+        onUpdate: async ({ transaction }) => {
+            const saved = await save(viper, records, collection, transaction.mutations);
+            store(saved);
+        },
+        onDelete: async ({ transaction }) => {
+            await save(viper, records, collection, transaction.mutations);
+            sink?.write(() => {
+                for (const m of transaction.mutations)
+                    sink?.remove(m.key);
+            });
+        },
+    };
+}
+// True when a write's answer holds only the ids, which is what the server
+// sends when the view rule no longer lets the caller see the saved row.
+function hiddenAnswer(record) {
+    return Object.keys(record).every((key) => key === "id" || key === "collectionId" || key === "collectionName");
+}
+// Sends the mutations: one call for one, a single all-or-nothing batch for
+// several. Resolves to the saved records, in order (null for a delete).
+async function save(viper, records, collection, mutations) {
+    if (mutations.length > 1) {
+        return viper.batch(mutations.map((m) => toOp(collection, m)));
+    }
+    const m = mutations[0];
+    if (m.type === "insert")
+        return [await records.create(m.modified)];
+    if (m.type === "update")
+        return [await records.update(m.key, m.changes)];
+    await records.delete(m.key);
+    return [null];
+}
+// One mutation as a batch write.
+function toOp(collection, m) {
+    if (m.type === "insert") {
+        return { method: "create", collection, body: m.modified };
+    }
+    if (m.type === "update") {
+        return { method: "update", collection, id: m.key, body: m.changes };
+    }
+    return { method: "delete", collection, id: m.key };
+}
+// Collections made by `useViperCollection`, one per client, name and mode, so
+// two components asking for `posts` share one copy of it (and one fetch).
+const made = new WeakMap();
+/**
+ * The Viper collection `name` for the client in `<ViperProvider>`, made once
+ * and shared: every component asking for the same name and mode gets the same
+ * collection, so its records are fetched once. Use it to insert, update and
+ * delete, and as a `from` in live queries. Nothing about `useRecords` changes.
+ *
+ * ```tsx
+ * const posts = useViperCollection<Post>("posts")
+ * posts.insert({ id: newId(), title: "Hi" })
+ * ```
+ */
+export function useViperCollection(name, options = {}) {
+    const viper = useViper();
+    const mode = options.syncMode ?? "eager";
+    let byName = made.get(viper);
+    if (!byName) {
+        byName = new Map();
+        made.set(viper, byName);
+    }
+    const key = `${mode}:${name}`;
+    let found = byName.get(key);
+    if (!found) {
+        found = createCollection(viperCollectionOptions({ viper, collection: name, syncMode: mode }));
+        byName.set(key, found);
+    }
+    return found;
+}
+/**
+ * The rows of a Viper collection as a live list, like `useRecords` but read
+ * from the shared collection, so it updates row by row with no refetch. Give
+ * `query` to filter, sort or join; without it you get every row. In
+ * `on-demand` mode `query` is what decides what is loaded.
+ *
+ * ```tsx
+ * const { data, loading } = useLiveRecords<Post>("posts", {
+ *   query: (q, posts) =>
+ *     q.from({ p: posts }).where(({ p }) => eq(p.status, "live")),
+ * })
+ * ```
+ */
+export function useLiveRecords(name, options = {}) {
+    const rows = useViperCollection(name, options);
+    const { query } = options;
+    const live = useLiveQuery({
+        query: (q) => (query ? query(q, rows) : q.from({ row: rows })),
+    });
+    return {
+        data: live.isReady ? live.data : null,
+        error: live.isError ? new Error(`${name} could not be loaded`) : null,
+        loading: live.isLoading || live.isIdle,
+    };
+}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { ViperProvider, useViper, type ViperProviderProps } from "./provider.js";
-export { useAuth, useSession, useUser } from "./auth.js";
+export { useAuth, useAuthMethods, useSession, useInvites, useSessions, useTenants, useUser, } from "./auth.js";
 export { useRealtime, useRealtimeStatus } from "./realtime.js";
 export { useRecord, useRecords, type Query, type RecordsOptions, } from "./records.js";
-export { Viper, ViperError, fieldError, memoryStorage, type ListOptions, type ListResult, type RealtimeEvent, type RealtimeStatus, type RecordInput, type RecordModel, type Session, type ViperOptions, } from "@polyphron/viper-client";
+export { useRun, type RunState } from "./runs.js";
+export { Viper, ViperError, fieldError, memoryStorage, type ListOptions, type ListResult, type RealtimeEvent, type RealtimeStatus, type RecordInput, type RecordModel, type Session, type UserSession, type StartedRun, type ViperOptions, type WorkflowRun, } from "@polyphron/viper-client";

package/dist/index.js

@@ -1,6 +1,7 @@
 export { ViperProvider, useViper } from "./provider.js";
-export { useAuth, useSession, useUser } from "./auth.js";
+export { useAuth, useAuthMethods, useSession, useInvites, useSessions, useTenants, useUser, } from "./auth.js";
 export { useRealtime, useRealtimeStatus } from "./realtime.js";
 export { useRecord, useRecords, } from "./records.js";
+export { useRun } from "./runs.js";
 // Re-exported so an app only needs @polyphron/viper-react in its imports.
 export { Viper, ViperError, fieldError, memoryStorage, } from "@polyphron/viper-client";

package/dist/page-plan.d.ts

@@ -0,0 +1,29 @@
+import type { RealtimeEvent, RecordModel } from "@polyphron/viper-client";
+/** One page as the server sent it, and how it was asked for. */
+export type PageState<T extends RecordModel = RecordModel> = {
+    /** The rows, in the server's order. */
+    rows: T[];
+    page: number;
+    /** -1 when unknown. */
+    totalPages: number;
+    /** The sort the page was asked for, like `-updated,title`. */
+    sort?: string;
+    filter?: string;
+    deleted?: boolean;
+    /** The `expand` it was asked for, like `author,tags.owner`. */
+    expand?: string;
+};
+/** What to do: write `patch` in, take `drop` out, and maybe ask again. */
+export type PagePlan<T extends RecordModel = RecordModel> = {
+    patch?: T;
+    drop?: string;
+    refetch: boolean;
+};
+/**
+ * Orders rows as the server does for `sort`, or null when the sort has a
+ * field the browser can't order the same way (text in the database's
+ * collation, numbers, lists).
+ */
+export declare function pageComparator<T extends RecordModel>(sort: string | undefined): ((a: T, b: T) => number) | null;
+/** What `event` does to `page`. */
+export declare function planPage<T extends RecordModel>(event: RealtimeEvent<T>, page: PageState<T>): PagePlan<T>;

package/dist/page-plan.js

@@ -0,0 +1,102 @@
+// Sort fields the browser orders just as Postgres does: times compared as
+// times, and ids (a-z and 0-9) compared as text.
+const TIMES = new Set(["created", "updated"]);
+/**
+ * The sort as the server applies it, with its tie-breaker. The server
+ * breaks ties on `id` ascending, or sorts `-created,-id` when none is given.
+ */
+function sortKeys(sort) {
+    const given = (sort ?? "")
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    if (!given.length) {
+        return [
+            { field: "created", desc: true },
+            { field: "id", desc: true },
+        ];
+    }
+    return [
+        ...given.map((s) => ({
+            field: s.replace(/^[-+]/, ""),
+            desc: s.startsWith("-"),
+        })),
+        { field: "id", desc: false },
+    ];
+}
+/**
+ * Orders rows as the server does for `sort`, or null when the sort has a
+ * field the browser can't order the same way (text in the database's
+ * collation, numbers, lists).
+ */
+export function pageComparator(sort) {
+    const keys = sortKeys(sort);
+    if (!keys.every((k) => k.field === "id" || TIMES.has(k.field)))
+        return null;
+    return (a, b) => {
+        for (const { field, desc } of keys) {
+            const x = String(a[field]);
+            const y = String(b[field]);
+            const order = field === "id"
+                ? x < y
+                    ? -1
+                    : x > y
+                        ? 1
+                        : 0
+                : Date.parse(x) - Date.parse(y);
+            if (order)
+                return desc ? -order : order;
+        }
+        return 0;
+    };
+}
+// True when two field values are the same, lists and objects included.
+function same(a, b) {
+    return a === b || JSON.stringify(a) === JSON.stringify(b);
+}
+/** What `event` does to `page`. */
+export function planPage(event, page) {
+    // A new row, or a view that changed: only the server knows where it goes.
+    if (event.action === "create" || event.action === "refresh") {
+        return { refetch: true };
+    }
+    const { record } = event;
+    const old = page.rows.find((r) => r.id === record.id);
+    // The rows after it move up, and the count changes.
+    if (event.action === "delete") {
+        return { drop: old ? record.id : undefined, refetch: true };
+    }
+    // A row that isn't on the page can only move onto it if its sort values
+    // changed. Its old values aren't known, so only a sort on fields an
+    // update never changes (created, id) is safe to skip.
+    if (!old) {
+        const fixed = sortKeys(page.sort).every((k) => k.field === "created" || k.field === "id");
+        return { refetch: !fixed || !!page.filter || !!page.deleted };
+    }
+    // A change carries no `expand`, so the old one stays while the links do.
+    const relations = (page.expand ?? "")
+        .split(",")
+        .map((path) => path.trim().split(".")[0])
+        .filter(Boolean);
+    const relinked = relations.some((f) => !same(old[f], record[f]));
+    const patch = relinked ? record : { ...record, expand: old.expand };
+    // A filter or the Deleted view may now leave it out, and the filter can't
+    // be run here.
+    if (page.filter || page.deleted || relinked)
+        return { patch, refetch: true };
+    const moved = sortKeys(page.sort).some((k) => !same(old[k.field], record[k.field]));
+    if (!moved)
+        return { patch, refetch: false };
+    // It moved. Order the page here, and ask again only if it may now belong
+    // on the page before or after this one.
+    const compare = pageComparator(page.sort);
+    if (!compare)
+        return { patch, refetch: true };
+    const rows = page.rows
+        .map((r) => (r.id === record.id ? patch : r))
+        .sort(compare);
+    const at = rows.findIndex((r) => r.id === record.id);
+    const more = page.totalPages < 0 || page.page < page.totalPages;
+    const leaves = (at === 0 && page.page > 1) || (at === rows.length - 1 && more);
+    return { patch, refetch: leaves };
+}

package/dist/records.d.ts

@@ -2,8 +2,14 @@ import type { ListOptions, ListResult, RecordModel } from "@polyphron/viper-clie
 export type Query<T> = {
     data: T | null;
     error: unknown;
-    /** True until the first answer arrives, and again during a `reload`. */
+    /**
+     * True until the first answer arrives for what is being shown (a new
+     * collection, or a new record id). A `reload` or a live update does not set
+     * it again, so the last data stays on screen; see `refreshing`.
+     */
     loading: boolean;
+    /** True whenever a request is in flight, first load and reloads included. */
+    refreshing: boolean;
     /** Fetches again now. */
     reload: () => void;
 };

package/dist/records.js

@@ -13,57 +13,65 @@ export function useRecords(collection, options = {}) {
     const { live = false, ...list } = options;
     // Options are a fresh object every render; compare them by value.
     const key = JSON.stringify(list);
-    const query = useFetch(useCallback((signal) => viper
+    const query = useFetch(collection, useCallback((signal) => viper
         .collection(collection)
         .list({ ...JSON.parse(key), signal }), [viper, collection, key]));
-    useLiveReload(live, collection, query.reload);
+    useLiveReload(live, collection, query.reload, viper);
     return query;
 }
 /** One record, re-fetched when the id changes. */
 export function useRecord(collection, id, options = {}) {
     const viper = useViper();
     const { live = false, expand } = options;
-    const query = useFetch(useCallback((signal) => id
+    const query = useFetch(
+    // A different record must never show the last one's data.
+    `${collection}/${id ?? ""}`, useCallback((signal) => id
         ? viper.collection(collection).view(id, { expand, signal })
         : Promise.resolve(null), [viper, collection, id, expand]));
-    useLiveReload(live && Boolean(id), `${collection}/${id}`, query.reload);
+    useLiveReload(live && Boolean(id), `${collection}/${id}`, query.reload, viper);
     return query;
 }
 // Runs `run` whenever it changes, and gives back its state. Answers from a
 // call that has already been replaced are dropped, so a slow first request
 // can't overwrite a fast second one.
 //
-// `loading` is worked out rather than stored: the answer carries the request
-// it belongs to, so anything older than the current request means "still
-// waiting" — and no state has to be set while the effect is starting.
-function useFetch(run) {
+// `refreshing` and `loading` are worked out rather than stored: the answer
+// carries the request it belongs to, so anything older than the current
+// request means "still waiting" — and no state has to be set while the effect
+// is starting. `subject` names what is being shown; data from another subject
+// is never handed back, only data from a reload of the same one.
+function useFetch(subject, run) {
     const [attempt, setAttempt] = useState(0);
-    const [answer, setAnswer] = useState({ run: null, attempt: -1, data: null, error: null });
+    const [answer, setAnswer] = useState({ subject: "", run: null, attempt: -1, data: null, error: null });
     useEffect(() => {
         const controller = new AbortController();
         run(controller.signal).then((data) => {
             if (!controller.signal.aborted) {
-                setAnswer({ run, attempt, data, error: null });
+                setAnswer({ subject, run, attempt, data, error: null });
             }
         }, (error) => {
             if (!controller.signal.aborted) {
-                setAnswer({ run, attempt, data: null, error });
+                setAnswer({ subject, run, attempt, data: null, error });
             }
         });
         return () => controller.abort();
-    }, [run, attempt]);
+    }, [subject, run, attempt]);
     const current = answer.run === run && answer.attempt === attempt;
+    const sameSubject = answer.run !== null && answer.subject === subject;
     return {
         // The last good data stays on screen while a reload is in flight.
-        data: answer.data,
+        data: sameSubject ? answer.data : null,
         error: current ? answer.error : null,
-        loading: !current,
+        loading: !sameSubject,
+        refreshing: !current,
         reload: useCallback(() => setAttempt((n) => n + 1), []),
     };
 }
-// Reloads on every realtime event for `topic`, when `live` is on. The hook
-// below is always called, because hooks can't be conditional; an empty topic
-// means no subscription.
-function useLiveReload(live, topic, reload) {
+// Reloads on every realtime event for `topic`, when `live` is on, and once
+// more after the socket comes back from a drop, since events may have been
+// missed while it was down. The hooks are always called, because hooks can't
+// be conditional; an empty topic means no subscription.
+function useLiveReload(live, topic, reload, viper) {
     useRealtime(live ? topic : [], reload);
+    useEffect(() => (live ? viper.realtime.onResync(reload) : undefined), [live, viper, reload]);
 }

package/dist/runs.d.ts

@@ -0,0 +1,23 @@
+import type { StartedRun, WorkflowRun } from "@polyphron/viper-client";
+export type RunState<T> = {
+    /** The run as last read, or null before the first answer. */
+    data: WorkflowRun<T> | null;
+    error: unknown;
+    /** True from the start until the run is done or failed, or can't be read. */
+    pending: boolean;
+};
+/**
+ * Watches a background workflow's run until it's done or failed, reading
+ * it every `every` milliseconds (a second by default). Pass the
+ * `StartedRun` its call returned; nothing is read while it's empty.
+ *
+ * ```tsx
+ * const [started, setStarted] = useState<StartedRun>()
+ * const { data, pending } = useRun<{ text: string }>("forge", started)
+ * // on click: setStarted(await viper.workflows.call<StartedRun>("forge", input))
+ * // when done: data.response.body.text
+ * ```
+ */
+export declare function useRun<T = unknown>(name: string, started: StartedRun | null | undefined, options?: {
+    every?: number;
+}): RunState<T>;

package/dist/runs.js

@@ -0,0 +1,58 @@
+import { useEffect, useState } from "react";
+import { useViper } from "./provider.js";
+/**
+ * Watches a background workflow's run until it's done or failed, reading
+ * it every `every` milliseconds (a second by default). Pass the
+ * `StartedRun` its call returned; nothing is read while it's empty.
+ *
+ * ```tsx
+ * const [started, setStarted] = useState<StartedRun>()
+ * const { data, pending } = useRun<{ text: string }>("forge", started)
+ * // on click: setStarted(await viper.workflows.call<StartedRun>("forge", input))
+ * // when done: data.response.body.text
+ * ```
+ */
+export function useRun(name, started, options = {}) {
+    const viper = useViper();
+    const every = options.every ?? 1000;
+    const run = started?.run;
+    const token = started?.token;
+    // The answer carries the run it's for, so another run's never shows.
+    const [state, setState] = useState({ key: "", data: null, error: null });
+    useEffect(() => {
+        if (run === undefined || token === undefined)
+            return;
+        const key = `${name}/${run}`;
+        const controller = new AbortController();
+        let timer;
+        const read = async () => {
+            try {
+                const data = await viper.workflows.run(name, { run, token }, { signal: controller.signal });
+                setState({ key, data, error: null });
+                if (data.status !== "done" && data.status !== "failed") {
+                    timer = setTimeout(() => void read(), every);
+                }
+            }
+            catch (error) {
+                if (!controller.signal.aborted)
+                    setState({ key, data: null, error });
+            }
+        };
+        void read();
+        return () => {
+            controller.abort();
+            clearTimeout(timer);
+        };
+    }, [viper, name, run, token, every]);
+    const mine = run !== undefined && state.key === `${name}/${run}`;
+    const data = mine ? state.data : null;
+    const error = mine ? state.error : null;
+    return {
+        data,
+        error,
+        pending: run !== undefined &&
+            !error &&
+            data?.status !== "done" &&
+            data?.status !== "failed",
+    };
+}