@wix/himalaya-cli 0.1319.0 → 0.1321.0

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

@@ -1,8 +1,3 @@
-// ../../stdlib/flows/iap-checkout/src/checkout-source.ts
-function appleIapCheckoutEnabled() {
-  return false;
-}
-
 // ../../core/sdk/dispatch/src/index.ts
 function dispatch(handlerId, params, _options) {
   const himalaya = globalThis.himalaya;
@@ -18,6 +13,31 @@ function dispatch(handlerId, params, _options) {
   return himalaya.dispatch(handlerId, stringParams);
 }
 
+// ../../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 dispatch("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;
@@ -30,7 +50,7 @@ function createPurchaseCoordinator(deps) {
   let outcome = "idle";
   let purchasing = false;
   let signInPrompt = false;
-  let unavailable = null;
+  let unavailable2 = null;
   let pendingApproval = null;
   let errorCode = null;
   let errorFromReconcile = false;
@@ -66,7 +86,7 @@ function createPurchaseCoordinator(deps) {
     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 ?? unavailable?.code ?? null, items: snapshot, unfinishedCount, nextWakeAt: due.length > 0 ? Math.min(...due) : null };
+    return { phase: currentPhase(), errorCode: errorCode ?? unavailable2?.code ?? null, items: snapshot, unfinishedCount, nextWakeAt: due.length > 0 ? Math.min(...due) : null };
   }
   function dispose() {
     disposed = true;
@@ -78,7 +98,7 @@ function createPurchaseCoordinator(deps) {
     setError(null, false);
     outcome = "idle";
     pendingApproval = null;
-    unavailable = null;
+    unavailable2 = null;
     releaseSignIn();
     if (session.kind !== "member") {
       requireSignIn();
@@ -137,7 +157,7 @@ function createPurchaseCoordinator(deps) {
     }
   }
   function clearReconcileProblem() {
-    if (unavailable?.from === "reconcile") unavailable = null;
+    if (unavailable2?.from === "reconcile") unavailable2 = null;
     if (errorFromReconcile) setError(null, false);
   }
   async function runRetry() {
@@ -304,7 +324,7 @@ function createPurchaseCoordinator(deps) {
     outcome = "idle";
     purchasing = false;
     signInPrompt = false;
-    unavailable = null;
+    unavailable2 = null;
     pendingApproval = null;
     unfinishedCount = null;
     setError(null, false);
@@ -362,8 +382,8 @@ function createPurchaseCoordinator(deps) {
   }
   function failStore(code, fromReconcile) {
     setError(code, fromReconcile);
-    if (UNAVAILABLE_CODES.has(code) && unavailable?.from !== "purchase") {
-      unavailable = { from: fromReconcile ? "reconcile" : "purchase", code };
+    if (UNAVAILABLE_CODES.has(code) && unavailable2?.from !== "purchase") {
+      unavailable2 = { from: fromReconcile ? "reconcile" : "purchase", code };
     }
     publish();
   }
@@ -381,9 +401,9 @@ function createPurchaseCoordinator(deps) {
   }
   function currentPhase() {
     if (purchasing) return "purchasing";
-    if (unavailable?.from === "purchase") return "unavailable";
+    if (unavailable2?.from === "purchase") return "unavailable";
     if (signInPrompt) return "signInRequired";
-    if (unavailable?.from === "reconcile") return "unavailable";
+    if (unavailable2?.from === "reconcile") return "unavailable";
     return outcome;
   }
   function setError(code, fromReconcile) {
@@ -519,8 +539,8 @@ function createSerialQueue() {
   return {
     /** Callers joined onto a shared job all receive that job's result. */
     run(name, job, { joinRunning = false }) {
-      const shared = waiting.get(name) ?? (joinRunning ? running.get(name) : void 0);
-      if (shared) return shared;
+      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;
@@ -529,17 +549,741 @@ function createSerialQueue() {
   };
 }
 
+// ../../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: (id) => id, 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 [id, mapping] of decodeMappings(reply)) if (wanted.has(id)) mapped.set(id, 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 id = appProductIdOf(reference);
+  const mapping = id ? mapped.get(id) : 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/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 attempt(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 attempt(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 dispatch("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 (!nonempty(input?.productId) || !isUUID2(input?.appAccountToken)) return failure2("invalidArgument");
+  if (!nonempty2(input?.productId) || !isUUID2(input?.appAccountToken)) return failure2("invalidArgument");
   const result = await managedDispatch(() => dispatch("capability.iap.purchaseForVerification", input));
   if (result?.status === "purchased" && isAppleTransaction(result.transaction)) {
     return { status: "purchased", transaction: decodeTransaction(result.transaction) };
@@ -555,21 +1299,57 @@ async function getUnfinishedTransactions() {
   return decodeFailure(result);
 }
 async function finishTransaction(input) {
-  if (!nonempty(input?.transactionId)) return failure2("invalidArgument");
+  if (!nonempty2(input?.transactionId)) return failure2("invalidArgument");
   const result = await managedDispatch(() => dispatch("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 dispatch("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 nonempty = (value) => typeof value === "string" && value.trim().length > 0;
+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 isObject2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var isObject4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 async function managedDispatch(invoke) {
   try {
     const value = await invoke();
-    return isObject2(value) ? value : null;
+    return isObject4(value) ? value : null;
   } catch {
     return failure2("unavailable");
   }
@@ -578,14 +1358,26 @@ function decodeFailure(value) {
   return value?.status === "failed" && transactionErrors.has(value.code) ? failure2(value.code) : failure2("invalidResponse");
 }
 function isAppleTransaction(value) {
-  if (!isObject2(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) && nonempty(value.transactionId) && nonempty(value.originalTransactionId) && nonempty(value.productId) && (value.appAccountToken === null || isUUID2(value.appAccountToken)) && ["production", "sandbox", "xcode", "unknown"].includes(value.environment);
+  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;
+}
+function appleIapCheckoutEnabled() {
+  return appleIapCheckoutRoutes() !== null;
+}
+
 // ../../stdlib/flows/iap-checkout/src/cashier-charges.ts
 async function ensureAppleIapCharge(bridge, route, orderId) {
   if (!isRoutePrefix2(route.prefix)) return { status: "notConfigured" };
@@ -622,22 +1414,22 @@ function decideFromCharges(charges) {
   return isAwaitingApple(apple) ? { status: "pending", transactionId: apple.transactionId } : { status: "invalidResponse" };
 }
 function chargedFrom(body) {
-  const charge = isObject3(body) ? decodeCharge(body.charge) : null;
+  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 (!isObject3(body)) return null;
+  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 (!isObject3(raw) || !isNonEmpty2(raw.chargeId) || !isNonEmpty2(raw.transactionId)) return null;
-  const state = isObject3(raw.state) && isObject3(raw.state.transactionStatus) ? raw.state.transactionStatus : {};
+  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 };
 }
@@ -650,7 +1442,7 @@ function chargesPath(route, orderId) {
 function isRoutePrefix2(prefix) {
   return /^\/[A-Za-z0-9._~\-/]*[A-Za-z0-9._~-]$/.test(prefix);
 }
-function isObject3(value) {
+function isObject5(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function isNonEmpty2(value) {
@@ -749,7 +1541,7 @@ function readVersioned(store, location) {
   if (raw === void 0) return null;
   if (raw === null || raw === "") return "empty";
   const parsed = safely(() => JSON.parse(raw));
-  return isObject4(parsed) && parsed.v === VERSION ? parsed : null;
+  return isObject6(parsed) && parsed.v === VERSION ? parsed : null;
 }
 function writeVerified(store, location, value) {
   if (!store) return false;
@@ -759,7 +1551,7 @@ function writeVerified(store, location, value) {
   }) === true;
 }
 function isOrderRef(value) {
-  if (!isObject4(value) || typeof value.key !== "string" || !STAGES.has(value.stage)) return false;
+  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;
@@ -794,9 +1586,9 @@ function hostStorage() {
   const storage = globalThis.himalaya?.storage;
   return typeof storage?.getItem === "function" && typeof storage.setItem === "function" ? storage : void 0;
 }
-function safely(read) {
+function safely(read2) {
   try {
-    return read();
+    return read2();
   } catch {
     return void 0;
   }
@@ -805,9 +1597,9 @@ function serialize(value) {
   return JSON.stringify(value);
 }
 function isStringMap(value) {
-  return isObject4(value) && Object.values(value).every((entry) => typeof entry === "string");
+  return isObject6(value) && Object.values(value).every((entry) => typeof entry === "string");
 }
-function isObject4(value) {
+function isObject6(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function isUUID3(value) {
@@ -826,7 +1618,7 @@ function bindBridge(session, provider, bridge) {
     if (!isCurrent()) return SESSION_CHANGED;
     const expectation = boundExpectation(session, provider, bridge);
     if (expectation === "refuse") return { status: "notEnabled" };
-    const outcome = await attempt(bridge, method, path, body, expectation);
+    const outcome = await attempt2(bridge, method, path, body, expectation);
     return isCurrent() ? outcome : SESSION_CHANGED;
   }
   return { call, isCurrent };
@@ -837,7 +1629,7 @@ function hostBridge() {
   return typeof bridge?.call === "function" ? bridge : void 0;
 }
 var MISSING_BRIDGE = { call: () => Promise.reject(new Error("wixApi not enabled")) };
-async function attempt(bridge, method, path, body, expectation) {
+async function attempt2(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 };
@@ -859,8 +1651,8 @@ function isLiveHost(bridge) {
 function refusalOf(error) {
   const message = error?.message;
   const text = typeof message === "string" ? message : "";
-  if (BRIDGE_REFUSAL.test(text)) return { status: "notEnabled" };
-  if (PRINCIPAL_CHANGED.test(text)) return SESSION_CHANGED;
+  if (BRIDGE_REFUSAL2.test(text)) return { status: "notEnabled" };
+  if (PRINCIPAL_CHANGED2.test(text)) return SESSION_CHANGED;
   const http = /^HTTP (\d{3})(?: \[([^\]]+)\])?:/.exec(text);
   if (!http) return { status: "unavailable" };
   return httpRefusal(Number(http[1]), http[2] ?? "");
@@ -871,8 +1663,8 @@ function httpRefusal(httpStatus, code) {
   return { status: "http", httpStatus, code };
 }
 var SESSION_CHANGED = { status: "sessionChanged" };
-var BRIDGE_REFUSAL = /^(wixApi not enabled|capability wix_api not allowed)\b|^NotInstalled\(\)$/;
-var PRINCIPAL_CHANGED = /^PRINCIPAL_CHANGED\b/;
+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) {
@@ -934,26 +1726,26 @@ function createWixOrderBackend(deps) {
     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 attempt2 = 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, attempt2);
+    const attempt3 = 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, attempt3);
   }
   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, attempt2) {
-    if (attempt2.status === "granted") return alreadyOwned(sale);
-    if (attempt2.status === "refused") return stopWith("rejected", attempt2.reason);
-    if (attempt2.status !== "open") return attempt2.status === "sessionChanged" ? STALE2 : retry("unavailable");
-    const kept = existing && existing.cashierOrderId === attempt2.cashierOrderId ? existing : { key: sale.catalogRef, updatedAt: 0 };
+  function recordOrder(sale, existing, attempt3) {
+    if (attempt3.status === "granted") return alreadyOwned(sale);
+    if (attempt3.status === "refused") return stopWith("rejected", attempt3.reason);
+    if (attempt3.status !== "open") return attempt3.status === "sessionChanged" ? STALE2 : retry("unavailable");
+    const kept = existing && existing.cashierOrderId === attempt3.cashierOrderId ? existing : { key: sale.catalogRef, updatedAt: 0 };
     return persist(sale, {
       ...kept,
       key: sale.catalogRef,
       stage: "ordered",
       kind: sale.adapter.kind,
-      verticalRef: attempt2.verticalRef,
-      cashierOrderId: attempt2.cashierOrderId,
+      verticalRef: attempt3.verticalRef,
+      cashierOrderId: attempt3.cashierOrderId,
       updatedAt: now()
     });
   }
@@ -1194,6 +1986,8 @@ function enabledCheckout(deps) {
   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;
@@ -1229,6 +2023,28 @@ function enabledCheckout(deps) {
     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);
@@ -1287,6 +2103,7 @@ function enabledCheckout(deps) {
     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) {
@@ -1323,6 +2140,7 @@ function enabledCheckout(deps) {
     generation = next;
     sales.clear();
     payments.clear();
+    readGrants.clear();
     awaitingApproval.clear();
     partitionRead = null;
     current = { item: null, failure: null, buying: false };
@@ -1392,10 +2210,10 @@ function enabledCheckout(deps) {
     return readDue || [...payments.values()].some((payment) => payment.access === "processing" && isDue(payment.key, true));
   }
   async function trackOne(session, partition, ref) {
-    const read = await deps.wixIap.getPayment({ paymentId: ref.paymentId ?? "" });
+    const read2 = await deps.wixIap.getPayment({ paymentId: ref.paymentId ?? "" });
     if (!isCurrent(session)) return;
-    if (read.status !== "found") return read.kind === "application" ? markNeedsSupport(partition, ref) : backOff(partition, ref, false);
-    await settlePayment(session, partition, ref, read.payment);
+    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);
@@ -1446,12 +2264,15 @@ function enabledCheckout(deps) {
   function isCurrent(session) {
     return !disposed && deps.session.current().generation === session.generation;
   }
-  return { start, buy, reconcile: reconcile2, retry: retry2, tick, state, dispose };
+  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, reconcile: resolved, retry: resolved, tick: resolved, state, dispose: () => {
+  return { start: resolved, buy: resolved, checkAccess: resolved, reconcile: resolved, retry: resolved, tick: resolved, state, dispose: () => {
   } };
 }
 function blankState(enabled) {
@@ -1499,6 +2320,307 @@ function failureOfAccess(access) {
 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 open() {
+    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 open();
+    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/apple-iap.ts
 function createAppleIapCheckout(deps) {
   return createAppleIapCheckoutWith({ ...deps, enabled: appleIapCheckoutEnabled() });
@@ -1527,9 +2649,9 @@ function isHttp(outcome, httpStatus) {
 }
 function bodyObject(outcome, name) {
   const body = outcome.body;
-  return isObject5(body) && isObject5(body[name]) ? body[name] : null;
+  return isObject7(body) && isObject7(body[name]) ? body[name] : null;
 }
-function isObject5(value) {
+function isObject7(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function isNonEmpty3(value) {
@@ -1548,20 +2670,21 @@ var onlineProgramOrders = {
   eligibility: (item) => singleUnitOf(KIND, item),
   openOrder,
   reopenOrder,
-  readAccess
+  readAccess,
+  currentAccess
 };
 async function openOrder(item, bridge) {
   const found = await currentApplication(item.reference.id, bridge);
   if ("attempt" in found) return found.attempt;
-  const read = found.application ? { application: found.application } : await createdApplication(item.reference.id, bridge);
-  if ("attempt" in read) return read.attempt;
-  return orderOf(read.application, bridge, { mayPrepare: true });
+  const read2 = found.application ? { application: found.application } : await createdApplication(item.reference.id, bridge);
+  if ("attempt" in read2) return read2.attempt;
+  return orderOf(read2.application, bridge, { mayPrepare: true });
 }
 async function reopenOrder(order, bridge) {
-  const read = await applicationById(order.verticalRef.joinApplicationId, bridge);
-  if ("attempt" in read) return read.attempt;
-  const attempt2 = await orderOf(read.application, bridge, { mayPrepare: false });
-  return attempt2.status === "open" && attempt2.cashierOrderId !== order.cashierOrderId ? ORDER_CLOSED : attempt2;
+  const read2 = await applicationById(order.verticalRef.joinApplicationId, bridge);
+  if ("attempt" in read2) return read2.attempt;
+  const attempt3 = await orderOf(read2.application, bridge, { mayPrepare: false });
+  return attempt3.status === "open" && attempt3.cashierOrderId !== order.cashierOrderId ? ORDER_CLOSED : attempt3;
 }
 async function readAccess(verticalRef, bridge) {
   if (!isNonEmpty3(verticalRef.joinApplicationId)) return "unavailable";
@@ -1570,6 +2693,14 @@ async function readAccess(verticalRef, bridge) {
   const application = bodyObject(answer, "joinApplication");
   return application ? accessOf(application) : "unavailable";
 }
+async function currentAccess(item, bridge) {
+  const answer = await bridge.call("GET", `${BASE}/current/${encodeURIComponent(item.reference.id)}`);
+  if (isRefusal(answer)) return accessRefused(answer);
+  const application = bodyObject(answer, "joinApplication");
+  if (!application) return "unavailable";
+  const access = accessOf(application);
+  return access !== "granted" && ENDED_STATUS.has(String(application.status)) ? "none" : access;
+}
 function accessOf(application) {
   const paid = application.paymentStatus === "PAYMENT_SUCCESSFUL" || application.paymentStatus === "NO_PAYMENT_REQUIRED";
   if (application.status === "APPROVED" && paid && isNonEmpty3(application.participantId)) return "granted";
@@ -1602,8 +2733,8 @@ async function preparedOrder(application, bridge) {
   return prepared ? orderOf(prepared, bridge, { mayPrepare: false }) : ORDER_REFUSED;
 }
 async function reopenAfterRace(id, bridge) {
-  const read = await applicationById(id, bridge);
-  return "attempt" in read ? read.attempt : orderOf(read.application, bridge, { mayPrepare: false });
+  const read2 = await applicationById(id, bridge);
+  return "attempt" in read2 ? read2.attempt : orderOf(read2.application, bridge, { mayPrepare: false });
 }
 async function currentApplication(programId, bridge) {
   const answer = await bridge.call("GET", `${BASE}/current/${encodeURIComponent(programId)}`);
@@ -1636,6 +2767,7 @@ function applicationIn(answer) {
 var PREPARABLE = /* @__PURE__ */ new Set(["PAYMENT_PENDING", "PAYMENT_FAILED", "PAYMENT_CANCELED"]);
 var PAYMENT_UNDER_WAY = /* @__PURE__ */ new Set(["PAYMENT_PENDING", "PAYMENT_IN_PROGRESS", "PENDING_OWNER_APPROVAL"]);
 var NO_ACCESS_STATUS = /* @__PURE__ */ new Set(["CANCELLED", "DECLINED", "SUSPENDED", "INVITED", "APPROVAL_PENDING"]);
+var ENDED_STATUS = /* @__PURE__ */ new Set(["CANCELLED", "DECLINED", "SUSPENDED"]);
 var NO_ACCESS_PAYMENT = /* @__PURE__ */ new Set(["PAYMENT_FAILED", "PAYMENT_CANCELED"]);
 
 // ../../stdlib/flows/iap-checkout/src/iap-verticals/pricing-plans.ts
@@ -1659,10 +2791,10 @@ async function openOrder2(item, bridge) {
   return orderOf2(bodyObject(created, "order"), planId);
 }
 async function reopenOrder2(order, bridge) {
-  const read = await memberOrder(order.verticalRef.orderId, bridge);
-  if ("attempt" in read) return read.attempt;
-  const attempt2 = orderOf2(read.order, order.verticalRef.planId ?? "");
-  return attempt2.status === "open" && attempt2.cashierOrderId !== order.cashierOrderId ? ORDER_CLOSED : attempt2;
+  const read2 = await memberOrder(order.verticalRef.orderId, bridge);
+  if ("attempt" in read2) return read2.attempt;
+  const attempt3 = orderOf2(read2.order, order.verticalRef.planId ?? "");
+  return attempt3.status === "open" && attempt3.cashierOrderId !== order.cashierOrderId ? ORDER_CLOSED : attempt3;
 }
 async function readAccess2(verticalRef, bridge) {
   if (!isNonEmpty3(verticalRef.orderId)) return "unavailable";
@@ -1743,7 +2875,7 @@ async function readAccess3(verticalRef, bridge) {
   return NO_ACCESS2.has(status) ? "none" : "unavailable";
 }
 async function placedOrder(body, bridge) {
-  if (!isObject5(body) || !isNonEmpty3(body.orderId)) return ORDER_REFUSED;
+  if (!isObject7(body) || !isNonEmpty3(body.orderId)) return ORDER_REFUSED;
   const verticalRef = { orderId: body.orderId };
   if (isNonEmpty3(body.paymentGatewayOrderId)) return { status: "open", cashierOrderId: body.paymentGatewayOrderId, verticalRef };
   const access = await readAccess3(verticalRef, bridge);
@@ -1755,7 +2887,9 @@ var NO_ACCESS2 = /* @__PURE__ */ new Set(["FULLY_REFUNDED", "PARTIALLY_REFUNDED"
 export {
   classifyCart,
   createAppleIapCheckout,
+  createIapCommerce,
   createWorkerOrderRefStore,
+  iapPurchaseFields,
   onlineProgramOrders,
   pricingPlanOrders,
   storesProductOrders