@pgflow/client 0.7.1 → 0.7.2

package/dist/index.js

@@ -1,61 +1,61 @@
-var N = (e) => {
-  throw TypeError(e);
+var N = (s) => {
+  throw TypeError(s);
 };
-var O = (e, t, s) => t.has(e) || N("Cannot " + s);
-var r = (e, t, s) => (O(e, t, "read from private field"), s ? s.call(e) : t.get(e)), c = (e, t, s) => t.has(e) ? N("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, s), g = (e, t, s, n) => (O(e, t, "write to private field"), n ? n.call(e, s) : t.set(e, s), s), w = (e, t, s) => (O(e, t, "access private method"), s);
-var H = (e, t, s, n) => ({
+var O = (s, t, r) => t.has(s) || N("Cannot " + r);
+var e = (s, t, r) => (O(s, t, "read from private field"), r ? r.call(s) : t.get(s)), d = (s, t, r) => t.has(s) ? N("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(s) : t.set(s, r), _ = (s, t, r, n) => (O(s, t, "write to private field"), n ? n.call(s, r) : t.set(s, r), r), m = (s, t, r) => (O(s, t, "access private method"), r);
+var H = (s, t, r, n) => ({
   set _(i) {
-    g(e, t, i, s);
+    _(s, t, i, r);
   },
   get _() {
-    return r(e, t, n);
+    return e(s, t, n);
   }
 });
-import { v4 as st } from "uuid";
+import { v4 as et } from "uuid";
 import { createNanoEvents as L } from "nanoevents";
-var u = /* @__PURE__ */ ((e) => (e.Started = "started", e.Completed = "completed", e.Failed = "failed", e))(u || {});
-function ct(e) {
-  return !!e && typeof e == "object" && "run_id" in e && "flow_slug" in e && !("step_slug" in e) && "status" in e && (e.status === "started" || e.status === "completed" || e.status === "failed");
+var c = /* @__PURE__ */ ((s) => (s.Started = "started", s.Completed = "completed", s.Failed = "failed", s))(c || {});
+function lt(s) {
+  return !!s && typeof s == "object" && "run_id" in s && "flow_slug" in s && !("step_slug" in s) && "status" in s && (s.status === "started" || s.status === "completed" || s.status === "failed");
 }
-function pt(e) {
-  return e.status === "started";
+function dt(s) {
+  return s.status === "started";
 }
-function ht(e) {
-  return e.status === "completed";
+function ct(s) {
+  return s.status === "completed";
 }
-function _t(e) {
-  return e.status === "failed";
+function pt(s) {
+  return s.status === "failed";
 }
-var l = /* @__PURE__ */ ((e) => (e.Created = "created", e.Started = "started", e.Completed = "completed", e.Failed = "failed", e))(l || {});
-function K(e) {
-  return !!e && typeof e == "object" && "run_id" in e && "step_slug" in e && "status" in e && (e.status === "started" || e.status === "completed" || e.status === "failed");
+var h = /* @__PURE__ */ ((s) => (s.Created = "created", s.Started = "started", s.Completed = "completed", s.Failed = "failed", s))(h || {});
+function K(s) {
+  return !!s && typeof s == "object" && "run_id" in s && "step_slug" in s && "status" in s && (s.status === "started" || s.status === "completed" || s.status === "failed");
 }
-function ft(e) {
-  return K(e) && e.status === "started" && "event_type" in e && e.event_type === "step:started";
+function ht(s) {
+  return K(s) && s.status === "started" && "event_type" in s && s.event_type === "step:started";
 }
-function mt(e) {
-  return K(e) && e.status === "completed" && "event_type" in e && e.event_type === "step:completed";
+function ft(s) {
+  return K(s) && s.status === "completed" && "event_type" in s && s.event_type === "step:completed";
 }
-function gt(e) {
-  return K(e) && e.status === "failed" && "event_type" in e && e.event_type === "step:failed";
+function _t(s) {
+  return K(s) && s.status === "failed" && "event_type" in s && s.event_type === "step:failed";
 }
-var S, C, F, M, I, f, j, X, z, Y, Z, v, k, G;
-class rt {
+var S, C, F, U, I, f, j, V, z, X, Y, Z, k, G;
+class st {
   /**
    * Creates a new instance of SupabaseBroadcastAdapter
    *
    * @param supabase - Supabase client instance
    */
-  constructor(t, s = {}) {
-    c(this, f);
-    c(this, S);
-    c(this, C, /* @__PURE__ */ new Map());
-    c(this, F, L());
-    c(this, M);
-    c(this, I);
+  constructor(t, r = {}) {
+    d(this, f);
+    d(this, S);
+    d(this, C, /* @__PURE__ */ new Map());
+    d(this, F, L());
+    d(this, U);
+    d(this, I);
     // Store unsubscribe functions per run ID for reference equality
-    c(this, k, /* @__PURE__ */ new Map());
-    g(this, S, t), g(this, M, s.reconnectDelayMs ?? 2e3), g(this, I, s.schedule ?? setTimeout);
+    d(this, k, /* @__PURE__ */ new Map());
+    _(this, S, t), _(this, U, r.reconnectDelayMs ?? 2e3), _(this, I, r.schedule ?? setTimeout);
   }
   /**
    * Fetches flow definition metadata from the database
@@ -63,16 +63,16 @@ class rt {
    * @param flow_slug - Flow slug to fetch
    */
   async fetchFlowDefinition(t) {
-    const [s, n] = await Promise.all([
-      r(this, S).schema("pgflow").from("flows").select("*").eq("flow_slug", t).single(),
-      r(this, S).schema("pgflow").from("steps").select("*").eq("flow_slug", t).order("step_index", { ascending: !0 })
+    const [r, n] = await Promise.all([
+      e(this, S).schema("pgflow").from("flows").select("*").eq("flow_slug", t).single(),
+      e(this, S).schema("pgflow").from("steps").select("*").eq("flow_slug", t).order("step_index", { ascending: !0 })
     ]);
-    if (s.error) throw s.error;
-    if (!s.data) throw new Error(`Flow "${t}" not found`);
+    if (r.error) throw r.error;
+    if (!r.data) throw new Error(`Flow "${t}" not found`);
     if (n.error) throw n.error;
     const i = Array.isArray(n.data) ? n.data : [];
     return {
-      flow: s.data,
+      flow: r.data,
       steps: i
     };
   }
@@ -83,10 +83,10 @@ class rt {
    * @returns Function to unsubscribe from the event
    */
   onRunEvent(t) {
-    const s = r(this, F).on("runEvent", t);
+    const r = e(this, F).on("runEvent", t);
     return () => {
       try {
-        s();
+        r();
       } catch (n) {
         console.warn("Could not unsubscribe from run event - emitter may have been disposed", n);
       }
@@ -99,10 +99,10 @@ class rt {
    * @returns Function to unsubscribe from the event
    */
   onStepEvent(t) {
-    const s = r(this, F).on("stepEvent", t);
+    const r = e(this, F).on("stepEvent", t);
     return () => {
       try {
-        s();
+        r();
       } catch (n) {
         console.warn("Could not unsubscribe from step event - emitter may have been disposed", n);
       }
@@ -115,28 +115,28 @@ class rt {
    * @returns Function to unsubscribe
    */
   async subscribeToRun(t) {
-    const s = `pgflow:run:${t}`;
-    if (r(this, C).has(t)) {
-      const _ = r(this, k).get(t);
-      if (_)
-        return _;
-      w(this, f, G).call(this, t);
+    const r = `pgflow:run:${t}`;
+    if (e(this, C).has(t)) {
+      const p = e(this, k).get(t);
+      if (p)
+        return p;
+      m(this, f, G).call(this, t);
     }
-    const n = r(this, S).channel(s);
-    n.on("broadcast", { event: "*" }, w(this, f, j).bind(this)), n.on("system", { event: "closed" }, () => {
-      console.log(`Channel ${s} closed`);
-    }), n.on("system", { event: "error" }, (_) => {
-      console.log(`Channel ${s} error:`, _), w(this, f, z).call(this, t, s, n, _.error);
-    }), console.log(`Subscribing to channel ${s}...`), await new Promise((_, h) => {
-      const d = setTimeout(() => {
-        h(new Error(`Subscription timeout for channel ${s}`));
+    const n = e(this, S).channel(r);
+    n.on("broadcast", { event: "*" }, m(this, f, j).bind(this)), n.on("system", { event: "closed" }, () => {
+      console.log(`Channel ${r} closed`);
+    }), n.on("system", { event: "error" }, (p) => {
+      console.log(`Channel ${r} error:`, p), m(this, f, z).call(this, t, r, n, p.error);
+    }), console.log(`Subscribing to channel ${r}...`), await new Promise((p, u) => {
+      const l = setTimeout(() => {
+        u(new Error(`Subscription timeout for channel ${r}`));
       }, 2e4);
-      n.subscribe((m) => {
-        console.log(`Channel ${s} subscription status:`, m), m === "SUBSCRIBED" && (clearTimeout(d), _());
+      n.subscribe((b) => {
+        console.log(`Channel ${r} subscription status:`, b), b === "SUBSCRIBED" && (clearTimeout(l), p());
       });
-    }), r(this, C).set(t, n);
-    const a = () => this.unsubscribe(t);
-    return r(this, k).set(t, a), a;
+    }), e(this, C).set(t, n);
+    const w = () => this.unsubscribe(t);
+    return e(this, k).set(t, w), w;
   }
   /**
    * Unsubscribes from a run's events
@@ -144,7 +144,7 @@ class rt {
    * @param run_id - Run ID to unsubscribe from
    */
   unsubscribe(t) {
-    w(this, f, G).call(this, t);
+    m(this, f, G).call(this, t);
   }
   /**
    * Fetches current state of a run and its steps
@@ -152,24 +152,24 @@ class rt {
    * @param run_id - Run ID to fetch
    */
   async getRunWithStates(t) {
-    const { data: s, error: n } = await r(this, S).schema("pgflow").rpc("get_run_with_states", { run_id: t });
+    const { data: r, error: n } = await e(this, S).schema("pgflow").rpc("get_run_with_states", { run_id: t });
     if (n) throw n;
-    if (!s) throw new Error(`No data returned for run ${t}`);
-    return s;
+    if (!r) throw new Error(`No data returned for run ${t}`);
+    return r;
   }
 }
-S = new WeakMap(), C = new WeakMap(), F = new WeakMap(), M = new WeakMap(), I = new WeakMap(), f = new WeakSet(), /**
+S = new WeakMap(), C = new WeakMap(), F = new WeakMap(), U = new WeakMap(), I = new WeakMap(), f = new WeakSet(), /**
  * Handle broadcast messages from Supabase
  * @param payload - The message payload
  */
 j = function(t) {
-  const { event: s, payload: n } = t, i = n;
-  w(this, f, X).call(this, i), s.startsWith("run:") ? r(this, F).emit("runEvent", i) : s.startsWith("step:") && r(this, F).emit("stepEvent", i);
+  const { event: r, payload: n } = t, i = n;
+  m(this, f, V).call(this, i), r.startsWith("run:") ? e(this, F).emit("runEvent", i) : r.startsWith("step:") && e(this, F).emit("stepEvent", i);
 }, /**
  * Parse JSON string fields in broadcast event data
  * @param eventData - The event data object to parse
  */
-X = function(t) {
+V = function(t) {
   if ("output" in t && typeof t.output == "string")
     try {
       t.output = JSON.parse(t.output);
@@ -180,55 +180,55 @@ X = function(t) {
       t.input = JSON.parse(t.input);
     } catch {
     }
-}, z = async function(t, s, n, i) {
-  console.error(`Channel ${s} error:`, i), r(this, I).call(this, async () => {
-    r(this, C).has(t) && await w(this, f, Z).call(this, t, s);
-  }, r(this, M));
+}, z = async function(t, r, n, i) {
+  console.error(`Channel ${r} error:`, i), e(this, I).call(this, async () => {
+    e(this, C).has(t) && await m(this, f, Y).call(this, t, r);
+  }, e(this, U));
 }, /**
  * Creates and configures a channel for a run
  * @param run_id - The run ID
  * @param channelName - The channel name
  * @returns The configured RealtimeChannel
  */
-Y = function(t, s) {
-  const n = r(this, S).channel(s);
-  return n.on("broadcast", { event: "*" }, w(this, f, j).bind(this)), n;
-}, Z = async function(t, s) {
-  console.log(`Attempting to reconnect to ${s}`);
+X = function(t, r) {
+  const n = e(this, S).channel(r);
+  return n.on("broadcast", { event: "*" }, m(this, f, j).bind(this)), n;
+}, Y = async function(t, r) {
+  console.log(`Attempting to reconnect to ${r}`);
   try {
     const n = await this.getRunWithStates(t);
-    w(this, f, v).call(this, t, n);
-    const i = w(this, f, Y).call(this, t, s);
+    m(this, f, Z).call(this, t, n);
+    const i = m(this, f, X).call(this, t, r);
     i.on("system", { event: "subscribed" }, () => {
-      console.log(`Reconnected and subscribed to channel ${s}`);
+      console.log(`Reconnected and subscribed to channel ${r}`);
     }), i.on("system", { event: "closed" }, () => {
-      console.log(`Reconnected channel ${s} closed`);
+      console.log(`Reconnected channel ${r} closed`);
     }), i.on(
       "system",
       { event: "error" },
-      (a) => w(this, f, z).call(this, t, s, i, a.error)
-    ), i.subscribe(), r(this, C).set(t, i);
+      (w) => m(this, f, z).call(this, t, r, i, w.error)
+    ), i.subscribe(), e(this, C).set(t, i);
   } catch (n) {
-    console.error(`Failed to reconnect to ${s}:`, n);
+    console.error(`Failed to reconnect to ${r}:`, n);
   }
 }, /**
  * Refresh client state from a state snapshot
  * @param run_id - The run ID
  * @param state - The state snapshot
  */
-v = function(t, s) {
-  if (!s || !s.run) return;
+Z = function(t, r) {
+  if (!r || !r.run) return;
   const n = {
-    event_type: `run:${s.run.status}`,
-    ...s.run
+    event_type: `run:${r.run.status}`,
+    ...r.run
   };
-  if (r(this, F).emit("runEvent", n), s.steps && Array.isArray(s.steps))
-    for (const i of s.steps) {
-      const a = {
+  if (e(this, F).emit("runEvent", n), r.steps && Array.isArray(r.steps))
+    for (const i of r.steps) {
+      const w = {
         event_type: `step:${i.status}`,
         ...i
       };
-      r(this, F).emit("stepEvent", a);
+      e(this, F).emit("stepEvent", w);
     }
 }, k = new WeakMap(), /**
  * Unsubscribes from a run's events
@@ -236,81 +236,81 @@ v = function(t, s) {
  * @param run_id - Run ID to unsubscribe from
  */
 G = function(t) {
-  const s = r(this, C).get(t);
-  s && (s.unsubscribe(), r(this, C).delete(t), r(this, k).delete(t));
+  const r = e(this, C).get(t);
+  r && (r.unsubscribe(), e(this, C).delete(t), e(this, k).delete(t));
 };
-var p, $, W, J, tt;
-class nt {
+var o, $, W, J, v;
+class rt {
   /**
    * Creates a new FlowStep instance
    * 
    * @param initialState - Initial state for the step
    */
   constructor(t) {
-    c(this, J);
-    c(this, p);
-    c(this, $, L());
-    c(this, W, {
-      [l.Created]: 0,
-      [l.Started]: 1,
-      [l.Completed]: 2,
-      [l.Failed]: 3
+    d(this, J);
+    d(this, o);
+    d(this, $, L());
+    d(this, W, {
+      [h.Created]: 0,
+      [h.Started]: 1,
+      [h.Completed]: 2,
+      [h.Failed]: 3
     });
-    g(this, p, t);
+    _(this, o, t);
   }
   /**
    * Get the run ID this step belongs to
    */
   get run_id() {
-    return r(this, p).run_id;
+    return e(this, o).run_id;
   }
   /**
    * Get the step slug
    */
   get step_slug() {
-    return r(this, p).step_slug;
+    return e(this, o).step_slug;
   }
   /**
    * Get the current status
    */
   get status() {
-    return r(this, p).status;
+    return e(this, o).status;
   }
   /**
    * Get the started_at timestamp
    */
   get started_at() {
-    return r(this, p).started_at;
+    return e(this, o).started_at;
   }
   /**
    * Get the completed_at timestamp
    */
   get completed_at() {
-    return r(this, p).completed_at;
+    return e(this, o).completed_at;
   }
   /**
    * Get the failed_at timestamp
    */
   get failed_at() {
-    return r(this, p).failed_at;
+    return e(this, o).failed_at;
   }
   /**
    * Get the step output
    */
   get output() {
-    return r(this, p).output;
+    return e(this, o).output;
   }
   /**
    * Get the error object
    */
   get error() {
-    return r(this, p).error;
+    return e(this, o).error;
   }
   /**
    * Get the error message
    */
   get error_message() {
-    return r(this, p).error_message;
+    return e(this, o).error_message;
   }
   /**
    * Register an event handler for a step event
@@ -319,8 +319,8 @@ class nt {
    * @param callback - Callback function to execute when event is emitted
    * @returns Function to unsubscribe from the event
    */
-  on(t, s) {
-    return r(this, $).on(t, s);
+  on(t, r) {
+    return e(this, $).on(t, r);
   }
   /**
    * Wait for the step to reach a specific status
@@ -329,88 +329,98 @@ class nt {
    * @param options - Optional timeout and abort signal
    * @returns Promise that resolves with the step instance when the status is reached
    */
-  waitForStatus(t, s) {
-    const n = (s == null ? void 0 : s.timeoutMs) ?? 3e5, { signal: i } = s || {};
-    return this.status === t ? Promise.resolve(this) : new Promise((a, _) => {
-      let h, d = !1;
-      n > 0 && (h = setTimeout(() => {
-        d || (d = !0, A(), _(new Error(`Timeout waiting for step ${this.step_slug} to reach status '${t}'`)));
+  waitForStatus(t, r) {
+    const n = (r == null ? void 0 : r.timeoutMs) ?? 3e5, { signal: i } = r || {};
+    return this.status === t ? Promise.resolve(this) : new Promise((w, p) => {
+      let u, l = !1;
+      n > 0 && (u = setTimeout(() => {
+        l || (l = !0, T(), p(new Error(`Timeout waiting for step ${this.step_slug} to reach status '${t}'`)));
       }, n));
-      let m;
+      let b;
       if (i) {
         const E = () => {
-          d || (d = !0, h && clearTimeout(h), A(), _(new Error(`Aborted waiting for step ${this.step_slug} to reach status '${t}'`)));
+          l || (l = !0, u && clearTimeout(u), T(), p(new Error(`Aborted waiting for step ${this.step_slug} to reach status '${t}'`)));
         };
-        i.addEventListener("abort", E), m = () => {
+        i.addEventListener("abort", E), b = () => {
           i.removeEventListener("abort", E);
         };
       }
-      const A = this.on("*", (E) => {
+      const T = this.on("*", (E) => {
         if (E.status === t) {
-          if (d) return;
-          d = !0, h && clearTimeout(h), m && m(), A(), a(this);
+          if (l) return;
+          l = !0, u && clearTimeout(u), b && b(), T(), w(this);
         }
       });
     });
   }
+  /**
+   * Apply state from database snapshot (no events emitted)
+   * Used when initializing state from start_flow_with_states() or get_run_with_states()
+   *
+   * @internal This method is only intended for use by PgflowClient.
+   * Applications should not call this directly.
+   */
+  applySnapshot(t) {
+    e(this, o).status = t.status, e(this, o).started_at = t.started_at ? new Date(t.started_at) : null, e(this, o).completed_at = t.completed_at ? new Date(t.completed_at) : null, e(this, o).failed_at = t.failed_at ? new Date(t.failed_at) : null, e(this, o).error_message = t.error_message, e(this, o).error = t.error_message ? new Error(t.error_message) : null;
+  }
   /**
    * Updates the step state based on an event
-   * 
+   *
    * @internal This method is only intended for use by FlowRun and tests.
    * Applications should not call this directly - state updates should come from
    * database events through the PgflowClient.
-   * 
+   *
    * TODO: After v1.0, make this method private and refactor tests to use PgflowClient
    * with event emission instead of direct state manipulation.
    */
   updateState(t) {
-    if (t.step_slug !== r(this, p).step_slug || t.run_id !== r(this, p).run_id || !w(this, J, tt).call(this, r(this, p).status, t.status))
+    if (t.step_slug !== e(this, o).step_slug || t.run_id !== e(this, o).run_id || !m(this, J, v).call(this, e(this, o).status, t.status))
       return !1;
     switch (t.status) {
-      case l.Started:
-        g(this, p, {
-          ...r(this, p),
-          status: l.Started,
+      case h.Started:
+        _(this, o, {
+          ...e(this, o),
+          status: h.Started,
           started_at: typeof t.started_at == "string" ? new Date(t.started_at) : /* @__PURE__ */ new Date()
-        }), r(this, $).emit("started", t);
+        }), e(this, $).emit("started", t);
         break;
-      case l.Completed:
-        g(this, p, {
-          ...r(this, p),
-          status: l.Completed,
+      case h.Completed:
+        _(this, o, {
+          ...e(this, o),
+          status: h.Completed,
           completed_at: typeof t.completed_at == "string" ? new Date(t.completed_at) : /* @__PURE__ */ new Date(),
           output: t.output
-        }), r(this, $).emit("completed", t);
+        }), e(this, $).emit("completed", t);
         break;
-      case l.Failed:
-        g(this, p, {
-          ...r(this, p),
-          status: l.Failed,
+      case h.Failed:
+        _(this, o, {
+          ...e(this, o),
+          status: h.Failed,
           failed_at: typeof t.failed_at == "string" ? new Date(t.failed_at) : /* @__PURE__ */ new Date(),
           error_message: typeof t.error_message == "string" ? t.error_message : "Unknown error",
           error: new Error(typeof t.error_message == "string" ? t.error_message : "Unknown error")
-        }), r(this, $).emit("failed", t);
+        }), e(this, $).emit("failed", t);
         break;
       default:
         return !1;
     }
-    return r(this, $).emit("*", t), !0;
+    return e(this, $).emit("*", t), !0;
   }
 }
-p = new WeakMap(), $ = new WeakMap(), W = new WeakMap(), J = new WeakSet(), /**
+o = new WeakMap(), $ = new WeakMap(), W = new WeakMap(), J = new WeakSet(), /**
  * Determines if a status should be updated based on precedence
  * 
  * @param currentStatus - Current status
  * @param newStatus - New status
  * @returns true if the status should be updated, false otherwise
  */
-tt = function(t, s) {
-  if (t === l.Completed || t === l.Failed)
+v = function(t, r) {
+  if (t === h.Completed || t === h.Failed)
     return !1;
-  const n = r(this, W)[t];
-  return r(this, W)[s] > n;
+  const n = e(this, W)[t];
+  return e(this, W)[r] > n;
 };
-var o, R, D, x, U, P, T, B, et;
+var a, R, A, x, M, P, D, B, tt;
 class Q {
   /**
    * Creates a new FlowRun instance
@@ -418,85 +428,85 @@ class Q {
    * @param initialState - Initial state for the run
    */
   constructor(t) {
-    c(this, T);
-    c(this, o);
-    c(this, R, L());
-    c(this, D, /* @__PURE__ */ new Map());
-    c(this, x, {
-      [u.Started]: 0,
-      [u.Completed]: 1,
-      [u.Failed]: 2
+    d(this, D);
+    d(this, a);
+    d(this, R, L());
+    d(this, A, /* @__PURE__ */ new Map());
+    d(this, x, {
+      [c.Started]: 0,
+      [c.Completed]: 1,
+      [c.Failed]: 2
     });
-    c(this, U, !1);
+    d(this, M, !1);
     // Track number of listeners
-    c(this, P, 0);
-    g(this, o, t);
+    d(this, P, 0);
+    _(this, a, t);
   }
   /**
    * Get the run ID
    */
   get run_id() {
-    return r(this, o).run_id;
+    return e(this, a).run_id;
   }
   /**
    * Get the flow slug
    */
   get flow_slug() {
-    return r(this, o).flow_slug;
+    return e(this, a).flow_slug;
   }
   /**
    * Get the current status
    */
   get status() {
-    return r(this, o).status;
+    return e(this, a).status;
   }
   /**
    * Get the started_at timestamp
    */
   get started_at() {
-    return r(this, o).started_at;
+    return e(this, a).started_at;
   }
   /**
    * Get the completed_at timestamp
    */
   get completed_at() {
-    return r(this, o).completed_at;
+    return e(this, a).completed_at;
   }
   /**
    * Get the failed_at timestamp
    */
   get failed_at() {
-    return r(this, o).failed_at;
+    return e(this, a).failed_at;
   }
   /**
    * Get the flow input
    */
   get input() {
-    return r(this, o).input;
+    return e(this, a).input;
   }
   /**
    * Get the flow output
    */
   get output() {
-    return r(this, o).output;
+    return e(this, a).output;
   }
   /**
    * Get the error object
    */
   get error() {
-    return r(this, o).error;
+    return e(this, a).error;
   }
   /**
    * Get the error message
    */
   get error_message() {
-    return r(this, o).error_message;
+    return e(this, a).error_message;
   }
   /**
    * Get the number of remaining steps
    */
   get remaining_steps() {
-    return r(this, o).remaining_steps;
+    return e(this, a).remaining_steps;
   }
   /**
    * Register an event handler for a run event
@@ -505,11 +515,11 @@ class Q {
    * @param callback - Callback function to execute when event is emitted
    * @returns Function to unsubscribe from the event
    */
-  on(t, s) {
+  on(t, r) {
     H(this, P)._++;
-    const n = r(this, R).on(t, s);
+    const n = e(this, R).on(t, r);
     return () => {
-      n(), H(this, P)._--, w(this, T, B).call(this);
+      n(), H(this, P)._--, m(this, D, B).call(this);
     };
   }
   /**
@@ -519,13 +529,13 @@ class Q {
    * @returns FlowStep instance for the specified step
    */
   step(t) {
-    const s = r(this, D).get(t);
-    if (s)
-      return s;
-    const n = new nt({
+    const r = e(this, A).get(t);
+    if (r)
+      return r;
+    const n = new rt({
       run_id: this.run_id,
       step_slug: t,
-      status: l.Created,
+      status: h.Created,
       output: null,
       error: null,
       error_message: null,
@@ -533,7 +543,7 @@ class Q {
       completed_at: null,
       failed_at: null
     });
-    return r(this, D).set(
+    return e(this, A).set(
       t,
       n
     ), n;
@@ -545,7 +555,7 @@ class Q {
    * @returns true if the step exists, false otherwise
    */
   hasStep(t) {
-    return r(this, D).has(t);
+    return e(this, A).has(t);
   }
   /**
    * Wait for the run to reach a specific status
@@ -554,84 +564,94 @@ class Q {
    * @param options - Optional timeout and abort signal
    * @returns Promise that resolves with the run instance when the status is reached
    */
-  waitForStatus(t, s) {
-    const n = (s == null ? void 0 : s.timeoutMs) ?? 3e5, { signal: i } = s || {};
-    return this.status === t ? Promise.resolve(this) : new Promise((a, _) => {
-      let h, d = !1;
-      n > 0 && (h = setTimeout(() => {
-        d || (d = !0, A(), _(
+  waitForStatus(t, r) {
+    const n = (r == null ? void 0 : r.timeoutMs) ?? 3e5, { signal: i } = r || {};
+    return this.status === t ? Promise.resolve(this) : new Promise((w, p) => {
+      let u, l = !1;
+      n > 0 && (u = setTimeout(() => {
+        l || (l = !0, T(), p(
           new Error(
             `Timeout waiting for run ${this.run_id} to reach status '${t}'`
           )
         ));
       }, n));
-      let m;
+      let b;
       if (i) {
         const E = () => {
-          d || (d = !0, h && clearTimeout(h), A(), _(
+          l || (l = !0, u && clearTimeout(u), T(), p(
             new Error(
               `Aborted waiting for run ${this.run_id} to reach status '${t}'`
             )
           ));
         };
-        i.addEventListener("abort", E), m = () => {
+        i.addEventListener("abort", E), b = () => {
           i.removeEventListener("abort", E);
         };
       }
-      const A = this.on("*", (E) => {
+      const T = this.on("*", (E) => {
         if (E.status === t) {
-          if (d) return;
-          d = !0, h && clearTimeout(h), m && m(), A(), a(this);
+          if (l) return;
+          l = !0, u && clearTimeout(u), b && b(), T(), w(this);
         }
       });
     });
   }
+  /**
+   * Apply state from database snapshot (no events emitted)
+   * Used when initializing state from start_flow_with_states() or get_run_with_states()
+   *
+   * @internal This method is only intended for use by PgflowClient.
+   * Applications should not call this directly.
+   */
+  applySnapshot(t) {
+    e(this, a).status = t.status, e(this, a).input = t.input, e(this, a).output = t.output, e(this, a).started_at = t.started_at ? new Date(t.started_at) : null, e(this, a).completed_at = t.completed_at ? new Date(t.completed_at) : null, e(this, a).failed_at = t.failed_at ? new Date(t.failed_at) : null, e(this, a).remaining_steps = t.remaining_steps, e(this, a).error_message = null, e(this, a).error = null;
+  }
   /**
    * Updates the run state based on an event
-   * 
+   *
    * @internal This method is only intended for use by PgflowClient and tests.
    * Applications should not call this directly - state updates should come from
    * database events through the PgflowClient.
-   * 
+   *
    * TODO: After v1.0, make this method private and refactor tests to use PgflowClient
    * with event emission instead of direct state manipulation.
    */
   updateState(t) {
-    if (t.run_id !== r(this, o).run_id || !w(this, T, et).call(this, r(this, o).status, t.status))
+    if (t.run_id !== e(this, a).run_id || !m(this, D, tt).call(this, e(this, a).status, t.status))
       return !1;
     switch (t.status) {
-      case u.Started:
-        g(this, o, {
-          ...r(this, o),
-          status: u.Started,
+      case c.Started:
+        _(this, a, {
+          ...e(this, a),
+          status: c.Started,
           started_at: typeof t.started_at == "string" ? new Date(t.started_at) : /* @__PURE__ */ new Date(),
-          remaining_steps: "remaining_steps" in t ? Number(t.remaining_steps) : r(this, o).remaining_steps
-        }), r(this, R).emit("started", t);
+          remaining_steps: "remaining_steps" in t ? Number(t.remaining_steps) : e(this, a).remaining_steps
+        }), e(this, R).emit("started", t);
         break;
-      case u.Completed:
-        g(this, o, {
-          ...r(this, o),
-          status: u.Completed,
+      case c.Completed:
+        _(this, a, {
+          ...e(this, a),
+          status: c.Completed,
           completed_at: typeof t.completed_at == "string" ? new Date(t.completed_at) : /* @__PURE__ */ new Date(),
           output: t.output,
           remaining_steps: 0
-        }), r(this, R).emit("completed", t), w(this, T, B).call(this);
+        }), e(this, R).emit("completed", t), m(this, D, B).call(this);
         break;
-      case u.Failed:
-        g(this, o, {
-          ...r(this, o),
-          status: u.Failed,
+      case c.Failed:
+        _(this, a, {
+          ...e(this, a),
+          status: c.Failed,
           failed_at: typeof t.failed_at == "string" ? new Date(t.failed_at) : /* @__PURE__ */ new Date(),
           error_message: typeof t.error_message == "string" ? t.error_message : "Unknown error",
           error: new Error(
             typeof t.error_message == "string" ? t.error_message : "Unknown error"
           )
-        }), r(this, R).emit("failed", t), w(this, T, B).call(this);
+        }), e(this, R).emit("failed", t), m(this, D, B).call(this);
         break;
       default:
         return !1;
     }
-    return r(this, R).emit("*", t), !0;
+    return e(this, R).emit("*", t), !0;
   }
   /**
    * Updates a step state based on an event
@@ -640,21 +660,21 @@ class Q {
    * @param event - Event data to update the step with
    * @returns true if the state was updated, false otherwise
    */
-  updateStepState(t, s) {
-    return this.step(t).updateState(s);
+  updateStepState(t, r) {
+    return this.step(t).updateState(r);
   }
   /**
    * Clean up all resources held by this run
    */
   dispose() {
-    r(this, U) || (r(this, D).clear(), g(this, R, L()), g(this, P, 0), g(this, U, !0));
+    e(this, M) || (e(this, A).clear(), _(this, R, L()), _(this, P, 0), _(this, M, !0));
   }
 }
-o = new WeakMap(), R = new WeakMap(), D = new WeakMap(), x = new WeakMap(), U = new WeakMap(), P = new WeakMap(), T = new WeakSet(), /**
+a = new WeakMap(), R = new WeakMap(), A = new WeakMap(), x = new WeakMap(), M = new WeakMap(), P = new WeakMap(), D = new WeakSet(), /**
  * Checks if auto-dispose should be triggered (when in terminal state with no listeners)
  */
 B = function() {
-  r(this, U) || this.status !== u.Completed && this.status !== u.Failed || r(this, P) === 0 && this.dispose();
+  e(this, M) || this.status !== c.Completed && this.status !== c.Failed || e(this, P) === 0 && this.dispose();
 }, /**
  * Determines if a status should be updated based on precedence
  *
@@ -662,164 +682,95 @@ B = function() {
  * @param newStatus - New status
  * @returns true if the status should be updated, false otherwise
  */
-et = function(t, s) {
-  if (t === u.Completed || t === u.Failed)
+tt = function(t, r) {
+  if (t === c.Completed || t === c.Failed)
     return !1;
-  const n = r(this, x)[t];
-  return r(this, x)[s] > n;
+  const n = e(this, x)[t];
+  return e(this, x)[r] > n;
 };
-function it(e) {
-  switch (e.status) {
-    case u.Started:
-      return {
-        event_type: "run:started",
-        run_id: e.run_id,
-        flow_slug: e.flow_slug,
-        status: u.Started,
-        started_at: e.started_at,
-        remaining_steps: e.remaining_steps,
-        input: e.input
-      };
-    case u.Completed:
-      return {
-        event_type: "run:completed",
-        run_id: e.run_id,
-        flow_slug: e.flow_slug,
-        status: u.Completed,
-        completed_at: e.completed_at,
-        output: e.output
-      };
-    case u.Failed:
-      return {
-        event_type: "run:failed",
-        run_id: e.run_id,
-        flow_slug: e.flow_slug,
-        status: u.Failed,
-        failed_at: e.failed_at,
-        error_message: e.error_message
-      };
-  }
-}
-function at(e) {
-  switch (e.status) {
-    case l.Started:
-      return {
-        event_type: "step:started",
-        run_id: e.run_id,
-        step_slug: e.step_slug,
-        status: l.Started,
-        started_at: e.started_at
-      };
-    case l.Completed:
-      return {
-        event_type: "step:completed",
-        run_id: e.run_id,
-        step_slug: e.step_slug,
-        status: l.Completed,
-        completed_at: e.completed_at,
-        output: e.output
-      };
-    case l.Failed:
-      return {
-        event_type: "step:failed",
-        run_id: e.run_id,
-        step_slug: e.step_slug,
-        status: l.Failed,
-        failed_at: e.failed_at,
-        error_message: e.error_message
-      };
-  }
-}
-function ut(e) {
-  switch (e.status) {
-    case "started":
+function nt(s) {
+  switch (s.status) {
+    case c.Started:
       return {
         event_type: "run:started",
-        run_id: e.run_id,
-        flow_slug: e.flow_slug,
-        status: u.Started,
-        started_at: e.started_at,
-        remaining_steps: e.remaining_steps,
-        input: e.input
+        run_id: s.run_id,
+        flow_slug: s.flow_slug,
+        status: c.Started,
+        started_at: s.started_at,
+        remaining_steps: s.remaining_steps,
+        input: s.input
       };
-    case "completed":
+    case c.Completed:
       return {
         event_type: "run:completed",
-        run_id: e.run_id,
-        flow_slug: e.flow_slug,
-        status: u.Completed,
-        completed_at: e.completed_at,
-        output: e.output
+        run_id: s.run_id,
+        flow_slug: s.flow_slug,
+        status: c.Completed,
+        completed_at: s.completed_at,
+        output: s.output
       };
-    case "failed":
+    case c.Failed:
       return {
         event_type: "run:failed",
-        run_id: e.run_id,
-        flow_slug: e.flow_slug,
-        status: u.Failed,
-        failed_at: e.failed_at,
-        error_message: "Flow failed"
-        // Database doesn't have error_message for runs
+        run_id: s.run_id,
+        flow_slug: s.flow_slug,
+        status: c.Failed,
+        failed_at: s.failed_at,
+        error_message: s.error_message
       };
-    default:
-      throw new Error(`Unknown run status: ${e.status}`);
   }
 }
-function V(e) {
-  switch (e.status) {
-    case "created":
-    case "started":
+function it(s) {
+  switch (s.status) {
+    case h.Started:
       return {
         event_type: "step:started",
-        run_id: e.run_id,
-        step_slug: e.step_slug,
-        status: l.Started,
-        started_at: e.started_at
+        run_id: s.run_id,
+        step_slug: s.step_slug,
+        status: h.Started,
+        started_at: s.started_at
       };
-    case "completed":
+    case h.Completed:
       return {
         event_type: "step:completed",
-        run_id: e.run_id,
-        step_slug: e.step_slug,
-        status: l.Completed,
-        completed_at: e.completed_at,
-        output: {}
-        // Database doesn't have output in step_states
+        run_id: s.run_id,
+        step_slug: s.step_slug,
+        status: h.Completed,
+        completed_at: s.completed_at,
+        output: s.output
       };
-    case "failed":
+    case h.Failed:
       return {
         event_type: "step:failed",
-        run_id: e.run_id,
-        step_slug: e.step_slug,
-        status: l.Failed,
-        failed_at: e.failed_at,
-        error_message: e.error_message || "Step failed"
+        run_id: s.run_id,
+        step_slug: s.step_slug,
+        status: h.Failed,
+        failed_at: s.failed_at,
+        error_message: s.error_message
       };
-    default:
-      throw new Error(`Unknown step status: ${e.status}`);
   }
 }
-var q, b, y;
-class wt {
+var q, g, y;
+class mt {
   /**
    * Creates a new PgflowClient instance
    *
    * @param supabaseClient - Supabase client instance
    */
   constructor(t) {
-    c(this, q);
-    c(this, b);
+    d(this, q);
+    d(this, g);
     // Use the widest event type - keeps the compiler happy but
     // still provides the structural API we need (updateState/step/...)
-    c(this, y, /* @__PURE__ */ new Map());
-    g(this, q, t), g(this, b, new rt(t)), r(this, b).onRunEvent((s) => {
-      const n = r(this, y).get(s.run_id);
-      n && n.updateState(it(s));
-    }), r(this, b).onStepEvent((s) => {
-      const n = r(this, y).get(s.run_id);
+    d(this, y, /* @__PURE__ */ new Map());
+    _(this, q, t), _(this, g, new st(t)), e(this, g).onRunEvent((r) => {
+      const n = e(this, y).get(r.run_id);
+      n && n.updateState(nt(r));
+    }), e(this, g).onStepEvent((r) => {
+      const n = e(this, y).get(r.run_id);
       if (n) {
-        const i = s.step_slug;
-        n.step(i).updateState(at(s));
+        const i = r.step_slug;
+        n.step(i).updateState(it(r));
       }
     });
   }
@@ -831,12 +782,12 @@ class wt {
    * @param run_id - Optional run ID (will be generated if not provided)
    * @returns Promise that resolves with the FlowRun instance
    */
-  async startFlow(t, s, n) {
-    const i = n || st(), a = {
+  async startFlow(t, r, n) {
+    const i = n || et(), w = {
       run_id: i,
       flow_slug: t,
-      status: u.Started,
-      input: s,
+      status: c.Started,
+      input: r,
       output: null,
       error: null,
       error_message: null,
@@ -845,19 +796,19 @@ class wt {
       failed_at: null,
       remaining_steps: -1
       // Use -1 to indicate unknown until first snapshot arrives
-    }, _ = new Q(a);
-    r(this, y).set(i, _), await r(this, b).subscribeToRun(i);
-    const { data: h, error: d } = await r(this, q).schema("pgflow").rpc("start_flow_with_states", {
+    }, p = new Q(w);
+    e(this, y).set(i, p), await e(this, g).subscribeToRun(i);
+    const { data: u, error: l } = await e(this, q).schema("pgflow").rpc("start_flow_with_states", {
       flow_slug: t,
-      input: s,
+      input: r,
       run_id: i
     });
-    if (d)
-      throw this.dispose(i), d;
-    if (h.run && _.updateState(ut(h.run)), h.steps && Array.isArray(h.steps))
-      for (const m of h.steps)
-        _.step(m.step_slug).updateState(V(m));
-    return _;
+    if (l)
+      throw this.dispose(i), l;
+    if (u.run && p.applySnapshot(u.run), u.steps && Array.isArray(u.steps))
+      for (const b of u.steps)
+        p.step(b.step_slug).applySnapshot(b);
+    return p;
   }
   /**
    * Dispose a specific flow run
@@ -865,14 +816,14 @@ class wt {
    * @param runId - Run ID to dispose
    */
   dispose(t) {
-    const s = r(this, y).get(t);
-    s && (r(this, b).unsubscribe(t), s.dispose(), r(this, y).delete(t));
+    const r = e(this, y).get(t);
+    r && (e(this, g).unsubscribe(t), r.dispose(), e(this, y).delete(t));
   }
   /**
    * Dispose all flow runs
    */
   disposeAll() {
-    for (const t of r(this, y).keys())
+    for (const t of e(this, y).keys())
       this.dispose(t);
   }
   // Delegate IFlowRealtime methods to the adapter
@@ -880,33 +831,33 @@ class wt {
    * Fetch flow definition metadata
    */
   async fetchFlowDefinition(t) {
-    return r(this, b).fetchFlowDefinition(t);
+    return e(this, g).fetchFlowDefinition(t);
   }
   /**
    * Register a callback for run events
    * @returns Function to unsubscribe from the event
    */
   onRunEvent(t) {
-    return r(this, b).onRunEvent(t);
+    return e(this, g).onRunEvent(t);
   }
   /**
    * Register a callback for step events
    * @returns Function to unsubscribe from the event
    */
   onStepEvent(t) {
-    return r(this, b).onStepEvent(t);
+    return e(this, g).onStepEvent(t);
   }
   /**
    * Subscribe to a flow run's events
    */
   async subscribeToRun(t) {
-    return await r(this, b).subscribeToRun(t);
+    return await e(this, g).subscribeToRun(t);
   }
   /**
    * Fetch current state of a run and its steps
    */
   async getRunWithStates(t) {
-    return r(this, b).getRunWithStates(t);
+    return e(this, g).getRunWithStates(t);
   }
   /**
    * Get a flow run by ID
@@ -915,38 +866,37 @@ class wt {
    * @returns Promise that resolves with the FlowRun instance or null if not found
    */
   async getRun(t) {
-    const s = r(this, y).get(t);
-    if (s)
-      return s;
+    const r = e(this, y).get(t);
+    if (r)
+      return r;
     try {
       const { run: n, steps: i } = await this.getRunWithStates(t);
       if (!n)
         return null;
-      const a = n;
-      if (!a.run_id || !a.flow_slug || !a.status)
+      if (!n.run_id || !n.flow_slug || !n.status)
         throw new Error("Invalid run data: missing required fields");
-      if (!Object.values(u).includes(a.status))
-        throw new Error(`Invalid run data: invalid status '${a.status}'`);
-      const h = {
-        run_id: a.run_id,
-        flow_slug: a.flow_slug,
-        status: a.status,
-        input: a.input,
-        output: a.output,
-        error: a.error_message ? new Error(a.error_message) : null,
-        error_message: a.error_message || null,
-        started_at: a.started_at ? new Date(a.started_at) : null,
-        completed_at: a.completed_at ? new Date(a.completed_at) : null,
-        failed_at: a.failed_at ? new Date(a.failed_at) : null,
-        remaining_steps: a.remaining_steps || 0
-      }, d = new Q(h);
-      if (r(this, y).set(t, d), await r(this, b).subscribeToRun(t), i && Array.isArray(i))
-        for (const m of i) {
-          if (!m.step_slug || !m.status)
+      if (!Object.values(c).includes(n.status))
+        throw new Error(`Invalid run data: invalid status '${n.status}'`);
+      const p = {
+        run_id: n.run_id,
+        flow_slug: n.flow_slug,
+        status: n.status,
+        input: n.input,
+        output: null,
+        error: null,
+        error_message: null,
+        started_at: null,
+        completed_at: null,
+        failed_at: null,
+        remaining_steps: 0
+      }, u = new Q(p);
+      if (u.applySnapshot(n), e(this, y).set(t, u), await e(this, g).subscribeToRun(t), i && Array.isArray(i))
+        for (const l of i) {
+          if (!l.step_slug || !l.status)
             throw new Error("Invalid step data: missing required fields");
-          d.step(m.step_slug).updateState(V(m));
+          u.step(l.step_slug).applySnapshot(l);
         }
-      return d;
+      return u;
     } catch (n) {
       if (console.error("Error getting run:", n), n instanceof Error && (n.message.includes("Invalid run data") || n.message.includes("Invalid step data")))
         throw n;
@@ -954,20 +904,20 @@ class wt {
     }
   }
 }
-q = new WeakMap(), b = new WeakMap(), y = new WeakMap();
+q = new WeakMap(), g = new WeakMap(), y = new WeakMap();
 export {
   Q as FlowRun,
-  u as FlowRunStatus,
-  nt as FlowStep,
-  l as FlowStepStatus,
-  wt as PgflowClient,
-  ht as isFlowRunCompletedEvent,
-  ct as isFlowRunEvent,
-  _t as isFlowRunFailedEvent,
-  pt as isFlowRunStartedEvent,
-  mt as isStepCompletedEvent,
+  c as FlowRunStatus,
+  rt as FlowStep,
+  h as FlowStepStatus,
+  mt as PgflowClient,
+  ct as isFlowRunCompletedEvent,
+  lt as isFlowRunEvent,
+  pt as isFlowRunFailedEvent,
+  dt as isFlowRunStartedEvent,
+  ft as isStepCompletedEvent,
   K as isStepEvent,
-  gt as isStepFailedEvent,
-  ft as isStepStartedEvent
+  _t as isStepFailedEvent,
+  ht as isStepStartedEvent
 };
 //# sourceMappingURL=index.js.map