@pgflow/client 0.4.1

package/dist/index.js

@@ -0,0 +1,971 @@
+var N = (e) => {
+  throw TypeError(e);
+};
+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) => ({
+  set _(i) {
+    g(e, t, i, s);
+  },
+  get _() {
+    return r(e, t, n);
+  }
+});
+import { v4 as st } 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");
+}
+function pt(e) {
+  return e.status === "started";
+}
+function ht(e) {
+  return e.status === "completed";
+}
+function _t(e) {
+  return e.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");
+}
+function ft(e) {
+  return K(e) && e.status === "started" && "event_type" in e && e.event_type === "step:started";
+}
+function mt(e) {
+  return K(e) && e.status === "completed" && "event_type" in e && e.event_type === "step:completed";
+}
+function gt(e) {
+  return K(e) && e.status === "failed" && "event_type" in e && e.event_type === "step:failed";
+}
+var S, C, F, M, I, f, j, X, z, Y, Z, v, k, G;
+class rt {
+  /**
+   * 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);
+    // 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);
+  }
+  /**
+   * Fetches flow definition metadata from the database
+   *
+   * @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 })
+    ]);
+    if (s.error) throw s.error;
+    if (!s.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,
+      steps: i
+    };
+  }
+  /**
+   * Registers a callback for run events
+   *
+   * @param callback - Function to call when run events are received
+   * @returns Function to unsubscribe from the event
+   */
+  onRunEvent(t) {
+    const s = r(this, F).on("runEvent", t);
+    return () => {
+      try {
+        s();
+      } catch (n) {
+        console.warn("Could not unsubscribe from run event - emitter may have been disposed", n);
+      }
+    };
+  }
+  /**
+   * Registers a callback for step events
+   *
+   * @param callback - Function to call when step events are received
+   * @returns Function to unsubscribe from the event
+   */
+  onStepEvent(t) {
+    const s = r(this, F).on("stepEvent", t);
+    return () => {
+      try {
+        s();
+      } catch (n) {
+        console.warn("Could not unsubscribe from step event - emitter may have been disposed", n);
+      }
+    };
+  }
+  /**
+   * Subscribes to a flow run's events
+   *
+   * @param run_id - Run ID to subscribe to
+   * @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 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}`));
+      }, 2e4);
+      n.subscribe((m) => {
+        console.log(`Channel ${s} subscription status:`, m), m === "SUBSCRIBED" && (clearTimeout(d), _());
+      });
+    }), r(this, C).set(t, n);
+    const a = () => this.unsubscribe(t);
+    return r(this, k).set(t, a), a;
+  }
+  /**
+   * Unsubscribes from a run's events
+   * 
+   * @param run_id - Run ID to unsubscribe from
+   */
+  unsubscribe(t) {
+    w(this, f, G).call(this, t);
+  }
+  /**
+   * Fetches current state of a run and its steps
+   *
+   * @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 });
+    if (n) throw n;
+    if (!s) throw new Error(`No data returned for run ${t}`);
+    return s;
+  }
+}
+S = new WeakMap(), C = new WeakMap(), F = new WeakMap(), M = 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);
+}, /**
+ * Parse JSON string fields in broadcast event data
+ * @param eventData - The event data object to parse
+ */
+X = function(t) {
+  if ("output" in t && typeof t.output == "string")
+    try {
+      t.output = JSON.parse(t.output);
+    } catch {
+    }
+  if ("input" in t && typeof t.input == "string")
+    try {
+      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));
+}, /**
+ * 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}`);
+  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);
+    i.on("system", { event: "subscribed" }, () => {
+      console.log(`Reconnected and subscribed to channel ${s}`);
+    }), i.on("system", { event: "closed" }, () => {
+      console.log(`Reconnected channel ${s} 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);
+  } catch (n) {
+    console.error(`Failed to reconnect to ${s}:`, 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;
+  const n = {
+    event_type: `run:${s.run.status}`,
+    ...s.run
+  };
+  if (r(this, F).emit("runEvent", n), s.steps && Array.isArray(s.steps))
+    for (const i of s.steps) {
+      const a = {
+        event_type: `step:${i.status}`,
+        ...i
+      };
+      r(this, F).emit("stepEvent", a);
+    }
+}, k = new WeakMap(), /**
+ * Unsubscribes from a run's events
+ *
+ * @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));
+};
+var p, $, W, J, tt;
+class nt {
+  /**
+   * 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
+    });
+    g(this, p, t);
+  }
+  /**
+   * Get the run ID this step belongs to
+   */
+  get run_id() {
+    return r(this, p).run_id;
+  }
+  /**
+   * Get the step slug
+   */
+  get step_slug() {
+    return r(this, p).step_slug;
+  }
+  /**
+   * Get the current status
+   */
+  get status() {
+    return r(this, p).status;
+  }
+  /**
+   * Get the started_at timestamp
+   */
+  get started_at() {
+    return r(this, p).started_at;
+  }
+  /**
+   * Get the completed_at timestamp
+   */
+  get completed_at() {
+    return r(this, p).completed_at;
+  }
+  /**
+   * Get the failed_at timestamp
+   */
+  get failed_at() {
+    return r(this, p).failed_at;
+  }
+  /**
+   * Get the step output
+   */
+  get output() {
+    return r(this, p).output;
+  }
+  /**
+   * Get the error object
+   */
+  get error() {
+    return r(this, p).error;
+  }
+  /**
+   * Get the error message
+   */
+  get error_message() {
+    return r(this, p).error_message;
+  }
+  /**
+   * Register an event handler for a step event
+   * 
+   * @param event - Event type to listen for
+   * @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);
+  }
+  /**
+   * Wait for the step to reach a specific status
+   * 
+   * @param targetStatus - The status to wait for
+   * @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}'`)));
+      }, n));
+      let m;
+      if (i) {
+        const E = () => {
+          d || (d = !0, h && clearTimeout(h), A(), _(new Error(`Aborted waiting for step ${this.step_slug} to reach status '${t}'`)));
+        };
+        i.addEventListener("abort", E), m = () => {
+          i.removeEventListener("abort", E);
+        };
+      }
+      const A = this.on("*", (E) => {
+        if (E.status === t) {
+          if (d) return;
+          d = !0, h && clearTimeout(h), m && m(), A(), a(this);
+        }
+      });
+    });
+  }
+  /**
+   * 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))
+      return !1;
+    switch (t.status) {
+      case l.Started:
+        g(this, p, {
+          ...r(this, p),
+          status: l.Started,
+          started_at: typeof t.started_at == "string" ? new Date(t.started_at) : /* @__PURE__ */ new Date()
+        }), r(this, $).emit("started", t);
+        break;
+      case l.Completed:
+        g(this, p, {
+          ...r(this, p),
+          status: l.Completed,
+          completed_at: typeof t.completed_at == "string" ? new Date(t.completed_at) : /* @__PURE__ */ new Date(),
+          output: t.output
+        }), r(this, $).emit("completed", t);
+        break;
+      case l.Failed:
+        g(this, p, {
+          ...r(this, p),
+          status: l.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);
+        break;
+      default:
+        return !1;
+    }
+    return r(this, $).emit("*", t), !0;
+  }
+}
+p = 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)
+    return !1;
+  const n = r(this, W)[t];
+  return r(this, W)[s] > n;
+};
+var o, R, D, x, U, P, T, B, et;
+class Q {
+  /**
+   * Creates a new FlowRun instance
+   *
+   * @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
+    });
+    c(this, U, !1);
+    // Track number of listeners
+    c(this, P, 0);
+    g(this, o, t);
+  }
+  /**
+   * Get the run ID
+   */
+  get run_id() {
+    return r(this, o).run_id;
+  }
+  /**
+   * Get the flow slug
+   */
+  get flow_slug() {
+    return r(this, o).flow_slug;
+  }
+  /**
+   * Get the current status
+   */
+  get status() {
+    return r(this, o).status;
+  }
+  /**
+   * Get the started_at timestamp
+   */
+  get started_at() {
+    return r(this, o).started_at;
+  }
+  /**
+   * Get the completed_at timestamp
+   */
+  get completed_at() {
+    return r(this, o).completed_at;
+  }
+  /**
+   * Get the failed_at timestamp
+   */
+  get failed_at() {
+    return r(this, o).failed_at;
+  }
+  /**
+   * Get the flow input
+   */
+  get input() {
+    return r(this, o).input;
+  }
+  /**
+   * Get the flow output
+   */
+  get output() {
+    return r(this, o).output;
+  }
+  /**
+   * Get the error object
+   */
+  get error() {
+    return r(this, o).error;
+  }
+  /**
+   * Get the error message
+   */
+  get error_message() {
+    return r(this, o).error_message;
+  }
+  /**
+   * Get the number of remaining steps
+   */
+  get remaining_steps() {
+    return r(this, o).remaining_steps;
+  }
+  /**
+   * Register an event handler for a run event
+   *
+   * @param event - Event type to listen for
+   * @param callback - Callback function to execute when event is emitted
+   * @returns Function to unsubscribe from the event
+   */
+  on(t, s) {
+    H(this, P)._++;
+    const n = r(this, R).on(t, s);
+    return () => {
+      n(), H(this, P)._--, w(this, T, B).call(this);
+    };
+  }
+  /**
+   * Get a FlowStep instance for a specific step
+   *
+   * @param stepSlug - Step slug to get
+   * @returns FlowStep instance for the specified step
+   */
+  step(t) {
+    const s = r(this, D).get(t);
+    if (s)
+      return s;
+    const n = new nt({
+      run_id: this.run_id,
+      step_slug: t,
+      status: l.Created,
+      output: null,
+      error: null,
+      error_message: null,
+      started_at: null,
+      completed_at: null,
+      failed_at: null
+    });
+    return r(this, D).set(
+      t,
+      n
+    ), n;
+  }
+  /**
+   * Check if this run has a specific step
+   *
+   * @param stepSlug - Step slug to check
+   * @returns true if the step exists, false otherwise
+   */
+  hasStep(t) {
+    return r(this, D).has(t);
+  }
+  /**
+   * Wait for the run to reach a specific status
+   *
+   * @param targetStatus - The status to wait for
+   * @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(), _(
+          new Error(
+            `Timeout waiting for run ${this.run_id} to reach status '${t}'`
+          )
+        ));
+      }, n));
+      let m;
+      if (i) {
+        const E = () => {
+          d || (d = !0, h && clearTimeout(h), A(), _(
+            new Error(
+              `Aborted waiting for run ${this.run_id} to reach status '${t}'`
+            )
+          ));
+        };
+        i.addEventListener("abort", E), m = () => {
+          i.removeEventListener("abort", E);
+        };
+      }
+      const A = this.on("*", (E) => {
+        if (E.status === t) {
+          if (d) return;
+          d = !0, h && clearTimeout(h), m && m(), A(), a(this);
+        }
+      });
+    });
+  }
+  /**
+   * 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))
+      return !1;
+    switch (t.status) {
+      case u.Started:
+        g(this, o, {
+          ...r(this, o),
+          status: u.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);
+        break;
+      case u.Completed:
+        g(this, o, {
+          ...r(this, o),
+          status: u.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);
+        break;
+      case u.Failed:
+        g(this, o, {
+          ...r(this, o),
+          status: u.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);
+        break;
+      default:
+        return !1;
+    }
+    return r(this, R).emit("*", t), !0;
+  }
+  /**
+   * Updates a step state based on an event
+   *
+   * @param stepSlug - Step slug to update
+   * @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);
+  }
+  /**
+   * 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));
+  }
+}
+o = new WeakMap(), R = new WeakMap(), D = new WeakMap(), x = new WeakMap(), U = new WeakMap(), P = new WeakMap(), T = 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();
+}, /**
+ * 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
+ */
+et = function(t, s) {
+  if (t === u.Completed || t === u.Failed)
+    return !1;
+  const n = r(this, x)[t];
+  return r(this, x)[s] > 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":
+      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 "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 "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
+      };
+    default:
+      throw new Error(`Unknown run status: ${e.status}`);
+  }
+}
+function V(e) {
+  switch (e.status) {
+    case "created":
+    case "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 "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
+      };
+    case "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"
+      };
+    default:
+      throw new Error(`Unknown step status: ${e.status}`);
+  }
+}
+var q, b, y;
+class wt {
+  /**
+   * Creates a new PgflowClient instance
+   *
+   * @param supabaseClient - Supabase client instance
+   */
+  constructor(t) {
+    c(this, q);
+    c(this, b);
+    // 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);
+      if (n) {
+        const i = s.step_slug;
+        n.step(i).updateState(at(s));
+      }
+    });
+  }
+  /**
+   * Start a flow with optional run_id
+   *
+   * @param flow_slug - Flow slug to start
+   * @param input - Input data for the flow
+   * @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 = {
+      run_id: i,
+      flow_slug: t,
+      status: u.Started,
+      input: s,
+      output: null,
+      error: null,
+      error_message: null,
+      started_at: null,
+      completed_at: null,
+      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", {
+      flow_slug: t,
+      input: s,
+      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 _;
+  }
+  /**
+   * Dispose a specific flow run
+   *
+   * @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));
+  }
+  /**
+   * Dispose all flow runs
+   */
+  disposeAll() {
+    for (const t of r(this, y).keys())
+      this.dispose(t);
+  }
+  // Delegate IFlowRealtime methods to the adapter
+  /**
+   * Fetch flow definition metadata
+   */
+  async fetchFlowDefinition(t) {
+    return r(this, b).fetchFlowDefinition(t);
+  }
+  /**
+   * Register a callback for run events
+   * @returns Function to unsubscribe from the event
+   */
+  onRunEvent(t) {
+    return r(this, b).onRunEvent(t);
+  }
+  /**
+   * Register a callback for step events
+   * @returns Function to unsubscribe from the event
+   */
+  onStepEvent(t) {
+    return r(this, b).onStepEvent(t);
+  }
+  /**
+   * Subscribe to a flow run's events
+   */
+  async subscribeToRun(t) {
+    return await r(this, b).subscribeToRun(t);
+  }
+  /**
+   * Fetch current state of a run and its steps
+   */
+  async getRunWithStates(t) {
+    return r(this, b).getRunWithStates(t);
+  }
+  /**
+   * Get a flow run by ID
+   * 
+   * @param run_id - ID of the run to get
+   * @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;
+    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)
+        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)
+            throw new Error("Invalid step data: missing required fields");
+          d.step(m.step_slug).updateState(V(m));
+        }
+      return d;
+    } 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;
+      return null;
+    }
+  }
+}
+q = new WeakMap(), b = new WeakMap(), y = new WeakMap();
+export {
+  u as FlowRunStatus,
+  l as FlowStepStatus,
+  wt as PgflowClient,
+  ht as isFlowRunCompletedEvent,
+  ct as isFlowRunEvent,
+  _t as isFlowRunFailedEvent,
+  pt as isFlowRunStartedEvent,
+  mt as isStepCompletedEvent,
+  K as isStepEvent,
+  gt as isStepFailedEvent,
+  ft as isStepStartedEvent
+};
+//# sourceMappingURL=index.js.map