@wix/himalaya-cli 0.1324.0 → 0.1325.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/screens.mjs

@@ -16,7 +16,7 @@ async function dispatch(handlerId, params) {
   return await fn(handlerId, params);
 }
 var DEFAULT_AUTH_PREFIX = "himi.wix";
-var id = (opts, action) => `${opts?.prefix ?? DEFAULT_AUTH_PREFIX}.${action}`;
+var id = (opts, action2) => `${opts?.prefix ?? DEFAULT_AUTH_PREFIX}.${action2}`;
 function emailOf(raw) {
   const direct = raw;
   const wrapped = raw;
@@ -44,10 +44,10 @@ async function authState(opts) {
     return { signedIn: false, email: "" };
   }
 }
-async function attempt(action, params, failureText, opts) {
+async function attempt(action2, params, failureText, opts) {
   let raw;
   try {
-    raw = await dispatch(id(opts, action), params);
+    raw = await dispatch(id(opts, action2), params);
   } catch (e) {
     return { ok: false, reason: e?.message || failureText };
   }
@@ -205,59 +205,2800 @@ function createOnlineOrder(planId, couponCode) {
 
 // ../../stdlib/flows/checkout/src/index.ts
 var GRANTS_ACCESS = "ACTIVE";
-async function entitlement() {
+async function entitlement(planId) {
   try {
-    const res = await listMyPlanOrders({ statuses: [GRANTS_ACCESS], limit: 50 });
-    const active = (res.orders ?? []).find(
-      (o) => (o.status ?? "").toUpperCase() === GRANTS_ACCESS
-    );
+    const pages = /* @__PURE__ */ new Set();
+    for (let offset = 0; ; offset += 50) {
+      const res = await listMyPlanOrders({ statuses: [GRANTS_ACCESS], limit: 50, offset });
+      const orders = res.orders ?? [];
+      const page = JSON.stringify(orders.map((order) => [order.id, order.planId, order.status]));
+      if (orders.length === 50 && pages.has(page)) break;
+      pages.add(page);
+      const active = orders.find((order) => order.status === GRANTS_ACCESS && (!planId || order.planId === planId));
+      if (active) return { entitled: true, planName: active.planName ?? "", planId: active.planId ?? "" };
+      if (orders.length < 50) break;
+    }
+  } catch {
+  }
+  return { entitled: false, planName: "", planId: "" };
+}
+var WITHDRAWN = { kind: "failed", reason: "the caller withdrew the charge" };
+async function payOrder(req) {
+  if (!req.snapshotId && !req.cashierUrl) {
+    return { kind: "failed", reason: "no order to settle" };
+  }
+  const availability = await isAvailable().catch(() => "unavailable");
+  if (availability === "full" && req.snapshotId) {
+    if (await req.mayCharge?.() === false) return WITHDRAWN;
+    const r = await proceedToPayment({
+      appId: req.appId,
+      snapshotId: req.snapshotId,
+      msid: req.msid,
+      amount: req.amount,
+      currency: req.currency
+    }).catch(() => ({ status: "failed" }));
+    if (r.status === "paid" || r.status === "pending") {
+      const chargeId = r.chargeId;
+      return {
+        kind: "paid",
+        pending: r.status === "pending",
+        ...typeof chargeId === "string" ? { chargeId } : {}
+      };
+    }
+    if (r.status === "cancelled") return { kind: "cancelled" };
+  }
+  if (req.cashierUrl) {
+    const url = await req.cashierUrl().catch(() => void 0);
+    if (url) {
+      if (await req.mayCharge?.() === false) return WITHDRAWN;
+      const opened = await open(url, "in_app_browser").catch(() => ({ opened: false }));
+      if (opened.opened) return { kind: "handoff" };
+    }
+  }
+  return {
+    kind: "failed",
+    reason: availability === "full" ? "the wallet declined and no in-app cashier is configured" : "no payment rail is available"
+  };
+}
+
+// ../../core/sdk/app-info/src/index.ts
+var PLATFORMS = ["ios", "android", "macos", "web", "react-native"];
+function str(v) {
+  return typeof v === "string" ? v.trim() : "";
+}
+async function get() {
+  const r = await dispatch2("capability.app_info.get");
+  const platform = str(r?.platform);
+  const releaseId = str(r?.releaseId);
+  const serveBaseUrl = str(r?.serveBaseUrl);
+  return {
+    appId: str(r?.appId),
+    bundleId: str(r?.bundleId),
+    version: str(r?.version),
+    buildNumber: str(r?.buildNumber),
+    binaryVersion: str(r?.binaryVersion),
+    releaseId: releaseId || null,
+    releasePinned: r?.releasePinned === true,
+    // Trust the host's own answer; fall back to inferring from whether a serve origin is set.
+    environment: str(r?.environment) === "prod" ? "prod" : serveBaseUrl ? "prod" : "dev",
+    serveBaseUrl: serveBaseUrl || null,
+    platform: PLATFORMS.includes(platform) ? platform : "unknown"
+  };
+}
+
+// ../../core/sdk/iap/src/delivery.ts
+var MAX_AUTOMATIC_ATTEMPTS = 5;
+var MAX_RETRY_DELAY_MS = 6e4;
+var BASE_RETRY_DELAY_MS = 1e3;
+var UNAVAILABLE_CODES = /* @__PURE__ */ new Set(["unsupported", "unavailable", "notEnabled"]);
+function createPurchaseCoordinator(deps) {
+  const items = /* @__PURE__ */ new Map();
+  const queue = createSerialQueue();
+  const store = guardStore(deps.store);
+  let outcome = "idle";
+  let purchasing = false;
+  let signInPrompt = false;
+  let unavailable2 = null;
+  let pendingApproval = null;
+  let errorCode = null;
+  let errorFromReconcile = false;
+  let unfinishedCount = null;
+  let generation = deps.session.current().generation;
+  let staleSignal = createSignal();
+  let started = false;
+  let disposed = false;
+  const unsubscribe = deps.session.subscribe(onSessionNotified);
+  function start() {
+    started = true;
+    return reconcile2();
+  }
+  function purchase(catalogRef) {
+    onSessionNotified();
+    const requestedBy = deps.session.current();
+    const name = `purchase:${requestedBy.generation}:${catalogRef}`;
+    return runJob(name, () => runPurchase(requestedBy, catalogRef), { joinRunning: true }).then(([dropped, state]) => dropped ? { ...state, errorCode: "sessionChanged" } : state);
+  }
+  function reconcile2() {
+    resetIfSessionChanged();
+    return enqueue("reconcile", runReconcile);
+  }
+  function retry2() {
+    resetIfSessionChanged();
+    return enqueue("retry", runRetry);
+  }
+  function tick() {
+    if (resetIfSessionChanged() && started) return reconcile2();
+    return enqueue("tick", runDue);
+  }
+  function getState() {
+    if (disposed || !sessionMatches()) return { phase: "idle", errorCode: null, items: [], unfinishedCount: null, nextWakeAt: null };
+    const snapshot = [...items.values()].map((item) => ({ ...item.state }));
+    const due = snapshot.map((item) => item.nextAttemptAt).filter((at) => at !== null);
+    return { phase: currentPhase(), errorCode: errorCode ?? unavailable2?.code ?? null, items: snapshot, unfinishedCount, nextWakeAt: due.length > 0 ? Math.min(...due) : null };
+  }
+  function dispose() {
+    disposed = true;
+    unsubscribe();
+    staleSignal.fire();
+  }
+  async function runPurchase(session, catalogRef) {
+    if (!isCurrent(session)) return !disposed;
+    setError(null, false);
+    outcome = "idle";
+    pendingApproval = null;
+    unavailable2 = null;
+    releaseSignIn();
+    if (session.kind !== "member") {
+      requireSignIn();
+      return false;
+    }
+    const context = await purchaseContext(session, catalogRef);
+    if (!isCurrent(session)) return !disposed;
+    if (!context) return false;
+    purchasing = true;
+    publish();
+    const { productId, appAccountToken } = context;
+    const result = await store.purchaseForVerification({ productId, appAccountToken });
+    purchasing = false;
+    if (!isCurrent(session)) return !disposed;
+    if (result.status === "purchased") await deliverPurchase(session, result.transaction, context);
+    else if (result.status === "failed") failStore(result.code, false);
+    else if (result.status === "pending") {
+      if (!await awaitApproval(session, context)) return !disposed;
+    } else setOutcome("cancelled");
+    return false;
+  }
+  async function deliverPurchase(session, transaction, context) {
+    const item = upsert2(transaction, null);
+    applyDelivered(await deliver(session, [item], context));
+    await enumerate(session);
+    publish();
+  }
+  async function runReconcile() {
+    resetIfSessionChanged();
+    const session = deps.session.current();
+    const listing = await enumerate(session);
+    if (listing === "stale") return;
+    if (session.kind !== "member") return requireSignIn();
+    if (listing === "listed") clearReconcileProblem();
+    const now = deps.clock.now();
+    const eligible = itemsWhere((item) => isAwaitingDelivery(item) && (item.state.nextAttemptAt === null || item.state.nextAttemptAt <= now));
+    eligible.forEach(restartAttemptBudget);
+    await settleDelivery(session, await deliver(session, eligible));
+  }
+  async function settleDelivery(session, delivered) {
+    applyDelivered(delivered);
+    if (delivered.finished) await enumerate(session);
+    publish();
+  }
+  function applyDelivered(delivered) {
+    if (delivered.confirmedProducts.length === 0) return;
+    if (outcome === "cancelled") outcome = "idle";
+    if (!delivered.signInLost) releaseSignIn();
+  }
+  function releaseSignIn() {
+    if (!signInPrompt) return;
+    signInPrompt = false;
+    const now = deps.clock.now();
+    for (const item of items.values()) {
+      if (item.state.access === "signInRequired") Object.assign(item.state, { access: "waitingToRetry", attempts: 0, nextAttemptAt: now });
+    }
+  }
+  function clearReconcileProblem() {
+    if (unavailable2?.from === "reconcile") unavailable2 = null;
+    if (errorFromReconcile) setError(null, false);
+  }
+  async function runRetry() {
+    releaseSignIn();
+    for (const item of items.values()) unblock(item);
+    await runReconcile();
+  }
+  async function runDue() {
+    if (resetIfSessionChanged()) return started ? runReconcile() : void 0;
+    const session = memberSession();
+    const now = deps.clock.now();
+    const due = itemsWhere((item) => item.state.nextAttemptAt !== null && item.state.nextAttemptAt <= now);
+    if (!session || due.length === 0) return;
+    await settleDelivery(session, await deliver(session, due));
+  }
+  async function deliver(session, batch, known) {
+    const needProof = batch.filter((item) => !item.finishAllowed);
+    const context = known ?? (needProof.length > 0 ? await memberContext(session, needProof) : void 0);
+    const delivered = noDelivery();
+    for (const item of batch) {
+      if (!isCurrent(session)) return noDelivery();
+      const wasAllowed = item.finishAllowed;
+      if (delivered.signInLost && !wasAllowed) {
+        blockWithoutSession(item);
+        continue;
+      }
+      if (await deliverItem(session, item, context)) delivered.finished = true;
+      if (!wasAllowed && item.finishAllowed) delivered.confirmedProducts.push(item.state.productId);
+      if (item.state.access === "signInRequired") delivered.signInLost = true;
+    }
+    return delivered;
+  }
+  function blockWithoutSession(item) {
+    block(item.state, item.transaction.appAccountToken === null ? "ownershipConflict" : "signInRequired", null);
+  }
+  async function deliverItem(session, item, context) {
+    if (!item.finishAllowed) {
+      if (!context || !await confirmAccess(session, item, context)) return false;
+    }
+    return complete(session, item);
+  }
+  async function confirmAccess(session, item, context) {
+    if (item.transaction.appAccountToken === null) {
+      block(item.state, "ownershipConflict", null);
+      return false;
+    }
+    updateItem(item, { access: "confirming", nextAttemptAt: null });
+    const settled = await settle(session, () => deps.backend.submitProof(session, item.transaction));
+    if (settled.kind === "stale") return false;
+    if (settled.kind === "error") return recordFailedAttempt(item, void 0);
+    return applySubmission(item, settled.value, context.scopeKey);
+  }
+  function applySubmission(item, raw, scopeKey) {
+    if (!isObject(raw)) return block(item.state, "rejected", "invalidResponse");
+    switch (raw.status) {
+      case "processed":
+      case "alreadyProcessed":
+      case "accepted":
+      case "refusedFinal":
+        if (!acknowledges(raw.acknowledgement, item.transaction, scopeKey)) return block(item.state, "rejected", "invalidResponse");
+        item.finishAllowed = true;
+        Object.assign(item.state, { ...FINISH_ALLOWED_STATE[raw.status], nextAttemptAt: null });
+        return true;
+      case "retryable":
+        return recordFailedAttempt(item, retryAfter(raw.retryAfterMs));
+      case "authRequired":
+        signInPrompt = true;
+        return block(item.state, "signInRequired", null);
+      case "ownershipConflict":
+        return block(item.state, "ownershipConflict", null);
+      case "rejected":
+        return block(item.state, "rejected", "proofRejected");
+      default:
+        return block(item.state, "rejected", "invalidResponse");
+    }
+  }
+  async function complete(session, item) {
+    if (!isCurrent(session)) return false;
+    const result = await store.finishTransaction({ transactionId: item.transaction.transactionId });
+    if (!isCurrent(session)) return false;
+    if (result.status === "failed") {
+      item.state.completion = "retryRequired";
+      recordFailedAttempt(item, void 0);
+      return false;
+    }
+    Object.assign(item.state, { completion: result.status, held: false, nextAttemptAt: null });
+    return result.status === "finished";
+  }
+  function recordFailedAttempt(item, retryAfterMs) {
+    const state = item.state;
+    state.attempts += 1;
+    if (!item.finishAllowed) state.access = "waitingToRetry";
+    state.nextAttemptAt = state.attempts >= MAX_AUTOMATIC_ATTEMPTS ? null : deps.clock.now() + retryDelay(state.attempts, retryAfterMs);
+    return false;
+  }
+  function retryDelay(attempts, retryAfterMs) {
+    if (retryAfterMs !== void 0) return Math.min(retryAfterMs, MAX_RETRY_DELAY_MS);
+    const base = Math.min(BASE_RETRY_DELAY_MS * 2 ** (attempts - 1), MAX_RETRY_DELAY_MS);
+    return base + Math.max(0, deps.jitter?.(base) ?? 0);
+  }
+  async function purchaseContext(session, catalogRef) {
+    const settled = await settle(session, () => deps.backend.getPurchaseContext(session, catalogRef));
+    if (settled.kind === "stale") return null;
+    const decoded = decodeContext(settled, isPurchaseContext);
+    if (decoded.kind === "ok") return decoded.context;
+    if (decoded.kind === "signInRequired") requireSignIn();
+    else failContext(decoded.kind);
+    return null;
+  }
+  async function memberContext(session, waiting) {
+    const settled = await settle(session, () => deps.backend.getMemberContext(session));
+    if (settled.kind === "stale") return void 0;
+    const decoded = decodeContext(settled, isMemberContext);
+    if (decoded.kind === "ok") return decoded.context;
+    if (decoded.kind === "rejected") setError("contextRejected", true);
+    if (decoded.kind === "signInRequired") signInPrompt = true;
+    for (const item of waiting) {
+      if (decoded.kind === "unavailable") recordFailedAttempt(item, decoded.retryAfterMs);
+      else if (decoded.kind === "rejected") block(item.state, "waitingToRetry", "contextRejected");
+      else block(item.state, "signInRequired", null);
+    }
+    return void 0;
+  }
+  async function enumerate(session, { quiet = false } = {}) {
+    if (!isCurrent(session)) return "stale";
+    const result = await store.getUnfinishedTransactions();
+    if (!isCurrent(session)) return "stale";
+    if (result.status !== "ok") {
+      unfinishedCount = null;
+      if (!quiet) failStore(result.code, true);
+      return "failed";
+    }
+    const held = new Set(result.transactions.map((transaction) => upsert2(transaction, true)));
+    for (const item of items.values()) if (!held.has(item)) item.state.held = false;
+    unfinishedCount = result.transactions.length;
+    return "listed";
+  }
+  function upsert2(transaction, held) {
+    const key = identityOf(transaction);
+    const existing = items.get(key);
+    if (existing) {
+      existing.transaction = transaction;
+      if (held !== null) existing.state.held = held;
+      return existing;
+    }
+    if (pendingApproval?.productId === transaction.productId && !pendingApproval.known.has(key) && sameAccount(transaction.appAccountToken, pendingApproval.token)) {
+      pendingApproval = null;
+      if (outcome === "awaitingApproval") outcome = "idle";
+    }
+    const item = { transaction, state: newItemState(transaction, held), finishAllowed: false };
+    items.set(key, item);
+    return item;
+  }
+  function onSessionNotified() {
+    if (resetIfSessionChanged() && started) void reconcile2();
+  }
+  function resetIfSessionChanged() {
+    const next = deps.session.current().generation;
+    if (disposed || next === generation) return false;
+    generation = next;
+    staleSignal.fire();
+    staleSignal = createSignal();
+    items.clear();
+    outcome = "idle";
+    purchasing = false;
+    signInPrompt = false;
+    unavailable2 = null;
+    pendingApproval = null;
+    unfinishedCount = null;
+    setError(null, false);
+    publish();
+    return true;
+  }
+  function memberSession() {
+    const session = deps.session.current();
+    return session.kind === "member" ? session : null;
+  }
+  function sessionMatches() {
+    return deps.session.current().generation === generation;
+  }
+  function isCurrent(session) {
+    return !disposed && session.generation === generation && sessionMatches();
+  }
+  async function settle(session, call) {
+    const stale = staleSignal.waiter();
+    try {
+      const pending = Promise.resolve().then(() => {
+        if (!isCurrent(session)) throw ABANDONED;
+        return call();
+      });
+      const settled = await Promise.race([pending.then((value) => ({ kind: "value", value })), stale.fired.then(() => STALE)]);
+      return isCurrent(session) ? settled : STALE;
+    } catch {
+      return isCurrent(session) ? { kind: "error" } : STALE;
+    } finally {
+      stale.cancel();
+    }
+  }
+  function runJob(name, run, options = {}) {
+    return queue.run(name, () => disposed ? Promise.resolve(void 0) : run(), options).then((result) => [result, getState()]);
+  }
+  function enqueue(name, run) {
+    return runJob(name, run).then(([, state]) => state);
+  }
+  function itemsWhere(predicate) {
+    return [...items.values()].filter(predicate);
+  }
+  function updateItem(item, patch) {
+    Object.assign(item.state, patch);
+    publish();
+  }
+  function requireSignIn() {
+    for (const item of items.values()) {
+      if (isAwaitingDelivery(item) && !item.finishAllowed) block(item.state, "signInRequired", null);
+    }
+    signInPrompt = true;
+    publish();
+  }
+  function failContext(reason) {
+    setError(reason === "rejected" ? "contextRejected" : "contextUnavailable", false);
+    publish();
+  }
+  function failStore(code, fromReconcile) {
+    setError(code, fromReconcile);
+    if (UNAVAILABLE_CODES.has(code) && unavailable2?.from !== "purchase") {
+      unavailable2 = { from: fromReconcile ? "reconcile" : "purchase", code };
+    }
+    publish();
+  }
+  async function awaitApproval(session, context) {
+    if (await enumerate(session, { quiet: true }) === "stale") return false;
+    const known = new Set([...items.keys()].filter((key) => items.get(key).state.productId === context.productId));
+    pendingApproval = { productId: context.productId, token: context.appAccountToken, known };
+    setOutcome("awaitingApproval");
+    deps.onAwaitingApproval?.(context.productId);
+    return true;
+  }
+  function setOutcome(next) {
+    outcome = next;
+    publish();
+  }
+  function currentPhase() {
+    if (purchasing) return "purchasing";
+    if (unavailable2?.from === "purchase") return "unavailable";
+    if (signInPrompt) return "signInRequired";
+    if (unavailable2?.from === "reconcile") return "unavailable";
+    return outcome;
+  }
+  function setError(code, fromReconcile) {
+    errorCode = code;
+    errorFromReconcile = code !== null && fromReconcile;
+  }
+  function publish() {
+    if (!disposed && sessionMatches()) deps.onState?.(getState());
+  }
+  return { start, purchase, reconcile: reconcile2, retry: retry2, tick, getState, dispose };
+}
+var FINISH_ALLOWED_STATE = {
+  processed: { access: "confirmed", errorCode: null },
+  alreadyProcessed: { access: "confirmed", errorCode: null },
+  accepted: { access: "processing", errorCode: null },
+  refusedFinal: { access: "rejected", errorCode: "proofRejected" }
+};
+var noDelivery = () => ({ finished: false, confirmedProducts: [], signInLost: false });
+var STALE = { kind: "stale" };
+var ABANDONED = { abandoned: true };
+async function storeCall(call) {
+  try {
+    return await call();
+  } catch {
+    return { status: "failed", code: "storeError" };
+  }
+}
+function guardStore(store) {
+  return {
+    purchaseForVerification: (input) => storeCall(() => store.purchaseForVerification(input)),
+    getUnfinishedTransactions: () => storeCall(() => store.getUnfinishedTransactions()),
+    finishTransaction: (input) => storeCall(() => store.finishTransaction(input))
+  };
+}
+function identityOf(transaction) {
+  return `${transaction.store}:${transaction.environment}:${transaction.transactionId}`;
+}
+function newItemState(transaction, held) {
+  return {
+    productId: transaction.productId,
+    environment: transaction.environment,
+    held,
+    access: "pending",
+    completion: "pending",
+    attempts: 0,
+    nextAttemptAt: null,
+    errorCode: null
+  };
+}
+function isAwaitingDelivery(item) {
+  const state = item.state;
+  if (item.finishAllowed) return state.completion === "pending" || state.completion === "retryRequired";
+  return state.access === "pending" || state.access === "waitingToRetry" || state.access === "signInRequired";
+}
+function restartAttemptBudget(item) {
+  item.state.attempts = 0;
+}
+function unblock(item) {
+  if (!item.finishAllowed) Object.assign(item.state, { access: "pending", errorCode: null });
+  Object.assign(item.state, { attempts: 0, nextAttemptAt: null });
+}
+function block(state, access, errorCode) {
+  Object.assign(state, { access, errorCode, nextAttemptAt: null });
+  return false;
+}
+function sameAccount(transactionToken, memberToken) {
+  return transactionToken !== null && transactionToken.toLowerCase() === memberToken.toLowerCase();
+}
+function acknowledges(acknowledgement, transaction, scopeKey) {
+  return isObject(acknowledgement) && acknowledgement.transactionId === transaction.transactionId && acknowledgement.productId === transaction.productId && acknowledgement.environment === transaction.environment && acknowledgement.scopeKey === scopeKey;
+}
+function decodeContext(settled, isContext) {
+  const raw = settled.kind === "value" ? settled.value : null;
+  if (!isObject(raw)) return { kind: "unavailable" };
+  if (raw.status === "ok" && isContext(raw.context)) return { kind: "ok", context: raw.context };
+  if (raw.status === "authRequired") return { kind: "signInRequired" };
+  if (raw.status === "rejected") return { kind: "rejected" };
+  return { kind: "unavailable", retryAfterMs: retryAfter(raw.retryAfterMs) };
+}
+function isPurchaseContext(value) {
+  return isMemberContext(value) && isObject(value) && isNonEmpty(value.productId) && isNonEmpty(value.appAccountToken);
+}
+function isMemberContext(value) {
+  return isObject(value) && isNonEmpty(value.scopeKey);
+}
+function retryAfter(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function isNonEmpty(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function createSignal() {
+  const listeners = /* @__PURE__ */ new Set();
+  let hasFired = false;
+  return {
+    fire() {
+      hasFired = true;
+      for (const listener of listeners) listener();
+      listeners.clear();
+    },
+    waiter() {
+      let listener = () => {
+      };
+      const fired = new Promise((resolve) => {
+        listener = resolve;
+      });
+      if (hasFired) listener();
+      else listeners.add(listener);
+      return { fired, cancel: () => {
+        listeners.delete(listener);
+      } };
+    }
+  };
+}
+function createSerialQueue() {
+  let tail = Promise.resolve();
+  const waiting = /* @__PURE__ */ new Map();
+  const running = /* @__PURE__ */ new Map();
+  async function execute(name, self, job) {
+    waiting.delete(name);
+    running.set(name, self);
+    try {
+      return await job();
+    } catch {
+      return void 0;
+    } finally {
+      running.delete(name);
+    }
+  }
+  return {
+    /** Callers joined onto a shared job all receive that job's result. */
+    run(name, job, { joinRunning = false }) {
+      const shared2 = waiting.get(name) ?? (joinRunning ? running.get(name) : void 0);
+      if (shared2) return shared2;
+      const scheduled = tail.then(() => execute(name, scheduled, job));
+      waiting.set(name, scheduled);
+      tail = scheduled;
+      return scheduled;
+    }
+  };
+}
+
+// ../../core/sdk/iap/src/pricing.ts
+function createPricingController(deps) {
+  let state = { revision: 0, scope: null, items: [] };
+  let lastInput;
+  let active;
+  let disposed = false;
+  function load(input) {
+    if (disposed) return Promise.resolve();
+    const captured = captureInput(input);
+    const key = JSON.stringify(captured);
+    if (active?.key === key) return active.promise;
+    lastInput = captured;
+    const revision = state.revision + 1;
+    let complete;
+    const promise = new Promise((resolve) => {
+      complete = resolve;
+    });
+    active = { key, promise };
+    publish({ revision, scope: captured.scope, items: captured.items.map((item) => ({ reference: item.reference, status: "loading" })) });
+    void run(captured, revision).finally(complete);
+    return promise;
+  }
+  async function run(input, revision) {
+    const current = () => !disposed && state.revision === revision;
+    if (!current()) return;
+    const items = await resolvePrices(input, deps, current);
+    if (!current()) return;
+    active = void 0;
+    publish({ revision, scope: input.scope, items });
+  }
+  function publish(next) {
+    state = next;
+    try {
+      deps.onState?.(getState());
+    } catch {
+    }
+  }
+  function getState() {
+    return {
+      ...state,
+      scope: state.scope ? { ...state.scope } : null,
+      items: state.items.map((item) => ({ ...item, reference: { ...item.reference } }))
+    };
+  }
+  function dispose() {
+    disposed = true;
+    active = void 0;
+    lastInput = void 0;
+    state = { revision: state.revision + 1, scope: null, items: [] };
+  }
+  return { load, refresh: () => lastInput ? load(lastInput) : Promise.resolve(), getState, dispose };
+}
+function captureInput(input) {
+  const scope = {
+    appId: input.scope.appId,
+    bundleId: input.scope.bundleId,
+    siteId: input.scope.siteId,
+    ...input.scope.contextRevision === void 0 ? {} : { contextRevision: input.scope.contextRevision }
+  };
+  const items = /* @__PURE__ */ new Map();
+  for (const item of input.items) {
+    const reference = { kind: item.reference.kind, id: item.reference.id };
+    const key = JSON.stringify([reference.kind, reference.id]);
+    if (!items.has(key)) items.set(key, { reference, ...item.commerceDisplayPrice === void 0 ? {} : { commerceDisplayPrice: item.commerceDisplayPrice } });
+  }
+  return { scope, platform: input.platform, items: [...items.values()] };
+}
+async function resolvePrices(input, deps, current) {
+  if (input.items.length === 0) return [];
+  if (![input.scope.appId, input.scope.bundleId, input.scope.siteId].every(nonempty)) {
+    return input.items.map((item) => unavailable(item.reference, "invalidInput"));
+  }
+  const mappings = await resolveMappings(input, deps);
+  if (!current()) return [];
+  if (mappings === null) return input.items.map((item) => unavailable(item.reference, "mappingUnavailable"));
+  const routes = input.items.map((item) => resolveRoute(item, mappings, input.platform));
+  const ids = [...new Set(routes.flatMap((route) => route.status === "loading" ? [route.mapping.productId] : []))];
+  const products = ids.length ? await lookupProducts(ids, deps) : [];
+  return routes.map((route) => route.status === "loading" ? applePrice(route.mapping, products) : route);
+}
+async function resolveMappings(input, deps) {
+  try {
+    const references = input.items.filter((item) => nonempty(item.reference.kind) && nonempty(item.reference.id)).map((item) => ({ ...item.reference }));
+    if (!references.length) return [];
+    const result = await deps.mapping.resolve({ scope: { ...input.scope }, references });
+    return Array.isArray(result) ? result : [];
+  } catch {
+    return null;
+  }
+}
+async function lookupProducts(ids, deps) {
+  try {
+    const products = await deps.getProducts(ids);
+    return Array.isArray(products) ? products : [];
+  } catch {
+    return [];
+  }
+}
+function resolveRoute(item, mappings, platform) {
+  if (!nonempty(item.reference.kind) || !nonempty(item.reference.id)) return unavailable(item.reference, "invalidInput");
+  const matches = mappings.filter((value) => isObject2(value) && sameReference(value.reference, item.reference));
+  if (matches.length !== 1) return unavailable(item.reference, "mappingUnresolved");
+  const mapping = matches[0];
+  if (mapping.route === "regular") return regularPrice(item);
+  if (mapping.route !== "appleIap" || !nonempty(mapping.productId) || mapping.productId.includes(",") || !nonempty(mapping.mappingRevision)) {
+    return unavailable(item.reference, "mappingUnresolved");
+  }
+  if (platform !== "ios") return unavailable(item.reference, "unsupportedPlatform");
+  return { status: "loading", mapping: { reference: item.reference, route: "appleIap", productId: mapping.productId, mappingRevision: mapping.mappingRevision } };
+}
+function regularPrice(item) {
+  return nonempty(item.commerceDisplayPrice) ? { reference: item.reference, status: "ready", source: "regular", displayPrice: item.commerceDisplayPrice } : unavailable(item.reference, "commercePriceUnavailable");
+}
+function applePrice(mapping, products) {
+  const matches = products.filter((value) => isObject2(value) && value.id === mapping.productId);
+  const product = matches[0];
+  if (matches.length !== 1 || !nonempty(product?.displayPrice)) return unavailable(mapping.reference, "priceUnavailable");
+  if (product?.type !== "nonConsumable") return unavailable(mapping.reference, "unsupportedProductType");
+  return {
+    reference: mapping.reference,
+    status: "ready",
+    source: "appleIap",
+    productId: mapping.productId,
+    mappingRevision: mapping.mappingRevision,
+    displayPrice: product.displayPrice
+  };
+}
+function unavailable(reference, reason) {
+  return { reference, status: "unavailable", reason, retryable: !["invalidInput", "unsupportedPlatform", "unsupportedProductType", "commercePriceUnavailable"].includes(reason) };
+}
+var isObject2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var nonempty = (value) => typeof value === "string" && value.trim().length > 0;
+var sameReference = (value, reference) => isObject2(value) && value.kind === reference.kind && value.id === reference.id;
+
+// ../../core/sdk/iap/src/wix-payments-contract.ts
+var HIMALAYA_SERVE_IAP_ROUTE = { prefix: "/himalaya-serve/v1/iap" };
+var APPLE_SALE_RULES = {
+  onlineProgram: { appProductId: (id2) => id2, productType: "NON_CONSUMABLE" }
+};
+
+// ../../core/sdk/iap/src/mapping-source.ts
+function iapMappingSource() {
+  return createWixIapMappingSource({ binding: sharedHostAppBindingSource(), call: hostWixCall });
+}
+function createWixIapMappingSource(deps) {
+  return {
+    // Only a binding the host actually returned: a read that failed is re-asked on the next load.
+    active: async () => await deps.binding.current() !== null,
+    mapping: {
+      resolve: async ({ scope, references }) => {
+        const binding = await deps.binding.current();
+        if (!binding) return references.map((reference) => ({ reference, route: "regular" }));
+        if (scope.siteId && !sameId(scope.siteId, binding.siteId)) return references.map((reference) => ({ reference, route: "unavailable" }));
+        const asked = [...new Set(references.flatMap((reference) => appProductIdOf(reference) ?? []))];
+        const mapped = await resolveAll(deps.call, binding, asked);
+        return references.map((reference) => decide(reference, binding, mapped));
+      }
+    }
+  };
+}
+function appProductIdOf(reference) {
+  return reference.id ? APPLE_SALE_RULES[reference.kind]?.appProductId(reference.id) : void 0;
+}
+var PATH = `${HIMALAYA_SERVE_IAP_ROUTE.prefix}/mappings`;
+var BATCH = 100;
+async function resolveAll(call, binding, ids) {
+  const mapped = /* @__PURE__ */ new Map();
+  const wanted = new Set(ids);
+  for (let at = 0; at < ids.length; at += BATCH) {
+    const batch = ids.slice(at, at + BATCH);
+    const reply = await call("POST", PATH, { appId: binding.purchasesAppId, appProductIds: batch }, { "wix-site-id": binding.siteId });
+    for (const [id2, mapping] of decodeMappings(reply)) if (wanted.has(id2)) mapped.set(id2, mapping);
+  }
+  return mapped;
+}
+function decodeMappings(reply) {
+  const list = reply?.mappings;
+  if (!Array.isArray(list)) throw new Error("the mapping route answered without a mappings list");
+  return list.map((raw) => {
+    const m = raw;
+    if (typeof m?.appProductId !== "string" || typeof m.storeProductId !== "string" || !m.storeProductId) {
+      throw new Error("the mapping route answered a mapping without its ids");
+    }
+    return [m.appProductId, { storeProductId: m.storeProductId, type: String(m.type ?? ""), active: m.active === true }];
+  });
+}
+function decide(reference, binding, mapped) {
+  const id2 = appProductIdOf(reference);
+  const mapping = id2 ? mapped.get(id2) : void 0;
+  if (!mapping) return { reference, route: "regular" };
+  if (!mapping.active || mapping.type !== APPLE_SALE_RULES[reference.kind]?.productType) return { reference, route: "unavailable" };
+  return { reference, route: "appleIap", productId: mapping.storeProductId, mappingRevision: `${binding.purchasesAppId}:${mapping.storeProductId}` };
+}
+function sameId(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+function hostWixCall(method, path, body, headers) {
+  const bridge = globalThis.himalaya?.wixApi;
+  if (!bridge) return Promise.reject(new Error("the host did not install the wixApi bridge"));
+  return bridge.call(method, path, body, headers);
+}
+
+// ../../core/sdk/iap/src/catalog-pricing-core.ts
+var POLL_ID = "iapCatalogPricing";
+var POLL_INTERVAL_MS = 6e4;
+function createIapCatalogPricingWith(deps) {
+  return deps.source ? enabledPricing(deps.source, deps) : disabledPricing();
+}
+function disabledPricing() {
+  return {
+    enabled: false,
+    load: () => Promise.resolve(),
+    refresh: () => Promise.resolve(),
+    view: disabledView,
+    checkoutGuard: (reference) => decisionOf(disabledView(reference)),
+    continueCheckoutGuard: (reference) => decisionOf(disabledView(reference)),
+    appleProduct: () => null,
+    pollDirective: () => void 0,
+    dispose: () => {
+    }
+  };
+}
+function enabledPricing(source, deps) {
+  let controller;
+  let disposed = false;
+  const settled = /* @__PURE__ */ new Map();
+  let settledScope = "";
+  const rememberSettled = (state) => {
+    const scopeKey = JSON.stringify(state.scope);
+    if (scopeKey !== settledScope) {
+      settled.clear();
+      settledScope = scopeKey;
+    }
+    for (const item of state.items) {
+      const answered = viewOf(item.reference, item);
+      if (!unanswered(answered)) settled.set(referenceKey(item.reference), answered);
+    }
+  };
+  let selling = "active";
+  let lookupRevision = 0;
+  let answeredRoutes;
+  const mapping = {
+    resolve: async (request) => {
+      const asked = lookupRevision;
+      const answer = await source.mapping.resolve(request);
+      if (asked === lookupRevision) answeredRoutes = routesAnswered(answer);
+      return answer;
+    }
+  };
+  const trackLookup = (state) => {
+    if (state.revision !== lookupRevision) {
+      lookupRevision = state.revision;
+      answeredRoutes = void 0;
+    }
+  };
+  const ensureController = () => controller ?? (controller = createPricingController({
+    mapping,
+    getProducts: deps.getProducts,
+    onState: (state) => {
+      trackLookup(state);
+      rememberSettled(state);
+      deps.onChange?.();
+    }
+  }));
+  const view = (reference) => disposed ? blockedView(reference, "unavailable") : selling === "inactive" ? disabledView(reference) : selling === "unknown" ? sellingUnknownView(reference) : viewOf(reference, controller && itemFor(controller.getState().items, reference));
+  const load = async (input) => {
+    if (disposed) return;
+    selling = source.active ? await source.active().then((active) => active ? "active" : "inactive", () => "unknown") : "active";
+    if (selling !== "active") {
+      deps.onChange?.();
+      return;
+    }
+    await ensureController().load(pricingInput(input, source));
+  };
+  const continueCheckoutGuard = (reference) => {
+    const current = view(reference);
+    if (!unanswered(current) || selling !== "active") return decisionOf(current);
+    if (answeredRoutes) return routeDecision(answeredRoutes.get(referenceKey(reference)) ?? "unavailable");
+    return decisionOf(settled.get(referenceKey(reference)) ?? current);
+  };
+  return {
+    enabled: true,
+    load,
+    refresh: () => controller?.refresh() ?? Promise.resolve(),
+    view,
+    checkoutGuard: (reference) => decisionOf(view(reference)),
+    continueCheckoutGuard,
+    appleProduct: (reference) => disposed || selling !== "active" ? null : appleProductOf(controller && itemFor(controller.getState().items, reference)),
+    pollDirective: (action2) => ({ id: POLL_ID, action: action2, intervalMs: POLL_INTERVAL_MS, immediate: true }),
+    dispose: () => {
+      disposed = true;
+      settled.clear();
+      controller?.dispose();
+    }
+  };
+}
+function pricingInput(input, source) {
+  return { scope: pricingScope(input.scope, source.siteId), platform: input.platform, items: input.items };
+}
+function pricingScope(scope, boundSiteId) {
+  return {
+    appId: scope.appId,
+    bundleId: scope.bundleId,
+    siteId: siteIdFor(scope.siteId, boundSiteId),
+    ...scope.contextRevision === void 0 ? {} : { contextRevision: scope.contextRevision }
+  };
+}
+function siteIdFor(callerSiteId, boundSiteId) {
+  if (callerSiteId && boundSiteId && callerSiteId !== boundSiteId) return "";
+  return callerSiteId || boundSiteId || "";
+}
+var referenceKey = (reference) => JSON.stringify([reference.kind, reference.id]);
+function routesAnswered(answer) {
+  const routes = /* @__PURE__ */ new Map();
+  for (const entry of Array.isArray(answer) ? answer : []) {
+    const reference = entry?.reference;
+    if (typeof reference?.kind !== "string" || typeof reference.id !== "string") continue;
+    const key = referenceKey(reference);
+    const route = entry.route;
+    routes.set(key, routes.has(key) ? "unavailable" : route === "regular" || route === "appleIap" ? route : "unavailable");
+  }
+  return routes;
+}
+function routeDecision(route) {
+  return { allowed: route === "regular", route };
+}
+function unanswered(view) {
+  return view.route === "resolving" || view.reason === "mappingUnavailable";
+}
+function itemFor(items, reference) {
+  return items.find((item) => item.reference.kind === reference.kind && item.reference.id === reference.id);
+}
+function appleProductOf(item) {
+  if (item?.status !== "ready" || item.source !== "appleIap") return null;
+  return { productId: item.productId, mappingRevision: item.mappingRevision };
+}
+function viewOf(reference, item) {
+  if (!item || item.status === "loading") return blockedView(reference, "resolving");
+  if (item.status === "ready") return readyView(reference, item);
+  return unavailableView(reference, item);
+}
+function readyView(reference, item) {
+  return item.source === "appleIap" ? { ...blockedView(reference, "appleIap"), displayPrice: item.displayPrice } : { ...regularView(reference), displayPrice: item.displayPrice };
+}
+function unavailableView(reference, item) {
+  if (item.reason === "commercePriceUnavailable") return regularView(reference);
+  return { ...blockedView(reference, "unavailable"), reason: item.reason, retryable: item.retryable };
+}
+function blockedView(reference, route) {
+  return { reference: { kind: reference.kind, id: reference.id }, route, displayPrice: "", retryable: false, canStartRegularCheckout: false, purchasable: false };
+}
+function regularView(reference) {
+  return { ...blockedView(reference, "regular"), canStartRegularCheckout: true };
+}
+function sellingUnknownView(reference) {
+  return { ...blockedView(reference, "unavailable"), reason: "mappingUnavailable", retryable: true };
+}
+function disabledView(reference) {
+  return { ...blockedView(reference, "disabled"), canStartRegularCheckout: true };
+}
+function decisionOf(view) {
+  return { allowed: view.canStartRegularCheckout, route: view.route };
+}
+
+// ../../core/sdk/iap/src/catalog-pricing.ts
+function createIapCatalogPricing(options = {}) {
+  return createIapCatalogPricingWith({ source: iapMappingSource(), getProducts, onChange: options.onChange });
+}
+
+// ../../core/sdk/iap/src/catalog-price-fields.ts
+function iapPriceFields(view, copy) {
+  const fields = {
+    priceText: "",
+    priceNote: "",
+    priceLoading: false,
+    hidePriceRetry: true,
+    actionDisabled: !view.canStartRegularCheckout,
+    actionNote: ""
+  };
+  switch (view.route) {
+    case "resolving":
+      return { ...fields, priceText: copy.loading, priceLoading: true };
+    case "appleIap":
+      return { ...fields, priceText: view.displayPrice, priceNote: copy.oneTimePurchase, actionNote: copy.purchaseUnavailable };
+    case "unavailable":
+      return { ...fields, priceText: copy.unavailable, hidePriceRetry: !view.retryable };
+    case "regular":
+      return { ...fields, priceText: view.displayPrice };
+    case "disabled":
+      return fields;
+  }
+}
+
+// ../../core/sdk/iap/src/host-session.ts
+var SIGNED_OUT = {
+  generation: 0,
+  kind: "signedOut",
+  memberId: null,
+  siteId: null,
+  appId: null,
+  ready: false,
+  epoch: 0
+};
+var KINDS = /* @__PURE__ */ new Set(["member", "visitor", "owner", "signedOut"]);
+function createHostSession(source) {
+  let seen = -1;
+  let latest = SIGNED_OUT;
+  const byGeneration = /* @__PURE__ */ new Map();
+  function pull() {
+    const snap = parseSession(source.current());
+    if (snap.generation < seen) return latest;
+    seen = snap.generation;
+    latest = snap;
+    const expectation = expectationOf(snap);
+    if (expectation && !byGeneration.has(snap.generation)) byGeneration.set(snap.generation, expectation);
+    return snap;
+  }
+  return {
+    identityBound: source.identityBound,
+    current() {
+      const snap = pull();
+      return { generation: snap.generation, kind: snap.kind };
+    },
+    identity(session) {
+      pull();
+      return byGeneration.get(session.generation) ?? null;
+    },
+    site() {
+      const snap = pull();
+      return snap.ready ? snap.siteId : null;
+    },
+    subscribe(listener) {
+      return source.subscribe(() => {
+        const before = seen;
+        pull();
+        if (latest.generation >= before) listener();
+      });
+    }
+  };
+}
+function hostSessionFromGlobal() {
+  const api = wixApiGlobal();
+  const session = api?.session;
+  if (!session || typeof session.current !== "function" || typeof session.subscribe !== "function") {
+    return createHostSession({ identityBound: false, current: () => SIGNED_OUT, subscribe: () => () => {
+    } });
+  }
+  return createHostSession({
+    identityBound: api?.identityBound === true,
+    current: () => session.current(),
+    subscribe: (listener) => session.subscribe(listener)
+  });
+}
+function memberIdentityOf(source) {
+  return { memberId: (session) => Promise.resolve(source.identity(session)?.memberId ?? null) };
+}
+function readIdentityBound() {
+  return wixApiGlobal()?.identityBound === true;
+}
+function expectationOf(snap) {
+  if (!snap.ready || snap.kind !== "member" || !snap.memberId || !snap.siteId || !snap.appId) return null;
+  return { generation: snap.generation, kind: "member", memberId: snap.memberId, siteId: snap.siteId, appId: snap.appId };
+}
+function parseSession(raw) {
+  if (raw === null || typeof raw !== "object") return SIGNED_OUT;
+  const value = raw;
+  const kind = value.kind;
+  if (typeof value.generation !== "number" || !Number.isSafeInteger(value.generation)) return SIGNED_OUT;
+  if (typeof kind !== "string" || !KINDS.has(kind)) return SIGNED_OUT;
+  return {
+    generation: value.generation,
+    kind,
+    memberId: typeof value.memberId === "string" && value.memberId.length > 0 ? value.memberId : null,
+    siteId: typeof value.siteId === "string" && value.siteId.length > 0 ? value.siteId : null,
+    appId: typeof value.appId === "string" && value.appId.length > 0 ? value.appId : null,
+    ready: value.ready === true,
+    epoch: typeof value.epoch === "number" ? value.epoch : 0
+  };
+}
+function wixApiGlobal() {
+  return globalThis.himalaya?.wixApi;
+}
+
+// ../../core/sdk/iap/src/wix-payments-wire.ts
+function startPaymentCall(scope, wixTransactionId) {
+  return post(scope, "/payments/start", { appId: scope.binding.purchasesAppId, wixTransactionId });
+}
+function completePaymentCall(scope, signedTransaction) {
+  return post(scope, "/payments/complete", { appId: scope.binding.purchasesAppId, apple: { signedTransaction } });
+}
+function paymentCall(scope, paymentId) {
+  return get2(scope, `/payments/${encodeURIComponent(paymentId)}`);
+}
+function isRoutePrefix(prefix) {
+  return /^\/[A-Za-z0-9._~\-/]*[A-Za-z0-9._~-]$/.test(prefix);
+}
+function decodeStarted(raw, expected) {
+  if (!isObject3(raw) || !isStoreProductId(raw.storeProductId) || !isUUID(raw.appAccountToken)) return null;
+  const payment = decodePayment(raw.payment, expected);
+  return payment && { payment, storeProductId: raw.storeProductId, appAccountToken: raw.appAccountToken };
+}
+function decodePaymentAnswer(raw, expected) {
+  return isObject3(raw) ? decodePayment(raw.payment, expected) : null;
+}
+function decodePayment(raw, expected) {
+  if (!isObject3(raw) || !hasPaymentIds(raw) || !echoes(raw, expected) || !hasValidOptionals(raw)) return null;
+  const status = ownValue(STATUSES, raw.status);
+  return status ? toPayment(raw, status) : null;
+}
+function hasPaymentIds(raw) {
+  return isUUID(raw.id) && isUUID(raw.appId) && isUUID(raw.memberId) && isUUID(raw.wixTransactionId);
+}
+function echoes(raw, expected) {
+  return sameUUID(raw.appId, expected.appId) && (expected.memberId === null || sameUUID(raw.memberId, expected.memberId)) && (expected.paymentId === void 0 || sameUUID(raw.id, expected.paymentId)) && (expected.wixTransactionId === void 0 || sameUUID(raw.wixTransactionId, expected.wixTransactionId));
+}
+function hasValidOptionals(raw) {
+  return (raw.appProductId === void 0 || isStoreProductId(raw.appProductId)) && (raw.purchaseTransactionId === void 0 || isUUID(raw.purchaseTransactionId)) && TIMESTAMPS.every((field) => raw[field] === void 0 || isTimestamp(raw[field]));
+}
+function toPayment(raw, status) {
+  const optional = {
+    appProductId: raw.appProductId,
+    cancelReason: ownValue(CANCEL_REASONS, raw.cancelReason),
+    purchaseTransactionId: raw.purchaseTransactionId,
+    expiresDate: raw.expiresDate,
+    approvedDate: raw.approvedDate,
+    canceledDate: raw.canceledDate,
+    refundedDate: raw.refundedDate
+  };
+  const ids = { paymentId: raw.id, appId: raw.appId, memberId: raw.memberId, wixTransactionId: raw.wixTransactionId };
+  return { ...ids, status, ...withoutUndefined(optional) };
+}
+function classifyFailure(error, operation, codes) {
+  const message = messageOf(error);
+  if (BRIDGE_REFUSAL.test(message)) return failure(operation, "notEnabled");
+  if (PRINCIPAL_CHANGED.test(message)) return failure(operation, "sessionChanged");
+  const http = /^HTTP (\d{3})(?: \[([^\]]+)\])?:/.exec(message);
+  if (!http) return failure(operation, "unavailable");
+  return classifyHttp({ operation, codes, httpStatus: Number(http[1]), code: http[2] ?? "" });
+}
+function failure(operation, kind) {
+  return { status: "failed", operation, kind };
+}
+function classifyHttp(refusal) {
+  const { operation, codes, httpStatus, code } = refusal;
+  if (code === "PRINCIPAL_CHANGED") return failure(operation, "sessionChanged");
+  if (isOneOf(codes, code)) return { status: "failed", operation, kind: "application", code, httpStatus };
+  return { status: "failed", operation, kind: kindForStatus(httpStatus, code), httpStatus };
+}
+function kindForStatus(httpStatus, code) {
+  if (code === "UNAVAILABLE" || httpStatus === 408 || httpStatus === 429 || httpStatus >= 500) return "unavailable";
+  if (httpStatus === 401 || code === "UNAUTHENTICATED") return "authRequired";
+  if (httpStatus === 403 || code === "PERMISSION_DENIED") return "notPermitted";
+  return "unrecognized";
+}
+function post(scope, route, body) {
+  return { method: "POST", path: `${scope.prefix}${route}`, body, headers: siteHeaders(scope.binding) };
+}
+function get2(scope, route) {
+  return { method: "GET", path: `${scope.prefix}${route}`, headers: siteHeaders(scope.binding) };
+}
+function siteHeaders(binding) {
+  return { "wix-site-id": binding.siteId };
+}
+function messageOf(error) {
+  const message = error?.message;
+  return typeof message === "string" ? message : "";
+}
+function withoutUndefined(value) {
+  const kept = {};
+  for (const key of Object.keys(value)) {
+    if (value[key] !== void 0) kept[key] = value[key];
+  }
+  return kept;
+}
+function isOneOf(codes, code) {
+  return codes.includes(code);
+}
+function ownValue(table, key) {
+  return typeof key === "string" && Object.prototype.hasOwnProperty.call(table, key) ? table[key] : void 0;
+}
+function isObject3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isUUID(value) {
+  return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function sameUUID(value, expected) {
+  return isUUID(value) && value.toLowerCase() === expected.toLowerCase();
+}
+function isStoreProductId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 255;
+}
+function isTimestamp(value) {
+  return typeof value === "string" && !Number.isNaN(Date.parse(value));
+}
+var STATUSES = {
+  PENDING: "pending",
+  APPROVING: "approving",
+  APPROVED: "approved",
+  CANCELING: "canceling",
+  CANCELED: "canceled",
+  REFUNDING: "refunding",
+  REFUNDED: "refunded"
+};
+var CANCEL_REASONS = { EXPIRED: "expired", REJECTED: "rejected" };
+var TIMESTAMPS = ["createdDate", "updatedDate", "expiresDate", "approvedDate", "canceledDate", "refundedDate"];
+var BRIDGE_REFUSAL = /^(wixApi not enabled|capability wix_api not allowed)\b|^NotInstalled\(\)$/;
+var PRINCIPAL_CHANGED = /^PRINCIPAL_CHANGED\b/;
+
+// ../../core/sdk/iap/src/wix-payments.ts
+function createWixIapClient(deps) {
+  function startPayment(input) {
+    if (!isUUID(input.wixTransactionId)) return Promise.resolve(failure("startPayment", "invalidArgument"));
+    return run({
+      operation: "startPayment",
+      codes: START_PAYMENT_CODES,
+      request: (scope) => startPaymentCall(scope, input.wixTransactionId),
+      decode: (raw, scope) => {
+        const started = decodeStarted(raw, { ...expectationOf2(scope), wixTransactionId: input.wixTransactionId });
+        return started && { status: "started", ...started };
+      }
+    });
+  }
+  function completePayment(transaction) {
+    const refusal = refuseProof(transaction);
+    if (refusal) return Promise.resolve(refusal);
+    return run({
+      operation: "completePayment",
+      codes: COMPLETE_PAYMENT_CODES,
+      request: (scope) => completePaymentCall(scope, transaction.signedTransaction),
+      decode: (raw, scope) => {
+        const payment = decodePaymentAnswer(raw, expectationOf2(scope));
+        return payment && { status: "matched", payment };
+      }
+    });
+  }
+  function getPayment(input) {
+    if (!isUUID(input.paymentId)) return Promise.resolve(failure("getPayment", "invalidArgument"));
+    return run({
+      operation: "getPayment",
+      codes: GET_PAYMENT_CODES,
+      request: (scope) => paymentCall(scope, input.paymentId),
+      decode: (raw, scope) => {
+        const payment = decodePaymentAnswer(raw, { ...expectationOf2(scope), paymentId: input.paymentId });
+        return payment && { status: "found", payment };
+      }
+    });
+  }
+  async function run(spec) {
+    const scope = await resolveScope(deps.session.current(), spec.operation);
+    if ("failure" in scope) return scope.failure;
+    const sent = await send(scope, spec);
+    if ("failure" in sent) return sent.failure;
+    return spec.decode(sent.answer, scope) ?? failure(spec.operation, "invalidResponse");
+  }
+  async function resolveScope(session, operation) {
+    if (session.kind !== "member") return refused(operation, "authRequired");
+    if (!isRoutePrefix(deps.route.prefix)) return refused(operation, "notProvisioned");
+    const binding = await read(() => deps.binding.current(), operation);
+    if ("failure" in binding) return binding;
+    if (!binding.value || !isBindingFor(binding.value, deps.host)) return refused(operation, "notProvisioned");
+    const member = await expectedMember(session, operation);
+    if ("failure" in member) return member;
+    return { session, binding: binding.value, prefix: deps.route.prefix, memberId: member.memberId };
+  }
+  async function expectedMember(session, operation) {
+    const identity = deps.identity;
+    if (!identity) return { memberId: null };
+    const memberId = await read(() => identity.memberId(session), operation);
+    if ("failure" in memberId) return memberId;
+    return memberId.value ? { memberId: memberId.value } : refused(operation, "authRequired");
+  }
+  async function send(scope, spec) {
+    const transport = deps.transport ?? bridgeTransport();
+    if (!transport) return refused(spec.operation, "notEnabled");
+    if (!isCurrent(scope.session)) return refused(spec.operation, "sessionChanged");
+    const expectation = boundExpectation2(scope.session, deps.transport == null);
+    if (expectation === "refuse") return refused(spec.operation, "notEnabled");
+    const outcome = await attempt2(transport, spec.request(scope), spec, expectation);
+    return isCurrent(scope.session) ? outcome : refused(spec.operation, "sessionChanged");
+  }
+  function boundExpectation2(session, liveHost) {
+    const source = deps.session;
+    if (liveHost && (source.identityBound !== true || !readIdentityBound())) return "refuse";
+    if (typeof source.identity !== "function") return liveHost ? "refuse" : void 0;
+    return source.identity(session) ?? "refuse";
+  }
+  function isCurrent(session) {
+    return deps.session.current().generation === session.generation;
+  }
+  return { startPayment, completePayment, getPayment };
+}
+async function attempt2(transport, call, spec, expectation) {
+  try {
+    const answer = expectation ? await transport.call(call.method, call.path, call.body, call.headers, expectation) : await transport.call(call.method, call.path, call.body, call.headers);
+    return { answer };
+  } catch (error) {
+    return { failure: classifyFailure(error, spec.operation, spec.codes) };
+  }
+}
+async function read(call, operation) {
+  try {
+    return { value: await call() };
+  } catch (error) {
+    return { failure: classifyFailure(error, operation, []) };
+  }
+}
+function refused(operation, kind) {
+  return { failure: failure(operation, kind) };
+}
+function expectationOf2(scope) {
+  return { appId: scope.binding.purchasesAppId, memberId: scope.memberId };
+}
+function refuseProof(transaction) {
+  if (transaction.environment !== "production" && transaction.environment !== "sandbox") return failure("completePayment", "environmentUnsupported");
+  const signed = transaction.signedTransaction;
+  return typeof signed === "string" && signed.length > 0 && signed.length <= MAX_SIGNED_TRANSACTION ? null : failure("completePayment", "invalidArgument");
+}
+function isBindingFor(binding, host) {
+  return binding.himalayaAppId === host.appId && binding.bundleId === host.bundleId && binding.siteId === host.siteId;
+}
+function bridgeTransport() {
+  const himalaya = globalThis.himalaya;
+  const bridge = himalaya ? himalaya.wixApi : void 0;
+  return typeof bridge?.call === "function" ? bridge : void 0;
+}
+var MAX_SIGNED_TRANSACTION = 2e4;
+var START_PAYMENT_CODES = [
+  "NOT_PENDING",
+  "WRONG_PAYMENT_METHOD",
+  "NOT_ORDER_BUYER",
+  "UNSUPPORTED_ORDER",
+  "PRODUCT_NOT_AVAILABLE",
+  "ALREADY_OWNED"
+];
+var COMPLETE_PAYMENT_CODES = [
+  "INVALID_PURCHASE",
+  "OWNED_BY_ANOTHER_CUSTOMER",
+  "PURCHASE_REVOKED",
+  "NOT_PURCHASED",
+  "ZERO_PRICE",
+  "NO_MATCHING_PAYMENT",
+  "PAYMENT_NOT_PENDING",
+  "APP_NOT_CONFIGURED"
+];
+var GET_PAYMENT_CODES = ["NOT_FOUND"];
+
+// ../../core/sdk/iap/src/index.ts
+async function getProducts(productIds) {
+  if (!productIds || productIds.length === 0) return [];
+  const r = await dispatch2("capability.iap.getProducts", {
+    // Product ids are reverse-DNS-ish and never contain commas — comma-join
+    // matches the @himalaya/push list-param convention.
+    productIds: productIds.join(",")
+  });
+  return Array.isArray(r?.products) ? r.products : [];
+}
+async function purchaseForVerification(input) {
+  if (!nonempty2(input?.productId) || !isUUID2(input?.appAccountToken)) return failure2("invalidArgument");
+  const result = await managedDispatch(() => dispatch2("capability.iap.purchaseForVerification", input));
+  if (result?.status === "purchased" && isAppleTransaction(result.transaction)) {
+    return { status: "purchased", transaction: decodeTransaction(result.transaction) };
+  }
+  if (result?.status === "pending" || result?.status === "cancelled") return { status: result.status };
+  return decodeFailure(result);
+}
+async function getUnfinishedTransactions() {
+  const result = await managedDispatch(() => dispatch2("capability.iap.getUnfinishedTransactions"));
+  if (result?.status === "ok" && Array.isArray(result.transactions) && result.transactions.every(isAppleTransaction)) {
+    return { status: "ok", transactions: result.transactions.map(decodeTransaction) };
+  }
+  return decodeFailure(result);
+}
+async function finishTransaction(input) {
+  if (!nonempty2(input?.transactionId)) return failure2("invalidArgument");
+  const result = await managedDispatch(() => dispatch2("capability.iap.finishTransaction", input));
+  if (result?.status === "finished" || result?.status === "notFound") return { status: result.status };
+  return decodeFailure(result);
+}
+var appleManagedStore = { purchaseForVerification, getUnfinishedTransactions, finishTransaction };
+function hostAppBindingSource() {
+  let read2;
+  return {
+    current: () => read2 ?? (read2 = readHostBinding().catch((error) => {
+      read2 = void 0;
+      throw error;
+    }))
+  };
+}
+async function readHostBinding() {
+  let answer;
+  try {
+    answer = await dispatch2("capability.iap.appBinding");
+  } catch (error) {
+    if (bindingNotOffered(error)) return null;
+    throw new Error("the host could not read the app binding");
+  }
+  if (!isObject4(answer)) throw new Error("the host could not read the app binding");
+  if (answer.status === "bound") return decodeBinding(answer.binding);
+  if (answer.status === "unbound" || answer.status === "failed" && answer.code === "unsupported") return null;
+  throw new Error("the host could not read the app binding");
+}
+function bindingNotOffered(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /(unknown|no capability handler for|needs a fixture for)\W[^\n]{0,20}capability\.iap\.appBinding|capability iap not allowed/i.test(message);
+}
+var shared;
+function sharedHostAppBindingSource() {
+  return shared ?? (shared = hostAppBindingSource());
+}
+function decodeBinding(raw) {
+  if (!isObject4(raw)) return null;
+  const { purchasesAppId, himalayaAppId, bundleId, siteId } = raw;
+  if (!isUUID2(purchasesAppId) || !isUUID2(siteId) || !nonempty2(himalayaAppId) || !nonempty2(bundleId)) return null;
+  return { purchasesAppId, himalayaAppId, bundleId, siteId };
+}
+var transactionErrors = /* @__PURE__ */ new Set(["unsupported", "unavailable", "invalidArgument", "invalidResponse", "notEnabled", "unsupportedProductType", "unknownProduct", "verificationFailed", "persistenceFailed", "ownershipConflict", "storeError", "busy"]);
+var failure2 = (code) => ({ status: "failed", code });
+var nonempty2 = (value) => typeof value === "string" && value.trim().length > 0;
+var isUUID2 = (value) => typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value) && value.length === 36;
+var isObject4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+async function managedDispatch(invoke) {
+  try {
+    const value = await invoke();
+    return isObject4(value) ? value : null;
+  } catch {
+    return failure2("unavailable");
+  }
+}
+function decodeFailure(value) {
+  return value?.status === "failed" && transactionErrors.has(value.code) ? failure2(value.code) : failure2("invalidResponse");
+}
+function isAppleTransaction(value) {
+  if (!isObject4(value)) return false;
+  return value.store === "apple" && typeof value.signedTransaction === "string" && /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/.test(value.signedTransaction) && nonempty2(value.transactionId) && nonempty2(value.originalTransactionId) && nonempty2(value.productId) && (value.appAccountToken === null || isUUID2(value.appAccountToken)) && ["production", "sandbox", "xcode", "unknown"].includes(value.environment);
+}
+function decodeTransaction(value) {
+  const { store, signedTransaction, transactionId, originalTransactionId, productId, appAccountToken, environment } = value;
+  return { store, signedTransaction, transactionId, originalTransactionId, productId, appAccountToken, environment };
+}
+
+// ../../stdlib/flows/iap-checkout/src/checkout-source.ts
+var HIMALAYA_SERVE_CHECKOUT_ROUTES = {
+  wixIap: HIMALAYA_SERVE_IAP_ROUTE,
+  cashier: { prefix: HIMALAYA_SERVE_IAP_ROUTE.prefix }
+};
+function appleIapCheckoutRoutes() {
+  return HIMALAYA_SERVE_CHECKOUT_ROUTES;
+}
+
+// ../../stdlib/flows/iap-checkout/src/cashier-charges.ts
+async function ensureAppleIapCharge(bridge, route, orderId) {
+  if (!isRoutePrefix2(route.prefix)) return { status: "notConfigured" };
+  if (!orderId) return { status: "invalidResponse" };
+  const listed = await listOrderCharges(bridge, route, orderId);
+  if (listed.status !== "ok") return listed;
+  return decideFromCharges(listed.charges) ?? chargeThenReconcile(bridge, route, orderId);
+}
+async function listOrderCharges(bridge, route, orderId) {
+  const answer = await bridge.call("GET", chargesPath(route, orderId));
+  if (answer.status !== "ok") return failureOf(answer);
+  const charges = decodeCharges(answer.body);
+  return charges ? { status: "ok", charges } : { status: "invalidResponse" };
+}
+async function chargeThenReconcile(bridge, route, orderId) {
+  const answer = await bridge.call("POST", chargesPath(route, orderId), APPLE_IAP_PAYMENT);
+  if (answer.status === "ok") return chargedFrom(answer.body) ?? reconcile(bridge, route, orderId);
+  if (answer.status === "sessionChanged" || answer.status === "notEnabled") return { status: answer.status };
+  return reconcile(bridge, route, orderId);
+}
+async function reconcile(bridge, route, orderId) {
+  const listed = await listOrderCharges(bridge, route, orderId);
+  if (listed.status !== "ok") return listed;
+  const decided = decideFromCharges(listed.charges);
+  return decided && decided.status !== "closed" ? decided : { status: "invalidResponse" };
+}
+function decideFromCharges(charges) {
+  const live = charges.filter((charge) => !RETRYABLE_AFTER.has(charge.status));
+  if (live.length === 0) return void 0;
+  if (live.some((charge) => CLOSED.has(charge.status))) return { status: "closed" };
+  const apple = live.find((charge) => charge.paymentMethod === APPLE_IAP);
+  if (!apple) return { status: "inOtherPayment" };
+  if (apple.status === "APPROVED") return { status: "approved", transactionId: apple.transactionId };
+  return isAwaitingApple(apple) ? { status: "pending", transactionId: apple.transactionId } : { status: "invalidResponse" };
+}
+function chargedFrom(body) {
+  const charge = isObject5(body) ? decodeCharge(body.charge) : null;
+  return charge && isAwaitingApple(charge) ? { status: "pending", transactionId: charge.transactionId } : null;
+}
+function isAwaitingApple(charge) {
+  return charge.paymentMethod === APPLE_IAP && AWAITING_PAYMENT.has(charge.status);
+}
+function decodeCharges(body) {
+  if (!isObject5(body)) return null;
+  const raw = body.charges ?? [];
+  if (!Array.isArray(raw)) return null;
+  const charges = raw.map(decodeCharge);
+  return charges.every((charge) => charge !== null) ? charges : null;
+}
+function decodeCharge(raw) {
+  if (!isObject5(raw) || !isNonEmpty2(raw.chargeId) || !isNonEmpty2(raw.transactionId)) return null;
+  const state = isObject5(raw.state) && isObject5(raw.state.transactionStatus) ? raw.state.transactionStatus : {};
+  const method = isNonEmpty2(raw.paymentMethodId) ? raw.paymentMethodId : isNonEmpty2(raw.paymentMethod) ? raw.paymentMethod : "";
+  return { chargeId: raw.chargeId, transactionId: raw.transactionId, status: isNonEmpty2(state.status) ? state.status : "UNDEFINED", paymentMethod: method };
+}
+function failureOf(answer) {
+  return answer.status === "http" ? { status: "refused" } : { status: answer.status };
+}
+function chargesPath(route, orderId) {
+  return `${route.prefix}/orders/${encodeURIComponent(orderId)}/charges`;
+}
+function isRoutePrefix2(prefix) {
+  return /^\/[A-Za-z0-9._~\-/]*[A-Za-z0-9._~-]$/.test(prefix);
+}
+function isObject5(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNonEmpty2(value) {
+  return typeof value === "string" && value.length > 0;
+}
+var APPLE_IAP = "appleIAP";
+var APPLE_IAP_PAYMENT = { payment: { details: { paymentMethod: APPLE_IAP } } };
+var AWAITING_PAYMENT = /* @__PURE__ */ new Set(["INITIALIZATION", "INITIALIZED", "IN_PROCESS", "PENDING_BUYER"]);
+var RETRYABLE_AFTER = /* @__PURE__ */ new Set(["DECLINED", "FAILED"]);
+var CLOSED = /* @__PURE__ */ new Set(["BUYER_CANCELED", "TIMEOUT", "VOIDED", "REFUND", "CHARGE_BACK", "OFFLINE"]);
+
+// ../../stdlib/flows/iap-checkout/src/iap-finish-policy.ts
+var COMPLETE_PAYMENT_REFUSALS = {
+  // After recordPurchase (PurchaseMatcher.refusalOf / orphan): the purchase is recorded.
+  NOT_PURCHASED: "refusedFinal",
+  PURCHASE_REVOKED: "refusedFinal",
+  ZERO_PRICE: "refusedFinal",
+  NO_MATCHING_PAYMENT: "refusedFinal",
+  PAYMENT_NOT_PENDING: "refusedFinal",
+  // Before recordPurchase: nothing is recorded. Held pending owner confirmation.
+  INVALID_PURCHASE: "hold",
+  APP_NOT_CONFIGURED: "hold",
+  OWNED_BY_ANOTHER_CUSTOMER: "ownershipConflict"
+};
+function isFinalRefusal(status) {
+  return status === "canceling" || status === "canceled" || status === "refunding" || status === "refunded";
+}
+
+// ../../stdlib/flows/iap-checkout/src/order-refs.ts
+var NEEDS_SUPPORT_HOLD_MS = 6048e5;
+function pruneExpiredHolds(partition, now) {
+  const expired = partition.refs().filter((ref) => HOLDS.has(ref.stage) && now - ref.updatedAt >= NEEDS_SUPPORT_HOLD_MS);
+  return expired.filter((ref) => partition.remove(ref.key)).map((ref) => ref.key);
+}
+var MAX_ORDER_REFS = 16;
+function createWorkerOrderRefStore(storage) {
+  const kv = () => storage ?? hostStorage();
+  function open2(key) {
+    if (!isPartitionKey(key)) return null;
+    const location = partitionKey(key);
+    if (readRefs(kv(), location) === null) return null;
     return {
-      entitled: !!active,
-      planName: active?.planName ?? "",
-      planId: active?.planId ?? ""
+      refs: () => readRefs(kv(), location) ?? [],
+      put: (ref) => writeWith(location, key, (refs) => upsert(refs, ref)),
+      remove: (refKey) => writeWith(location, key, (refs) => refs.filter((stored) => stored.key !== refKey))
     };
+  }
+  function writeWith(location, key, change) {
+    const store = kv();
+    if (!store) return false;
+    const current = readRefs(store, location);
+    const next = current && change(current);
+    if (!next) return false;
+    if (next.length > 0 && !updateIndex(store, key, true)) return false;
+    if (!writeVerified(store, location, serialize({ v: VERSION, refs: next }))) return false;
+    if (next.length === 0) updateIndex(store, key, false);
+    return true;
+  }
+  function hasRefs(app) {
+    if (!isUUID3(app.purchasesAppId) || !isUUID3(app.siteId)) return null;
+    const members = readIndex(kv(), indexKey(app));
+    return members && members.length > 0;
+  }
+  return { open: open2, hasRefs };
+}
+function upsert(refs, ref) {
+  const others = refs.filter((stored) => stored.key !== ref.key);
+  if (others.length < MAX_ORDER_REFS) return [...others, ref];
+  const evictable = others.filter((stored) => EVICTABLE.has(stored.stage)).sort((a, b) => a.updatedAt - b.updatedAt)[0];
+  return evictable ? [...others.filter((stored) => stored !== evictable), ref] : null;
+}
+function updateIndex(store, key, holdsRefs) {
+  const location = indexKey(key);
+  const members = readIndex(store, location);
+  if (members === null) return false;
+  const member = memberKey(key.memberId);
+  const others = members.filter((stored) => stored !== member);
+  const next = holdsRefs ? [...others, member] : others;
+  return next.length === members.length && next.every((m, i) => m === members[i]) || writeVerified(store, location, serialize({ v: VERSION, members: next }));
+}
+function readRefs(store, location) {
+  const parsed = readVersioned(store, location);
+  if (parsed === "empty") return [];
+  if (!parsed || !Array.isArray(parsed.refs) || !parsed.refs.every(isOrderRef)) return null;
+  return parsed.refs;
+}
+function readIndex(store, location) {
+  const parsed = readVersioned(store, location);
+  if (parsed === "empty") return [];
+  if (!parsed || !Array.isArray(parsed.members) || !parsed.members.every(isMemberKey)) return null;
+  return parsed.members;
+}
+function readVersioned(store, location) {
+  if (!store) return null;
+  const raw = safely(() => store.getItem(location));
+  if (raw === void 0) return null;
+  if (raw === null || raw === "") return "empty";
+  const parsed = safely(() => JSON.parse(raw));
+  return isObject6(parsed) && parsed.v === VERSION ? parsed : null;
+}
+function writeVerified(store, location, value) {
+  if (!store) return false;
+  return safely(() => {
+    store.setItem(location, value);
+    return store.getItem(location) === value;
+  }) === true;
+}
+function isOrderRef(value) {
+  if (!isObject6(value) || typeof value.key !== "string" || !STAGES.has(value.stage)) return false;
+  if (typeof value.updatedAt !== "number") return false;
+  const optional = ["kind", "cashierOrderId", "wixTransactionId", "paymentId", "storeProductId", "appProductId", "appleTransactionId", "appAccountToken"];
+  if (!optional.every((field) => value[field] === void 0 || typeof value[field] === "string")) return false;
+  return value.verticalRef === void 0 || isStringMap(value.verticalRef);
+}
+function isPartitionKey(key) {
+  return isUUID3(key.purchasesAppId) && isUUID3(key.siteId) && isUUID3(key.memberId);
+}
+function partitionKey(key) {
+  return `${PREFIX}.${key.purchasesAppId}.${key.siteId}.${memberKey(key.memberId)}`;
+}
+function memberKey(memberId) {
+  const text2 = memberId.toLowerCase();
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0; i < text2.length; i++) {
+    const code = text2.charCodeAt(i);
+    h1 = Math.imul(h1 ^ code, 2654435761);
+    h2 = Math.imul(h2 ^ code, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return `m${(4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16).padStart(14, "0")}`;
+}
+function isMemberKey(value) {
+  return typeof value === "string" && /^m[0-9a-f]{14}$/.test(value);
+}
+function indexKey(app) {
+  return `${PREFIX}.${app.purchasesAppId}.${app.siteId}.members`;
+}
+function hostStorage() {
+  const storage = globalThis.himalaya?.storage;
+  return typeof storage?.getItem === "function" && typeof storage.setItem === "function" ? storage : void 0;
+}
+function safely(read2) {
+  try {
+    return read2();
   } catch {
-    return { entitled: false, planName: "", planId: "" };
+    return void 0;
   }
 }
-var WITHDRAWN = { kind: "failed", reason: "the caller withdrew the charge" };
-async function payOrder(req) {
-  if (!req.snapshotId && !req.cashierUrl) {
-    return { kind: "failed", reason: "no order to settle" };
+function serialize(value) {
+  return JSON.stringify(value);
+}
+function isStringMap(value) {
+  return isObject6(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function isObject6(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isUUID3(value) {
+  return typeof value === "string" && /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(value);
+}
+var VERSION = 1;
+var PREFIX = "himi.iap.wix-checkout.v1";
+var STAGES = /* @__PURE__ */ new Set(["ordered", "charged", "started", "submitted", "held", "needsSupport"]);
+var HOLDS = /* @__PURE__ */ new Set(["held", "needsSupport"]);
+var EVICTABLE = /* @__PURE__ */ new Set(["ordered", "charged", "started"]);
+
+// ../../stdlib/flows/iap-checkout/src/wix-bridge.ts
+function bindBridge(session, provider, bridge) {
+  const isCurrent = () => session.kind === "member" && provider.current().generation === session.generation;
+  async function call(method, path, body) {
+    if (!isCurrent()) return SESSION_CHANGED;
+    const expectation = boundExpectation(session, provider, bridge);
+    if (expectation === "refuse") return { status: "notEnabled" };
+    const outcome = await attempt3(bridge, method, path, body, expectation);
+    return isCurrent() ? outcome : SESSION_CHANGED;
   }
-  const availability = await isAvailable().catch(() => "unavailable");
-  if (availability === "full" && req.snapshotId) {
-    if (req.mayCharge?.() === false) return WITHDRAWN;
-    const r = await proceedToPayment({
-      appId: req.appId,
-      snapshotId: req.snapshotId,
-      msid: req.msid,
-      amount: req.amount,
-      currency: req.currency
-    }).catch(() => ({ status: "failed" }));
-    if (r.status === "paid" || r.status === "pending") {
-      const chargeId = r.chargeId;
-      return {
-        kind: "paid",
-        pending: r.status === "pending",
-        ...typeof chargeId === "string" ? { chargeId } : {}
-      };
+  return { call, isCurrent };
+}
+function hostBridge() {
+  const himalaya = globalThis.himalaya;
+  const bridge = himalaya ? himalaya.wixApi : void 0;
+  return typeof bridge?.call === "function" ? bridge : void 0;
+}
+var MISSING_BRIDGE = { call: () => Promise.reject(new Error("wixApi not enabled")) };
+async function attempt3(bridge, method, path, body, expectation) {
+  try {
+    const answer = expectation ? await bridge.call(method, path, body, void 0, expectation) : await bridge.call(method, path, body);
+    return { status: "ok", body: answer };
+  } catch (error) {
+    return refusalOf(error);
+  }
+}
+function boundExpectation(session, provider, bridge) {
+  const source = provider;
+  const live = isLiveHost(bridge);
+  if (live && (source.identityBound !== true || !readIdentityBound())) return "refuse";
+  if (typeof source.identity !== "function") return live ? "refuse" : void 0;
+  return source.identity(session) ?? "refuse";
+}
+function isLiveHost(bridge) {
+  const api = globalThis.himalaya?.wixApi;
+  return api != null && (bridge === api || bridge.call === api.call);
+}
+function refusalOf(error) {
+  const message = error?.message;
+  const text2 = typeof message === "string" ? message : "";
+  if (BRIDGE_REFUSAL2.test(text2)) return { status: "notEnabled" };
+  if (PRINCIPAL_CHANGED2.test(text2)) return SESSION_CHANGED;
+  const http = /^HTTP (\d{3})(?: \[([^\]]+)\])?:/.exec(text2);
+  if (!http) return { status: "unavailable" };
+  return httpRefusal(Number(http[1]), http[2] ?? "");
+}
+function httpRefusal(httpStatus, code) {
+  if (code === "PRINCIPAL_CHANGED") return SESSION_CHANGED;
+  if (code === "UNAVAILABLE" || httpStatus === 408 || httpStatus === 429 || httpStatus >= 500) return { status: "unavailable" };
+  return { status: "http", httpStatus, code };
+}
+var SESSION_CHANGED = { status: "sessionChanged" };
+var BRIDGE_REFUSAL2 = /^(wixApi not enabled|capability wix_api not allowed)\b|^NotInstalled\(\)$/;
+var PRINCIPAL_CHANGED2 = /^PRINCIPAL_CHANGED\b/;
+
+// ../../stdlib/flows/iap-checkout/src/iap-order-backend.ts
+function createWixOrderBackend(deps) {
+  let cached = null;
+  const now = () => deps.clock.now();
+  const isCurrent = (session) => session.kind === "member" && deps.session.current().generation === session.generation;
+  const adapterFor = (kind) => deps.adapters.find((adapter) => adapter.kind === kind);
+  async function memberOf(session) {
+    if (cached?.generation === session.generation) return cached.member;
+    const binding = await readBinding(deps.binding);
+    if (!isCurrent(session)) return STALE2;
+    if (binding === void 0) return retry("unavailable");
+    if (!binding) return stopWith("rejected", "notConfigured");
+    const memberId = await readMemberId(deps.identity, session);
+    if (!isCurrent(session)) return STALE2;
+    if (memberId === void 0) return retry("unavailable");
+    if (!memberId) return SIGN_IN;
+    const member = memberFor(binding, memberId);
+    cached = { generation: session.generation, member };
+    return member;
+  }
+  function memberFor(binding, memberId) {
+    const partition = deps.refs.open({ purchasesAppId: binding.purchasesAppId, siteId: binding.siteId, memberId });
+    return { memberId, scopeKey: `${binding.purchasesAppId}:${memberId.toLowerCase()}`, partition };
+  }
+  async function getPurchaseContext(session, catalogRef) {
+    const sale = await saleFor(session, catalogRef);
+    if (isStop(sale)) return contextResult(catalogRef, sale);
+    const ordered = await orderFor(sale);
+    if (isStop(ordered)) return contextResult(catalogRef, ordered);
+    const charged = await chargeFor(sale, ordered, { reordered: false });
+    if (isStop(charged)) return contextResult(catalogRef, charged);
+    return startFor(sale, charged);
+  }
+  async function saleFor(session, catalogRef) {
+    const sold = deps.itemFor(catalogRef);
+    const adapter = sold && adapterFor(sold.item.reference.kind);
+    if (!sold || !adapter) return stopWith("rejected", "unsupportedItem");
+    const eligibility = adapter.eligibility(sold.item);
+    if (!eligibility.eligible) return stopWith("rejected", eligibility.reason);
+    const member = await memberOf(session);
+    if (isStop(member)) return member;
+    if (!member.partition) return stopWith("rejected", "storageUnavailable");
+    if (!isCurrent(session)) return STALE2;
+    pruneExpiredHolds(member.partition, now());
+    return {
+      catalogRef,
+      item: sold.item,
+      appleProduct: sold.appleProduct,
+      adapter,
+      member,
+      partition: member.partition,
+      bridge: bindBridge(session, deps.session, deps.bridge)
+    };
+  }
+  async function orderFor(sale) {
+    const existing = refAt(sale.partition, sale.catalogRef);
+    if (existing?.stage === "submitted") return stopWith("rejected", "paymentInProgress");
+    if (existing?.stage === "held") return stopWith("rejected", "paymentHeld");
+    if (existing?.stage === "needsSupport") return stopWith("rejected", "needsSupport");
+    if (deps.productBusy?.(sale.appleProduct.productId)) return stopWith("rejected", "paymentInProgress");
+    const attempt4 = existing?.cashierOrderId && existing.verticalRef ? await reopenOrOpen(sale, { cashierOrderId: existing.cashierOrderId, verticalRef: existing.verticalRef }) : await sale.adapter.openOrder(sale.item, sale.bridge);
+    return recordOrder(sale, existing, attempt4);
+  }
+  async function reopenOrOpen(sale, order) {
+    const reopened = await sale.adapter.reopenOrder(order, sale.bridge);
+    const closed = reopened.status === "refused" && reopened.reason === "orderClosed";
+    return closed ? sale.adapter.openOrder(sale.item, sale.bridge) : reopened;
+  }
+  function recordOrder(sale, existing, attempt4) {
+    if (attempt4.status === "granted") return alreadyOwned(sale);
+    if (attempt4.status === "refused") return stopWith("rejected", attempt4.reason);
+    if (attempt4.status !== "open") return attempt4.status === "sessionChanged" ? STALE2 : retry("unavailable");
+    const kept = existing && existing.cashierOrderId === attempt4.cashierOrderId ? existing : { key: sale.catalogRef, updatedAt: 0 };
+    return persist(sale, {
+      ...kept,
+      key: sale.catalogRef,
+      stage: "ordered",
+      kind: sale.adapter.kind,
+      verticalRef: attempt4.verticalRef,
+      cashierOrderId: attempt4.cashierOrderId,
+      updatedAt: now()
+    });
+  }
+  async function chargeFor(sale, ref, options) {
+    const charge = await ensureAppleIapCharge(sale.bridge, deps.cashier, ref.cashierOrderId ?? "");
+    switch (charge.status) {
+      case "pending":
+        return persist(sale, { ...ref, stage: "charged", wixTransactionId: charge.transactionId, updatedAt: now() });
+      case "approved":
+        return alreadyPaid(sale, ref);
+      case "closed":
+        return options.reordered ? stopWith("rejected", "orderClosed") : reorder(sale);
+      case "inOtherPayment":
+        return stopWith("rejected", "orderRefused");
+      case "refused":
+        return stopWith("rejected", "chargeFailed");
+      case "notConfigured":
+      case "notEnabled":
+        return stopWith("rejected", "notConfigured");
+      case "sessionChanged":
+        return STALE2;
+      default:
+        return retry("unavailable");
     }
-    if (r.status === "cancelled") return { kind: "cancelled" };
   }
-  if (req.cashierUrl) {
-    const url = await req.cashierUrl().catch(() => void 0);
-    if (url) {
-      if (req.mayCharge?.() === false) return WITHDRAWN;
-      const opened = await open(url, "in_app_browser").catch(() => ({ opened: false }));
-      if (opened.opened) return { kind: "handoff" };
+  async function reorder(sale) {
+    if (!forget(sale, sale.catalogRef)) return stopWith("rejected", "storageUnavailable");
+    const recorded = recordOrder(sale, void 0, await sale.adapter.openOrder(sale.item, sale.bridge));
+    return isStop(recorded) ? recorded : chargeFor(sale, recorded, { reordered: true });
+  }
+  async function alreadyPaid(sale, ref) {
+    const access = await sale.adapter.readAccess(ref.verticalRef ?? {}, sale.bridge);
+    if (access === "granted") return alreadyOwned(sale);
+    if (access === "sessionChanged") return STALE2;
+    return access === "unavailable" ? retry("unavailable") : stopWith("rejected", "paymentInProgress");
+  }
+  async function startFor(sale, ref) {
+    if (!sale.bridge.isCurrent()) return contextResult(sale.catalogRef, STALE2);
+    const started = await deps.wixIap.startPayment({ wixTransactionId: ref.wixTransactionId ?? "" });
+    if (!sale.bridge.isCurrent()) return contextResult(sale.catalogRef, STALE2);
+    if (started.status !== "started") return contextResult(sale.catalogRef, await startRefusal(sale, ref, started));
+    const mismatch = startedMismatch(sale, started);
+    if (mismatch) return contextResult(sale.catalogRef, stopWith("rejected", mismatch));
+    const recorded = persist(sale, {
+      ...ref,
+      stage: "started",
+      paymentId: started.payment.paymentId,
+      storeProductId: started.storeProductId,
+      appAccountToken: started.appAccountToken.toLowerCase(),
+      ...started.payment.appProductId ? { appProductId: started.payment.appProductId } : {},
+      updatedAt: now()
+    });
+    if (isStop(recorded)) return contextResult(sale.catalogRef, recorded);
+    return { status: "ok", context: { productId: started.storeProductId, appAccountToken: started.appAccountToken, scopeKey: sale.member.scopeKey } };
+  }
+  function startedMismatch(sale, started) {
+    return sale.appleProduct.productId === started.storeProductId ? null : "productChanged";
+  }
+  async function startRefusal(sale, ref, failure3) {
+    if (failure3.kind !== "application") return failureStop(failure3);
+    if (failure3.code === "ALREADY_OWNED") return alreadyPaid(sale, ref);
+    if (failure3.code === "NOT_PENDING" || failure3.code === "NOT_ORDER_BUYER") forget(sale, sale.catalogRef);
+    return stopWith("rejected", failure3.code === "NOT_PENDING" ? "orderClosed" : "paymentRefused");
+  }
+  function alreadyOwned(sale) {
+    forget(sale, sale.catalogRef);
+    return stopWith("rejected", "alreadyOwned");
+  }
+  function persist(sale, ref) {
+    if (!sale.bridge.isCurrent()) return STALE2;
+    return sale.partition.put(ref) ? ref : stopWith("rejected", "storageUnavailable");
+  }
+  function forget(sale, key) {
+    return sale.bridge.isCurrent() && sale.partition.remove(key);
+  }
+  function contextResult(catalogRef, stop) {
+    if (stop.failure) deps.report({ key: catalogRef, failure: stop.failure });
+    return { status: stop.result };
+  }
+  async function submitProof(session, transaction) {
+    const member = await memberOf(session);
+    if (isStop(member)) return { status: member.result };
+    if (!isCurrent(session)) return RETRYABLE;
+    const completed = await deps.wixIap.completePayment(transaction);
+    if (!isCurrent(session)) return RETRYABLE;
+    const proof = { session, transaction, member, acknowledgement: acknowledgementOf(transaction, member.scopeKey) };
+    return completed.status === "matched" ? matchedProof(proof, completed.payment) : refusedProof(proof, completed);
+  }
+  async function matchedProof(proof, payment) {
+    const refs = proof.member.partition?.refs() ?? [];
+    const ref = refs.find((stored) => stored.paymentId === payment.paymentId) ?? refs.find((stored) => stored.wixTransactionId === payment.wixTransactionId) ?? refByToken(refs, proof.transaction);
+    if (ref?.storeProductId && ref.storeProductId !== proof.transaction.productId) return holdAssociation(ref);
+    const tracking = trackingRef(ref, payment, proof.transaction, now());
+    if (isFinalRefusal(payment.status)) return finalRefusal(proof, tracking);
+    if (payment.status === "pending") return RETRYABLE;
+    if (payment.status === "approved") {
+      const granted = await accessGranted(proof, tracking);
+      if (granted === "stale") return RETRYABLE;
+      if (granted) return processed(proof, tracking);
     }
+    return acceptTracking(proof, tracking, payment);
+  }
+  function holdAssociation(ref) {
+    deps.report({ key: ref.key, failure: "invalidAssociation" });
+    return { status: "rejected" };
+  }
+  async function accessGranted(proof, ref) {
+    const adapter = adapterFor(ref.kind);
+    if (!adapter || !ref.verticalRef) return false;
+    const bridge = bindBridge(proof.session, deps.session, deps.bridge);
+    const access = await adapter.readAccess(ref.verticalRef, bridge);
+    if (!bridge.isCurrent()) return "stale";
+    return access === "granted";
+  }
+  function processed(proof, ref) {
+    proof.member.partition?.remove(ref.key);
+    deps.report({ key: ref.key, access: "granted" });
+    return { status: "processed", acknowledgement: proof.acknowledgement };
+  }
+  function acceptTracking(proof, ref, payment) {
+    const partition = proof.member.partition;
+    if (!partition || !isCurrent(proof.session) || !partition.put(ref)) return RETRYABLE;
+    deps.report({ key: ref.key, access: !ref.kind && payment.status === "approved" ? "accessUnknown" : "processing" });
+    return { status: "accepted", acknowledgement: proof.acknowledgement };
+  }
+  function finalRefusal(proof, ref) {
+    const hold = ref ?? unassociatedHold(proof.transaction, now());
+    const partition = proof.member.partition;
+    const stored = { ...hold, stage: "needsSupport", appleTransactionId: proof.transaction.transactionId, updatedAt: now() };
+    if (!partition || !isCurrent(proof.session) || !partition.put(stored)) return RETRYABLE;
+    deps.report({ key: hold.key, access: "needsSupport" });
+    return { status: "refusedFinal", acknowledgement: proof.acknowledgement };
+  }
+  function refusedProof(proof, failure3) {
+    const refusal = failure3.kind === "application" ? COMPLETE_PAYMENT_REFUSALS[failure3.code] : failureStop(failure3).result;
+    if (refusal === "refusedFinal") return finalRefusal(proof, startedRefFor(proof));
+    if (refusal === "hold" || refusal === "rejected") return heldProof(proof, "rejected");
+    return refusal === "ownershipConflict" ? heldProof(proof, "ownershipConflict") : { status: refusal };
+  }
+  function heldProof(proof, status) {
+    const started = startedRefFor(proof);
+    const hold = started && { ...started, stage: "held", appleTransactionId: proof.transaction.transactionId, updatedAt: now() };
+    if (hold && !(isCurrent(proof.session) && proof.member.partition?.put(hold))) return RETRYABLE;
+    deps.report({ key: started?.key ?? `payment:${proof.transaction.transactionId}`, failure: "paymentHeld" });
+    return { status };
+  }
+  function startedRefFor(proof) {
+    const refs = proof.member.partition?.refs() ?? [];
+    const { productId, transactionId } = proof.transaction;
+    const holding = refs.find((ref) => (ref.stage === "held" || ref.stage === "needsSupport") && ref.appleTransactionId === transactionId);
+    if (holding) return holding;
+    if (proof.transaction.appAccountToken) return refByToken(refs, proof.transaction);
+    return refs.filter((ref) => ref.stage === "started" && ref.storeProductId === productId).reduce((newest, ref) => !newest || ref.updatedAt >= newest.updatedAt ? ref : newest, void 0);
   }
+  async function getMemberContext(session) {
+    const member = await memberOf(session);
+    if (isStop(member)) return { status: member.result };
+    return { status: "ok", context: { scopeKey: member.scopeKey } };
+  }
+  return { getPurchaseContext, getMemberContext, submitProof };
+}
+var RETRYABLE = { status: "retryable" };
+var STALE2 = { stop: true, result: "retryable" };
+function stopWith(result, failure3) {
+  return { stop: true, result, failure: failure3 };
+}
+function retry(failure3) {
+  return stopWith("retryable", failure3);
+}
+function isStop(value) {
+  return typeof value === "object" && value !== null && value.stop === true;
+}
+function failureStop(failure3) {
+  if (failure3.kind === "application") return stopWith("rejected", "notConfigured");
+  return KIND_STOPS[failure3.kind];
+}
+var SIGN_IN = { stop: true, result: "authRequired", failure: "signInRequired" };
+var NOT_CONFIGURED = { stop: true, result: "rejected", failure: "notConfigured" };
+var UNAVAILABLE = { stop: true, result: "retryable", failure: "unavailable" };
+var KIND_STOPS = {
+  authRequired: SIGN_IN,
+  notPermitted: SIGN_IN,
+  notEnabled: NOT_CONFIGURED,
+  notProvisioned: NOT_CONFIGURED,
+  environmentUnsupported: NOT_CONFIGURED,
+  invalidArgument: NOT_CONFIGURED,
+  sessionChanged: STALE2,
+  unavailable: UNAVAILABLE,
+  unrecognized: UNAVAILABLE,
+  invalidResponse: UNAVAILABLE
+};
+function trackingRef(ref, payment, transaction, updatedAt) {
+  const ids = { paymentId: payment.paymentId, wixTransactionId: payment.wixTransactionId, appleTransactionId: transaction.transactionId, updatedAt };
+  if (ref) return { ...ref, ...ids, stage: "submitted" };
   return {
-    kind: "failed",
-    reason: availability === "full" ? "the wallet declined and no in-app cashier is configured" : "no payment rail is available"
+    key: `payment:${payment.paymentId}`,
+    stage: "submitted",
+    storeProductId: transaction.productId,
+    ...payment.appProductId ? { appProductId: payment.appProductId } : {},
+    ...ids
+  };
+}
+function unassociatedHold(transaction, updatedAt) {
+  return { key: `payment:${transaction.transactionId}`, stage: "needsSupport", storeProductId: transaction.productId, appleTransactionId: transaction.transactionId, updatedAt };
+}
+function acknowledgementOf(transaction, scopeKey) {
+  return { transactionId: transaction.transactionId, productId: transaction.productId, environment: transaction.environment, scopeKey };
+}
+function refAt(partition, key) {
+  return partition.refs().find((ref) => ref.key === key);
+}
+async function readMemberId(identity, session) {
+  try {
+    return await identity.memberId(session);
+  } catch {
+    return void 0;
+  }
+}
+function refByToken(refs, transaction) {
+  const token = transaction.appAccountToken?.toLowerCase();
+  return token ? refs.find((ref) => ref.appAccountToken === token) : void 0;
+}
+async function readBinding(source) {
+  try {
+    return await source.current();
+  } catch {
+    return void 0;
+  }
+}
+
+// ../../stdlib/flows/iap-checkout/src/apple-iap-core.ts
+function createAppleIapCheckoutWith(deps) {
+  return deps.enabled ? enabledCheckout(deps) : disabledCheckout();
+}
+var ASK_TO_BUY_HOLD_MS = 60 * 6e4;
+function enabledCheckout(deps) {
+  const refs = deps.refs ?? createWorkerOrderRefStore();
+  const bridge = deps.bridge ?? hostBridge() ?? MISSING_BRIDGE;
+  const sales = /* @__PURE__ */ new Map();
+  const payments = /* @__PURE__ */ new Map();
+  const readGrants = /* @__PURE__ */ new Set();
+  const accessReads = /* @__PURE__ */ new Map();
+  let current = { item: null, failure: null, buying: false };
+  let generation = deps.session.current().generation;
+  let disposed = false;
+  let tracking = Promise.resolve();
+  let partitionRead = null;
+  const awaitingApproval = /* @__PURE__ */ new Map();
+  const backend = createWixOrderBackend({
+    wixIap: deps.wixIap,
+    identity: deps.identity,
+    binding: deps.binding,
+    session: deps.session,
+    clock: deps.clock,
+    cashier: deps.cashier,
+    adapters: deps.adapters,
+    refs,
+    bridge,
+    itemFor: (key) => sales.get(key),
+    productBusy,
+    report: onEvent
+  });
+  const coordinator = createPurchaseCoordinator({
+    store: deps.store ?? appleManagedStore,
+    backend,
+    session: deps.session,
+    clock: deps.clock,
+    jitter: deps.jitter,
+    onState: publish,
+    onAwaitingApproval: reserveAskToBuy
+  });
+  async function start() {
+    resetIfSessionChanged();
+    await coordinator.start();
+    await trackPayments({ dueOnly: false });
+    return state();
+  }
+  async function checkAccess(items) {
+    resetIfSessionChanged();
+    const session = deps.session.current();
+    if (session.kind !== "member") return state();
+    for (const item of items) {
+      const key = itemKey(item);
+      const adapter = deps.adapters.find((candidate) => candidate.kind === item.reference.kind);
+      if (!adapter?.currentAccess || payments.has(key) && payments.get(key).access !== "granted" && !readGrants.has(key)) continue;
+      const seq = (accessReads.get(key) ?? 0) + 1;
+      accessReads.set(key, seq);
+      const access = await adapter.currentAccess(item, bindBridge(session, deps.session, bridge)).catch(() => "unavailable");
+      if (deps.session.current().generation !== session.generation) break;
+      if (accessReads.get(key) !== seq) continue;
+      if (access === "granted") {
+        setPayment(key, "granted");
+        readGrants.add(key);
+      } else if (access === "none" && readGrants.delete(key)) {
+        payments.delete(key);
+      }
+    }
+    return publishAndReturn();
+  }
+  async function buy(item) {
+    resetIfSessionChanged();
+    const key = itemKey(item);
+    const appleProduct = settledAppleProduct(item);
+    current = { item: key, failure: appleProduct ? null : "notAppleRoute", buying: false };
+    if (!appleProduct) return publishAndReturn();
+    sales.set(key, { item, appleProduct });
+    current.buying = true;
+    publish();
+    await coordinator.purchase(key);
+    if (current.item === key) current.buying = false;
+    return publishAndReturn();
+  }
+  async function reconcile2() {
+    resetIfSessionChanged();
+    await coordinator.reconcile();
+    await trackPayments({ dueOnly: false });
+    return state();
+  }
+  async function retry2() {
+    resetIfSessionChanged();
+    await coordinator.retry();
+    await trackPayments({ dueOnly: false });
+    return state();
+  }
+  async function tick() {
+    resetIfSessionChanged();
+    await coordinator.tick();
+    await trackPayments({ dueOnly: true });
+    return state();
+  }
+  function state() {
+    if (disposed || deps.session.current().generation !== generation) return blankState(true);
+    const purchase = coordinator.getState();
+    const progress = [...payments.values()].map(({ item, access, nextAttemptAt }) => ({ item, access, nextAttemptAt }));
+    return {
+      enabled: true,
+      phase: phaseOf(purchase, progress),
+      item: current.item,
+      failure: current.failure,
+      purchase,
+      payments: progress,
+      nextWakeAt: earliest([purchase.nextWakeAt, partitionRead?.nextAttemptAt ?? null, ...progress.map((payment) => payment.nextAttemptAt)])
+    };
+  }
+  function dispose() {
+    disposed = true;
+    coordinator.dispose();
+  }
+  function settledAppleProduct(item) {
+    return deps.pricing.view(item.reference).route === "appleIap" ? deps.pricing.appleProduct(item.reference) : null;
+  }
+  function onEvent(event) {
+    resetIfSessionChanged();
+    const owned = event.failure === "alreadyOwned";
+    const access = owned ? "granted" : event.access;
+    const failure3 = owned ? void 0 : event.failure;
+    if (access) setPayment(event.key, access);
+    if (owned) readGrants.add(event.key);
+    if (labelOf(event.key) === current.item && (failure3 || access)) current.failure = failure3 ?? failureOfAccess(access);
+  }
+  function setPayment(key, access) {
+    const due = access === "processing" ? deps.clock.now() + BASE_DELAY_MS : null;
+    payments.set(key, { key, item: labelOf(key), access, attempts: 0, nextAttemptAt: due });
+  }
+  function phaseOf(purchase, progress) {
+    const mine = progress.find((payment) => payment.item === current.item);
+    if (mine?.access === "granted") return "accessReady";
+    if (current.failure) return "refused";
+    if (OVERLAY_PHASES.has(purchase.phase)) return purchase.phase;
+    if (current.buying) return "preparing";
+    if (mine?.access === "processing" || purchase.items.some(isInFlight)) return "processing";
+    if (!current.item && progress.some((payment) => payment.access === "processing")) return "processing";
+    return "idle";
+  }
+  function reserveAskToBuy(productId) {
+    awaitingApproval.set(productId, { items: itemsFor(productId).length, since: deps.clock.now() });
+  }
+  function productBusy(productId) {
+    const items = itemsFor(productId);
+    const pending = awaitingApproval.get(productId);
+    if (pending && (items.length > pending.items || deps.clock.now() - pending.since >= ASK_TO_BUY_HOLD_MS)) {
+      awaitingApproval.delete(productId);
+    }
+    return awaitingApproval.has(productId) || items.some(isUnfinished);
+  }
+  function itemsFor(productId) {
+    return coordinator.getState().items.filter((held) => held.productId === productId);
+  }
+  function resetIfSessionChanged() {
+    const next = deps.session.current().generation;
+    if (next === generation) return;
+    generation = next;
+    sales.clear();
+    payments.clear();
+    readGrants.clear();
+    awaitingApproval.clear();
+    partitionRead = null;
+    current = { item: null, failure: null, buying: false };
+  }
+  function publish() {
+    if (!disposed && deps.session.current().generation === generation) deps.onState?.(state());
+  }
+  function publishAndReturn() {
+    publish();
+    return state();
+  }
+  function trackPayments(options) {
+    const run = tracking.then(() => trackOnce(options));
+    tracking = run.catch(() => void 0);
+    return run;
+  }
+  async function trackOnce(options) {
+    resetIfSessionChanged();
+    const session = deps.session.current();
+    if (session.kind !== "member" || options.dueOnly && !anyDue()) return;
+    if (!options.dueOnly) partitionRead = null;
+    const tracked = await trackedPartition(session);
+    if (!isCurrent(session)) return;
+    if (tracked === "none") return;
+    if (!tracked) return backOffDue();
+    partitionRead = null;
+    for (const key of pruneExpiredHolds(tracked.partition, deps.clock.now())) payments.delete(key);
+    for (const ref of tracked.partition.refs()) {
+      if (!isCurrent(session)) return;
+      if (ref.stage === "needsSupport") setPayment(ref.key, "needsSupport");
+      if (ref.stage !== "submitted" || !ref.paymentId) continue;
+      if (!options.dueOnly) restartBudget(ref.key);
+      if (isDue(ref.key, options.dueOnly)) await trackOne(session, tracked.partition, ref);
+    }
+    publish();
+  }
+  async function trackedPartition(session) {
+    const binding = await bindingOf(deps.binding);
+    if (!binding || !isCurrent(session)) return binding === null ? "none" : null;
+    const stored = refs.hasRefs(binding);
+    if (stored !== true) return stored === false ? "none" : null;
+    const memberId = await memberIdOf(session);
+    if (!memberId || !isCurrent(session)) return null;
+    const partition = refs.open({ purchasesAppId: binding.purchasesAppId, siteId: binding.siteId, memberId });
+    return partition && { partition };
+  }
+  async function memberIdOf(session) {
+    try {
+      return await deps.identity.memberId(session);
+    } catch {
+      return null;
+    }
+  }
+  function backOffDue() {
+    const attempts = (partitionRead?.attempts ?? 0) + 1;
+    partitionRead = { attempts, nextAttemptAt: attempts >= MAX_AUTOMATIC_ATTEMPTS ? null : deps.clock.now() + backoffDelay(attempts, deps.jitter) };
+    for (const payment of payments.values()) {
+      if (payment.access !== "processing" || !isDue(payment.key, true)) continue;
+      const attempts2 = payment.attempts + 1;
+      const nextAttemptAt = attempts2 >= MAX_AUTOMATIC_ATTEMPTS ? null : deps.clock.now() + backoffDelay(attempts2, deps.jitter);
+      Object.assign(payment, { attempts: attempts2, nextAttemptAt });
+    }
+    publish();
+  }
+  function anyDue() {
+    const readDue = partitionRead?.nextAttemptAt != null && partitionRead.nextAttemptAt <= deps.clock.now();
+    return readDue || [...payments.values()].some((payment) => payment.access === "processing" && isDue(payment.key, true));
+  }
+  async function trackOne(session, partition, ref) {
+    const read2 = await deps.wixIap.getPayment({ paymentId: ref.paymentId ?? "" });
+    if (!isCurrent(session)) return;
+    if (read2.status !== "found") return read2.kind === "application" ? markNeedsSupport(partition, ref) : backOff(partition, ref, false);
+    await settlePayment(session, partition, ref, read2.payment);
+  }
+  async function settlePayment(session, partition, ref, payment) {
+    if (isFinalRefusal(payment.status)) return markNeedsSupport(partition, ref);
+    if (payment.status !== "approved") return backOff(partition, ref, false);
+    if (!ref.kind) return settleUnassociated(partition, ref);
+    const access = await accessOf2(session, ref);
+    if (!isCurrent(session)) return;
+    if (access === "granted") return grant(partition, ref);
+    backOff(partition, ref, access === "none");
+  }
+  function grant(partition, ref) {
+    partition.remove(ref.key);
+    setPayment(ref.key, "granted");
+  }
+  function settleUnassociated(partition, ref) {
+    partition.remove(ref.key);
+    setPayment(ref.key, "accessUnknown");
+  }
+  async function accessOf2(session, ref) {
+    const adapter = deps.adapters.find((candidate) => candidate.kind === ref.kind);
+    if (!adapter || !ref.verticalRef) return "unavailable";
+    return adapter.readAccess(ref.verticalRef, bindBridge(session, deps.session, bridge));
+  }
+  function markNeedsSupport(partition, ref) {
+    partition.put({ ...ref, stage: "needsSupport", updatedAt: deps.clock.now() });
+    setPayment(ref.key, "needsSupport");
+    if (labelOf(ref.key) === current.item) current.failure = "needsSupport";
+  }
+  function backOff(partition, ref, approvedWithoutAccess) {
+    const payment = payments.get(ref.key) ?? newTracked(ref.key);
+    const attempts = payment.attempts + 1;
+    const exhausted = attempts >= MAX_AUTOMATIC_ATTEMPTS;
+    if (exhausted && approvedWithoutAccess) return markNeedsSupport(partition, ref);
+    const nextAttemptAt = exhausted ? null : deps.clock.now() + backoffDelay(attempts, deps.jitter);
+    payments.set(ref.key, { ...payment, access: "processing", attempts, nextAttemptAt });
+  }
+  function restartBudget(key) {
+    const payment = payments.get(key);
+    if (payment?.access === "processing") Object.assign(payment, { attempts: 0, nextAttemptAt: deps.clock.now() });
+  }
+  function isDue(key, dueOnly) {
+    const nextAttemptAt = payments.get(key)?.nextAttemptAt;
+    return !dueOnly || nextAttemptAt === void 0 || nextAttemptAt !== null && nextAttemptAt <= deps.clock.now();
+  }
+  function newTracked(key) {
+    return { key, item: labelOf(key), access: "processing", attempts: 0, nextAttemptAt: null };
+  }
+  function isCurrent(session) {
+    return !disposed && deps.session.current().generation === session.generation;
+  }
+  return { start, buy, checkAccess, reconcile: reconcile2, retry: retry2, tick, state, dispose };
+}
+function notEnabledState() {
+  return blankState(false);
+}
+function disabledCheckout() {
+  const state = () => blankState(false);
+  const resolved = () => Promise.resolve(state());
+  return { start: resolved, buy: resolved, checkAccess: resolved, reconcile: resolved, retry: resolved, tick: resolved, state, dispose: () => {
+  } };
+}
+function blankState(enabled) {
+  return {
+    enabled,
+    phase: enabled ? "idle" : "notEnabled",
+    item: null,
+    failure: null,
+    payments: [],
+    nextWakeAt: null,
+    purchase: { phase: "idle", errorCode: null, items: [], unfinishedCount: null, nextWakeAt: null }
+  };
+}
+function isUnfinished(item) {
+  return item.completion === "pending" || item.completion === "retryRequired";
+}
+function isInFlight(item) {
+  if (item.completion === "finished") return false;
+  return item.access === "processing" || item.access === "confirming" || item.access === "pending" || item.access === "waitingToRetry";
+}
+function itemKey(item) {
+  return `${item.reference.kind}:${item.reference.id}`;
+}
+function labelOf(key) {
+  return key.startsWith("payment:") ? "payment" : key;
+}
+function backoffDelay(attempts, jitter) {
+  const base = Math.min(BASE_DELAY_MS * 2 ** (attempts - 1), MAX_RETRY_DELAY_MS);
+  return base + Math.max(0, jitter?.(base) ?? 0);
+}
+function earliest(times) {
+  const due = times.filter((time) => time !== null);
+  return due.length > 0 ? Math.min(...due) : null;
+}
+async function bindingOf(source) {
+  try {
+    return await source.current();
+  } catch {
+    return void 0;
+  }
+}
+function failureOfAccess(access) {
+  return access === "needsSupport" ? "needsSupport" : null;
+}
+var BASE_DELAY_MS = 1e3;
+var OVERLAY_PHASES = /* @__PURE__ */ new Set(["purchasing", "awaitingApproval", "cancelled", "signInRequired", "unavailable"]);
+
+// ../../stdlib/flows/iap-checkout/src/purchase-fields.ts
+function iapPurchaseFields(view, state, readiness, copy) {
+  const key = `${view.reference.kind}:${view.reference.id}`;
+  if (view.route !== "appleIap" && !holdsSale(state, key)) return { ...action(copy, "enabled", ""), appleRoute: false };
+  if (readiness.status !== "ready") return action(copy, "disabled", readiness.status === "checking" ? "" : copy.unavailable);
+  const own = state.item === key;
+  const payment = state.payments.find((tracked) => tracked.item === key)?.access;
+  if (own && state.phase === "accessReady" || payment === "granted") return { ...action(copy, "disabled", ""), accessReady: true };
+  if (IN_FLIGHT.has(state.phase)) return action(copy, "busy", own ? copy.processing : "");
+  if (own) return outcomeAction(state, copy);
+  if (payment === "processing") return action(copy, "busy", copy.processing);
+  if (payment === "needsSupport") return action(copy, "disabled", copy.support);
+  return action(copy, "enabled", "");
+}
+function holdsSale(state, key) {
+  if (state.payments.some((tracked) => tracked.item === key)) return true;
+  return state.item === key && (SALE_PHASES.has(state.phase) || state.purchase.phase === "awaitingApproval");
+}
+function outcomeAction(state, copy) {
+  if (state.purchase.phase === "awaitingApproval") return action(copy, "disabled", copy.awaitingApproval);
+  switch (state.phase) {
+    case "awaitingApproval":
+      return action(copy, "disabled", copy.awaitingApproval);
+    case "signInRequired":
+      return action(copy, "disabled", copy.signInRequired);
+    case "unavailable":
+      return action(copy, "enabled", copy.retry);
+    case "refused":
+      return refusalAction(state.failure, copy);
+    case "notEnabled":
+      return action(copy, "disabled", copy.unavailable);
+    default:
+      return action(copy, "enabled", "");
+  }
+}
+function refusalAction(failure3, copy) {
+  const [mode, note] = REFUSALS[failure3 ?? "unavailable"] ?? ["enabled", "retry"];
+  return action(copy, mode, note ? copy[note] : "");
+}
+function action(copy, mode, note) {
+  return { appleRoute: true, accessReady: false, buyLabel: copy.buy, buyDisabled: mode !== "enabled", buyBusy: mode === "busy", buyNote: note };
+}
+var IN_FLIGHT = /* @__PURE__ */ new Set(["preparing", "purchasing", "processing"]);
+var SALE_PHASES = /* @__PURE__ */ new Set([...IN_FLIGHT, "awaitingApproval", "accessReady"]);
+var REFUSALS = {
+  productChanged: ["enabled", "priceChanged"],
+  paymentHeld: ["disabled", "support"],
+  needsSupport: ["disabled", "support"],
+  invalidAssociation: ["disabled", "support"],
+  // Nothing in the checkout clears this, so the action stays tappable: a tap re-reads the order
+  // (never a second charge) and turns into access once the vertical grants it.
+  paymentInProgress: ["enabled", "processing"],
+  approvalRequired: ["disabled", "awaitingApproval"],
+  signInRequired: ["disabled", "signInRequired"],
+  notConfigured: ["disabled", "unavailable"],
+  notEnabled: ["disabled", "unavailable"],
+  storageUnavailable: ["disabled", "unavailable"],
+  unsupportedItem: ["disabled", "unavailable"],
+  // The action shows only on an App Store route, so a refusal for any other route is stale.
+  notAppleRoute: ["enabled", null]
+};
+
+// ../../stdlib/flows/iap-checkout/src/commerce-core.ts
+function createIapCommerceWith(deps) {
+  let readiness = { status: "checking" };
+  let checkout;
+  let opening;
+  let disposed = false;
+  let armedInterval = null;
+  let lastPollAt = null;
+  let lastPricedAt = null;
+  let pricedItems = null;
+  let lastScopeComplete = true;
+  let stopWatchingSession;
+  let stopWatchingAccess;
+  let checkoutStarted = false;
+  let recheckAfterOpening = false;
+  async function loadPrices(items) {
+    if (!deps.pricing.enabled) return { scopeComplete: true };
+    lastPricedAt = deps.clock.now();
+    pricedItems = items;
+    const [identity, read2] = await Promise.all([deps.host.identity(), deps.binding.current().then((binding) => ({ binding }), () => null)]);
+    const scope = read2 ? catalogScope(identity, read2.binding) : { appId: "", bundleId: "" };
+    await deps.pricing.load({ scope, platform: identity?.platform ?? "", items });
+    lastScopeComplete = identity !== null && read2 !== null;
+    if (checkout) await checkAccess(checkout);
+    return { scopeComplete: lastScopeComplete };
+  }
+  function pollDirective(action2) {
+    const interval = checkout?.state().nextWakeAt != null ? DUE_WORK_POLL_MS : deps.pricing.enabled || checkout ? PRICE_REFRESH_MS : null;
+    if (interval === null || interval === armedInterval) return void 0;
+    armedInterval = interval;
+    lastPollAt ?? (lastPollAt = deps.clock.now());
+    return { id: POLL_ID2, action: action2, intervalMs: interval, immediate: true };
+  }
+  async function poll() {
+    const now = deps.clock.now();
+    const suspended = lastPollAt !== null && now - lastPollAt > SUSPENDED_AFTER_MS;
+    lastPollAt = now;
+    await (suspended ? reconcile2() : checkout ? checkout.tick() : startedCheckout());
+    if (pricedItems && lastPricedAt !== null && now - lastPricedAt >= PRICE_REFRESH_MS - PRICE_REFRESH_SLACK_MS) await loadPrices(pricedItems);
+  }
+  function reconcile2() {
+    return recover((opened) => opened.reconcile());
+  }
+  function start() {
+    return recover((opened) => opened.start());
+  }
+  async function buy(item) {
+    if (unanswered2(deps.pricing.view(item.reference))) return state();
+    const started = await startedCheckout();
+    return started ? started.opened.buy(item) : state();
+  }
+  function purchaseFields(reference, copy) {
+    const view = deps.pricing.view(reference);
+    const fields = iapPurchaseFields({ ...view, route: deps.pricing.continueCheckoutGuard(reference).route }, state(), readiness, copy);
+    if (!fields.appleRoute || fields.accessReady || fields.buyDisabled) return fields;
+    if (deps.session.current().kind !== "member") return { ...fields, buyDisabled: true, buyNote: copy.signInRequired };
+    if (!unanswered2(view)) return fields;
+    return { ...fields, buyDisabled: true, buyNote: view.reason === "mappingUnavailable" ? copy.unavailable : fields.buyNote };
+  }
+  function catalogScope(identity, binding) {
+    const siteId = binding?.siteId ?? (identity?.platform === "web" ? "" : deps.host.preferenceSite());
+    return { appId: identity?.appId ?? "", bundleId: identity?.bundleId ?? "", ...siteId ? { siteId } : {} };
+  }
+  function open2() {
+    if (checkout || disposed) return Promise.resolve(checkout);
+    return opening ?? (opening = openWhenReady().finally(() => {
+      opening = void 0;
+      if (!recheckAfterOpening) return;
+      recheckAfterOpening = false;
+      if (!checkout && !disposed) void startedCheckout();
+    }));
+  }
+  async function openWhenReady() {
+    const staticGaps = configurationGaps();
+    if (staticGaps.length > 0) return settle({ status: "unavailable", gaps: staticGaps });
+    const routes = deps.routes;
+    const [identity, binding] = await Promise.all([deps.host.identity(), readBinding2()]);
+    const host = identity && binding && hostFor(identity, binding);
+    const gaps = await hostGaps(host, binding);
+    if (!host || gaps.length > 0 || disposed) {
+      watchSessionUntilReady();
+      return settle({ status: "unavailable", gaps });
+    }
+    stopWatchingSession?.();
+    stopWatchingSession = void 0;
+    checkout = createAppleIapCheckoutWith({
+      enabled: true,
+      wixIap: deps.wixIapClient({ host, route: routes.wixIap }),
+      binding: deps.binding,
+      session: deps.session,
+      identity: deps.identity,
+      clock: deps.clock,
+      cashier: routes.cashier,
+      adapters: deps.adapters,
+      pricing: deps.pricing,
+      store: deps.store,
+      refs: deps.refs,
+      bridge: deps.bridge,
+      jitter: deps.jitter,
+      onState: () => deps.onChange?.()
+    });
+    return settle({ status: "ready" });
+  }
+  function watchSessionUntilReady() {
+    stopWatchingSession ?? (stopWatchingSession = deps.session.subscribe(() => {
+      if (checkout || disposed) return;
+      if (opening) recheckAfterOpening = true;
+      else void startedCheckout();
+    }));
+  }
+  function configurationGaps() {
+    return [...deps.routes ? [] : ["routes"], ...deps.pricing.enabled ? [] : ["mapping"]];
+  }
+  async function hostGaps(host, binding) {
+    if (!host) return ["binding"];
+    if (!fencedTo(binding)) return ["nativeIdentity"];
+    const gaps = [];
+    if (!await managedStoreEnabled()) gaps.push("managedStore");
+    if (binding && deps.refs.hasRefs(binding) === null) gaps.push("storage");
+    return gaps;
+  }
+  function fencedTo(binding) {
+    const site = deps.session.site?.();
+    return deps.session.identityBound === true && !!binding && !!site && site.toLowerCase() === binding.siteId.toLowerCase();
+  }
+  async function managedStoreEnabled() {
+    const unfinished = await deps.store.getUnfinishedTransactions().catch(() => null);
+    return unfinished?.status === "ok";
+  }
+  function settle(next) {
+    const changed = JSON.stringify(next) !== JSON.stringify(readiness);
+    readiness = next;
+    if (changed) deps.onChange?.();
+    return checkout;
+  }
+  function readBinding2() {
+    return deps.binding.current().catch(() => null);
+  }
+  async function startedCheckout() {
+    if (deps.adapters.length === 0) return void 0;
+    const opened = await open2();
+    if (!opened) return void 0;
+    if (checkoutStarted) return { opened, fresh: false };
+    checkoutStarted = true;
+    await opened.start();
+    stopWatchingAccess = deps.session.subscribe(() => {
+      if (!disposed) void checkAccess(opened);
+    });
+    await checkAccess(opened);
+    return { opened, fresh: true };
+  }
+  async function recover(run) {
+    const started = await startedCheckout();
+    if (!started) return state();
+    if (started.fresh) return state();
+    await run(started.opened);
+    return checkAccess(started.opened);
+  }
+  function checkAccess(opened) {
+    const items = (pricedItems ?? []).filter((item) => deps.pricing.view(item.reference).route === "appleIap");
+    return items.length ? opened.checkAccess(items.map((item) => ({ reference: item.reference }))) : Promise.resolve(state());
+  }
+  function state() {
+    return checkout?.state() ?? notEnabledState();
+  }
+  return {
+    pricing: deps.pricing,
+    loadPrices,
+    readiness: () => readiness,
+    scopeComplete: () => lastScopeComplete,
+    state,
+    purchaseFields,
+    start,
+    buy,
+    reconcile: reconcile2,
+    tick: () => checkout ? checkout.tick() : Promise.resolve(state()),
+    pollDirective,
+    poll,
+    dispose: () => {
+      disposed = true;
+      stopWatchingSession?.();
+      stopWatchingAccess?.();
+      deps.pricing.dispose();
+      checkout?.dispose();
+    }
+  };
+}
+var POLL_ID2 = "iapCommerce";
+var PRICE_REFRESH_MS = 6e4;
+var PRICE_REFRESH_SLACK_MS = 1e4;
+var DUE_WORK_POLL_MS = 2e3;
+var SUSPENDED_AFTER_MS = 2 * PRICE_REFRESH_MS;
+function unanswered2(view) {
+  return view.route === "resolving" || view.reason === "mappingUnavailable";
+}
+function hostFor(identity, binding) {
+  if (binding.himalayaAppId !== identity.appId || binding.bundleId !== identity.bundleId) return null;
+  return { appId: identity.appId, bundleId: identity.bundleId, siteId: binding.siteId };
+}
+
+// ../../stdlib/flows/iap-checkout/src/commerce.ts
+function createIapCommerce(options = {}) {
+  const session = hostSessionFromGlobal();
+  const identity = memberIdentityOf(session);
+  const binding = sharedHostAppBindingSource();
+  return createIapCommerceWith({
+    routes: appleIapCheckoutRoutes(),
+    pricing: createIapCatalogPricing({ onChange: options.onChange }),
+    binding,
+    session,
+    host: hostOfWorker(),
+    store: appleManagedStore,
+    refs: createWorkerOrderRefStore(),
+    clock: { now: () => Date.now() },
+    adapters: options.adapters ?? [],
+    identity,
+    wixIapClient: ({ host, route }) => createWixIapClient({ session, binding, identity, host, route }),
+    onChange: options.onChange
+  });
+}
+function hostOfWorker() {
+  let read2;
+  return {
+    identity: () => read2 ?? (read2 = readIdentity().then((identity) => {
+      if (!identity) read2 = void 0;
+      return identity;
+    })),
+    preferenceSite
   };
 }
+async function readIdentity() {
+  const info = await get().catch(() => void 0);
+  return info?.appId && info.bundleId && info.platform ? { appId: info.appId, bundleId: info.bundleId, platform: info.platform } : null;
+}
+function preferenceSite() {
+  const value = globalThis.himalaya?.input?.__himiPreferenceBusiness;
+  return typeof value === "string" ? value.trim() : "";
+}
+
+// ../../stdlib/flows/iap-checkout/src/iap-verticals/shared.ts
+function singleUnitOf(kind, item) {
+  const quantity = item.quantity ?? 1;
+  if (item.reference.kind !== kind || !isNonEmpty3(item.reference.id) || quantity !== 1) return UNSUPPORTED;
+  return { eligible: true };
+}
+function attemptRefused(refusal) {
+  if (refusal.status === "sessionChanged" || refusal.status === "unavailable") return { status: refusal.status };
+  if (refusal.status === "notEnabled") return { status: "refused", reason: "notConfigured" };
+  return { status: "refused", reason: "orderRefused" };
+}
+function accessRefused(refusal) {
+  if (refusal.status === "sessionChanged") return "sessionChanged";
+  return refusal.status === "http" && refusal.httpStatus === 404 ? "none" : "unavailable";
+}
+function isRefusal(outcome) {
+  return outcome.status !== "ok";
+}
+function bodyObject(outcome, name) {
+  const body = outcome.body;
+  return isObject7(body) && isObject7(body[name]) ? body[name] : null;
+}
+function isObject7(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNonEmpty3(value) {
+  return typeof value === "string" && value.length > 0;
+}
+var UNSUPPORTED = { eligible: false, reason: "unsupportedItem" };
+var ORDER_REFUSED = { status: "refused", reason: "orderRefused" };
+var ORDER_CLOSED = { status: "refused", reason: "orderClosed" };
+var GRANTED = { status: "granted" };
+
+// ../../stdlib/flows/iap-checkout/src/iap-verticals/pricing-plans.ts
+var KIND = "pricingPlan";
+var CHECKOUT = "/pricing-plans/v2/checkout/orders";
+var MEMBER_ORDERS = "/pricing-plans/v2/member/orders";
+var pricingPlanOrders = {
+  kind: KIND,
+  eligibility: (item) => singleUnitOf(KIND, item),
+  openOrder,
+  reopenOrder,
+  readAccess,
+  currentAccess
+};
+async function currentAccess(item, bridge) {
+  let pending = false;
+  const pages = /* @__PURE__ */ new Set();
+  for (let offset = 0; ; offset += 50) {
+    const answer = await bridge.call("GET", `${MEMBER_ORDERS}?orderStatuses=ACTIVE&orderStatuses=PENDING&orderStatuses=DRAFT&limit=50&offset=${offset}`);
+    if (isRefusal(answer)) return accessRefused(answer);
+    const orders = answer.body?.orders;
+    if (!Array.isArray(orders)) return "unavailable";
+    const page = JSON.stringify(orders.map((order) => [order.id, order.planId, order.status]));
+    if (orders.length === 50 && pages.has(page)) return "unavailable";
+    pages.add(page);
+    const selected = orders.filter((order) => order.planId === item.reference.id);
+    if (selected.some((order) => order.status === "ACTIVE")) return "granted";
+    pending || (pending = selected.some((order) => order.status === "PENDING" || order.status === "DRAFT"));
+    if (orders.length < 50) return pending ? "pending" : "none";
+  }
+}
+async function openOrder(item, bridge) {
+  const planId = item.reference.id;
+  const preview = await bridge.call("POST", `${CHECKOUT}/preview-online`, { planId });
+  if (isRefusal(preview)) return attemptRefused(preview);
+  if (!isOneTimeUnlimited(bodyObject(preview, "order"))) return { status: "refused", reason: "unsupportedItem" };
+  const created = await bridge.call("POST", `${CHECKOUT}/online`, { planId });
+  if (isRefusal(created)) return attemptRefused(created);
+  return orderOf(bodyObject(created, "order"), planId);
+}
+async function reopenOrder(order, bridge) {
+  const read2 = await memberOrder(order.verticalRef.orderId, bridge);
+  if ("attempt" in read2) return read2.attempt;
+  const attempt4 = orderOf(read2.order, order.verticalRef.planId ?? "");
+  return attempt4.status === "open" && attempt4.cashierOrderId !== order.cashierOrderId ? ORDER_CLOSED : attempt4;
+}
+async function readAccess(verticalRef, bridge) {
+  if (!isNonEmpty3(verticalRef.orderId)) return "unavailable";
+  const answer = await bridge.call("GET", `${MEMBER_ORDERS}/${encodeURIComponent(verticalRef.orderId)}`);
+  if (isRefusal(answer)) return accessRefused(answer);
+  const order = bodyObject(answer, "order");
+  return order ? accessOf(order) : "unavailable";
+}
+function accessOf(order) {
+  if (order.status === "ACTIVE") return "granted";
+  if (order.status === "PENDING") return "pending";
+  if (order.status === "DRAFT") return "pending";
+  return NO_ACCESS.has(String(order.status)) ? "none" : "unavailable";
+}
+var NO_ACCESS = /* @__PURE__ */ new Set(["CANCELED", "ENDED", "PAUSED"]);
+function orderOf(order, planId) {
+  if (!order || !isNonEmpty3(order.id)) return ORDER_REFUSED;
+  if (accessOf(order) === "granted") return GRANTED;
+  if (order.status === "PENDING") return { status: "refused", reason: "paymentInProgress" };
+  if (order.status !== "DRAFT") return ORDER_CLOSED;
+  if (!isNonEmpty3(order.wixPayOrderId)) return ORDER_REFUSED;
+  return { status: "open", cashierOrderId: order.wixPayOrderId, verticalRef: { orderId: order.id, planId } };
+}
+async function memberOrder(orderId, bridge) {
+  if (!isNonEmpty3(orderId)) return { attempt: ORDER_CLOSED };
+  const answer = await bridge.call("GET", `${MEMBER_ORDERS}/${encodeURIComponent(orderId)}`);
+  if (isRefusal(answer)) return { attempt: answer.status === "http" && answer.httpStatus === 404 ? ORDER_CLOSED : attemptRefused(answer) };
+  return { order: bodyObject(answer, "order") };
+}
+function isOneTimeUnlimited(order) {
+  const pricing = order?.pricing;
+  return pricing?.singlePaymentUnlimited === true;
+}
 
 // ../../stdlib/wix-sdk/redirects-v1/src/index.ts
 function wixCallHeaders(opts) {
@@ -297,7 +3038,7 @@ var hideWhen = (n, path) => ({
 });
 var text = (id2, value, style = "body") => node(id2, "Text", { text: value, style });
 var vstack = (id2, children, spacing = 12, alignment = "leading") => node(id2, "VStack", { spacing, alignment, children });
-var button = (id2, title, action, style = "primary") => node(id2, "Button", { title, style, fullWidth: true, action });
+var button = (id2, title, action2, style = "primary") => node(id2, "Button", { title, style, fullWidth: true, action: action2 });
 var openScreen = (screenId) => ({ actionId: "himi.open", params: { screenId } });
 function envelope(screenId, title, root, logic) {
   return {
@@ -315,11 +3056,11 @@ function authScreen(opts) {
   const screenId = opts.screenId ?? "signin";
   const c = opts.copy ?? {};
   const withRegister = opts.register !== false;
-  const field = (key, label, action, extra = {}) => node(`${s2}.${key}`, "TextField", {
+  const field = (key, label, action2, extra = {}) => node(`${s2}.${key}`, "TextField", {
     label,
     placeholder: label,
     valuePath: `$service:${s2}.${key}`,
-    onChange: { actionId: action },
+    onChange: { actionId: action2 },
     ...extra
   });
   const children = [
@@ -505,6 +3246,42 @@ function createCheckoutService(opts = {}) {
   const c = opts.copy ?? {};
   const name = opts.service ?? "plans";
   const withJoined = opts.showJoined !== false;
+  const commerce = createIapCommerce({ adapters: [pricingPlanOrders], onChange: () => {
+    void svc.pricingPublish();
+  } });
+  const purchaseCopy = { buy: c.joinCta ?? "Get access", processing: c.pendingNotice ?? "Processing your purchase\u2026", awaitingApproval: "Waiting for approval", unavailable: c.failedNotice ?? "Purchasing is temporarily unavailable.", signInRequired: c.signInFirst ?? "Sign in to join a plan \u2014 memberships belong to a member account.", retry: c.failedNotice ?? "Something went wrong. Try again.", priceChanged: "The price changed. Check it and try again.", support: "We couldn't finish this purchase. Contact support." };
+  let catalogRows = [];
+  let items = [];
+  let started = false;
+  const memberSession = hostSessionFromGlobal();
+  let offerGeneration = memberSession.current().generation;
+  let existingAccess = { entitled: false, planId: "", generation: -1 };
+  let regularAccess = /* @__PURE__ */ new Set();
+  let loading = 0;
+  function project(state) {
+    const rows = catalogRows.map((row) => {
+      const reference = { kind: "pricingPlan", id: row.id };
+      const view = commerce.pricing.view(reference);
+      const price = iapPriceFields(view, { loading: "Loading price\u2026", unavailable: "Price unavailable", oneTimePurchase: "One-time purchase", purchaseUnavailable: purchaseCopy.unavailable });
+      const purchase = commerce.purchaseFields(reference, purchaseCopy);
+      const joined = purchase.appleRoute ? purchase.accessReady : memberSession.current().generation === offerGeneration && regularAccess.has(row.id);
+      return {
+        ...row,
+        joined,
+        notJoined: !joined,
+        joinedLabel: joined ? c.joinedLabel ?? "Current plan" : "",
+        priceLine: view.route === "disabled" ? row.priceLine : price.priceText,
+        periodLine: purchase.appleRoute ? price.priceNote : price.actionDisabled ? "" : row.periodLine,
+        cta: joined ? c.joinedLabel ?? "Current plan" : purchase.appleRoute ? purchase.buyLabel : row.cta,
+        joinDisabled: joined || (purchase.appleRoute ? purchase.buyDisabled || !row.appleSupported : price.actionDisabled || memberSession.current().generation !== offerGeneration),
+        joinNote: purchase.appleRoute ? row.appleSupported ? purchase.buyNote : purchaseCopy.unavailable : price.actionNote
+      };
+    });
+    const visibleAppleOwner = catalogRows.some((row) => row.id === existingAccess.planId && commerce.purchaseFields({ kind: "pricingPlan", id: row.id }, purchaseCopy).appleRoute);
+    const entitled = rows.some((row) => row.joined) || existingAccess.generation === memberSession.current().generation && !visibleAppleOwner && existingAccess.entitled;
+    const poll = commerce.pollDirective(`${name}.iapPoll`);
+    return { ...state, rows, entitled, notEntitled: !entitled, ...poll ? { _poll: poll } : {} };
+  }
   const BASE = {
     status: "loading",
     isLoading: true,
@@ -531,6 +3308,7 @@ function createCheckoutService(opts = {}) {
       joined: true,
       notJoined: false,
       joinedLabel: c.joinedLabel ?? "Current plan",
+      joinDisabled: true,
       cta: c.joinedLabel ?? "Current plan"
     } : r
   );
@@ -557,13 +3335,30 @@ function createCheckoutService(opts = {}) {
       joined,
       notJoined: !joined,
       joinedLabel: joined ? c.joinedLabel ?? "Current plan" : "",
-      cta: joined ? c.joinedLabel ?? "Current plan" : c.joinCta ?? "Join"
+      cta: joined ? c.joinedLabel ?? "Current plan" : c.joinCta ?? "Join",
+      appleSupported: p?.pricing?.singlePaymentUnlimited === true,
+      joinDisabled: false,
+      joinNote: ""
     };
   };
   const svc = defineService(name, {
-    state: BASE,
+    state: { ...BASE, rows: [] },
+    notHydrated: ["rows", "entitled", "notEntitled", "notice", "needsSignIn"],
     actions: {
+      pricingPublish: project,
+      pricingRefresh: async () => {
+        await commerce.loadPrices(items);
+        return void 0;
+      },
+      iapPoll: async () => {
+        await commerce.poll();
+        void svc.pricingPublish();
+        return void 0;
+      },
       load: async () => {
+        const generation = memberSession.current().generation;
+        const seq = ++loading;
+        offerGeneration = -1;
         let activePlanId = "";
         let entitled = false;
         if (withJoined) {
@@ -573,8 +3368,18 @@ function createCheckoutService(opts = {}) {
         }
         try {
           const res = await listPublicPlans();
+          if (seq !== loading || generation !== memberSession.current().generation) return void 0;
           const rows = (res.plans ?? []).filter((p) => !p?.archived).map((p) => rowFrom(p, activePlanId));
-          return {
+          catalogRows = rows;
+          items = rows.map((row) => ({ reference: { kind: "pricingPlan", id: row.id }, commerceDisplayPrice: row.priceLine }));
+          await commerce.loadPrices(items);
+          await (started ? commerce.reconcile() : commerce.start());
+          if (seq !== loading || generation !== memberSession.current().generation) return void 0;
+          started = true;
+          offerGeneration = generation;
+          existingAccess = { entitled, planId: activePlanId, generation };
+          regularAccess = new Set(rows.filter((row) => row.joined).map((row) => row.id));
+          return project({
             ...BASE,
             status: "ready",
             isLoading: false,
@@ -588,8 +3393,9 @@ function createCheckoutService(opts = {}) {
             notEntitled: !entitled,
             needsSignIn: false,
             notNeedsSignIn: true
-          };
+          });
         } catch {
+          if (seq !== loading || generation !== memberSession.current().generation) return void 0;
           return {
             ...BASE,
             status: "error",
@@ -622,12 +3428,25 @@ function createCheckoutService(opts = {}) {
             notNeedsSignIn: true
           };
         }
+        const generation = memberSession.current().generation;
+        const reference = { kind: "pricingPlan", id: id2 };
+        const purchase = commerce.purchaseFields(reference, purchaseCopy);
+        if (purchase.appleRoute) {
+          if (!row.appleSupported) return project(s2);
+          await commerce.buy({ reference });
+          void svc.pricingPublish();
+          return void 0;
+        }
+        if (generation !== offerGeneration || !commerce.pricing.checkoutGuard(reference).allowed) return project(s2);
         let purchaseFlowId = "";
         try {
           const res = await createOnlineOrder(id2);
           purchaseFlowId = String(res?.purchaseFlowId ?? "");
           const status = String(res?.order?.status ?? "").toUpperCase();
           if (status === GRANTS_ACCESS) {
+            if (generation !== memberSession.current().generation) return void 0;
+            offerGeneration = generation;
+            regularAccess.add(id2);
             return {
               ...s2,
               rows: markJoined(s2.rows, id2),
@@ -655,7 +3474,9 @@ function createCheckoutService(opts = {}) {
           snapshotId: purchaseFlowId,
           msid: "",
           amount: row.priceLine,
+          mayCharge: () => commerce.pricing.continueCheckoutGuard(reference).allowed,
           cashierUrl: async () => {
+            if (!commerce.pricing.continueCheckoutGuard(reference).allowed) return void 0;
             const r = await createRedirectSession({
               paidPlansCheckout: { planId: id2 },
               ...opts.returnTo ? { callbacks: { postFlowUrl: opts.returnTo } } : {}
@@ -664,15 +3485,20 @@ function createCheckoutService(opts = {}) {
           }
         });
         if (outcome.kind === "paid") {
+          const access = await entitlement(id2);
+          if (generation !== memberSession.current().generation) return void 0;
+          offerGeneration = generation;
+          const granted = access.entitled;
+          if (granted) regularAccess.add(id2);
           return {
             ...s2,
             // Settled ⇒ the row is theirs. PENDING is not access yet, so its row
             // stays joinable and the gate stays shut until the payment clears.
-            rows: outcome.pending ? s2.rows : markJoined(s2.rows, id2),
-            notice: outcome.pending ? c.pendingNotice ?? "Payment accepted and clearing. Access opens once it settles." : c.joinedNotice ?? `You've joined ${row.name}.`,
+            rows: granted ? markJoined(s2.rows, id2) : s2.rows,
+            notice: !granted ? c.pendingNotice ?? "Payment accepted and clearing. Access opens once it settles." : c.joinedNotice ?? `You've joined ${row.name}.`,
             noNotice: false,
-            entitled: !outcome.pending,
-            notEntitled: outcome.pending,
+            entitled: granted,
+            notEntitled: !granted,
             needsSignIn: false,
             notNeedsSignIn: true
           };
@@ -705,6 +3531,14 @@ function createCheckoutService(opts = {}) {
       }
     }
   });
+  if (globalThis.himalaya?.hydrationOptOut !== true) Object.assign(svc.getState(), BASE);
+  memberSession.subscribe(() => {
+    offerGeneration = -1;
+    existingAccess = { entitled: false, planId: "", generation: -1 };
+    regularAccess = /* @__PURE__ */ new Set();
+    void svc.pricingPublish();
+    void svc.load();
+  });
   svc.load();
   return svc;
 }
@@ -720,6 +3554,7 @@ function checkoutScreen(opts) {
       text(`${s2}.row_price`, "$item.priceLine", "title1"),
       text(`${s2}.row_period`, "$item.periodLine", "caption1"),
       text(`${s2}.row_desc`, "$item.description"),
+      text(`${s2}.row_note`, "$item.joinNote", "caption1"),
       hideWhen(text(`${s2}.row_perk1`, "$item.perk1"), "$item.noPerk1"),
       hideWhen(text(`${s2}.row_perk2`, "$item.perk2"), "$item.noPerk2"),
       hideWhen(text(`${s2}.row_perk3`, "$item.perk3"), "$item.noPerk3"),
@@ -729,6 +3564,7 @@ function checkoutScreen(opts) {
       hideWhen(
         node(`${s2}.row_join`, "Button", {
           title: "$item.cta",
+          disabledPath: "$item.joinDisabled",
           style: "primary",
           fullWidth: true,
           action: { actionId: `tier5.${s2}.join`, params: { id: "$item.id" } }
@@ -773,7 +3609,7 @@ function checkoutScreen(opts) {
     url: opts.bundleUrl,
     // wix_api reads the plans; the other two ARE the payment rail (in-app cashier,
     // then the hosted checkout). A paywall without them renders and cannot charge.
-    caps: ["wix_api", "wix_cashier", "open_url"]
+    caps: ["wix_api", "wix_cashier", "open_url", "iap", "app_info"]
   });
 }
 export {