@growupsell/commerce 0.0.0-stage → 1.0.0-alpha.2

package/dist/chunk-DHBRITDW.js

@@ -0,0 +1,2980 @@
+import {
+  GrowupsellApiError,
+  createClient
+} from "./chunk-AI2CWQ22.js";
+import {
+  DEFAULT_LISTING_CRITERIA,
+  LISTING_PAGE_SIZE,
+  categoryAndDescendants,
+  checkoutPreview,
+  defaultSelection,
+  formatSelectedVariants,
+  imagesFor,
+  isSelectionComplete,
+  listingQuery,
+  listingSearchOptions,
+  parseListingQuery,
+  paymentOptions,
+  productPricing,
+  requiresShippingAddress,
+  resolveSku,
+  selectOption,
+  specificationsFor,
+  variantChoices,
+  withCategory
+} from "./chunk-W2CJSBV4.js";
+
+// src/stores/runtime/concurrency.ts
+function start(run) {
+  try {
+    return Promise.resolve(run());
+  } catch (error) {
+    return Promise.reject(error);
+  }
+}
+function createLatest() {
+  let generation = 0;
+  return async (run) => {
+    const mine = ++generation;
+    try {
+      const value = await start(run);
+      return mine === generation ? { current: true, value } : { current: false };
+    } catch (error) {
+      if (mine !== generation) return { current: false };
+      throw error;
+    }
+  };
+}
+function createSingleFlight() {
+  const inFlight = /* @__PURE__ */ new Map();
+  return (key, run) => {
+    const existing = inFlight.get(key);
+    if (existing) return existing;
+    const promise = start(run).finally(() => {
+      if (inFlight.get(key) === promise) inFlight.delete(key);
+    });
+    inFlight.set(key, promise);
+    return promise;
+  };
+}
+function createSerialQueue() {
+  let tail = Promise.resolve();
+  return (run) => {
+    const next = tail.then(
+      () => start(run),
+      () => start(run)
+    );
+    tail = next.catch(() => {
+    });
+    return next;
+  };
+}
+function createCoalescer() {
+  const slots = /* @__PURE__ */ new Map();
+  function launch(key, slot, job) {
+    const sent = start(() => job.send(job.value));
+    job.settle(
+      sent.then(
+        (value) => slot.waiting ? { current: false } : { current: true, value },
+        (error) => {
+          if (slot.waiting) return { current: false };
+          throw error;
+        }
+      )
+    );
+    void sent.catch(() => {
+    }).then(() => {
+      const next = slot.waiting;
+      slot.waiting = null;
+      if (next) launch(key, slot, next);
+      else slots.delete(key);
+    });
+  }
+  return (key, value, send) => new Promise((resolve, reject) => {
+    const job = {
+      value,
+      send,
+      settle: (outcome) => outcome.then(resolve, reject)
+    };
+    const slot = slots.get(key);
+    if (!slot) {
+      const fresh = { waiting: null };
+      slots.set(key, fresh);
+      launch(key, fresh, job);
+      return;
+    }
+    slot.waiting?.settle(Promise.resolve({ current: false }));
+    slot.waiting = job;
+  });
+}
+async function runInEpoch(epoch, run) {
+  const started = epoch();
+  try {
+    const value = await start(run);
+    return epoch() === started ? { current: true, value } : { current: false };
+  } catch (error) {
+    if (epoch() !== started) return { current: false };
+    throw error;
+  }
+}
+
+// src/stores/runtime/errors.ts
+var ok = (value) => ({ ok: true, value });
+var fail = (error) => ({ ok: false, error });
+function storeError(kind, message, extra = {}) {
+  return { kind, message, status: extra.status ?? null, fieldErrors: extra.fieldErrors ?? {} };
+}
+var KINDS = /* @__PURE__ */ new Set([
+  "http",
+  "network",
+  "timeout",
+  "parse",
+  "validation",
+  "signed-out",
+  "session",
+  "superseded",
+  "unknown"
+]);
+function isStoreError(value) {
+  if (!value || typeof value !== "object" || value instanceof Error) return false;
+  const v = value;
+  return typeof v.kind === "string" && KINDS.has(v.kind) && typeof v.message === "string";
+}
+function toStoreError(error, context = {}) {
+  if (isStoreError(error)) return error;
+  if (error instanceof GrowupsellApiError) {
+    const deadSession = context.sentSession === true && error.kind === "http" && error.status === 404 && typeof error.body === "string";
+    const converted = storeError(deadSession ? "session" : error.kind, error.message, {
+      status: error.status ?? null,
+      fieldErrors: Object.fromEntries(
+        Object.entries(error.fieldErrors).map(([field, messages]) => [field, [...messages]])
+      )
+    });
+    if (error.retryAfterSeconds != null) converted.retryAfterSeconds = error.retryAfterSeconds;
+    return converted;
+  }
+  if (error instanceof TypeError || error instanceof RangeError) {
+    return storeError("validation", error.message);
+  }
+  if (error instanceof Error) return storeError("unknown", error.message);
+  if (typeof error === "string") return storeError("unknown", error);
+  return storeError("unknown", "Unknown error");
+}
+
+// src/stores/runtime/store.ts
+function readOnly(store) {
+  return {
+    getSnapshot: store.getSnapshot,
+    getServerSnapshot: store.getServerSnapshot,
+    subscribe: store.subscribe
+  };
+}
+var runtime = globalThis;
+function rethrowAsync(error) {
+  runtime.setTimeout(() => {
+    throw error;
+  }, 0);
+}
+function createStore(initial, options = {}) {
+  const onListenerError = options.onListenerError ?? rethrowAsync;
+  let snapshot = initial;
+  let listeners = [];
+  function set(next) {
+    if (Object.is(next, snapshot)) return;
+    snapshot = next;
+    for (const entry of listeners.slice()) {
+      try {
+        entry.listener();
+      } catch (error) {
+        onListenerError(error);
+      }
+    }
+  }
+  return {
+    getSnapshot: () => snapshot,
+    getServerSnapshot: () => initial,
+    subscribe(listener) {
+      const entry = { listener };
+      listeners = [...listeners, entry];
+      return () => {
+        listeners = listeners.filter((e) => e !== entry);
+      };
+    },
+    set,
+    update: (fn) => set(fn(snapshot))
+  };
+}
+
+// src/stores/auth.ts
+var SENDS_SESSION = /* @__PURE__ */ new Set(["login", "register", "verify"]);
+var SUPERSEDED = () => storeError("superseded", "The shopper changed while the request was running.");
+function createAuthStore(ctx) {
+  const store = createStore(
+    {
+      status: "unknown",
+      customer: null,
+      rewardPoints: null,
+      verification: null,
+      settings: null,
+      pending: null,
+      error: null
+    },
+    { onListenerError: ctx.onListenerError }
+  );
+  const patch = (next) => store.update((s) => ({ ...s, ...next }));
+  const flight = createSingleFlight();
+  let remembered = true;
+  let savedAt = 0;
+  ctx.onHydrate(({ auth, remembered: fromSecure }) => {
+    remembered = fromSecure;
+    savedAt = auth?.savedAt ?? 0;
+    patch(
+      auth ? {
+        status: "signed-in",
+        customer: auth.customer,
+        rewardPoints: auth.rewardPoints,
+        verification: null
+      } : { status: "signed-out", customer: null, rewardPoints: null }
+    );
+  });
+  function action(name, run) {
+    return flight(name, async () => {
+      patch({ pending: name, error: null });
+      let result;
+      try {
+        result = await run();
+      } catch (error) {
+        result = fail(toStoreError(error, { sentSession: SENDS_SESSION.has(name) }));
+      }
+      if (result.ok) {
+        if (store.getSnapshot().pending === name) patch({ pending: null });
+      } else {
+        failed(name, result.error);
+      }
+      return result;
+    });
+  }
+  function failed(name, error) {
+    const pending = store.getSnapshot().pending;
+    patch({ pending: pending === name ? null : pending, error });
+    ctx.events.emit({ type: "error", store: "auth", action: name, error });
+  }
+  function refuse(name, kind, message) {
+    const error = storeError(kind, message);
+    patch({ error });
+    ctx.events.emit({ type: "error", store: "auth", action: name, error });
+    return Promise.resolve(fail(error));
+  }
+  const signedIn = () => store.getSnapshot().status === "signed-in";
+  function signIn(session, via, remember) {
+    const rotated = ctx.hasSession();
+    ctx.tokens.setSessionToken(null);
+    ctx.records.session.remove();
+    ctx.tokens.setCustomerToken(session.token);
+    remembered = remember;
+    savedAt = Date.now();
+    persist(session.customer, session.token, session.rewardPoints);
+    patch({
+      status: "signed-in",
+      customer: session.customer,
+      rewardPoints: session.rewardPoints,
+      verification: null,
+      pending: null,
+      error: null
+    });
+    ctx.setIdentity({ kind: "customer", customerId: session.customer.id });
+    if (rotated) ctx.events.emit({ type: "session:replaced", reason: "rotated" });
+    ctx.events.emit({ type: "auth:signed-in", customerId: session.customer.id, via });
+  }
+  function persist(customer, token, rewardPoints) {
+    const record = { token, customer, rewardPoints, savedAt };
+    (remembered ? ctx.records.auth : ctx.records.ephemeralAuth).write(record);
+    (remembered ? ctx.records.ephemeralAuth : ctx.records.auth).remove();
+  }
+  function signOut(reason) {
+    const rotated = ctx.hasSession();
+    ctx.tokens.setCustomerToken(null);
+    ctx.tokens.setSessionToken(null);
+    ctx.records.auth.remove();
+    ctx.records.ephemeralAuth.remove();
+    ctx.records.session.remove();
+    patch({ status: "signed-out", customer: null, rewardPoints: null, verification: null });
+    ctx.setIdentity({ kind: "guest", customerId: null });
+    if (rotated) ctx.events.emit({ type: "session:replaced", reason: "rotated" });
+    ctx.events.emit({ type: "auth:signed-out", reason });
+  }
+  ctx.hooks.customerExpired = () => signOut("expired");
+  ctx.events.on("checkout:points-spent", ({ points }) => {
+    const { status, customer, rewardPoints } = store.getSnapshot();
+    const token = ctx.tokens.getCustomerToken();
+    if (status !== "signed-in" || !customer || rewardPoints === null || !token) return;
+    const estimate = Math.max(rewardPoints - points, 0);
+    persist(customer, token, estimate);
+    patch({ rewardPoints: estimate });
+  });
+  function authenticate(name, remember, send) {
+    return action(name, async () => {
+      await ctx.ready();
+      if (signedIn()) return fail(storeError("validation", "Already signed in; log out first."));
+      await ctx.ensureSession();
+      const answer = await ctx.inEpoch(send);
+      if (!answer.current) return fail(SUPERSEDED());
+      const result = answer.value;
+      if (result.status === "signed-in") {
+        signIn(result.session, name, remember !== false);
+        return ok({ status: "signed-in" });
+      }
+      patch({ verification: { customerId: result.customerId, contact: result.contact } });
+      return ok({ status: "verification-required", contact: result.contact });
+    });
+  }
+  function login({ remember, ...input }) {
+    return authenticate("login", remember, () => ctx.client.auth.login(input));
+  }
+  function register({ remember, ...input }) {
+    return authenticate("register", remember, () => ctx.client.auth.register(input));
+  }
+  function verifyOtp(otp) {
+    const verification = store.getSnapshot().verification;
+    if (!verification) {
+      return refuse("verify", "validation", "There is no verification in progress.");
+    }
+    return action("verify", async () => {
+      await ctx.ready();
+      await ctx.ensureSession();
+      const answer = await ctx.inEpoch(
+        () => ctx.client.auth.verifyOtp({ customerId: verification.customerId, otp })
+      );
+      if (!answer.current) return fail(SUPERSEDED());
+      if (!answer.value.customer.isActive) {
+        return fail(storeError("validation", "The account is still not verified."));
+      }
+      signIn(answer.value, "otp", true);
+      return ok({ status: "signed-in" });
+    });
+  }
+  function resendOtp() {
+    const contact = store.getSnapshot().verification?.contact;
+    if (!contact) {
+      return refuse("resend", "validation", "There is no contact to send a new OTP to.");
+    }
+    return action("resend", async () => {
+      await ctx.client.auth.sendOtp(contact);
+      return ok(void 0);
+    });
+  }
+  function cancelVerification() {
+    if (store.getSnapshot().verification) patch({ verification: null });
+  }
+  async function logout() {
+    await ctx.ready();
+    if (signedIn() || ctx.tokens.getCustomerToken() !== null) signOut("logout");
+    return ok(void 0);
+  }
+  function loadSettings() {
+    return action("settings", async () => {
+      const settings = await ctx.client.auth.settings();
+      patch({ settings });
+      return ok(settings);
+    });
+  }
+  async function updateProfile(input) {
+    await ctx.ready();
+    const customer = store.getSnapshot().customer;
+    if (!signedIn() || !customer) {
+      return refuse("profile", "signed-out", "Log in to change the profile.");
+    }
+    return action("profile", async () => {
+      const answer = await ctx.inEpoch(() => ctx.client.customer.updateProfile(customer.id, input));
+      if (!answer.current) return fail(SUPERSEDED());
+      const token = ctx.tokens.getCustomerToken();
+      if (token) persist(answer.value, token, store.getSnapshot().rewardPoints);
+      patch({ customer: answer.value });
+      return ok(answer.value);
+    });
+  }
+  return {
+    getSnapshot: store.getSnapshot,
+    getServerSnapshot: store.getServerSnapshot,
+    subscribe: store.subscribe,
+    loadSettings,
+    login,
+    register,
+    verifyOtp,
+    resendOtp,
+    cancelVerification,
+    logout,
+    updateProfile
+  };
+}
+
+// src/stores/business.ts
+var SECTIONS = ["settings", "themeSettings", "media", "socialLinks"];
+var NO_FEATURES = Object.freeze([]);
+function derive(state) {
+  return {
+    ...state,
+    currency: state.settings?.currency ?? null,
+    themeId: state.themeSettings?.id ?? null,
+    features: state.business?.features ?? NO_FEATURES
+  };
+}
+function overall(sections, current) {
+  const values = SECTIONS.map((section) => sections[section]);
+  if (values.every((v) => v === "error")) return "error";
+  if (values.every((v) => v === "ready" || v === "error")) return "ready";
+  if (current === "ready") return "ready";
+  return values.includes("loading") ? "loading" : "idle";
+}
+function createBusinessStore(ctx) {
+  const seed = ctx.seeds.business;
+  const sections = Object.fromEntries(
+    SECTIONS.map((section) => [section, seed?.[section] !== void 0 ? "ready" : "idle"])
+  );
+  const store = createStore(
+    derive({
+      status: overall(sections, "idle"),
+      refreshing: false,
+      error: null,
+      business: seed?.business ?? null,
+      settings: seed?.settings ?? null,
+      themeSettings: seed?.themeSettings ?? null,
+      media: seed?.media ?? null,
+      socialLinks: seed?.socialLinks ?? null,
+      sections,
+      pending: { themeSettings: false }
+    }),
+    { onListenerError: ctx.onListenerError }
+  );
+  const fetchers = {
+    settings: () => ctx.client.business.settings(),
+    themeSettings: () => ctx.client.business.themeSettings(),
+    media: () => ctx.client.business.media(),
+    socialLinks: () => ctx.client.business.socialLinks()
+  };
+  const generation = {
+    settings: 0,
+    themeSettings: 0,
+    media: 0,
+    socialLinks: 0
+  };
+  const flight = createSingleFlight();
+  const saves = createSerialQueue();
+  let loadsRunning = 0;
+  let savesWaiting = 0;
+  function set(next) {
+    store.set(derive(next));
+  }
+  function failed(action, error) {
+    ctx.events.emit({ type: "error", store: "business", action, error });
+    return fail(error);
+  }
+  async function run(wanted) {
+    const mine = wanted.map((section) => ++generation[section]);
+    loadsRunning += 1;
+    const before = store.getSnapshot();
+    const starting = { ...before.sections };
+    for (const section of wanted) if (starting[section] !== "ready") starting[section] = "loading";
+    set({
+      ...before,
+      sections: starting,
+      status: overall(starting, before.status),
+      refreshing: before.status === "ready",
+      error: null
+    });
+    const results = await Promise.allSettled(wanted.map((section) => fetchers[section]()));
+    loadsRunning -= 1;
+    if (ctx.isDisposed()) return fail(storeError("superseded", "The stores were disposed."));
+    const now = store.getSnapshot();
+    const next = { ...now, sections: { ...now.sections } };
+    const writable = next;
+    const statuses = next.sections;
+    let error = null;
+    for (const [i, result] of results.entries()) {
+      const section = wanted[i];
+      if (generation[section] !== mine[i]) continue;
+      if (result.status === "fulfilled") {
+        writable[section] = result.value;
+        statuses[section] = "ready";
+      } else {
+        error = toStoreError(result.reason);
+        if (statuses[section] !== "ready") statuses[section] = "error";
+      }
+    }
+    const status = overall(statuses, now.status);
+    set({ ...next, status, refreshing: loadsRunning > 0 && status === "ready", error });
+    return error ? failed("load", error) : ok(void 0);
+  }
+  return {
+    ...readOnly(store),
+    load(options = {}) {
+      if (options.force) return run(SECTIONS);
+      const sectionsNow = store.getSnapshot().sections;
+      const missing = SECTIONS.filter((section) => sectionsNow[section] !== "ready");
+      if (missing.length === 0) return Promise.resolve(ok(void 0));
+      return flight("load", () => run(missing));
+    },
+    updateThemeSettings(changes) {
+      savesWaiting += 1;
+      const s = store.getSnapshot();
+      set({ ...s, pending: { themeSettings: true }, error: null });
+      return saves(async () => {
+        let outcome;
+        try {
+          const saved = await ctx.client.business.updateThemeSettings(changes);
+          outcome = ok(saved);
+        } catch (error) {
+          outcome = fail(toStoreError(error));
+        }
+        savesWaiting -= 1;
+        if (ctx.isDisposed()) return fail(storeError("superseded", "The stores were disposed."));
+        const now = store.getSnapshot();
+        const pending = { themeSettings: savesWaiting > 0 };
+        if (!outcome.ok) {
+          set({ ...now, pending, error: outcome.error });
+          return failed("updateThemeSettings", outcome.error);
+        }
+        generation.themeSettings += 1;
+        const statuses = { ...now.sections, themeSettings: "ready" };
+        set({
+          ...now,
+          themeSettings: outcome.value,
+          sections: statuses,
+          status: overall(statuses, now.status),
+          pending,
+          error: null
+        });
+        return outcome;
+      });
+    },
+    hasFeature: (name) => store.getSnapshot().features.includes(name)
+  };
+}
+
+// src/stores/cart.ts
+var NO_PENDING = {
+  adding: [],
+  lines: {},
+  orderType: false,
+  discount: false,
+  addresses: false,
+  taxDetails: false
+};
+var INITIAL = {
+  status: "idle",
+  refreshing: false,
+  cart: null,
+  totalsStale: false,
+  pending: NO_PENDING,
+  delivery: { status: "idle", estimate: null, error: null },
+  mergeWarning: null,
+  error: null
+};
+var SUPERSEDED2 = storeError(
+  "superseded",
+  "A newer change, or a change of shopper, replaced this result."
+);
+function withLine(pending, lineId, kind, only) {
+  if (only && pending.lines[lineId] !== only) return pending;
+  if (!kind && !(lineId in pending.lines)) return pending;
+  const lines = { ...pending.lines };
+  if (kind) lines[lineId] = kind;
+  else delete lines[lineId];
+  return { ...pending, lines };
+}
+function withoutOne(list, value) {
+  const index = list.indexOf(value);
+  return index < 0 ? list : [...list.slice(0, index), ...list.slice(index + 1)];
+}
+function createCartStore(ctx) {
+  const store = createStore(INITIAL, { onListenerError: ctx.onListenerError });
+  const latest = createLatest();
+  const latestQuote = createLatest();
+  const serial = createSerialQueue();
+  const coalesce = createCoalescer();
+  let server = null;
+  const quantities = /* @__PURE__ */ new Map();
+  const removals = /* @__PURE__ */ new Map();
+  let orderType = null;
+  const gone = /* @__PURE__ */ new Set();
+  let needsLoad = false;
+  let mergeCheck = null;
+  let version = 0;
+  let memo = null;
+  const touch = () => {
+    version++;
+  };
+  function view() {
+    if (memo?.version === version) return memo.value;
+    const stale = quantities.size > 0 || removals.size > 0 || orderType !== null;
+    let value = { cart: server, totalsStale: false };
+    if (server && stale) {
+      const lines = server.lines.filter((line) => !removals.has(line.id)).map((line) => {
+        const quantity = quantities.get(line.id)?.value;
+        return quantity === void 0 || quantity === line.quantity ? line : { ...line, quantity };
+      });
+      value = {
+        cart: { ...server, lines, type: orderType?.value ?? server.type },
+        totalsStale: true
+      };
+    }
+    memo = { version, value };
+    return value;
+  }
+  function update(patch) {
+    const current = store.getSnapshot();
+    const keys = Object.keys(patch);
+    if (keys.every((key) => Object.is(patch[key], current[key]))) return;
+    store.set({ ...current, ...patch });
+  }
+  const render = (patch = {}) => update({ ...view(), ...patch });
+  const pending = () => store.getSnapshot().pending;
+  function reset(patch) {
+    server = null;
+    quantities.clear();
+    removals.clear();
+    orderType = null;
+    gone.clear();
+    touch();
+    store.set({ ...INITIAL, ...patch });
+  }
+  const epoch = () => ctx.identity.getSnapshot().epoch;
+  function act(name, keepError = false) {
+    const at = epoch();
+    const sentSession = ctx.hasSession();
+    if (!keepError && store.getSnapshot().error) update({ error: null });
+    const alive = () => !ctx.isDisposed() && epoch() === at;
+    const self = {
+      alive,
+      fail(cause, patch = {}) {
+        const error = toStoreError(cause, { sentSession });
+        if (!alive()) return fail(error.kind === "session" ? error : SUPERSEDED2);
+        if (error.kind === "superseded") return fail(error);
+        update({ ...patch, error });
+        ctx.events.emit({ type: "error", store: "cart", action: name, error });
+        return fail(error);
+      },
+      refuse: (kind, message) => self.fail(storeError(kind, message))
+    };
+    return self;
+  }
+  async function guard(action, run) {
+    try {
+      const value = await run();
+      return action.alive() ? { current: true, value } : { current: false };
+    } catch (error) {
+      if (action.alive() || toStoreError(error, { sentSession: true }).kind === "session") {
+        throw error;
+      }
+      return { current: false };
+    }
+  }
+  const isCustomer = () => ctx.identity.getSnapshot().kind === "customer";
+  const findLine = (lineId) => view().cart?.lines.find((line) => line.id === lineId);
+  async function load() {
+    await ctx.ready();
+    const action = act("refresh", true);
+    if (!isCustomer() && !ctx.hasSession()) {
+      void latest(() => Promise.resolve(null));
+      needsLoad = false;
+      server = null;
+      touch();
+      render({ status: "ready", refreshing: false });
+      return ok(null);
+    }
+    update(store.getSnapshot().status === "ready" ? { refreshing: true } : { status: "loading" });
+    const settled = settledChanges();
+    try {
+      const result = await guard(action, () => latest(() => ctx.client.cart.get()));
+      if (!result.current || !result.value.current) return fail(SUPERSEDED2);
+      server = result.value.value;
+      for (const forget of settled) forget();
+      touch();
+      needsLoad = false;
+      const missing = checkMerge(server);
+      render({ status: "ready", refreshing: false, ...missing && { mergeWarning: missing } });
+      if (missing) ctx.events.emit({ type: "cart:merge-incomplete", ...missing });
+      return ok(view().cart);
+    } catch (error) {
+      const status = store.getSnapshot().status === "ready" && server ? "ready" : "error";
+      return action.fail(error, { status, refreshing: false });
+    }
+  }
+  function checkMerge(cart) {
+    const guestSkus = mergeCheck;
+    mergeCheck = null;
+    if (!guestSkus) return null;
+    const present = new Set(cart.lines.map((line) => line.skuId));
+    const missingSkuIds = guestSkus.filter((skuId) => !present.has(skuId));
+    return missingSkuIds.length ? { missingSkuIds } : null;
+  }
+  function settledChanges() {
+    const forget = [];
+    for (const [map, entries] of [
+      [quantities, [...quantities]],
+      [removals, [...removals]]
+    ]) {
+      for (const [lineId, change] of entries) {
+        if (!change.settled) continue;
+        forget.push(() => {
+          if (map.get(lineId) === change) map.delete(lineId);
+        });
+      }
+    }
+    const type = orderType;
+    if (type?.settled) {
+      forget.push(() => {
+        if (orderType === type) orderType = null;
+      });
+    }
+    return forget;
+  }
+  async function refresh() {
+    await ctx.ready();
+    act("refresh");
+    return load();
+  }
+  async function add(input) {
+    await ctx.ready();
+    const action = act("add");
+    update({ pending: { ...pending(), adding: [...pending().adding, input.skuId] } });
+    try {
+      if (!isCustomer()) await ctx.ensureSession();
+      const result = await guard(action, () => serial(() => ctx.client.cart.addItem(input)));
+      if (!result.current) return fail(SUPERSEDED2);
+      update({ pending: { ...pending(), adding: withoutOne(pending().adding, input.skuId) } });
+      await load();
+      return ok({ lineId: result.value.lineId });
+    } catch (error) {
+      return action.fail(error, {
+        pending: { ...pending(), adding: withoutOne(pending().adding, input.skuId) }
+      });
+    }
+  }
+  async function setQuantity(lineId, quantity) {
+    await ctx.ready();
+    if (quantity === 0) return remove(lineId);
+    const action = act("setQuantity");
+    if (!Number.isInteger(quantity) || quantity < 0) {
+      return action.refuse("validation", `Cart quantity must be a whole number: ${quantity}.`);
+    }
+    const line = findLine(lineId);
+    if (!line) return action.refuse("validation", `There is no cart line ${lineId}.`);
+    if (line.maxQuantity !== null && quantity > line.maxQuantity) {
+      return action.refuse(
+        "validation",
+        `At most ${line.maxQuantity} of this item can be ordered.`
+      );
+    }
+    const change = { value: quantity, settled: false };
+    quantities.set(lineId, change);
+    touch();
+    render({ pending: withLine(pending(), lineId, "quantity") });
+    try {
+      const result = await guard(
+        action,
+        () => coalesce(
+          lineId,
+          quantity,
+          (value) => serial(async () => {
+            if (gone.has(lineId) || removals.has(lineId)) return;
+            await ctx.client.cart.setQuantity(lineId, value);
+          })
+        )
+      );
+      if (!result.current || !result.value.current) return fail(SUPERSEDED2);
+      change.settled = true;
+      update({ pending: withLine(pending(), lineId, null, "quantity") });
+      await load();
+      return ok(void 0);
+    } catch (error) {
+      if (quantities.get(lineId) === change) quantities.delete(lineId);
+      touch();
+      const failed = action.fail(error, {
+        ...view(),
+        pending: withLine(pending(), lineId, null, "quantity")
+      });
+      if (action.alive()) await load();
+      return failed;
+    }
+  }
+  async function remove(lineId) {
+    await ctx.ready();
+    const action = act("remove");
+    if (!findLine(lineId)) return action.refuse("validation", `There is no cart line ${lineId}.`);
+    const change = { value: true, settled: false };
+    removals.set(lineId, change);
+    touch();
+    render({ pending: withLine(pending(), lineId, "remove") });
+    try {
+      const result = await guard(action, () => serial(() => ctx.client.cart.removeItem(lineId)));
+      if (!result.current) return fail(SUPERSEDED2);
+      change.settled = true;
+      gone.add(lineId);
+      update({ pending: withLine(pending(), lineId, null) });
+      await load();
+      return ok(void 0);
+    } catch (error) {
+      if (removals.get(lineId) === change) removals.delete(lineId);
+      touch();
+      const failed = action.fail(error, { ...view(), pending: withLine(pending(), lineId, null) });
+      if (action.alive()) await load();
+      return failed;
+    }
+  }
+  async function setOrderType(type) {
+    await ctx.ready();
+    const action = act("setOrderType");
+    const cart = view().cart;
+    if (!cart) return action.refuse("validation", "There is no cart yet.");
+    if (cart.type === type) return ok(void 0);
+    const change = { value: type, settled: false };
+    orderType = change;
+    touch();
+    render({ pending: { ...pending(), orderType: true } });
+    try {
+      const result = await guard(action, () => serial(() => ctx.client.cart.setOrderType(type)));
+      if (!result.current) return fail(SUPERSEDED2);
+      change.settled = true;
+      update({ pending: { ...pending(), orderType: false } });
+      await load();
+      return ok(void 0);
+    } catch (error) {
+      if (orderType === change) orderType = null;
+      touch();
+      const failed = action.fail(error, { ...view(), pending: { ...pending(), orderType: false } });
+      if (action.alive()) await load();
+      return failed;
+    }
+  }
+  async function setAddresses(input) {
+    await ctx.ready();
+    const action = act("setAddresses");
+    if (!isCustomer()) return action.refuse("signed-out", "Sign in to choose addresses.");
+    update({ pending: { ...pending(), addresses: true } });
+    try {
+      const result = await guard(action, () => serial(() => ctx.client.cart.setAddresses(input)));
+      if (!result.current) return fail(SUPERSEDED2);
+      update({ pending: { ...pending(), addresses: false } });
+      await load();
+      return ok(void 0);
+    } catch (error) {
+      return action.fail(error, { pending: { ...pending(), addresses: false } });
+    }
+  }
+  async function setTaxDetails(input) {
+    await ctx.ready();
+    const action = act("setTaxDetails");
+    update({ pending: { ...pending(), taxDetails: true } });
+    try {
+      await ctx.ensureSession();
+      const result = await guard(action, () => serial(() => ctx.client.cart.setTaxDetails(input)));
+      if (!result.current) return fail(SUPERSEDED2);
+      update({ pending: { ...pending(), taxDetails: false } });
+      return ok(result.value);
+    } catch (error) {
+      return action.fail(error, { pending: { ...pending(), taxDetails: false } });
+    }
+  }
+  async function discount(action, run) {
+    update({ pending: { ...pending(), discount: true } });
+    let result;
+    try {
+      if (!isCustomer()) await ctx.ensureSession();
+      result = await run();
+    } catch (error) {
+      result = action.fail(error);
+    }
+    if (action.alive()) update({ pending: { ...pending(), discount: false } });
+    return result;
+  }
+  async function sendDiscount(action, send) {
+    let sent;
+    try {
+      sent = await guard(action, () => serial(send));
+    } catch (error) {
+      const failed = action.fail(error);
+      if (action.alive()) await load();
+      return failed;
+    }
+    if (!sent.current) return fail(SUPERSEDED2);
+    await load();
+    return ok(void 0);
+  }
+  async function applyOffer(offerId) {
+    await ctx.ready();
+    const action = act("applyOffer");
+    return discount(action, () => sendDiscount(action, () => ctx.client.cart.applyOffer(offerId)));
+  }
+  async function applyPromoCode(code) {
+    await ctx.ready();
+    const action = act("applyPromoCode");
+    if (code !== null && !code.trim()) return action.refuse("validation", "Enter a promo code.");
+    return discount(action, async () => {
+      if (code === null) {
+        const removed = await sendDiscount(action, () => ctx.client.cart.applyPromoCode(null));
+        return removed.ok ? ok(null) : removed;
+      }
+      const found = await guard(action, () => ctx.client.promotions.promoCode(code));
+      if (!found.current) return fail(SUPERSEDED2);
+      const promo = found.value;
+      if (!promo) return action.refuse("validation", "This promo code does not exist.");
+      if (promo.status !== "active") {
+        return action.fail(
+          storeError("validation", `This promo code is ${promo.status}.`, {
+            fieldErrors: { code: [promo.status] }
+          })
+        );
+      }
+      const applied = await sendDiscount(action, () => ctx.client.cart.applyPromoCode(promo.id));
+      return applied.ok ? ok(promo) : applied;
+    });
+  }
+  async function estimateDelivery(pincode) {
+    await ctx.ready();
+    const action = act("estimateDelivery");
+    const delivery = store.getSnapshot().delivery;
+    const refuse = (message) => {
+      const error = storeError("validation", message);
+      update({ delivery: { ...delivery, error } });
+      return fail(error);
+    };
+    const cart = view().cart;
+    if (!cart) return refuse("There is no cart yet.");
+    if (cart.deliveryChargeType !== "as_per_delivery_partner") {
+      return refuse("This business does not quote delivery charges.");
+    }
+    update({ delivery: { ...delivery, status: "loading", error: null } });
+    try {
+      const result = await guard(
+        action,
+        () => latestQuote(() => ctx.client.cart.deliveryEstimate(cart.id, { pincode }))
+      );
+      if (!result.current || !result.value.current) return fail(SUPERSEDED2);
+      const estimate = result.value.value;
+      update({ delivery: { status: "ready", estimate, error: null } });
+      await load();
+      return ok(estimate);
+    } catch (error) {
+      const failed = action.fail(error);
+      if (failed.ok || !action.alive() || failed.error.kind === "superseded") return failed;
+      const { estimate } = store.getSnapshot().delivery;
+      update({ delivery: { status: "error", estimate, error: failed.error } });
+      if (storedPayable(error)) await load();
+      return failed;
+    }
+  }
+  function dismissMergeWarning() {
+    update({ mergeWarning: null });
+  }
+  async function moveToWishlist(lineId) {
+    await ctx.ready();
+    const action = act("moveToWishlist");
+    if (!isCustomer()) return action.refuse("signed-out", "Sign in to save items.");
+    const skuId = findLine(lineId)?.skuId;
+    if (skuId == null) {
+      return action.refuse("validation", `Cart line ${lineId} has no item to save.`);
+    }
+    update({ pending: withLine(pending(), lineId, "wishlist") });
+    const wishlist = ctx.stores.wishlist;
+    if (!wishlist.has(skuId)) {
+      const added = await wishlist.add(skuId);
+      if (!action.alive()) return fail(SUPERSEDED2);
+      if (!added.ok) {
+        return action.fail(added.error, { pending: withLine(pending(), lineId, null) });
+      }
+    }
+    update({ pending: withLine(pending(), lineId, null) });
+    return remove(lineId);
+  }
+  ctx.autoLoad(() => void load());
+  ctx.onHydrate((read) => {
+    if (read.phase === "rehydrate") reset({});
+  });
+  ctx.events.on("auth:signed-in", () => {
+    const guestSkus = /* @__PURE__ */ new Set();
+    for (const line of server?.lines ?? []) if (line.skuId !== null) guestSkus.add(line.skuId);
+    mergeCheck = guestSkus.size ? [...guestSkus] : null;
+    needsLoad = true;
+    reset({ status: "loading" });
+    void load();
+  });
+  ctx.events.on("auth:signed-out", () => {
+    needsLoad = false;
+    mergeCheck = null;
+    reset({ status: "ready" });
+  });
+  ctx.events.on("session:replaced", ({ reason }) => {
+    if (isCustomer()) {
+      if (needsLoad && ctx.tokens.getCustomerToken()) void load();
+      return;
+    }
+    if (reason === "dead") {
+      reset({ status: "ready" });
+      void load();
+    }
+  });
+  ctx.events.on("order:placed", () => {
+    reset({ status: "loading" });
+    void load();
+  });
+  return {
+    ...readOnly(store),
+    refresh,
+    add,
+    setQuantity,
+    remove,
+    setOrderType,
+    setAddresses,
+    setTaxDetails,
+    applyOffer,
+    applyPromoCode,
+    estimateDelivery,
+    moveToWishlist,
+    dismissMergeWarning
+  };
+}
+function storedPayable(error) {
+  return error instanceof GrowupsellApiError && error.status === 400 && typeof error.body === "object" && error.body !== null && "final_payable_amount" in error.body;
+}
+
+// src/stores/catalog.ts
+function createCatalogStore(ctx) {
+  const seed = ctx.seeds.catalog;
+  const loaded = {
+    categories: seed?.categories !== void 0,
+    settings: seed?.settings !== void 0
+  };
+  const complete = () => loaded.categories && loaded.settings;
+  const store = createStore(
+    {
+      status: complete() ? "ready" : "idle",
+      refreshing: false,
+      error: null,
+      categories: seed?.categories ?? [],
+      settings: seed?.settings ?? null
+    },
+    { onListenerError: ctx.onListenerError }
+  );
+  const flight = createSingleFlight();
+  const latest = createLatest();
+  async function run(parts) {
+    store.update(
+      (s) => s.status === "ready" ? { ...s, refreshing: true, error: null } : { ...s, status: "loading", error: null }
+    );
+    const outcome = await latest(
+      () => Promise.allSettled([
+        parts.includes("categories") ? ctx.client.catalog.categories() : void 0,
+        parts.includes("settings") ? ctx.client.catalog.settings() : void 0
+      ])
+    );
+    if (!outcome.current || ctx.isDisposed()) {
+      return fail(storeError("superseded", "A newer catalog load replaced this one."));
+    }
+    const [categories, settings] = outcome.value;
+    let error = null;
+    const next = { ...store.getSnapshot() };
+    if (categories.status === "fulfilled" && parts.includes("categories")) {
+      next.categories = categories.value;
+      loaded.categories = true;
+    } else if (categories.status === "rejected") error = toStoreError(categories.reason);
+    if (settings.status === "fulfilled" && parts.includes("settings")) {
+      next.settings = settings.value;
+      loaded.settings = true;
+    } else if (settings.status === "rejected") error = toStoreError(settings.reason);
+    store.set({
+      ...next,
+      status: complete() ? "ready" : "error",
+      refreshing: false,
+      error
+    });
+    if (!error) return ok(void 0);
+    ctx.events.emit({ type: "error", store: "catalog", action: "load", error });
+    return fail(error);
+  }
+  return {
+    ...readOnly(store),
+    load(options = {}) {
+      if (options.force) return run(["categories", "settings"]);
+      const missing = ["categories", "settings"].filter((part) => !loaded[part]);
+      if (missing.length === 0) return Promise.resolve(ok(void 0));
+      return flight("load", () => run(missing));
+    }
+  };
+}
+
+// src/stores/selectors.ts
+function cartItemCount(state) {
+  return state.cart?.lines.reduce((sum, line) => sum + line.quantity, 0) ?? 0;
+}
+function cartLineForSku(state, skuId) {
+  return state.cart?.lines.find((line) => line.skuId === skuId && line.customData == null) ?? null;
+}
+function isInWishlist(state, skuId) {
+  return state.items.some((item) => item.sku?.id === skuId);
+}
+function checkoutPreviewFor(cart, checkout, auth) {
+  if (!cart.cart) return null;
+  const { rewardSettings } = checkout;
+  return checkoutPreview({
+    payable: cart.cart.payable,
+    subtotal: cart.cart.subtotal,
+    giftCards: checkout.giftCards,
+    rewardPoints: checkout.useRewardPoints && rewardSettings ? { available: auth.rewardPoints ?? 0, currencyPerPoint: rewardSettings.currencyPerPoint } : void 0
+  });
+}
+function paymentOptionsFor(cart, checkout, auth, features) {
+  if (!cart.cart || !checkout.settings || !checkout.rewardSettings) return null;
+  return paymentOptions({
+    cart: cart.cart,
+    settings: checkout.settings,
+    rewardPoints: checkout.rewardSettings,
+    availablePoints: auth.rewardPoints ?? 0,
+    features,
+    giftCardsSelected: checkout.giftCards.length > 0
+  });
+}
+
+// src/stores/checkout.ts
+var INITIAL2 = {
+  settings: null,
+  rewardSettings: null,
+  settingsStatus: "idle",
+  giftCards: [],
+  useRewardPoints: false,
+  phase: "idle",
+  order: null,
+  pending: { settings: false, giftCard: false },
+  error: null
+};
+var ORDER_IN_PROGRESS = /* @__PURE__ */ new Set([
+  "placing",
+  "awaiting-payment",
+  "confirming",
+  "outcome-unknown"
+]);
+var superseded = () => storeError("superseded", "The shopper changed while checkout ran.");
+function paymentStatusOf(detail, paymentId) {
+  const entry = paymentId != null && detail.payments.find((p) => p.id === paymentId) || detail.payments.at(-1);
+  return entry?.status ?? null;
+}
+function createCheckoutStore(ctx) {
+  const store = createStore(INITIAL2, { onListenerError: ctx.onListenerError });
+  const flight = createSingleFlight();
+  const currentCart = () => ctx.stores.cart.getSnapshot().cart;
+  const rewardPoints = () => ctx.stores.auth.getSnapshot().rewardPoints;
+  const features = () => ctx.stores.business.getSnapshot().business?.features ?? null;
+  const whenReady = () => ctx.identity.getSnapshot().kind === "unknown" ? ctx.ready() : void 0;
+  const patch = (changes) => store.update((s) => ({ ...s, ...changes }));
+  const setPending = (key, value) => store.update((s) => ({ ...s, pending: { ...s.pending, [key]: value } }));
+  function failWith(action, error, changes = {}) {
+    if (error.kind !== "superseded") {
+      patch({ ...changes, error });
+      ctx.events.emit({ type: "error", store: "checkout", action, error });
+    } else if (Object.keys(changes).length) {
+      patch(changes);
+    }
+    return fail(error);
+  }
+  const refuse = (action, message, kind = "validation") => failWith(action, storeError(kind, message));
+  const startAction = () => {
+    if (store.getSnapshot().error) patch({ error: null });
+  };
+  let watching = false;
+  function watchCart() {
+    if (watching) return;
+    watching = true;
+    const unsubscribe = ctx.stores.cart.subscribe(() => {
+      const s = store.getSnapshot();
+      if (currentCart()?.type === "cod" && (s.giftCards.length > 0 || s.useRewardPoints)) {
+        patch({ giftCards: [], useRewardPoints: false });
+      }
+    });
+    ctx.onDispose(unsubscribe);
+  }
+  ctx.events.on("auth:signed-out", () => {
+    const { settings, rewardSettings, settingsStatus } = store.getSnapshot();
+    store.set({ ...INITIAL2, settings, rewardSettings, settingsStatus });
+  });
+  function preview() {
+    return checkoutPreviewFor({ cart: currentCart() }, store.getSnapshot(), {
+      rewardPoints: rewardPoints()
+    });
+  }
+  function loadSettings() {
+    return flight("settings", async () => {
+      startAction();
+      store.update((s) => ({
+        ...s,
+        settingsStatus: s.settingsStatus === "ready" ? "ready" : "loading",
+        pending: { ...s.pending, settings: true }
+      }));
+      try {
+        await ctx.ready();
+        const [settings, rewardSettings] = await Promise.all([
+          ctx.client.checkout.settings(),
+          ctx.client.promotions.rewardPointSettings()
+        ]);
+        store.update((s) => ({
+          ...s,
+          settings,
+          rewardSettings,
+          settingsStatus: "ready",
+          pending: { ...s.pending, settings: false }
+        }));
+        return ok(void 0);
+      } catch (error) {
+        setPending("settings", false);
+        const failed = toStoreError(error);
+        return failWith("loadSettings", failed, {
+          settingsStatus: store.getSnapshot().settingsStatus === "ready" ? "ready" : "error"
+        });
+      }
+    });
+  }
+  function giftCardRefusal() {
+    const s = store.getSnapshot();
+    if (s.useRewardPoints) {
+      return "Gift cards and reward points cannot be combined; turn reward points off first.";
+    }
+    if (currentCart()?.type === "cod") return "Gift cards cannot pay a cash-on-delivery order.";
+    if (s.giftCards.length > 0 && preview()?.toPay === 0) {
+      return "The gift cards already pay the whole order.";
+    }
+    return null;
+  }
+  async function addGiftCard(input) {
+    await ctx.ready();
+    startAction();
+    const code = input.code?.trim() ?? "";
+    const pin = input.pin?.trim() ?? "";
+    if (!code || !pin) return refuse("addGiftCard", "Enter the gift card code and PIN.");
+    const held = store.getSnapshot().giftCards;
+    if (held.some((c) => c.code.toUpperCase() === code.toUpperCase())) {
+      return refuse("addGiftCard", "This gift card is already applied.");
+    }
+    const refusal = giftCardRefusal();
+    if (refusal) return refuse("addGiftCard", refusal);
+    watchCart();
+    setPending("giftCard", true);
+    let card;
+    try {
+      const result = await ctx.inEpoch(() => ctx.client.promotions.validateGiftCard({ code, pin }));
+      if (!result.current) {
+        setPending("giftCard", false);
+        return fail(superseded());
+      }
+      card = result.value;
+    } catch (error) {
+      setPending("giftCard", false);
+      return failWith("addGiftCard", toStoreError(error));
+    }
+    setPending("giftCard", false);
+    if (store.getSnapshot().giftCards.some((c) => c.id === card.id)) {
+      return refuse("addGiftCard", "This gift card is already applied.");
+    }
+    const late = giftCardRefusal();
+    if (late) return refuse("addGiftCard", late);
+    store.update((s) => ({ ...s, giftCards: [...s.giftCards, card] }));
+    return ok(card);
+  }
+  function removeGiftCard(giftCardId) {
+    store.update(
+      (s) => s.giftCards.some((c) => c.id === giftCardId) ? { ...s, giftCards: s.giftCards.filter((c) => c.id !== giftCardId) } : s
+    );
+  }
+  function setUseRewardPoints(use) {
+    startAction();
+    const s = store.getSnapshot();
+    if (!use) {
+      if (s.useRewardPoints) patch({ useRewardPoints: false });
+      return ok(void 0);
+    }
+    if (s.giftCards.length > 0) {
+      return refuse(
+        "setUseRewardPoints",
+        "Gift cards and reward points cannot be combined; remove the gift cards first."
+      );
+    }
+    const cart = currentCart();
+    if (!cart) return refuse("setUseRewardPoints", "The cart is not loaded.");
+    if (cart.type === "cod") {
+      return refuse("setUseRewardPoints", "Reward points cannot pay a cash-on-delivery order.");
+    }
+    if (!s.settings || !s.rewardSettings) {
+      return refuse("setUseRewardPoints", "Load the checkout settings first.");
+    }
+    const options = paymentOptionsFor(
+      { cart },
+      s,
+      { rewardPoints: rewardPoints() },
+      features() ?? ["giftcard", "reward-point"]
+    );
+    if (!options?.rewardPoints) {
+      return refuse("setUseRewardPoints", "Reward points cannot be used for this order.");
+    }
+    watchCart();
+    patch({ useRewardPoints: true });
+    return ok(void 0);
+  }
+  function orderPlaced(order, pointsUsed, payment) {
+    store.update((s) => ({
+      ...s,
+      phase: payment === "none" ? "placed" : "awaiting-payment",
+      order,
+      giftCards: [],
+      useRewardPoints: false,
+      error: null
+    }));
+    if (pointsUsed > 0) ctx.events.emit({ type: "checkout:points-spent", points: pointsUsed });
+    ctx.events.emit({ type: "order:placed", orderId: order.orderId, payment });
+  }
+  async function place() {
+    const ready = whenReady();
+    if (ready) await ready;
+    startAction();
+    const s = store.getSnapshot();
+    if (ctx.identity.getSnapshot().kind !== "customer") {
+      return refuse("placeOrder", "Log in to place the order.", "signed-out");
+    }
+    if (ORDER_IN_PROGRESS.has(s.phase)) {
+      return refuse("placeOrder", "This order is already placed; finish or check its payment.");
+    }
+    const cart = currentCart();
+    if (!cart || cart.lines.length === 0) return refuse("placeOrder", "The cart is empty.");
+    if (s.order && s.order.orderId === cart.id) {
+      return refuse("placeOrder", "This cart has already been placed as an order.");
+    }
+    if (requiresShippingAddress(cart.lines) && cart.shippingAddressId == null) {
+      return refuse("placeOrder", "Choose a shipping address.");
+    }
+    if (cart.type === "cod" && (s.giftCards.length > 0 || s.useRewardPoints)) {
+      return refuse("placeOrder", "Gift cards and reward points cannot pay cash on delivery.");
+    }
+    const pointsUsed = s.useRewardPoints ? preview()?.pointsUsed ?? 0 : 0;
+    const giftCardIds = s.giftCards.map((c) => c.id);
+    const useRewardPoints = s.useRewardPoints;
+    patch({ phase: "placing" });
+    let outcome;
+    try {
+      outcome = await ctx.inEpoch(
+        () => ctx.client.checkout.placeOrder(cart.id, { giftCardIds, useRewardPoints })
+      );
+    } catch (error) {
+      const failed = toStoreError(error);
+      if (failed.kind === "timeout" || failed.kind === "network") {
+        return afterUnknownOutcome(cart.id, failed, pointsUsed);
+      }
+      return failWith("placeOrder", failed, { phase: "idle" });
+    }
+    if (!outcome.current) return failWith("placeOrder", superseded(), { phase: "idle" });
+    const result = outcome.value;
+    if (result.status === "placed") {
+      orderPlaced(
+        { orderId: result.orderId, payment: null, paymentStatus: null },
+        pointsUsed,
+        "none"
+      );
+    } else {
+      orderPlaced(
+        { orderId: result.orderId, payment: result.payment, paymentStatus: null },
+        pointsUsed,
+        "required"
+      );
+    }
+    return ok(result);
+  }
+  async function afterUnknownOutcome(cartId, cause, pointsUsed) {
+    patch({ phase: "outcome-unknown" });
+    let read;
+    try {
+      read = await ctx.inEpoch(() => ctx.client.orders.detail(cartId));
+    } catch {
+      return failWith("placeOrder", cause, { phase: "outcome-unknown" });
+    }
+    if (!read.current) return failWith("placeOrder", superseded(), { phase: "idle" });
+    const detail = read.value;
+    if (detail.status === "cart") return failWith("placeOrder", cause, { phase: "idle" });
+    orderPlaced(
+      { orderId: cartId, payment: null, paymentStatus: paymentStatusOf(detail) },
+      pointsUsed,
+      "none"
+    );
+    return ok({ status: "placed", orderId: cartId });
+  }
+  function confirm(action, method, send, options = {}) {
+    return flight("confirm", async () => {
+      const ready = whenReady();
+      if (ready) await ready;
+      startAction();
+      const s = store.getSnapshot();
+      const order = s.order;
+      if (s.phase !== "awaiting-payment" || !order?.payment) {
+        return refuse(action, "There is no payment waiting for confirmation.");
+      }
+      if (method && order.payment.method !== method) {
+        return refuse(action, `The pending payment is not a ${method} payment.`);
+      }
+      return runConfirmation(
+        action,
+        order.orderId,
+        order.payment,
+        () => send(order.payment),
+        options
+      );
+    });
+  }
+  async function runConfirmation(action, orderId, payment, send, options = {}) {
+    const paymentId = options.paymentId ?? payment?.id;
+    patch({
+      phase: "confirming",
+      order: { orderId, payment, paymentStatus: store.getSnapshot().order?.paymentStatus ?? null }
+    });
+    let sendError = null;
+    try {
+      const sent = await ctx.inEpoch(send);
+      if (!sent.current) return failWith(action, superseded());
+    } catch (error) {
+      sendError = toStoreError(error);
+    }
+    let status;
+    try {
+      const read = await ctx.inEpoch(() => ctx.client.orders.detail(orderId));
+      if (!read.current) return failWith(action, superseded());
+      status = paymentStatusOf(read.value, paymentId);
+    } catch (error) {
+      return failWith(action, sendError ?? toStoreError(error), { phase: "awaiting-payment" });
+    }
+    const done = status === "paid" || options.endPlaced === true && sendError == null;
+    store.update((st) => ({
+      ...st,
+      phase: done ? "placed" : "awaiting-payment",
+      order: { orderId, payment, paymentStatus: status }
+    }));
+    if (done) {
+      ctx.events.emit({ type: "payment:confirmed", orderId, paymentStatus: status ?? "unpaid" });
+      return ok(status ?? "unpaid");
+    }
+    if (sendError) return failWith(action, sendError);
+    return ok(status ?? "unpaid");
+  }
+  function confirmPhonePe(input) {
+    return flight("confirm", async () => {
+      const ready = whenReady();
+      if (ready) await ready;
+      startAction();
+      const s = store.getSnapshot();
+      if (s.phase === "placing") {
+        return refuse("confirmPhonePe", "The order is still being placed.");
+      }
+      const known = s.order?.payment?.id === input.paymentId ? s.order.payment : null;
+      return runConfirmation(
+        "confirmPhonePe",
+        input.orderId,
+        known,
+        () => ctx.client.payments.confirmPhonePe(input.paymentId),
+        { paymentId: input.paymentId }
+      );
+    });
+  }
+  function reset() {
+    const { settings, rewardSettings, settingsStatus } = store.getSnapshot();
+    store.set({ ...INITIAL2, settings, rewardSettings, settingsStatus });
+  }
+  return {
+    ...readOnly(store),
+    loadSettings,
+    addGiftCard,
+    removeGiftCard,
+    setUseRewardPoints,
+    placeOrder: () => flight("place", place),
+    confirmStripe: () => confirm("confirmStripe", "stripe", (payment) => ctx.client.payments.confirmStripe(payment)),
+    confirmRazorpay: (result) => confirm(
+      "confirmRazorpay",
+      "razorpay",
+      (payment) => ctx.client.payments.confirmRazorpay(payment, result)
+    ),
+    confirmPhonePe,
+    submitTransferProof: (screenshot) => confirm(
+      "submitTransferProof",
+      "direct-transfer",
+      (payment) => ctx.client.payments.submitTransferProof(payment.id, screenshot),
+      { endPlaced: true }
+    ),
+    paymentDismissed: () => {
+    },
+    reset
+  };
+}
+
+// src/stores/listing.ts
+var runtime2 = globalThis;
+function derive2(base) {
+  return {
+    ...base,
+    pageCount: Math.max(1, Math.ceil(base.total / base.pageSize)),
+    query: listingQuery(base.criteria)
+  };
+}
+var sameCriteria = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+var toggle = (list, value) => list.includes(value) ? list.filter((v) => v !== value) : [...list, value];
+var emptyFacets = {
+  status: "idle",
+  price: null,
+  specifications: [],
+  brands: [],
+  variantGroups: []
+};
+function initialCriteria(input) {
+  const criteria = parseListingQuery(input.query ?? {});
+  if (criteria.categoryId === null && input.categoryId != null) {
+    return { ...criteria, categoryId: input.categoryId };
+  }
+  return criteria;
+}
+function createListingStore(ctx, input = {}) {
+  const pageSize = input.pageSize && Number.isInteger(input.pageSize) && input.pageSize > 0 ? input.pageSize : LISTING_PAGE_SIZE;
+  const store = createStore(
+    derive2({
+      criteria: initialCriteria(input),
+      status: "idle",
+      refreshing: false,
+      items: [],
+      total: 0,
+      pageSize,
+      error: null,
+      facets: emptyFacets
+    }),
+    { onListenerError: ctx.onListenerError }
+  );
+  const searches = createLatest();
+  const facetLoads = createLatest();
+  let disposed = false;
+  let started = false;
+  let scheduled = false;
+  let facetsFor;
+  const set = (changes) => {
+    if (!disposed) store.set(derive2({ ...store.getSnapshot(), ...changes }));
+  };
+  async function expand(categoryId) {
+    const { catalog } = ctx.stores;
+    await catalog.load();
+    return categoryAndDescendants(catalog.getSnapshot().categories, categoryId);
+  }
+  async function attempt(criteria2) {
+    await ctx.ready();
+    const epoch = ctx.identity.getSnapshot().epoch;
+    const changed = () => ctx.identity.getSnapshot().epoch !== epoch;
+    try {
+      await ctx.ensureSession();
+      const ids = criteria2.categoryId === null ? [] : await expand(criteria2.categoryId);
+      const page = await ctx.client.products.search(listingSearchOptions(criteria2, ids, pageSize));
+      return { page, epochChanged: changed() };
+    } catch (caught) {
+      return { error: toStoreError(caught, { sentSession: true }), epochChanged: changed() };
+    }
+  }
+  async function fetchPage(criteria2) {
+    let result = await attempt(criteria2);
+    if (result.epochChanged && !disposed) result = await attempt(criteria2);
+    if ("error" in result) throw result.error;
+    return result.page;
+  }
+  async function search() {
+    if (disposed) return fail(storeError("superseded", "listing: the store was disposed."));
+    const { criteria: criteria2, status } = store.getSnapshot();
+    set(status === "ready" ? { refreshing: true } : { status: "loading", refreshing: false });
+    try {
+      const result = await searches(() => fetchPage(criteria2));
+      if (!result.current || disposed) {
+        return fail(storeError("superseded", "listing: a newer search replaced this one."));
+      }
+      set({
+        status: "ready",
+        refreshing: false,
+        items: result.value.items,
+        total: result.value.total,
+        error: null
+      });
+      return ok(void 0);
+    } catch (caught) {
+      const error = toStoreError(caught);
+      if (disposed) return fail(error);
+      const shown = store.getSnapshot().status === "ready";
+      set(shown ? { refreshing: false, error } : { status: "error", refreshing: false, error });
+      ctx.events.emit({ type: "error", store: "listing", action: "search", error });
+      return fail(error);
+    }
+  }
+  async function loadFacets(categoryId) {
+    facetsFor = categoryId;
+    set({
+      facets: {
+        ...categoryId === null ? emptyFacets : store.getSnapshot().facets,
+        status: "loading"
+      }
+    });
+    const result = await facetLoads(async () => {
+      const ids = categoryId === null ? [] : await expand(categoryId);
+      return Promise.allSettled([
+        ctx.client.products.filterConfig(categoryId === null ? {} : { categoryId }),
+        categoryId === null ? [] : ctx.client.catalog.brands({ categoryIds: ids }),
+        categoryId === null ? [] : ctx.client.products.variantFilters(ids)
+      ]);
+    });
+    if (!result.current || disposed) return;
+    const [config, brands, variants] = result.value;
+    const failed = [config, brands, variants].find((r) => r.status === "rejected");
+    const facets = {
+      status: failed ? "error" : "ready",
+      price: config.status === "fulfilled" ? config.value.price : null,
+      specifications: config.status === "fulfilled" ? config.value.specifications : [],
+      brands: brands.status === "fulfilled" ? brands.value : [],
+      variantGroups: variants.status === "fulfilled" ? variants.value : []
+    };
+    if (failed) {
+      ctx.events.emit({
+        type: "error",
+        store: "listing",
+        action: "facets",
+        error: toStoreError(failed.reason)
+      });
+    }
+    const { criteria: criteria2 } = store.getSnapshot();
+    if (config.status === "fulfilled" && criteria2.specifications.length > 0) {
+      const offered = new Set(config.value.specifications.map((s) => s.id));
+      const kept = criteria2.specifications.filter((s) => offered.has(s.id));
+      if (kept.length !== criteria2.specifications.length) {
+        set({ facets, criteria: { ...criteria2, specifications: kept, page: 1 } });
+        schedule();
+        return;
+      }
+    }
+    set({ facets });
+  }
+  function run() {
+    started = true;
+    const { criteria: criteria2, facets } = store.getSnapshot();
+    if (facetsFor === void 0 || facetsFor !== criteria2.categoryId || facets.status === "error") {
+      void loadFacets(criteria2.categoryId);
+    }
+    return search();
+  }
+  function schedule() {
+    started = true;
+    if (scheduled || disposed) return;
+    scheduled = true;
+    runtime2.queueMicrotask(() => {
+      scheduled = false;
+      if (!disposed) void run();
+    });
+  }
+  function change(next) {
+    if (disposed) return;
+    const { criteria: criteria2 } = store.getSnapshot();
+    if (sameCriteria(next, criteria2)) return;
+    if (next.categoryId !== criteria2.categoryId) {
+      set({
+        criteria: next,
+        items: [],
+        total: 0,
+        status: "loading",
+        refreshing: false,
+        error: null
+      });
+    } else {
+      set({ criteria: next });
+    }
+    schedule();
+  }
+  const filter = (changes) => change({ ...store.getSnapshot().criteria, ...changes, page: 1 });
+  const criteria = () => store.getSnapshot().criteria;
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    unregister();
+  }
+  const unregister = ctx.onDispose(dispose);
+  return {
+    getSnapshot: store.getSnapshot,
+    getServerSnapshot: store.getServerSnapshot,
+    subscribe(listener) {
+      if (disposed) return () => {
+      };
+      const unsubscribe = store.subscribe(() => {
+        if (!disposed) listener();
+      });
+      if (!started) schedule();
+      return unsubscribe;
+    },
+    setCategory: (id) => change(withCategory(criteria(), id)),
+    setSearch: (text) => filter({ search: text?.trim() || null }),
+    toggleBrand: (id) => filter({ brandIds: toggle(criteria().brandIds, id).sort((a, b) => a - b) }),
+    toggleVariant: (label) => filter({ variantLabels: toggle(criteria().variantLabels, label) }),
+    toggleSpecification(id, value) {
+      const current = criteria().specifications;
+      const found = current.find((s) => s.id === id);
+      const specifications = found ? current.map((s) => s.id === id ? { id, values: toggle(s.values, value) } : s).filter((s) => s.values.length > 0) : [...current, { id, values: [value] }];
+      filter({ specifications });
+    },
+    setPriceRange(min, max) {
+      const [minPrice, maxPrice] = min !== null && max !== null && min > max ? [max, min] : [min, max];
+      filter({ minPrice, maxPrice });
+    },
+    setMinDiscount: (percent) => filter({ minDiscountPercent: percent }),
+    setMinRating: (rating) => filter({ minRating: rating }),
+    setSort: (sortBy) => filter({ sortBy }),
+    setPage(page) {
+      if (Number.isInteger(page) && page >= 1) change({ ...criteria(), page });
+    },
+    clearFilters() {
+      const { categoryId, search: search2, sortBy } = criteria();
+      change({ ...DEFAULT_LISTING_CRITERIA, categoryId, search: search2, sortBy });
+    },
+    applyQuery: (query) => change(parseListingQuery(query)),
+    retry: () => disposed ? search() : run(),
+    dispose
+  };
+}
+
+// src/stores/productDetail.ts
+function derive3(base) {
+  const { product, selection } = base;
+  if (!product) {
+    return {
+      ...base,
+      sku: null,
+      price: null,
+      mrp: null,
+      discountPercent: 0,
+      complete: false,
+      purchasable: false,
+      choices: [],
+      specifications: [],
+      images: [],
+      selectedVariantsParam: formatSelectedVariants(selection)
+    };
+  }
+  const complete = isSelectionComplete(product.variantGroups, selection);
+  const sku = complete ? resolveSku(product.skus, selection) : null;
+  const pricing = sku ? productPricing(sku) : null;
+  const scope = { skuId: sku?.id ?? null, variantIds: selection };
+  return {
+    ...base,
+    sku,
+    price: pricing?.price ?? null,
+    mrp: pricing?.compareAtPrice ?? null,
+    discountPercent: pricing?.discountPercent ?? 0,
+    complete,
+    purchasable: sku !== null && sku.active && sku.stockQty > 0,
+    choices: variantChoices(product, selection),
+    specifications: specificationsFor(product.specifications, scope),
+    images: imagesFor(product.images, scope),
+    selectedVariantsParam: formatSelectedVariants(selection)
+  };
+}
+function selectionFor(product, current) {
+  return defaultSelection(product, current);
+}
+function createProductDetailStore(ctx, input) {
+  const { productId, initial } = input;
+  const preferred = [...input.selectedVariantIds ?? []];
+  const store = createStore(
+    derive3({
+      productId,
+      status: initial ? "ready" : "idle",
+      refreshing: false,
+      product: initial ?? null,
+      error: null,
+      selection: initial ? defaultSelection(initial, preferred) : []
+    }),
+    { onListenerError: ctx.onListenerError }
+  );
+  const latest = createLatest();
+  let disposed = false;
+  let started = false;
+  const base = () => {
+    const { productId: productId2, status, refreshing, product, error, selection } = store.getSnapshot();
+    return { productId: productId2, status, refreshing, product, error, selection };
+  };
+  const set = (changes) => {
+    if (!disposed) store.set(derive3({ ...base(), ...changes }));
+  };
+  async function reload() {
+    started = true;
+    if (disposed) return fail(storeError("superseded", "productDetail: the store was disposed."));
+    const shown = store.getSnapshot().product !== null;
+    set(shown ? { refreshing: true } : { status: "loading", error: null });
+    try {
+      const result = await latest(() => ctx.client.products.detail(productId));
+      if (!result.current || disposed) {
+        return fail(storeError("superseded", "productDetail: a newer load replaced this one."));
+      }
+      const product = result.value;
+      const current = store.getSnapshot();
+      set({
+        status: "ready",
+        refreshing: false,
+        error: null,
+        product,
+        selection: selectionFor(product, current.product ? current.selection : preferred)
+      });
+      return ok(void 0);
+    } catch (caught) {
+      const error = toStoreError(caught);
+      if (disposed) return fail(error);
+      set(shown ? { refreshing: false, error } : { status: "error", refreshing: false, error });
+      ctx.events.emit({ type: "error", store: "productDetail", action: "reload", error });
+      return fail(error);
+    }
+  }
+  function select(groupId, optionId) {
+    const { product, selection } = store.getSnapshot();
+    const group = product?.variantGroups.find((g) => g.id === groupId);
+    if (!group?.options.some((option) => option.id === optionId)) {
+      return fail(
+        storeError("validation", `productDetail: group ${groupId} has no option ${optionId}.`)
+      );
+    }
+    set({ selection: selectOption(product.variantGroups, selection, optionId) });
+    return ok(void 0);
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    unregister();
+  }
+  const unregister = ctx.onDispose(dispose);
+  return {
+    getSnapshot: store.getSnapshot,
+    getServerSnapshot: store.getServerSnapshot,
+    subscribe(listener) {
+      if (disposed) return () => {
+      };
+      const unsubscribe = store.subscribe(() => {
+        if (!disposed) listener();
+      });
+      if (!started) void reload();
+      return unsubscribe;
+    },
+    select,
+    reload,
+    dispose
+  };
+}
+
+// src/stores/referral.ts
+var MAX_LENGTH = 64;
+function isReferralRecord(raw) {
+  if (!raw || typeof raw !== "object") return false;
+  const r = raw;
+  return typeof r.code === "string" && r.code.trim() !== "" && r.code.length <= MAX_LENGTH && typeof r.capturedAt === "number" && Number.isFinite(r.capturedAt);
+}
+function createReferralStore(ctx, options = {}) {
+  const ttlMs = options.ttlMs ?? ctx.config.referralTtlMs;
+  const record = ctx.persisted("referral", 1, isReferralRecord);
+  const store = createStore(
+    { status: "idle", code: null, capturedAt: null },
+    { onListenerError: ctx.onListenerError }
+  );
+  let changes = 0;
+  let reading = Promise.resolve();
+  const expired = (capturedAt) => Date.now() - capturedAt >= ttlMs;
+  function forget() {
+    changes += 1;
+    record.remove();
+    store.update((s) => ({ ...s, code: null, capturedAt: null }));
+  }
+  function restore() {
+    const startedAt = changes;
+    store.update((s) => s.status === "ready" ? s : { ...s, status: "loading" });
+    reading = record.read().then((read) => {
+      if (ctx.isDisposed()) return;
+      if (changes !== startedAt) {
+        store.update((s) => ({ ...s, status: "ready" }));
+        return;
+      }
+      let stored = read;
+      if (stored && expired(stored.capturedAt)) {
+        record.remove();
+        stored = null;
+      }
+      store.set({
+        status: "ready",
+        code: stored?.code ?? null,
+        capturedAt: stored?.capturedAt ?? null
+      });
+    });
+  }
+  async function settled() {
+    await ctx.ready();
+    await reading;
+  }
+  ctx.onHydrate(restore);
+  ctx.events.on("auth:signed-in", (event) => {
+    if (event.via === "register" || event.via === "otp") forget();
+  });
+  return {
+    ...readOnly(store),
+    async capture(code) {
+      const trimmed = typeof code === "string" ? code.trim() : "";
+      if (!trimmed || trimmed.length > MAX_LENGTH) {
+        const error = storeError(
+          "validation",
+          trimmed ? `A referral code has at most ${MAX_LENGTH} characters.` : "A referral code is required."
+        );
+        ctx.events.emit({ type: "error", store: "referral", action: "capture", error });
+        return fail(error);
+      }
+      changes += 1;
+      const capturedAt = Date.now();
+      store.update((s) => ({ ...s, code: trimmed, capturedAt }));
+      record.write({ code: trimmed, capturedAt });
+      await settled();
+      return ok(void 0);
+    },
+    current() {
+      const { code, capturedAt } = store.getSnapshot();
+      if (code === null || capturedAt === null) return null;
+      if (!expired(capturedAt)) return code;
+      forget();
+      return null;
+    },
+    async clear() {
+      forget();
+      await settled();
+      return ok(void 0);
+    }
+  };
+}
+
+// src/stores/runtime/events.ts
+function createEventBus(onListenerError) {
+  const listeners = /* @__PURE__ */ new Map();
+  return {
+    on(type, listener) {
+      const entry = { listener };
+      listeners.set(type, [...listeners.get(type) ?? [], entry]);
+      return () => {
+        const current = listeners.get(type);
+        if (current)
+          listeners.set(
+            type,
+            current.filter((e) => e !== entry)
+          );
+      };
+    },
+    emit(event) {
+      for (const entry of listeners.get(event.type)?.slice() ?? []) {
+        try {
+          entry.listener(event);
+        } catch (error) {
+          onListenerError(error);
+        }
+      }
+    }
+  };
+}
+
+// src/stores/runtime/storage.ts
+function createMemoryStorage() {
+  const data = /* @__PURE__ */ new Map();
+  return {
+    getItem: (key) => data.get(key) ?? null,
+    setItem: (key, value) => {
+      data.set(key, value);
+    },
+    removeItem: (key) => {
+      data.delete(key);
+    }
+  };
+}
+function resolveStorage(options) {
+  const storage = options.storage ?? createMemoryStorage();
+  return {
+    storage,
+    secure: options.secureStorage ?? storage,
+    ephemeral: options.ephemeralStorage ?? createMemoryStorage()
+  };
+}
+var ID_PART = /^[A-Za-z0-9_-]+$/;
+var NAME_PART = /^[A-Za-z0-9._-]+$/;
+function storageKey(businessId, name) {
+  const id = String(businessId);
+  if (!ID_PART.test(id)) {
+    throw new TypeError(`businessId must contain only letters, digits, "_" and "-": "${id}".`);
+  }
+  if (!NAME_PART.test(name)) {
+    throw new TypeError(`storage name must contain only letters, digits, ".", "_" and "-".`);
+  }
+  return `gs.${id}.${name}`;
+}
+function createPersisted(adapter, key, version, validate, onError) {
+  let tail = Promise.resolve();
+  function enqueue(operation, run, fallback) {
+    const next = tail.then(run).catch((error) => {
+      onError(error, operation);
+      return fallback;
+    });
+    tail = next;
+    return next;
+  }
+  async function removeQuietly() {
+    try {
+      await adapter.removeItem(key);
+    } catch (error) {
+      onError(error, "remove");
+    }
+  }
+  async function readNow() {
+    const raw = await adapter.getItem(key);
+    if (raw == null) return null;
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      await removeQuietly();
+      return null;
+    }
+    const record = parsed;
+    if (!record || typeof record !== "object" || record.v !== version || !validate(record.data)) {
+      await removeQuietly();
+      return null;
+    }
+    return record.data;
+  }
+  return {
+    read: () => enqueue("read", readNow, null),
+    write(value) {
+      void enqueue(
+        "write",
+        async () => adapter.setItem(key, JSON.stringify({ v: version, data: value })),
+        void 0
+      );
+    },
+    remove() {
+      void enqueue("remove", async () => adapter.removeItem(key), void 0);
+    }
+  };
+}
+
+// src/stores/runtime/context.ts
+var HOUR = 60 * 60 * 1e3;
+var DEFAULT_CUSTOMER_TOKEN_TTL_MS = 24 * HOUR;
+var REFERRAL_TTL_MS = 7 * 24 * HOUR;
+function isObject(raw) {
+  return !!raw && typeof raw === "object" && !Array.isArray(raw);
+}
+function isSessionRecord(raw) {
+  return isObject(raw) && typeof raw.id === "number" && typeof raw.token === "string" && !!raw.token;
+}
+function isAuthRecord(raw) {
+  return isObject(raw) && typeof raw.token === "string" && !!raw.token && isObject(raw.customer) && typeof raw.customer.id === "number" && (raw.rewardPoints === null || typeof raw.rewardPoints === "number") && typeof raw.savedAt === "number";
+}
+function validateOptions(options) {
+  if (typeof options?.baseURL !== "string" || !options.baseURL) {
+    throw new TypeError("createGrowupsellStores: baseURL is required.");
+  }
+  if (options.businessId == null || options.businessId === "") {
+    throw new TypeError(
+      "createGrowupsellStores: businessId is required (resolve the business first)."
+    );
+  }
+  storageKey(options.businessId, "check");
+  if (options.platform !== "website" && options.platform !== "app") {
+    throw new TypeError("createGrowupsellStores: platform must be 'website' or 'app'.");
+  }
+}
+function dropSession(ctx, reason) {
+  if (!ctx.tokens.getSessionToken()) return false;
+  ctx.tokens.setSessionToken(null);
+  ctx.records.session.remove();
+  const { kind, customerId } = ctx.identity.getSnapshot();
+  ctx.setIdentity({ kind: kind === "customer" ? "customer" : "guest", customerId });
+  ctx.events.emit({ type: "session:replaced", reason });
+  return true;
+}
+function clearCustomerCredentials(ctx) {
+  ctx.tokens.setCustomerToken(null);
+  ctx.records.auth.remove();
+  ctx.records.ephemeralAuth.remove();
+  dropSession(ctx, "rotated");
+  ctx.setIdentity({ kind: "guest", customerId: null });
+}
+function createRuntime(options) {
+  validateOptions(options);
+  const onListenerError = options.onError ?? rethrowAsync;
+  const config = {
+    customerTokenTtlMs: options.customerTokenTtlMs ?? DEFAULT_CUSTOMER_TOKEN_TTL_MS,
+    referralTtlMs: options.referralTtlMs ?? REFERRAL_TTL_MS,
+    autoLoad: options.autoLoad ?? true
+  };
+  const adapters = resolveStorage(options);
+  const seeds = { ...options.seeds };
+  let disposed = false;
+  let customerToken = null;
+  let sessionToken = null;
+  const tokens = {
+    getCustomerToken: () => customerToken,
+    setCustomerToken: (token) => {
+      customerToken = token;
+    },
+    getSessionToken: () => sessionToken,
+    setSessionToken: (token) => {
+      sessionToken = token;
+    }
+  };
+  const bus = createEventBus(onListenerError);
+  const events = {
+    on: bus.on,
+    emit: (event) => {
+      if (!disposed) bus.emit(event);
+    }
+  };
+  const identity = createStore(
+    { kind: "unknown", customerId: null, epoch: 0 },
+    { onListenerError }
+  );
+  const hydrated = createStore(false, { onListenerError });
+  const persistedByAdapter = /* @__PURE__ */ new Map();
+  function persisted(name, version, validate, where = "storage") {
+    const adapter = adapters[where];
+    const key = storageKey(options.businessId, name);
+    let byKey = persistedByAdapter.get(adapter);
+    if (!byKey) persistedByAdapter.set(adapter, byKey = /* @__PURE__ */ new Map());
+    let record = byKey.get(key);
+    if (!record) {
+      record = createPersisted(adapter, key, version, validate, (error, operation) => {
+        events.emit({
+          type: "error",
+          store: "storage",
+          action: operation,
+          error: toStoreError(error)
+        });
+        onListenerError(error);
+      });
+      byKey.set(key, record);
+    }
+    return record;
+  }
+  const records = {
+    session: persisted("session", 1, isSessionRecord, "secure"),
+    auth: persisted("auth", 1, isAuthRecord, "secure"),
+    ephemeralAuth: persisted("auth", 1, isAuthRecord, "ephemeral")
+  };
+  let hydration = null;
+  let rehydration = null;
+  const hydrateListeners = [];
+  const loaders = [];
+  function safely(run) {
+    try {
+      run();
+    } catch (error) {
+      onListenerError(error);
+    }
+  }
+  async function readRecords(phase) {
+    const [session, secureAuth, ephemeralAuth] = await Promise.all([
+      records.session.read(),
+      records.auth.read(),
+      records.ephemeralAuth.read()
+    ]);
+    let auth = secureAuth ?? ephemeralAuth;
+    const remembered = !!secureAuth;
+    if (auth && Date.now() - auth.savedAt > config.customerTokenTtlMs) {
+      (remembered ? records.auth : records.ephemeralAuth).remove();
+      auth = null;
+    }
+    return { phase, session, auth, remembered: !!auth && remembered };
+  }
+  function apply(read, epoch) {
+    tokens.setSessionToken(read.session?.token ?? null);
+    tokens.setCustomerToken(read.auth?.token ?? null);
+    for (const listener of hydrateListeners.slice()) safely(() => listener(read));
+    identity.set({
+      kind: read.auth ? "customer" : "guest",
+      customerId: read.auth?.customer.id ?? null,
+      epoch
+    });
+    hydrated.set(true);
+  }
+  function runLoaders() {
+    if (!config.autoLoad) return;
+    for (const load of loaders.slice()) safely(load);
+  }
+  function hydrate() {
+    hydration ??= readRecords("hydrate").then((read) => {
+      if (disposed) return;
+      apply(read, 1);
+      runLoaders();
+    }, onListenerError);
+    return hydration;
+  }
+  function rehydrate() {
+    if (!hydrated.getSnapshot()) return hydrate();
+    rehydration ??= readRecords("rehydrate").then((read) => {
+      if (disposed) return;
+      const sameSession = (read.session?.token ?? null) === tokens.getSessionToken();
+      const sameCustomer = (read.auth?.token ?? null) === tokens.getCustomerToken();
+      if (sameSession && sameCustomer) return;
+      const wasCustomer = tokens.getCustomerToken() !== null;
+      apply(read, identity.getSnapshot().epoch + 1);
+      if (wasCustomer && !read.auth) events.emit({ type: "auth:signed-out", reason: "logout" });
+      runLoaders();
+    }, onListenerError).finally(() => {
+      rehydration = null;
+    });
+    return rehydration;
+  }
+  const flight = createSingleFlight();
+  const disposedError2 = () => storeError("superseded", "The stores were disposed.");
+  const reported = /* @__PURE__ */ new Set();
+  function routeUnauthorized({ kind, token }) {
+    if (disposed) return;
+    if (kind === "customer") {
+      if (token !== tokens.getCustomerToken()) return;
+      safely(() => ctx.hooks.customerExpired());
+    } else if (kind === "session") {
+      if (token !== tokens.getSessionToken()) return;
+      safely(() => ctx.hooks.sessionDead());
+    }
+    const key = `${kind}\0${token}`;
+    if (reported.has(key)) return;
+    reported.add(key);
+    safely(() => options.onUnauthorized?.({ kind }));
+  }
+  const credentials = () => ({
+    businessId: options.businessId,
+    customerToken: tokens.getCustomerToken(),
+    sessionToken: tokens.getSessionToken(),
+    merchantToken: options.merchantToken?.() ?? null
+  });
+  const client = createClient({
+    baseURL: options.baseURL,
+    fetch: options.fetch,
+    timeoutMs: options.timeoutMs,
+    // Synchronous once hydrated; a request made earlier waits for (and starts) hydration.
+    credentials: () => hydrated.getSnapshot() || disposed ? credentials() : hydrate().then(credentials),
+    onUnauthorized: routeUnauthorized
+  });
+  let registry = null;
+  const cleanups = /* @__PURE__ */ new Set();
+  const ctx = {
+    client,
+    businessId: options.businessId,
+    platform: options.platform,
+    events,
+    identity: readOnly(identity),
+    seeds,
+    ready: hydrate,
+    async ensureSession() {
+      await hydrate();
+      if (disposed) throw disposedError2();
+      const held = tokens.getSessionToken();
+      if (held) return held;
+      return flight("session", () => ctx.hooks.createSession());
+    },
+    hasSession: () => tokens.getSessionToken() !== null,
+    persisted,
+    get stores() {
+      if (!registry) {
+        throw new Error("ctx.stores is not available during construction: read it inside actions.");
+      }
+      return registry;
+    },
+    onListenerError,
+    config,
+    tokens,
+    records,
+    hooks: {
+      async createSession() {
+        const session = await client.session.create();
+        if (disposed) throw disposedError2();
+        tokens.setSessionToken(session.token);
+        records.session.write({ id: session.id, token: session.token });
+        return session.token;
+      },
+      customerExpired() {
+        clearCustomerCredentials(ctx);
+        events.emit({ type: "auth:signed-out", reason: "expired" });
+      },
+      sessionDead() {
+        dropSession(ctx, "dead");
+      }
+    },
+    setIdentity(next) {
+      identity.set({ ...next, epoch: identity.getSnapshot().epoch + 1 });
+    },
+    inEpoch: (run) => runInEpoch(() => disposed ? -1 : identity.getSnapshot().epoch, run),
+    onHydrate(listener) {
+      hydrateListeners.push(listener);
+    },
+    autoLoad(load) {
+      loaders.push(load);
+    },
+    onDispose(cleanup) {
+      const entry = { run: cleanup };
+      cleanups.add(entry);
+      return () => {
+        cleanups.delete(entry);
+      };
+    },
+    isDisposed: () => disposed
+  };
+  return {
+    ctx,
+    hydrated: readOnly(hydrated),
+    hydrate,
+    rehydrate,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const entry of [...cleanups]) safely(entry.run);
+      cleanups.clear();
+    },
+    attach(stores) {
+      registry = stores;
+    }
+  };
+}
+
+// src/stores/searchSuggestions.ts
+var runtime3 = globalThis;
+var DEFAULT_DEBOUNCE_MS = 300;
+function createSearchSuggestionsStore(ctx, options = {}) {
+  const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  const store = createStore(
+    { query: "", status: "idle", items: [], error: null },
+    { onListenerError: ctx.onListenerError }
+  );
+  let timer = null;
+  let generation = 0;
+  let disposed = false;
+  const update = (changes) => {
+    if (!disposed) store.set({ ...store.getSnapshot(), ...changes });
+  };
+  function cancelTimer() {
+    if (timer !== null) runtime3.clearTimeout(timer);
+    timer = null;
+  }
+  async function ask(word) {
+    const mine = ++generation;
+    update({ status: "loading", error: null });
+    try {
+      const items = await ctx.client.products.suggestions(word);
+      if (mine === generation) update({ status: "ready", items, error: null });
+    } catch (caught) {
+      if (mine !== generation) return;
+      const error = toStoreError(caught);
+      update({ status: "error", items: [], error });
+      if (!disposed) {
+        ctx.events.emit({ type: "error", store: "searchSuggestions", action: "setQuery", error });
+      }
+    }
+  }
+  function setQuery(text) {
+    if (disposed) return;
+    cancelTimer();
+    const word = text.trim();
+    if (!word) {
+      generation += 1;
+      update({ query: text, status: "idle", items: [], error: null });
+      return;
+    }
+    update({ query: text });
+    timer = runtime3.setTimeout(() => {
+      timer = null;
+      void ask(word);
+    }, debounceMs);
+  }
+  function clear() {
+    if (disposed) return;
+    cancelTimer();
+    generation += 1;
+    update({ query: "", status: "idle", items: [], error: null });
+  }
+  function dispose() {
+    if (disposed) return;
+    cancelTimer();
+    generation += 1;
+    disposed = true;
+    unregister();
+  }
+  const unregister = ctx.onDispose(dispose);
+  return {
+    getSnapshot: store.getSnapshot,
+    getServerSnapshot: store.getServerSnapshot,
+    subscribe: store.subscribe,
+    setQuery,
+    clear,
+    dispose
+  };
+}
+
+// src/stores/session.ts
+var LOOP_LIMIT = 3;
+var LOOP_WINDOW_MS = 6e4;
+function createSessionStore(ctx) {
+  const store = createStore(
+    { status: "unknown", creating: false, error: null },
+    { onListenerError: ctx.onListenerError }
+  );
+  const patch = (next) => store.update((s) => ({ ...s, ...next }));
+  const status = () => ctx.hasSession() ? "active" : "none";
+  function failed(action, error) {
+    patch({ status: status(), creating: false, error });
+    ctx.events.emit({ type: "error", store: "session", action, error });
+  }
+  ctx.onHydrate(() => patch({ status: status() }));
+  ctx.events.on("session:replaced", () => patch({ status: status() }));
+  const create = ctx.hooks.createSession;
+  ctx.hooks.createSession = async () => {
+    patch({ creating: true, error: null });
+    try {
+      const token = await create();
+      patch({ status: status(), creating: false });
+      return token;
+    } catch (error) {
+      patch({ status: status(), creating: false, error: toStoreError(error) });
+      throw error;
+    }
+  };
+  let replacements = [];
+  let stopped = false;
+  ctx.hooks.sessionDead = () => {
+    dropSession(ctx, "dead");
+    const now = Date.now();
+    replacements = replacements.filter((at) => now - at < LOOP_WINDOW_MS);
+    if (stopped || replacements.length >= LOOP_LIMIT) {
+      stopped = true;
+      failed(
+        "replace",
+        storeError("session", "The guest session keeps being rejected; call ensure() to retry.")
+      );
+      return;
+    }
+    replacements.push(now);
+    ctx.ensureSession().then(
+      () => {
+      },
+      (error) => failed("replace", toStoreError(error))
+    );
+  };
+  async function ensure() {
+    stopped = false;
+    replacements = [];
+    try {
+      await ctx.ensureSession();
+      patch({ status: status(), error: null });
+      return ok(void 0);
+    } catch (error) {
+      const storeErr = toStoreError(error);
+      failed("ensure", storeErr);
+      return fail(storeErr);
+    }
+  }
+  return {
+    getSnapshot: store.getSnapshot,
+    getServerSnapshot: store.getServerSnapshot,
+    subscribe: store.subscribe,
+    ensure
+  };
+}
+
+// src/stores/themeConfig.ts
+var IDLE = Object.freeze({
+  status: "idle",
+  content: null,
+  saving: false,
+  error: null
+});
+var superseded2 = () => storeError("superseded", "A newer save of this section replaced it.");
+var disposedError = () => storeError("superseded", "The stores were disposed.");
+function createThemeConfigStore(ctx) {
+  const confirmed = /* @__PURE__ */ new Map();
+  const sections = {};
+  for (const [slug, content] of Object.entries(ctx.seeds.themeContent ?? {})) {
+    confirmed.set(slug, content);
+    sections[slug] = { status: "ready", content, saving: false, error: null };
+  }
+  const store = createStore(
+    {
+      platform: ctx.platform,
+      themeId: ctx.seeds.business?.themeSettings?.id ?? null,
+      sections
+    },
+    { onListenerError: ctx.onListenerError }
+  );
+  const flight = createSingleFlight();
+  const generation = /* @__PURE__ */ new Map();
+  const slots = /* @__PURE__ */ new Map();
+  const section = (slug) => store.getSnapshot().sections[slug] ?? IDLE;
+  function patch(changes, themeId) {
+    const s = store.getSnapshot();
+    const next = { ...s.sections };
+    for (const [slug, change] of Object.entries(changes)) {
+      next[slug] = { ...next[slug] ?? IDLE, ...change };
+    }
+    store.set({ ...s, sections: next, themeId: themeId ?? s.themeId });
+  }
+  function failed(action, error) {
+    ctx.events.emit({ type: "error", store: "themeConfig", action, error });
+    return fail(error);
+  }
+  async function resolveThemeId() {
+    const business = ctx.stores.business;
+    let id = business.getSnapshot().themeId;
+    if (id == null) {
+      await business.load();
+      id = business.getSnapshot().themeId;
+    }
+    if (id == null) return storeError("validation", "themeConfig: theme settings are not loaded");
+    return id;
+  }
+  function checkSlug(slug) {
+    const key = typeof slug === "string" ? slug.trim() : "";
+    if (!key) return storeError("validation", "themeConfig: a section slug is required.");
+    if (key.includes(",")) {
+      return storeError("validation", `themeConfig: slug "${key}" contains a comma.`);
+    }
+    return key;
+  }
+  async function runLoad(slugs) {
+    const mine = new Map(slugs.map((slug) => [slug, (generation.get(slug) ?? 0) + 1]));
+    for (const [slug, gen] of mine) generation.set(slug, gen);
+    const isMine = (slug) => generation.get(slug) === mine.get(slug);
+    patch(
+      Object.fromEntries(
+        slugs.map((slug) => [
+          slug,
+          { status: section(slug).status === "ready" ? "ready" : "loading", error: null }
+        ])
+      )
+    );
+    const settle = (error) => {
+      patch(
+        Object.fromEntries(
+          slugs.filter(isMine).map((slug) => [
+            slug,
+            { status: section(slug).status === "ready" ? "ready" : "error", error }
+          ])
+        )
+      );
+      return failed("load", error);
+    };
+    const themeId = await resolveThemeId();
+    if (ctx.isDisposed()) return fail(disposedError());
+    if (typeof themeId !== "number") return settle(themeId);
+    let contents;
+    try {
+      contents = await ctx.client.themeContent.getMany(themeId, slugs);
+    } catch (error) {
+      if (ctx.isDisposed()) return fail(disposedError());
+      return settle(toStoreError(error));
+    }
+    if (ctx.isDisposed()) return fail(disposedError());
+    const changes = {};
+    slugs.forEach((slug, i) => {
+      if (!isMine(slug)) return;
+      const content = contents[i] ?? null;
+      confirmed.set(slug, content);
+      changes[slug] = section(slug).saving ? { status: "ready", error: null } : { status: "ready", content, error: null };
+    });
+    patch(changes, themeId);
+    return ok(void 0);
+  }
+  async function send(slug, slot, job) {
+    slot.running = true;
+    let outcome;
+    const themeId = await resolveThemeId();
+    if (typeof themeId !== "number") outcome = fail(themeId);
+    else {
+      try {
+        const saved = await ctx.client.themeContent.update(themeId, slug, {
+          platform: ctx.platform,
+          data: job.data
+        });
+        outcome = ok(saved);
+      } catch (error) {
+        outcome = fail(toStoreError(error));
+      }
+    }
+    if (ctx.isDisposed()) {
+      slot.running = false;
+      slot.waiting?.resolve(fail(disposedError()));
+      slot.waiting = null;
+      job.resolve(fail(disposedError()));
+      return;
+    }
+    const next = slot.waiting;
+    slot.waiting = null;
+    if (outcome.ok) {
+      confirmed.set(slug, outcome.value);
+      generation.set(slug, (generation.get(slug) ?? 0) + 1);
+      if (!next) {
+        patch(
+          { [slug]: { status: "ready", content: outcome.value, saving: false, error: null } },
+          outcome.value.themeId
+        );
+      }
+      job.resolve(outcome);
+    } else {
+      if (!next) {
+        patch({
+          [slug]: { content: confirmed.get(slug) ?? null, saving: false, error: outcome.error }
+        });
+      }
+      job.resolve(failed("save", outcome.error));
+    }
+    if (next) void send(slug, slot, next);
+    else slot.running = false;
+  }
+  return {
+    ...readOnly(store),
+    load(slugs, options = {}) {
+      const keys = [];
+      for (const slug of slugs) {
+        const key = checkSlug(slug);
+        if (typeof key !== "string") return Promise.resolve(fail(key));
+        if (!keys.includes(key)) keys.push(key);
+      }
+      const wanted = options.force ? keys : keys.filter((key) => section(key).status !== "ready");
+      if (wanted.length === 0) return Promise.resolve(ok(void 0));
+      return flight(
+        `${options.force ? "force" : "load"}:${wanted.join(",")}`,
+        () => runLoad(wanted)
+      );
+    },
+    save(slug, data) {
+      const key = checkSlug(slug);
+      if (typeof key !== "string") {
+        return Promise.resolve(fail(key));
+      }
+      const s = store.getSnapshot();
+      const base = section(key).content;
+      const optimistic = base ? { ...base, platform: ctx.platform, data } : { id: 0, themeId: s.themeId ?? 0, slug: key, platform: ctx.platform, data };
+      patch({ [key]: { content: optimistic, saving: true, error: null } });
+      return new Promise((resolve) => {
+        const job = { data, resolve };
+        let slot = slots.get(key);
+        if (!slot) slots.set(key, slot = { running: false, waiting: null });
+        if (slot.running) {
+          slot.waiting?.resolve(fail(superseded2()));
+          slot.waiting = job;
+          return;
+        }
+        void send(key, slot, job);
+      });
+    },
+    section: (slug) => section(slug)
+  };
+}
+
+// src/stores/wishlist.ts
+var INITIAL3 = {
+  status: "idle",
+  refreshing: false,
+  items: [],
+  pending: { adding: [], removing: [], moving: [] },
+  error: null
+};
+var isId = (value) => Number.isInteger(value) && value > 0;
+var without = (list, value) => list.filter((v) => v !== value);
+var superseded3 = () => fail(storeError("superseded", "The shopper changed while the wishlist was being updated."));
+function createWishlistStore(ctx) {
+  const store = createStore(INITIAL3, { onListenerError: ctx.onListenerError });
+  const latest = createLatest();
+  const queue = createSerialQueue();
+  const adds = /* @__PURE__ */ new Map();
+  const removes = /* @__PURE__ */ new Map();
+  const moves = /* @__PURE__ */ new Map();
+  const customerId = () => {
+    const identity = ctx.identity.getSnapshot();
+    return identity.kind === "customer" ? identity.customerId : null;
+  };
+  const epoch = () => ctx.isDisposed() ? -1 : ctx.identity.getSnapshot().epoch;
+  const snapshot = () => store.getSnapshot();
+  const has = (skuId) => isInWishlist(snapshot(), skuId);
+  function report(action, error, started = null) {
+    if (error.kind === "superseded" || started !== null && epoch() !== started) return;
+    store.update((s) => ({ ...s, error }));
+    ctx.events.emit({ type: "error", store: "wishlist", action, error });
+  }
+  function refuse(action, error) {
+    report(action, error);
+    return fail(error);
+  }
+  async function guard(action) {
+    await ctx.ready();
+    if (customerId() !== null) return null;
+    return refuse(action, storeError("signed-out", "Sign in to use the wishlist."));
+  }
+  function send(started, run) {
+    return queue(
+      async () => epoch() === started ? ctx.inEpoch(run) : { current: false }
+    );
+  }
+  function once(flights, key, run) {
+    const existing = flights.get(key);
+    if (existing) return existing;
+    const promise = run().finally(() => flights.delete(key));
+    flights.set(key, promise);
+    return promise;
+  }
+  let owner = null;
+  ctx.onDispose(
+    ctx.identity.subscribe(() => {
+      const id = customerId();
+      if (id === owner) return;
+      owner = id;
+      store.set(INITIAL3);
+    })
+  );
+  ctx.onDispose(ctx.events.on("auth:signed-in", () => void refresh()));
+  ctx.autoLoad(() => {
+    if (customerId() !== null) void refresh();
+  });
+  async function refresh() {
+    const refused = await guard("refresh");
+    if (refused) return refused;
+    const loadedFor = customerId();
+    store.update((s) => ({
+      ...s,
+      status: s.status === "ready" ? "ready" : "loading",
+      refreshing: s.status === "ready",
+      error: null
+    }));
+    let outcome;
+    try {
+      outcome = await latest(() => ctx.inEpoch(() => ctx.client.wishlist.list()));
+    } catch (caught) {
+      const error = toStoreError(caught);
+      store.update((s) => ({
+        ...s,
+        status: s.status === "ready" ? "ready" : "error",
+        refreshing: false
+      }));
+      report("refresh", error);
+      return fail(error);
+    }
+    if (!outcome.current) return superseded3();
+    if (!outcome.value.current) {
+      if (!ctx.isDisposed() && customerId() === loadedFor) return refresh();
+      return superseded3();
+    }
+    const items = outcome.value.value;
+    store.update((s) => ({
+      ...s,
+      status: "ready",
+      refreshing: false,
+      // An entry being removed stays hidden, although the server listed it a moment ago.
+      items: items.filter((item) => !s.pending.removing.includes(item.id))
+    }));
+    return ok(items);
+  }
+  function addNow(skuId) {
+    return once(adds, skuId, async () => {
+      if (has(skuId)) {
+        if (snapshot().error) store.update((s) => ({ ...s, error: null }));
+        return ok(void 0);
+      }
+      const started = epoch();
+      store.update((s) => ({
+        ...s,
+        error: null,
+        pending: { ...s.pending, adding: [...s.pending.adding, skuId] }
+      }));
+      const done = () => {
+        if (epoch() === started) {
+          store.update((s) => ({
+            ...s,
+            pending: { ...s.pending, adding: without(s.pending.adding, skuId) }
+          }));
+        }
+      };
+      try {
+        const sent = await send(started, () => ctx.client.wishlist.add(skuId));
+        if (!sent.current) return superseded3();
+        await refresh();
+        done();
+        return epoch() === started ? ok(void 0) : superseded3();
+      } catch (caught) {
+        const error = toStoreError(caught);
+        if (error.kind === "http" && error.status === 400) {
+          await refresh();
+          if (epoch() === started && has(skuId)) {
+            done();
+            return ok(void 0);
+          }
+        }
+        done();
+        report("add", error, started);
+        return epoch() === started ? fail(error) : superseded3();
+      }
+    });
+  }
+  function removeNow(wishlistId, action) {
+    return once(removes, wishlistId, async () => {
+      const state = snapshot();
+      const index = state.items.findIndex((item2) => item2.id === wishlistId);
+      if (index < 0) {
+        return refuse(action, storeError("validation", "This entry is not in the wishlist."));
+      }
+      const item = state.items[index];
+      const started = epoch();
+      store.set({
+        ...state,
+        error: null,
+        items: state.items.filter((i) => i !== item),
+        pending: { ...state.pending, removing: [...state.pending.removing, wishlistId] }
+      });
+      const settle = (items) => store.update((s) => ({
+        ...s,
+        items: items(s),
+        pending: { ...s.pending, removing: without(s.pending.removing, wishlistId) }
+      }));
+      try {
+        const sent = await send(started, () => ctx.client.wishlist.remove(wishlistId));
+        if (!sent.current) return superseded3();
+        settle((s) => s.items);
+        return ok(void 0);
+      } catch (caught) {
+        const error = toStoreError(caught);
+        settle(
+          (s) => s.items.some((i) => i.id === wishlistId) ? s.items : [...s.items.slice(0, index), item, ...s.items.slice(index)]
+        );
+        report(action, error);
+        return fail(error);
+      }
+    });
+  }
+  async function add(skuId) {
+    const refused = await guard("add");
+    if (refused) return refused;
+    if (!isId(skuId)) {
+      return refuse("add", storeError("validation", "A SKU id is a positive integer."));
+    }
+    return addNow(skuId);
+  }
+  async function remove(wishlistId) {
+    const refused = await guard("remove");
+    return refused ?? removeNow(wishlistId, "remove");
+  }
+  async function toggle2(skuId) {
+    const refused = await guard("toggle");
+    if (refused) return refused;
+    if (!isId(skuId)) {
+      return refuse("toggle", storeError("validation", "A SKU id is a positive integer."));
+    }
+    const adding = adds.get(skuId);
+    if (adding) {
+      const added2 = await adding;
+      if (!added2.ok) return added2;
+    }
+    const saved = snapshot().items.find((item) => item.sku?.id === skuId);
+    if (saved) {
+      const removed = await removeNow(saved.id, "toggle");
+      return removed.ok ? ok({ saved: false }) : removed;
+    }
+    const added = await addNow(skuId);
+    return added.ok ? ok({ saved: true }) : added;
+  }
+  async function moveToCart(wishlistId, quantity = 1) {
+    const refused = await guard("moveToCart");
+    if (refused) return refused;
+    const moving = moves.get(wishlistId);
+    if (moving) return moving;
+    const item = snapshot().items.find((i) => i.id === wishlistId);
+    if (!item) {
+      return refuse("moveToCart", storeError("validation", "This entry is not in the wishlist."));
+    }
+    if (!item.available || !item.sku) {
+      return refuse("moveToCart", storeError("validation", "This item is no longer available."));
+    }
+    if (!isId(quantity)) {
+      return refuse("moveToCart", storeError("validation", "The quantity is a positive integer."));
+    }
+    const skuId = item.sku.id;
+    return once(moves, wishlistId, async () => {
+      const started = epoch();
+      store.update((s) => ({
+        ...s,
+        error: null,
+        pending: { ...s.pending, moving: [...s.pending.moving, wishlistId] }
+      }));
+      const done = () => {
+        if (epoch() === started) {
+          store.update((s) => ({
+            ...s,
+            pending: { ...s.pending, moving: without(s.pending.moving, wishlistId) }
+          }));
+        }
+      };
+      const added = await ctx.stores.cart.add({ skuId, quantity });
+      if (epoch() !== started) return superseded3();
+      if (!added.ok) {
+        done();
+        report("moveToCart", added.error, started);
+        return fail(added.error);
+      }
+      const removed = await removeNow(wishlistId, "moveToCart");
+      done();
+      return removed;
+    });
+  }
+  return {
+    ...readOnly(store),
+    refresh,
+    add,
+    remove,
+    toggle: toggle2,
+    moveToCart,
+    has
+  };
+}
+
+// src/stores/create.ts
+function createGrowupsellStores(options) {
+  const runtime4 = createRuntime(options);
+  const { ctx } = runtime4;
+  const registry = {
+    session: createSessionStore(ctx),
+    auth: createAuthStore(ctx),
+    cart: createCartStore(ctx),
+    wishlist: createWishlistStore(ctx),
+    checkout: createCheckoutStore(ctx),
+    business: createBusinessStore(ctx),
+    catalog: createCatalogStore(ctx),
+    themeConfig: createThemeConfigStore(ctx),
+    referral: createReferralStore(ctx)
+  };
+  runtime4.attach(registry);
+  const screens = {
+    createListing: (input) => createListingStore(ctx, input),
+    createProductDetail: (input) => createProductDetailStore(ctx, input),
+    createSearchSuggestions: (options2) => createSearchSuggestionsStore(ctx, options2)
+  };
+  return {
+    ...registry,
+    ...screens,
+    client: ctx.client,
+    identity: ctx.identity,
+    hydrated: runtime4.hydrated,
+    events: ctx.events,
+    hydrate: runtime4.hydrate,
+    rehydrate: runtime4.rehydrate,
+    dispose: runtime4.dispose
+  };
+}
+
+export {
+  cartItemCount,
+  cartLineForSku,
+  isInWishlist,
+  checkoutPreviewFor,
+  paymentOptionsFor,
+  createMemoryStorage,
+  REFERRAL_TTL_MS,
+  createGrowupsellStores
+};
+//# sourceMappingURL=chunk-DHBRITDW.js.map