@coji/durably-react 0.10.0 → 0.12.0

package/dist/index.js

@@ -1,468 +1,547 @@
 import {
-  initialSubscriptionState,
   isJobDefinition,
-  subscriptionReducer,
   useSubscription
-} from "./chunk-XRJEZWAV.js";
+} from "./chunk-TGMPMPMX.js";
 
-// src/context.tsx
-import { Suspense, createContext, use, useContext } from "react";
-import { jsx } from "react/jsx-runtime";
-var DurablyContext = createContext(null);
-function DurablyProviderInner({
-  durably: durablyOrPromise,
-  children
-}) {
-  const durably = durablyOrPromise instanceof Promise ? use(durablyOrPromise) : durablyOrPromise;
-  return /* @__PURE__ */ jsx(DurablyContext.Provider, { value: { durably }, children });
-}
-function DurablyProvider({
-  durably,
-  fallback,
-  children
-}) {
-  const inner = /* @__PURE__ */ jsx(DurablyProviderInner, { durably, children });
-  if (fallback !== void 0) {
-    return /* @__PURE__ */ jsx(Suspense, { fallback, children: inner });
-  }
-  return inner;
-}
-function useDurably() {
-  const context = useContext(DurablyContext);
-  if (!context) {
-    throw new Error("useDurably must be used within a DurablyProvider");
-  }
-  return context;
+// src/client/use-job.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+
+// src/client/use-sse-subscription.ts
+import { useMemo } from "react";
+
+// src/shared/sse-event-subscriber.ts
+function createSSEEventSubscriber(apiBaseUrl) {
+  return {
+    subscribe(runId, onEvent) {
+      const url = `${apiBaseUrl}/subscribe?runId=${encodeURIComponent(runId)}`;
+      const eventSource = new EventSource(url);
+      eventSource.onmessage = (messageEvent) => {
+        try {
+          const data = JSON.parse(messageEvent.data);
+          if (data.runId !== runId) return;
+          switch (data.type) {
+            case "run:start":
+              onEvent({ type: "run:start" });
+              break;
+            case "run:complete":
+              onEvent({
+                type: "run:complete",
+                output: data.output
+              });
+              break;
+            case "run:fail":
+              onEvent({ type: "run:fail", error: data.error });
+              break;
+            case "run:cancel":
+              onEvent({ type: "run:cancel" });
+              break;
+            case "run:progress":
+              onEvent({ type: "run:progress", progress: data.progress });
+              break;
+            case "log:write":
+              onEvent({
+                type: "log:write",
+                runId: data.runId,
+                stepName: null,
+                level: data.level,
+                message: data.message,
+                data: data.data
+              });
+              break;
+          }
+        } catch {
+        }
+      };
+      eventSource.onerror = () => {
+        onEvent({ type: "connection_error", error: "Connection failed" });
+        eventSource.close();
+      };
+      return () => {
+        eventSource.close();
+      };
+    }
+  };
 }
 
-// src/hooks/use-job.ts
-import { useCallback as useCallback2, useEffect as useEffect3, useMemo, useRef as useRef2 } from "react";
+// src/client/use-sse-subscription.ts
+function useSSESubscription(api, runId, options) {
+  const subscriber = useMemo(
+    () => api ? createSSEEventSubscriber(api) : null,
+    [api]
+  );
+  return useSubscription(subscriber, runId, options);
+}
 
-// src/hooks/use-auto-resume.ts
-import { useEffect } from "react";
-function useAutoResume(jobHandle, options, callbacks) {
-  const enabled = options.enabled !== false;
-  const skipIfInitialRunId = options.skipIfInitialRunId !== false;
-  const initialRunId = options.initialRunId;
+// src/client/use-job.ts
+function useJob(options) {
+  const {
+    api,
+    jobName,
+    initialRunId,
+    autoResume = true,
+    followLatest = true
+  } = options;
+  const [currentRunId, setCurrentRunId] = useState(
+    initialRunId ?? null
+  );
+  const [isPending, setIsPending] = useState(false);
+  const hasUserTriggered = useRef(false);
+  const waitIntervalRef = useRef(null);
+  const subscription = useSSESubscription(api, currentRunId);
+  const subscriptionRef = useRef(subscription);
+  subscriptionRef.current = subscription;
   useEffect(() => {
-    if (!jobHandle) return;
-    if (!enabled) return;
-    if (skipIfInitialRunId && initialRunId) return;
-    let cancelled = false;
+    if (!autoResume) return;
+    if (initialRunId) return;
+    const abortController = new AbortController();
     const findActiveRun = async () => {
-      const runningRuns = await jobHandle.getRuns({ status: "running" });
-      if (cancelled) return;
-      if (runningRuns.length > 0) {
-        const run = runningRuns[0];
-        callbacks.onRunFound(run.id, run.status);
-        return;
+      const signal = abortController.signal;
+      const [runningRes, pendingRes] = await Promise.all([
+        fetch(
+          `${api}/runs?${new URLSearchParams({ jobName, status: "running", limit: "1" })}`,
+          { signal }
+        ),
+        fetch(
+          `${api}/runs?${new URLSearchParams({ jobName, status: "pending", limit: "1" })}`,
+          { signal }
+        )
+      ]);
+      if (hasUserTriggered.current) return;
+      if (runningRes.ok) {
+        const runs = await runningRes.json();
+        if (runs.length > 0) {
+          setCurrentRunId(runs[0].id);
+          return;
+        }
       }
-      const pendingRuns = await jobHandle.getRuns({ status: "pending" });
-      if (cancelled) return;
-      if (pendingRuns.length > 0) {
-        const run = pendingRuns[0];
-        callbacks.onRunFound(run.id, run.status);
+      if (pendingRes.ok) {
+        const runs = await pendingRes.json();
+        if (runs.length > 0) {
+          setCurrentRunId(runs[0].id);
+        }
       }
     };
-    findActiveRun();
+    findActiveRun().catch((err) => {
+      if (err.name !== "AbortError") {
+        console.error("autoResume error:", err);
+      }
+    });
     return () => {
-      cancelled = true;
+      abortController.abort();
     };
-  }, [jobHandle, enabled, skipIfInitialRunId, initialRunId, callbacks]);
-}
-
-// src/hooks/use-job-subscription.ts
-import { useCallback, useEffect as useEffect2, useReducer, useRef } from "react";
-function jobSubscriptionReducer(state, action) {
-  switch (action.type) {
-    case "set_run_id":
-      return { ...state, currentRunId: action.runId };
-    case "switch_to_run":
-      return {
-        ...initialSubscriptionState,
-        currentRunId: action.runId,
-        status: "running"
-      };
-    case "reset":
-      return {
-        ...initialSubscriptionState,
-        currentRunId: null
-      };
-    default:
-      return {
-        ...subscriptionReducer(state, action),
-        currentRunId: state.currentRunId
-      };
-  }
-}
-function useJobSubscription(durably, jobName, options) {
-  const initialState = {
-    ...initialSubscriptionState,
-    currentRunId: null
-  };
-  const [state, dispatch] = useReducer(
-    jobSubscriptionReducer,
-    initialState
-  );
-  const currentRunIdRef = useRef(null);
-  currentRunIdRef.current = state.currentRunId;
-  const followLatest = options?.followLatest !== false;
-  const maxLogs = options?.maxLogs ?? 0;
-  useEffect2(() => {
-    if (!durably) return;
-    const unsubscribes = [];
-    unsubscribes.push(
-      durably.on("run:start", (event) => {
-        if (event.jobName !== jobName) return;
-        if (followLatest) {
-          dispatch({ type: "switch_to_run", runId: event.runId });
-          currentRunIdRef.current = event.runId;
-        } else {
-          if (event.runId !== currentRunIdRef.current) return;
-          dispatch({ type: "run:start" });
+  }, [api, jobName, autoResume, initialRunId]);
+  useEffect(() => {
+    if (!followLatest) return;
+    const params = new URLSearchParams({ jobName });
+    const eventSource = new EventSource(`${api}/runs/subscribe?${params}`);
+    eventSource.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if ((data.type === "run:trigger" || data.type === "run:start") && data.runId) {
+          setCurrentRunId(data.runId);
         }
-      })
-    );
-    unsubscribes.push(
-      durably.on("run:complete", (event) => {
-        if (event.runId !== currentRunIdRef.current) return;
-        dispatch({ type: "run:complete", output: event.output });
-      })
-    );
-    unsubscribes.push(
-      durably.on("run:fail", (event) => {
-        if (event.runId !== currentRunIdRef.current) return;
-        dispatch({ type: "run:fail", error: event.error });
-      })
-    );
-    unsubscribes.push(
-      durably.on("run:cancel", (event) => {
-        if (event.runId !== currentRunIdRef.current) return;
-        dispatch({ type: "run:cancel" });
-      })
-    );
-    unsubscribes.push(
-      durably.on("run:retry", (event) => {
-        if (event.runId !== currentRunIdRef.current) return;
-        dispatch({ type: "run:retry" });
-      })
-    );
-    unsubscribes.push(
-      durably.on("run:progress", (event) => {
-        if (event.runId !== currentRunIdRef.current) return;
-        dispatch({ type: "run:progress", progress: event.progress });
-      })
-    );
-    unsubscribes.push(
-      durably.on("log:write", (event) => {
-        if (event.runId !== currentRunIdRef.current) return;
-        dispatch({
-          type: "log:write",
-          runId: event.runId,
-          stepName: event.stepName,
-          level: event.level,
-          message: event.message,
-          data: event.data,
-          maxLogs
-        });
-      })
-    );
-    return () => {
-      for (const unsubscribe of unsubscribes) {
-        unsubscribe();
+      } catch {
       }
     };
-  }, [durably, jobName, followLatest, maxLogs]);
-  const setCurrentRunId = useCallback((runId) => {
-    dispatch({ type: "set_run_id", runId });
-    currentRunIdRef.current = runId;
-  }, []);
-  const clearLogs = useCallback(() => {
-    dispatch({ type: "clear_logs" });
-  }, []);
-  const reset = useCallback(() => {
-    dispatch({ type: "reset" });
-    currentRunIdRef.current = null;
-  }, []);
-  return {
-    ...state,
-    setCurrentRunId,
-    clearLogs,
-    reset
-  };
-}
-
-// src/hooks/use-job.ts
-function useJob(jobDefinition, options) {
-  const { durably } = useDurably();
-  const jobHandleRef = useRef2(null);
-  useEffect3(() => {
-    if (!durably) return;
-    const d = durably.register({
-      _job: jobDefinition
-    });
-    jobHandleRef.current = d.jobs._job;
-  }, [durably, jobDefinition]);
-  const subscription = useJobSubscription(
-    durably,
-    jobDefinition.name,
-    {
-      followLatest: options?.followLatest
-    }
-  );
-  const autoResumeCallbacks = useMemo(
-    () => ({
-      onRunFound: (runId, _status) => {
-        subscription.setCurrentRunId(runId);
-      }
-    }),
-    [subscription.setCurrentRunId]
-  );
-  useAutoResume(
-    jobHandleRef.current,
-    {
-      enabled: options?.autoResume,
-      initialRunId: options?.initialRunId
-    },
-    autoResumeCallbacks
-  );
-  useEffect3(() => {
-    if (!durably || !options?.initialRunId) return;
-    subscription.setCurrentRunId(options.initialRunId);
-  }, [durably, options?.initialRunId, subscription.setCurrentRunId]);
-  const trigger = useCallback2(
+    eventSource.onerror = () => {
+    };
+    return () => {
+      eventSource.close();
+    };
+  }, [api, jobName, followLatest]);
+  const trigger = useCallback(
     async (input) => {
-      const jobHandle = jobHandleRef.current;
-      if (!jobHandle) {
-        throw new Error("Job not ready");
-      }
+      hasUserTriggered.current = true;
       subscription.reset();
-      const run = await jobHandle.trigger(input);
-      subscription.setCurrentRunId(run.id);
-      return { runId: run.id };
+      setIsPending(true);
+      const response = await fetch(`${api}/trigger`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ jobName, input })
+      });
+      if (!response.ok) {
+        setIsPending(false);
+        const errorText = await response.text();
+        throw new Error(errorText || `HTTP ${response.status}`);
+      }
+      const { runId } = await response.json();
+      setCurrentRunId(runId);
+      return { runId };
     },
-    [subscription]
+    [api, jobName, subscription.reset]
   );
-  const triggerAndWait = useCallback2(
+  const triggerAndWait = useCallback(
     async (input) => {
-      const jobHandle = jobHandleRef.current;
-      if (!jobHandle || !durably) {
-        throw new Error("Job not ready");
-      }
-      subscription.reset();
-      const run = await jobHandle.trigger(input);
-      subscription.setCurrentRunId(run.id);
+      const { runId } = await trigger(input);
       return new Promise((resolve, reject) => {
-        const checkCompletion = async () => {
-          const updatedRun = await jobHandle.getRun(run.id);
-          if (!updatedRun) {
-            reject(new Error("Run not found"));
-            return;
-          }
-          if (updatedRun.status === "completed") {
-            resolve({ runId: run.id, output: updatedRun.output });
-          } else if (updatedRun.status === "failed") {
-            reject(new Error(updatedRun.error ?? "Job failed"));
-          } else if (updatedRun.status === "cancelled") {
+        if (waitIntervalRef.current) {
+          clearInterval(waitIntervalRef.current);
+        }
+        const checkInterval = setInterval(() => {
+          const sub = subscriptionRef.current;
+          if (sub.status === "completed" && sub.output) {
+            clearInterval(checkInterval);
+            waitIntervalRef.current = null;
+            resolve({ runId, output: sub.output });
+          } else if (sub.status === "failed") {
+            clearInterval(checkInterval);
+            waitIntervalRef.current = null;
+            reject(new Error(sub.error ?? "Job failed"));
+          } else if (sub.status === "cancelled") {
+            clearInterval(checkInterval);
+            waitIntervalRef.current = null;
             reject(new Error("Job cancelled"));
-          } else {
-            setTimeout(checkCompletion, 50);
           }
-        };
-        checkCompletion();
+        }, 50);
+        waitIntervalRef.current = checkInterval;
       });
     },
-    [durably, subscription]
+    [trigger]
   );
+  useEffect(() => {
+    return () => {
+      if (waitIntervalRef.current) {
+        clearInterval(waitIntervalRef.current);
+      }
+    };
+  }, []);
+  const reset = useCallback(() => {
+    subscription.reset();
+    setCurrentRunId(null);
+    setIsPending(false);
+  }, [subscription.reset]);
+  const effectiveStatus = subscription.status ?? (isPending ? "pending" : null);
+  useEffect(() => {
+    if (subscription.status && isPending) {
+      setIsPending(false);
+    }
+  }, [subscription.status, isPending]);
   return {
     trigger,
     triggerAndWait,
-    status: subscription.status,
+    status: effectiveStatus,
     output: subscription.output,
     error: subscription.error,
     logs: subscription.logs,
     progress: subscription.progress,
-    isRunning: subscription.status === "running",
-    isPending: subscription.status === "pending",
-    isCompleted: subscription.status === "completed",
-    isFailed: subscription.status === "failed",
-    isCancelled: subscription.status === "cancelled",
-    currentRunId: subscription.currentRunId,
-    reset: subscription.reset
-  };
-}
-
-// src/hooks/use-run-subscription.ts
-import { useMemo as useMemo2 } from "react";
-
-// src/shared/durably-event-subscriber.ts
-function createDurablyEventSubscriber(durably) {
-  return {
-    subscribe(runId, onEvent) {
-      const unsubscribes = [];
-      unsubscribes.push(
-        durably.on("run:start", (event) => {
-          if (event.runId !== runId) return;
-          onEvent({ type: "run:start" });
-        })
-      );
-      unsubscribes.push(
-        durably.on("run:complete", (event) => {
-          if (event.runId !== runId) return;
-          onEvent({ type: "run:complete", output: event.output });
-        })
-      );
-      unsubscribes.push(
-        durably.on("run:fail", (event) => {
-          if (event.runId !== runId) return;
-          onEvent({ type: "run:fail", error: event.error });
-        })
-      );
-      unsubscribes.push(
-        durably.on("run:cancel", (event) => {
-          if (event.runId !== runId) return;
-          onEvent({ type: "run:cancel" });
-        })
-      );
-      unsubscribes.push(
-        durably.on("run:retry", (event) => {
-          if (event.runId !== runId) return;
-          onEvent({ type: "run:retry" });
-        })
-      );
-      unsubscribes.push(
-        durably.on("run:progress", (event) => {
-          if (event.runId !== runId) return;
-          onEvent({ type: "run:progress", progress: event.progress });
-        })
-      );
-      unsubscribes.push(
-        durably.on("log:write", (event) => {
-          if (event.runId !== runId) return;
-          onEvent({
-            type: "log:write",
-            runId: event.runId,
-            stepName: event.stepName,
-            level: event.level,
-            message: event.message,
-            data: event.data
-          });
-        })
-      );
-      return () => {
-        for (const unsubscribe of unsubscribes) {
-          unsubscribe();
-        }
-      };
-    }
+    isRunning: effectiveStatus === "running",
+    isPending: effectiveStatus === "pending",
+    isCompleted: effectiveStatus === "completed",
+    isFailed: effectiveStatus === "failed",
+    isCancelled: effectiveStatus === "cancelled",
+    currentRunId,
+    reset
   };
 }
 
-// src/hooks/use-run-subscription.ts
-function useRunSubscription(durably, runId, options) {
-  const subscriber = useMemo2(
-    () => durably ? createDurablyEventSubscriber(durably) : null,
-    [durably]
-  );
-  return useSubscription(subscriber, runId, options);
-}
-
-// src/hooks/use-job-logs.ts
+// src/client/use-job-logs.ts
 function useJobLogs(options) {
-  const { durably } = useDurably();
-  const { runId, maxLogs } = options;
-  const subscription = useRunSubscription(durably, runId, { maxLogs });
+  const { api, runId, maxLogs } = options;
+  const subscription = useSSESubscription(api, runId, { maxLogs });
   return {
     logs: subscription.logs,
     clearLogs: subscription.clearLogs
   };
 }
 
-// src/hooks/use-job-run.ts
-import { useEffect as useEffect4, useRef as useRef3 } from "react";
+// src/client/use-job-run.ts
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
 function useJobRun(options) {
-  const { durably } = useDurably();
-  const { runId } = options;
-  const subscription = useRunSubscription(durably, runId);
-  const fetchedRef = useRef3(/* @__PURE__ */ new Set());
-  useEffect4(() => {
-    if (!durably || !runId || fetchedRef.current.has(runId)) return;
-    fetchedRef.current.add(runId);
-  }, [durably, runId]);
+  const { api, runId, onStart, onComplete, onFail } = options;
+  const subscription = useSSESubscription(api, runId);
+  const effectiveStatus = subscription.status ?? (runId ? "pending" : null);
+  const isCompleted = effectiveStatus === "completed";
+  const isFailed = effectiveStatus === "failed";
+  const isPending = effectiveStatus === "pending";
+  const isRunning = effectiveStatus === "running";
+  const isCancelled = effectiveStatus === "cancelled";
+  const prevStatusRef = useRef2(null);
+  useEffect2(() => {
+    const prevStatus = prevStatusRef.current;
+    prevStatusRef.current = effectiveStatus;
+    if (prevStatus !== effectiveStatus) {
+      if (prevStatus === null && (isPending || isRunning) && onStart) {
+        onStart();
+      }
+      if (isCompleted && onComplete) {
+        onComplete();
+      }
+      if (isFailed && onFail) {
+        onFail();
+      }
+    }
+  }, [
+    effectiveStatus,
+    isPending,
+    isRunning,
+    isCompleted,
+    isFailed,
+    onStart,
+    onComplete,
+    onFail
+  ]);
   return {
-    status: subscription.status,
+    status: effectiveStatus,
     output: subscription.output,
     error: subscription.error,
     logs: subscription.logs,
     progress: subscription.progress,
-    isRunning: subscription.status === "running",
-    isPending: subscription.status === "pending",
-    isCompleted: subscription.status === "completed",
-    isFailed: subscription.status === "failed",
-    isCancelled: subscription.status === "cancelled"
+    isRunning,
+    isPending,
+    isCompleted,
+    isFailed,
+    isCancelled
   };
 }
 
-// src/hooks/use-runs.ts
-import { useCallback as useCallback3, useEffect as useEffect5, useMemo as useMemo3, useState } from "react";
+// src/client/create-job-hooks.ts
+function createJobHooks(options) {
+  const { api, jobName } = options;
+  return {
+    useJob: () => {
+      return useJob({ api, jobName });
+    },
+    useRun: (runId) => {
+      return useJobRun({ api, runId });
+    },
+    useLogs: (runId, logsOptions) => {
+      return useJobLogs({ api, runId, maxLogs: logsOptions?.maxLogs });
+    }
+  };
+}
+
+// src/client/use-run-actions.ts
+import { useCallback as useCallback2, useState as useState2 } from "react";
+function useRunActions(options) {
+  const { api } = options;
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const executeAction = useCallback2(
+    async (url, actionName, init) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const response = await fetch(url, init);
+        if (!response.ok) {
+          let errorMessage = `Failed to ${actionName}: ${response.statusText}`;
+          try {
+            const data = await response.json();
+            if (data.error) {
+              errorMessage = data.error;
+            }
+          } catch {
+          }
+          throw new Error(errorMessage);
+        }
+        return await response.json();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        setError(message);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    []
+  );
+  const retrigger = useCallback2(
+    async (runId) => {
+      const enc = encodeURIComponent(runId);
+      const data = await executeAction(
+        `${api}/retrigger?runId=${enc}`,
+        "retrigger",
+        { method: "POST" }
+      );
+      if (!data.runId) {
+        const message = "Failed to retrigger: missing runId in response";
+        setError(message);
+        throw new Error(message);
+      }
+      return data.runId;
+    },
+    [api, executeAction]
+  );
+  const cancel = useCallback2(
+    async (runId) => {
+      const enc = encodeURIComponent(runId);
+      await executeAction(`${api}/cancel?runId=${enc}`, "cancel", {
+        method: "POST"
+      });
+    },
+    [api, executeAction]
+  );
+  const deleteRun = useCallback2(
+    async (runId) => {
+      const enc = encodeURIComponent(runId);
+      await executeAction(`${api}/run?runId=${enc}`, "delete", {
+        method: "DELETE"
+      });
+    },
+    [api, executeAction]
+  );
+  const getRun = useCallback2(
+    async (runId) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const enc = encodeURIComponent(runId);
+        const response = await fetch(`${api}/run?runId=${enc}`);
+        if (response.status === 404) {
+          return null;
+        }
+        if (!response.ok) {
+          let errorMessage = `Failed to get run: ${response.statusText}`;
+          try {
+            const data = await response.json();
+            if (data.error) {
+              errorMessage = data.error;
+            }
+          } catch {
+          }
+          throw new Error(errorMessage);
+        }
+        return await response.json();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        setError(message);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [api]
+  );
+  const getSteps = useCallback2(
+    async (runId) => {
+      const enc = encodeURIComponent(runId);
+      return executeAction(
+        `${api}/steps?runId=${enc}`,
+        "get steps"
+      );
+    },
+    [api, executeAction]
+  );
+  return {
+    retrigger,
+    cancel,
+    deleteRun,
+    getRun,
+    getSteps,
+    isLoading,
+    error
+  };
+}
+
+// src/client/use-runs.ts
+import { useCallback as useCallback3, useEffect as useEffect3, useMemo as useMemo2, useRef as useRef3, useState as useState3 } from "react";
 function useRuns(jobDefinitionOrOptions, optionsArg) {
-  const { durably } = useDurably();
   const isJob = isJobDefinition(jobDefinitionOrOptions);
-  const jobName = isJob ? jobDefinitionOrOptions.name : jobDefinitionOrOptions?.jobName;
+  const jobName = isJob ? jobDefinitionOrOptions.name : jobDefinitionOrOptions.jobName;
   const options = isJob ? optionsArg : jobDefinitionOrOptions;
-  const pageSize = options?.pageSize ?? 10;
-  const realtime = options?.realtime ?? true;
-  const status = options?.status;
-  const labelsKey = options?.labels ? JSON.stringify(options.labels) : void 0;
-  const labels = useMemo3(
+  const { api, status, labels, pageSize = 10, realtime = true } = options;
+  const labelsKey = labels ? JSON.stringify(labels) : void 0;
+  const stableLabels = useMemo2(
     () => labelsKey ? JSON.parse(labelsKey) : void 0,
     [labelsKey]
   );
-  const [runs, setRuns] = useState([]);
-  const [page, setPage] = useState(0);
-  const [hasMore, setHasMore] = useState(false);
-  const [isLoading, setIsLoading] = useState(true);
+  const jobNameKey = jobName ? JSON.stringify(jobName) : void 0;
+  const stableJobName = useMemo2(
+    () => jobNameKey ? JSON.parse(jobNameKey) : void 0,
+    [jobNameKey]
+  );
+  const [runs, setRuns] = useState3([]);
+  const [page, setPage] = useState3(0);
+  const [hasMore, setHasMore] = useState3(false);
+  const [isLoading, setIsLoading] = useState3(true);
+  const [error, setError] = useState3(null);
+  const isMountedRef = useRef3(true);
+  const eventSourceRef = useRef3(null);
   const refresh = useCallback3(async () => {
-    if (!durably) return;
     setIsLoading(true);
+    setError(null);
     try {
-      const data = await durably.getRuns({
-        jobName,
-        status,
-        labels,
-        limit: pageSize + 1,
-        offset: page * pageSize
-      });
-      setHasMore(data.length > pageSize);
-      setRuns(data.slice(0, pageSize));
+      const params = new URLSearchParams();
+      appendJobNameToParams(params, stableJobName);
+      if (status) params.set("status", status);
+      appendLabelsToParams(params, stableLabels);
+      params.set("limit", String(pageSize + 1));
+      params.set("offset", String(page * pageSize));
+      const url = `${api}/runs?${params.toString()}`;
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch runs: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (isMountedRef.current) {
+        setHasMore(data.length > pageSize);
+        setRuns(data.slice(0, pageSize));
+      }
+    } catch (err) {
+      if (isMountedRef.current) {
+        setError(err instanceof Error ? err.message : "Unknown error");
+      }
     } finally {
-      setIsLoading(false);
+      if (isMountedRef.current) {
+        setIsLoading(false);
+      }
     }
-  }, [durably, jobName, status, labels, pageSize, page]);
-  useEffect5(() => {
-    if (!durably) return;
+  }, [api, stableJobName, status, stableLabels, pageSize, page]);
+  useEffect3(() => {
+    isMountedRef.current = true;
     refresh();
-    if (!realtime) return;
-    const unsubscribes = [
-      durably.on("run:trigger", refresh),
-      durably.on("run:start", refresh),
-      durably.on("run:complete", refresh),
-      durably.on("run:fail", refresh),
-      durably.on("run:cancel", refresh),
-      durably.on("run:delete", refresh),
-      durably.on("run:retry", refresh),
-      durably.on("run:progress", refresh),
-      durably.on("step:start", refresh),
-      durably.on("step:complete", refresh),
-      durably.on("step:fail", refresh),
-      durably.on("step:cancel", refresh)
-    ];
     return () => {
-      for (const unsubscribe of unsubscribes) {
-        unsubscribe();
+      isMountedRef.current = false;
+    };
+  }, [refresh]);
+  useEffect3(() => {
+    if (!realtime || page !== 0) {
+      if (eventSourceRef.current) {
+        eventSourceRef.current.close();
+        eventSourceRef.current = null;
+      }
+      return;
+    }
+    const params = new URLSearchParams();
+    appendJobNameToParams(params, stableJobName);
+    appendLabelsToParams(params, stableLabels);
+    const sseUrl = `${api}/runs/subscribe${params.toString() ? `?${params.toString()}` : ""}`;
+    const eventSource = new EventSource(sseUrl);
+    eventSourceRef.current = eventSource;
+    eventSource.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.type === "run:trigger" || data.type === "run:start" || data.type === "run:complete" || data.type === "run:fail" || data.type === "run:cancel" || data.type === "run:delete") {
+          refresh();
+        }
+        if (data.type === "run:progress") {
+          setRuns(
+            (prev) => prev.map(
+              (run) => run.id === data.runId ? { ...run, progress: data.progress } : run
+            )
+          );
+        }
+        if (data.type === "step:complete") {
+          setRuns(
+            (prev) => prev.map(
+              (run) => run.id === data.runId ? { ...run, currentStepIndex: data.stepIndex + 1 } : run
+            )
+          );
+        }
+        if (data.type === "step:start" || data.type === "step:fail" || data.type === "step:cancel") {
+          refresh();
+        }
+      } catch {
       }
     };
-  }, [durably, refresh, realtime]);
+    eventSource.onerror = () => {
+    };
+    return () => {
+      eventSource.close();
+      eventSourceRef.current = null;
+    };
+  }, [api, stableJobName, stableLabels, page, realtime, refresh]);
   const nextPage = useCallback3(() => {
     if (hasMore) {
       setPage((p) => p + 1);
@@ -479,18 +558,54 @@ function useRuns(jobDefinitionOrOptions, optionsArg) {
     page,
     hasMore,
     isLoading,
+    error,
     nextPage,
     prevPage,
     goToPage,
     refresh
   };
 }
+function appendJobNameToParams(params, jobName) {
+  if (!jobName) return;
+  for (const name of Array.isArray(jobName) ? jobName : [jobName]) {
+    params.append("jobName", name);
+  }
+}
+function appendLabelsToParams(params, labels) {
+  if (!labels) return;
+  for (const [key, value] of Object.entries(labels)) {
+    params.set(`label.${key}`, value);
+  }
+}
+
+// src/client/create-durably.ts
+function createDurably(options) {
+  const { api } = options;
+  const cache = /* @__PURE__ */ new Map();
+  const builtins = {
+    useRuns: (opts) => useRuns({ api, ...opts }),
+    useRunActions: () => useRunActions({ api })
+  };
+  return new Proxy({}, {
+    get(_target, key) {
+      if (typeof key !== "string") return void 0;
+      if (key in builtins) return builtins[key];
+      let hooks = cache.get(key);
+      if (!hooks) {
+        hooks = createJobHooks({ api, jobName: key });
+        cache.set(key, hooks);
+      }
+      return hooks;
+    }
+  });
+}
 export {
-  DurablyProvider,
-  useDurably,
+  createDurably,
+  createJobHooks,
   useJob,
   useJobLogs,
   useJobRun,
+  useRunActions,
   useRuns
 };
 //# sourceMappingURL=index.js.map