@tickean/checkout-js 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -1,3 +1,15 @@
+// src/types.ts
+var TickeanError = class extends Error {
+  constructor(payload, status, requestId) {
+    super(payload.message);
+    this.name = "TickeanError";
+    this.code = payload.code;
+    this.details = payload.details;
+    this.status = status;
+    this.requestId = requestId;
+  }
+};
+
 // src/demo.ts
 var demoEvent = {
   id: "evt_demo",
@@ -71,10 +83,26 @@ function createDemoTransport() {
   let unlocked = [];
   let purchaseId = "purchase_demo";
   let cartRef = "cart_demo";
+  let lastPayment = null;
+  let paymentConfirmed = false;
+  const publicEvent = () => ({
+    ...demoEvent,
+    shows: demoEvent.shows.map((show) => ({
+      ...show,
+      showOptions: [
+        ...show.showOptions.filter((o) => o.catalogVisibility !== "PROMO_GATED"),
+        ...unlocked.filter((u) => show.showOptions.some((o) => o.id === u.id))
+      ]
+    }))
+  });
   return {
     async request(path, init) {
       if (path === "/v1/checkout/sessions" && init.method === "POST") {
         sessionToken = `demo_${Date.now()}`;
+        buyer = null;
+        unlocked = [];
+        paymentConfirmed = false;
+        lastPayment = null;
         return {
           sessionId: "sess_demo",
           sessionToken,
@@ -93,25 +121,34 @@ function createDemoTransport() {
             discounts: true,
             transfer: true,
             onlinePayments: true
-          }
+          },
+          phase: "browsing"
         };
       }
-      if (path === "/v1/checkout/catalog") {
+      if (path === "/v1/checkout/session") {
         return {
-          ...demoEvent,
-          shows: demoEvent.shows.map((show) => ({
-            ...show,
-            showOptions: [
-              ...show.showOptions.filter(
-                (o) => o.catalogVisibility !== "PROMO_GATED"
-              ),
-              ...unlocked.filter(
-                (u) => show.showOptions.some((o) => o.id === u.id)
-              )
-            ]
-          }))
+          sessionId: "sess_demo",
+          sessionToken,
+          expiresAt: new Date(Date.now() + 36e5).toISOString(),
+          event: publicEvent(),
+          capabilities: {
+            tickets: true,
+            discounts: true,
+            transfer: true,
+            onlinePayments: true
+          },
+          status: "ACTIVE",
+          otpVerified: Boolean(buyer),
+          buyerId: buyer?.id || null,
+          purchaseId: purchaseId.startsWith("purchase_") ? purchaseId : null,
+          shoppingCartReference: cartRef,
+          nextAction: lastPayment?.nextAction || { type: "none" },
+          phase: paymentConfirmed ? "completed" : lastPayment ? "requires_action" : buyer ? "ready_to_purchase" : "browsing"
         };
       }
+      if (path === "/v1/checkout/catalog") {
+        return publicEvent();
+      }
       if (path === "/v1/checkout/quote" && init.method === "POST") {
         const body = init.body;
         if (body.discountCode?.toUpperCase() === "DEMO2X1") {
@@ -145,8 +182,9 @@ function createDemoTransport() {
       }
       if (path === "/v1/checkout/purchases") {
         if (!buyer) {
-          throw Object.assign(new Error("OTP required"), {
-            code: "checkout_otp_required"
+          throw new TickeanError({
+            code: "checkout_otp_required",
+            message: "OTP required"
           });
         }
         const body = init.body;
@@ -171,47 +209,81 @@ function createDemoTransport() {
         };
       }
       if (path === "/v1/checkout/payments") {
-        return {
-          id: `pay_${Date.now()}`,
-          paymentStatus: "PENDING",
-          paymentMethod: init.body?.paymentMethod,
-          paymentInstructions: {
-            alias: "tickean.demo",
-            cvu: "0000003100010000000001",
-            amount: init.body?.amount
-          },
-          redirectUrl: void 0,
-          returnUrl: null
+        const body = init.body;
+        const method = String(body?.paymentMethod || "TRANSFER").toUpperCase();
+        if (method === "TRANSFER") {
+          lastPayment = {
+            id: `pay_${Date.now()}`,
+            paymentStatus: "PENDING",
+            paymentMethod: method,
+            paymentInstructions: {
+              alias: "tickean.demo",
+              cvu: "0000003100010000000001",
+              amount: body?.amount
+            },
+            redirectUrl: void 0,
+            returnUrl: null,
+            nextAction: {
+              type: "display_instructions",
+              paymentInstructions: {
+                alias: "tickean.demo",
+                cvu: "0000003100010000000001",
+                amount: body?.amount
+              }
+            },
+            requiresAction: false
+          };
+        } else {
+          lastPayment = {
+            id: `pay_${Date.now()}`,
+            paymentStatus: "PENDING",
+            paymentMethod: method,
+            redirectUrl: "https://example.com/pay/demo",
+            returnUrl: null,
+            nextAction: {
+              type: "redirect",
+              url: "https://example.com/pay/demo"
+            },
+            requiresAction: true
+          };
+        }
+        return lastPayment;
+      }
+      if (path === "/v1/checkout/payments/confirm" && init.method === "POST") {
+        paymentConfirmed = true;
+        lastPayment = {
+          ...lastPayment || { id: `pay_${Date.now()}` },
+          paymentStatus: "COMPLETED",
+          nextAction: { type: "none" },
+          requiresAction: false
         };
+        return lastPayment;
       }
       if (path === "/v1/checkout/payments/status") {
         return {
-          status: "PENDING",
+          status: paymentConfirmed ? "COMPLETED" : "PENDING",
+          requiresAction: Boolean(
+            lastPayment?.nextAction && lastPayment.nextAction.type !== "none" && !paymentConfirmed
+          ),
+          phase: paymentConfirmed ? "completed" : lastPayment ? "requires_action" : "browsing",
+          nextAction: lastPayment?.nextAction || { type: "none" },
+          payment: lastPayment,
           purchase: {
             id: purchaseId,
-            status: "PENDING",
+            status: paymentConfirmed ? "COMPLETED" : "PENDING",
             totalPrice: 0,
             currency: "ARS",
             shoppingCartReference: cartRef
           }
         };
       }
-      throw new Error(`Demo transport: unhandled ${init.method || "GET"} ${path}`);
+      throw new Error(
+        `Demo transport: unhandled ${init.method || "GET"} ${path}`
+      );
     }
   };
 }
 
-// src/types.ts
-var TickeanError = class extends Error {
-  constructor(payload, status) {
-    super(payload.message);
-    this.name = "TickeanError";
-    this.code = payload.code;
-    this.details = payload.details;
-    this.status = status;
-  }
-};
-
 // src/http.ts
 function createHttpTransport(options) {
   const fetchImpl = options.fetchImpl || fetch;
@@ -224,6 +296,9 @@ function createHttpTransport(options) {
       if (init.sessionToken) {
         headers["X-Tickean-Checkout-Session"] = init.sessionToken;
       }
+      if (init.idempotencyKey) {
+        headers["Idempotency-Key"] = init.idempotencyKey;
+      }
       const response = await fetchImpl(
         `${options.apiBaseUrl.replace(/\/$/, "")}${path}`,
         {
@@ -233,6 +308,7 @@ function createHttpTransport(options) {
           credentials: "omit"
         }
       );
+      const requestId = response.headers.get("X-Request-Id") || response.headers.get("x-request-id") || void 0;
       const json = await response.json().catch(() => ({}));
       if (!response.ok) {
         const err = json?.error || {};
@@ -242,7 +318,8 @@ function createHttpTransport(options) {
             message: err.message || response.statusText || "Request failed",
             details: err.details
           },
-          response.status
+          response.status,
+          requestId
         );
       }
       return json;
@@ -250,7 +327,7 @@ function createHttpTransport(options) {
   };
 }
 
-// src/index.ts
+// src/client.ts
 function createTickean(options) {
   if (!options.publishableKey && !options.demo) {
     throw new TickeanError({
@@ -277,6 +354,9 @@ function createTickean(options) {
     get session() {
       return session;
     },
+    set session(value) {
+      session = value;
+    },
     async createSession(params) {
       session = await transport.request("/v1/checkout/sessions", {
         method: "POST",
@@ -284,6 +364,22 @@ function createTickean(options) {
       });
       return session;
     },
+    async getSession() {
+      const active = requireSession();
+      const result = await transport.request(
+        "/v1/checkout/session",
+        {
+          sessionToken: active.sessionToken
+        }
+      );
+      session = {
+        ...active,
+        ...result,
+        sessionToken: active.sessionToken,
+        event: result.event || active.event
+      };
+      return session;
+    },
     async getCatalog() {
       const active = requireSession();
       return transport.request("/v1/checkout/catalog", {
@@ -319,7 +415,8 @@ function createTickean(options) {
       return transport.request("/v1/checkout/purchases", {
         method: "POST",
         body: params,
-        sessionToken: active.sessionToken
+        sessionToken: active.sessionToken,
+        idempotencyKey: params.idempotencyKey
       });
     },
     async createPayment(params) {
@@ -327,7 +424,17 @@ function createTickean(options) {
       return transport.request("/v1/checkout/payments", {
         method: "POST",
         body: params,
-        sessionToken: active.sessionToken
+        sessionToken: active.sessionToken,
+        idempotencyKey: params.idempotencyKey
+      });
+    },
+    async confirmPayment(params) {
+      const active = requireSession();
+      return transport.request("/v1/checkout/payments/confirm", {
+        method: "POST",
+        body: params || {},
+        sessionToken: active.sessionToken,
+        idempotencyKey: params?.idempotencyKey
       });
     },
     async getPaymentStatus() {
@@ -348,13 +455,16 @@ function createTickean(options) {
           });
         }
         const status = await this.getPaymentStatus();
-        if (["COMPLETED", "CONFIRMED", "PAID"].includes(
+        if (["COMPLETED", "CONFIRMED", "PAID", "SUCCESS"].includes(
           String(status.status || "").toUpperCase()
-        ) || ["COMPLETED", "CONFIRMED", "PAID"].includes(
+        ) || ["COMPLETED", "CONFIRMED", "PAID", "SUCCESS"].includes(
           String(status.purchase?.status || "").toUpperCase()
         )) {
           return status;
         }
+        if (status.nextAction && status.nextAction.type !== "none" && status.requiresAction) {
+          return status;
+        }
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
       }
       throw new TickeanError({
@@ -364,7 +474,569 @@ function createTickean(options) {
     }
   };
 }
+
+// src/state.ts
+function createInitialState(partial) {
+  return {
+    phase: "initializing",
+    session: null,
+    event: null,
+    cart: [],
+    discountCode: null,
+    quote: null,
+    isQuoting: false,
+    buyer: null,
+    buyerVerified: false,
+    otpSent: false,
+    purchase: null,
+    payment: null,
+    nextAction: { type: "none" },
+    error: null,
+    loading: true,
+    ...partial
+  };
+}
+function derivePhase(state) {
+  if (state.phase === "completed" || state.phase === "failed" || state.phase === "expired" || state.phase === "purchasing" || state.phase === "processing" || state.phase === "requires_action" || state.phase === "initializing") {
+    return state.phase;
+  }
+  if (state.isQuoting) return "quoting";
+  if (state.otpSent && !state.buyerVerified) return "verifying_buyer";
+  if (state.buyerVerified && state.cart.length > 0) return "ready_to_purchase";
+  return "browsing";
+}
+function checkoutReducer(state, action) {
+  switch (action.type) {
+    case "INIT_START":
+      return { ...state, loading: true, error: null, phase: "initializing" };
+    case "INIT_SUCCESS": {
+      const next = {
+        ...state,
+        loading: false,
+        error: null,
+        session: action.session,
+        event: action.event,
+        phase: "browsing"
+      };
+      return { ...next, phase: derivePhase(next) };
+    }
+    case "INIT_FAILURE":
+      return {
+        ...state,
+        loading: false,
+        error: action.error,
+        phase: "failed"
+      };
+    case "SET_CART": {
+      const next = { ...state, cart: action.cart, error: null };
+      return { ...next, phase: derivePhase(next) };
+    }
+    case "SET_DISCOUNT":
+      return { ...state, discountCode: action.discountCode };
+    case "QUOTE_START": {
+      const next = { ...state, isQuoting: true, error: null };
+      return { ...next, phase: "quoting" };
+    }
+    case "QUOTE_SUCCESS": {
+      const next = {
+        ...state,
+        isQuoting: false,
+        quote: action.quote
+      };
+      return { ...next, phase: derivePhase(next) };
+    }
+    case "QUOTE_FAILURE":
+      return {
+        ...state,
+        isQuoting: false,
+        error: action.error,
+        phase: derivePhase({ ...state, isQuoting: false })
+      };
+    case "OTP_SENT": {
+      const next = { ...state, otpSent: true, error: null };
+      return { ...next, phase: "verifying_buyer" };
+    }
+    case "OTP_VERIFIED": {
+      const next = {
+        ...state,
+        buyer: action.buyer,
+        buyerVerified: true,
+        otpSent: true,
+        error: null
+      };
+      return { ...next, phase: derivePhase(next) };
+    }
+    case "SET_EVENT":
+      return { ...state, event: action.event };
+    case "PURCHASE_START":
+      return { ...state, phase: "purchasing", error: null };
+    case "PURCHASE_SUCCESS": {
+      const requiresProviderAction = action.nextAction.type !== "none" && action.nextAction.type !== "display_instructions";
+      return {
+        ...state,
+        purchase: action.purchase,
+        payment: action.payment,
+        nextAction: action.nextAction,
+        phase: requiresProviderAction ? "requires_action" : "processing",
+        error: null
+      };
+    }
+    case "PURCHASE_FAILURE":
+      return { ...state, phase: "failed", error: action.error };
+    case "SET_NEXT_ACTION":
+      return {
+        ...state,
+        nextAction: action.nextAction,
+        payment: action.payment === void 0 ? state.payment : action.payment,
+        phase: action.nextAction.type !== "none" && action.nextAction.type !== "display_instructions" ? "requires_action" : state.phase === "requires_action" ? "processing" : state.phase
+      };
+    case "PROCESSING":
+      return { ...state, phase: "processing" };
+    case "COMPLETED":
+      return {
+        ...state,
+        phase: "completed",
+        purchase: action.purchase ?? state.purchase,
+        nextAction: { type: "none" },
+        error: null
+      };
+    case "FAILED":
+      return { ...state, phase: "failed", error: action.error };
+    case "EXPIRED":
+      return { ...state, phase: "expired" };
+    case "CLEAR_ERROR":
+      return { ...state, error: null };
+    case "REHYDRATE":
+      return { ...state, ...action.partial };
+    default:
+      return state;
+  }
+}
+
+// src/persistence.ts
+function createMemoryPersistence() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      return store.get(key) ?? null;
+    },
+    set(key, value) {
+      store.set(key, { ...value });
+    },
+    remove(key) {
+      store.delete(key);
+    }
+  };
+}
+function createSessionStoragePersistence(storage) {
+  const getStorage = () => {
+    if (storage) return storage;
+    try {
+      if (typeof sessionStorage !== "undefined") return sessionStorage;
+    } catch {
+    }
+    return null;
+  };
+  return {
+    get(key) {
+      const s = getStorage();
+      if (!s) return null;
+      try {
+        const raw = s.getItem(key);
+        if (!raw) return null;
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    },
+    set(key, value) {
+      const s = getStorage();
+      if (!s) return;
+      try {
+        const safe = {
+          sessionToken: value.sessionToken,
+          eventSlug: value.eventSlug,
+          cart: value.cart,
+          discountCode: value.discountCode,
+          phase: value.phase,
+          buyerVerified: value.buyerVerified,
+          purchaseId: value.purchaseId
+        };
+        s.setItem(key, JSON.stringify(safe));
+      } catch {
+      }
+    },
+    remove(key) {
+      const s = getStorage();
+      if (!s) return;
+      try {
+        s.removeItem(key);
+      } catch {
+      }
+    }
+  };
+}
+
+// src/telemetry.ts
+function createNoopTelemetry() {
+  return {
+    track() {
+    }
+  };
+}
+function createEventEmitterTelemetry(listeners = []) {
+  const subs = new Set(listeners);
+  return {
+    track(event) {
+      for (const listener of subs) {
+        try {
+          listener(event);
+        } catch {
+        }
+      }
+    },
+    subscribe(listener) {
+      subs.add(listener);
+      return () => {
+        subs.delete(listener);
+      };
+    }
+  };
+}
+
+// src/controller.ts
+function generateIdempotencyKey() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return crypto.randomUUID();
+  }
+  return `idem_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function toTickeanError(err) {
+  if (err instanceof TickeanError) return err;
+  const anyErr = err;
+  return new TickeanError(
+    {
+      code: anyErr?.code || "checkout_unknown_error",
+      message: anyErr?.message || "Unexpected checkout error",
+      details: anyErr?.details
+    },
+    anyErr?.status
+  );
+}
+function createCheckoutController(options) {
+  const client = createTickean(options);
+  const telemetry = options.telemetry || createNoopTelemetry();
+  const persistenceKey = options.persistenceKey || `tickean.checkout.${options.eventSlug}.${options.publishableKey || "demo"}`;
+  const persistence = options.persistence === false ? null : options.persistence || (typeof sessionStorage !== "undefined" ? createSessionStoragePersistence() : createMemoryPersistence());
+  let state = createInitialState();
+  const listeners = /* @__PURE__ */ new Set();
+  let quoteTimer = null;
+  let quoteGeneration = 0;
+  const quoteDebounceMs = options.quoteDebounceMs ?? 300;
+  let disposed = false;
+  const emit = (name, properties) => {
+    telemetry.track({ name, timestamp: Date.now(), properties });
+  };
+  const notify = () => {
+    const snapshot = getSnapshot();
+    for (const listener of listeners) {
+      try {
+        listener(snapshot);
+      } catch {
+      }
+    }
+  };
+  const dispatch = (action) => {
+    state = checkoutReducer(state, action);
+    persist();
+    notify();
+  };
+  const persist = () => {
+    if (!persistence) return;
+    persistence.set(persistenceKey, {
+      sessionToken: state.session?.sessionToken,
+      eventSlug: options.eventSlug,
+      cart: state.cart,
+      discountCode: state.discountCode,
+      phase: state.phase,
+      buyerVerified: state.buyerVerified,
+      purchaseId: state.purchase?.id ?? null
+    });
+  };
+  const getSnapshot = () => state;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  };
+  const scheduleQuote = () => {
+    if (quoteTimer) clearTimeout(quoteTimer);
+    if (!state.session || state.cart.length === 0) {
+      dispatch({
+        type: "QUOTE_SUCCESS",
+        quote: {
+          valid: true,
+          totalPrice: 0,
+          pricingBreakdown: { subtotal: 0 }
+        }
+      });
+      return;
+    }
+    const gen = ++quoteGeneration;
+    quoteTimer = setTimeout(async () => {
+      dispatch({ type: "QUOTE_START" });
+      emit("checkout.quote.start", { items: state.cart.length });
+      try {
+        const quote = await client.quote({
+          items: state.cart,
+          discountCode: state.discountCode || void 0
+        });
+        if (disposed || gen !== quoteGeneration) return;
+        dispatch({ type: "QUOTE_SUCCESS", quote });
+        emit("checkout.quote.success", { totalPrice: quote.totalPrice });
+        if ((quote.unlockedShowOptions || []).length > 0) {
+          const catalog = await client.getCatalog();
+          if (!disposed && gen === quoteGeneration) {
+            dispatch({ type: "SET_EVENT", event: catalog });
+          }
+        }
+      } catch (err) {
+        if (disposed || gen !== quoteGeneration) return;
+        const error = toTickeanError(err);
+        dispatch({ type: "QUOTE_FAILURE", error });
+        emit("checkout.quote.error", { code: error.code });
+      }
+    }, quoteDebounceMs);
+  };
+  const setCartItem = (showOptionId, amount) => {
+    const next = state.cart.filter((item) => item.showOptionId !== showOptionId);
+    if (amount > 0) next.push({ showOptionId, amount });
+    dispatch({ type: "SET_CART", cart: next });
+    emit("checkout.cart.change", { showOptionId, amount });
+    scheduleQuote();
+  };
+  const setCart = (cart) => {
+    dispatch({
+      type: "SET_CART",
+      cart: cart.filter((item) => item.amount > 0)
+    });
+    emit("checkout.cart.change", { count: cart.length });
+    scheduleQuote();
+  };
+  const applyDiscountCode = async (code) => {
+    dispatch({ type: "SET_DISCOUNT", discountCode: code || null });
+    if (!state.session) {
+      throw new TickeanError({
+        code: "checkout_session_required",
+        message: "Session required"
+      });
+    }
+    dispatch({ type: "QUOTE_START" });
+    try {
+      const quote = await client.quote({
+        items: state.cart,
+        discountCode: code || void 0
+      });
+      dispatch({ type: "QUOTE_SUCCESS", quote });
+      emit("checkout.discount.applied", { code: code || null });
+      if ((quote.unlockedShowOptions || []).length > 0) {
+        const catalog = await client.getCatalog();
+        dispatch({ type: "SET_EVENT", event: catalog });
+      }
+      return quote;
+    } catch (err) {
+      const error = toTickeanError(err);
+      dispatch({ type: "QUOTE_FAILURE", error });
+      throw error;
+    }
+  };
+  const sendOtp = async (phone, channel) => {
+    await client.sendOtp({ phone, channel });
+    dispatch({ type: "OTP_SENT" });
+    emit("checkout.otp.sent");
+  };
+  const verifyOtp = async (params) => {
+    const result = await client.verifyOtp(params);
+    const buyer = result.buyer || {
+      id: "buyer",
+      phone: params.phone,
+      name: params.name,
+      email: params.email
+    };
+    dispatch({ type: "OTP_VERIFIED", buyer });
+    emit("checkout.otp.verified");
+  };
+  const purchaseAndPay = async (params) => {
+    dispatch({ type: "PURCHASE_START" });
+    const idempotencyKey = params.idempotencyKey || generateIdempotencyKey();
+    emit("checkout.purchase.start", { paymentMethod: params.paymentMethod });
+    try {
+      const purchase = await client.createPurchase({
+        items: state.cart,
+        paymentMethod: params.paymentMethod,
+        currency: params.currency,
+        discountCode: params.discountCode ?? state.discountCode ?? void 0,
+        expectedTotal: state.quote?.totalPrice,
+        showId: params.showId,
+        idempotencyKey
+      });
+      const payment = await client.createPayment({
+        orderId: purchase.purchase.id,
+        paymentMethod: params.paymentMethod,
+        currency: params.currency,
+        amount: purchase.purchase.totalPrice,
+        idempotencyKey: `${idempotencyKey}:payment`
+      });
+      const nextAction = payment.nextAction || (payment.paymentInstructions ? {
+        type: "display_instructions",
+        paymentInstructions: payment.paymentInstructions
+      } : payment.redirectUrl ? { type: "redirect", url: payment.redirectUrl } : { type: "none" });
+      dispatch({
+        type: "PURCHASE_SUCCESS",
+        purchase: purchase.purchase,
+        payment,
+        nextAction
+      });
+      emit("checkout.purchase.success", {
+        purchaseId: purchase.purchase.id,
+        nextActionType: nextAction.type
+      });
+      return { purchaseId: purchase.purchase.id, payment, nextAction };
+    } catch (err) {
+      const error = toTickeanError(err);
+      dispatch({ type: "PURCHASE_FAILURE", error });
+      emit("checkout.purchase.error", { code: error.code });
+      throw error;
+    }
+  };
+  const confirmPayment = async (params) => {
+    const payment = await client.confirmPayment({
+      ...params,
+      idempotencyKey: params?.idempotencyKey || generateIdempotencyKey()
+    });
+    const nextAction = payment.nextAction || { type: "none" };
+    dispatch({ type: "SET_NEXT_ACTION", nextAction, payment });
+    emit("checkout.payment.confirmed", { nextActionType: nextAction.type });
+    return payment;
+  };
+  const watchPayment = async (watchOptions) => {
+    dispatch({ type: "PROCESSING" });
+    emit("checkout.payment.watch.start");
+    try {
+      const status = await client.watchPayment(watchOptions);
+      if (["COMPLETED", "CONFIRMED", "PAID", "SUCCESS"].includes(
+        String(status.status || "").toUpperCase()
+      )) {
+        dispatch({ type: "COMPLETED", purchase: status.purchase });
+        emit("checkout.completed");
+      } else if (status.nextAction && status.nextAction.type !== "none") {
+        dispatch({
+          type: "SET_NEXT_ACTION",
+          nextAction: status.nextAction,
+          payment: status.payment
+        });
+      }
+      return status;
+    } catch (err) {
+      const error = toTickeanError(err);
+      if (error.code !== "checkout_payment_timeout") {
+        dispatch({ type: "FAILED", error });
+      }
+      emit("checkout.payment.watch.error", { code: error.code });
+      throw error;
+    }
+  };
+  const refreshCatalog = async () => {
+    const catalog = await client.getCatalog();
+    dispatch({ type: "SET_EVENT", event: catalog });
+    return catalog;
+  };
+  const initialize = async () => {
+    dispatch({ type: "INIT_START" });
+    emit("checkout.init.start", { eventSlug: options.eventSlug });
+    try {
+      const stored = persistence?.get(persistenceKey);
+      let session = await client.createSession({
+        eventSlug: options.eventSlug,
+        returnUrl: options.returnUrl
+      });
+      if (stored?.sessionToken && stored.sessionToken !== session.sessionToken) {
+        try {
+          client.session = {
+            ...session,
+            sessionToken: stored.sessionToken
+          };
+          const resumed = await client.getSession();
+          session = {
+            ...session,
+            ...resumed,
+            sessionToken: stored.sessionToken,
+            event: resumed.event || session.event
+          };
+        } catch {
+        }
+      }
+      dispatch({
+        type: "INIT_SUCCESS",
+        session,
+        event: session.event
+      });
+      if (stored?.cart?.length) {
+        dispatch({ type: "SET_CART", cart: stored.cart });
+        if (stored.discountCode) {
+          dispatch({ type: "SET_DISCOUNT", discountCode: stored.discountCode });
+        }
+        if (stored.buyerVerified) {
+          dispatch({
+            type: "REHYDRATE",
+            partial: { buyerVerified: true }
+          });
+        }
+        scheduleQuote();
+      }
+      emit("checkout.init.success", { sessionId: session.sessionId });
+    } catch (err) {
+      const error = toTickeanError(err);
+      dispatch({ type: "INIT_FAILURE", error });
+      emit("checkout.init.error", { code: error.code });
+      throw error;
+    }
+  };
+  const dispose = () => {
+    disposed = true;
+    if (quoteTimer) clearTimeout(quoteTimer);
+    listeners.clear();
+  };
+  const ready = initialize().catch(() => {
+  });
+  return {
+    client,
+    ready,
+    getSnapshot,
+    subscribe,
+    setCartItem,
+    setCart,
+    applyDiscountCode,
+    sendOtp,
+    verifyOtp,
+    purchaseAndPay,
+    confirmPayment,
+    watchPayment,
+    refreshCatalog,
+    dispose,
+    /** @internal test helper */
+    _dispatch: dispatch
+  };
+}
 export {
   TickeanError,
+  checkoutReducer,
+  createCheckoutController,
+  createEventEmitterTelemetry,
+  createInitialState,
+  createMemoryPersistence,
+  createNoopTelemetry,
+  createSessionStoragePersistence,
   createTickean
 };