@wix/himalaya-cli 0.1551.0 → 0.1552.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/dev-server/src/builder.d.ts

@@ -781,6 +781,9 @@ export declare function datePicker(props: {
     maxUnix?: number;
     mode?: "date" | "time" | "datetime";
     onChange?: ActionShape;
+    /** "$service:" binding → unix seconds or an ISO-8601 date; the picker prefills from and
+     *  tracks it (every renderer reads it; it overrides `valueUnix`). */
+    valuePath?: string;
 }, opts?: {
     id?: string;
 }): Component;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/sdk/iap/src/wix-payments-contract.d.ts

@@ -37,8 +37,8 @@ export interface AppleSaleRule {
     appProductId(entityId: string): string;
     productType: "NON_CONSUMABLE" | "CONSUMABLE";
 }
-export declare const BOOKINGS_APPLE_SALES_ENABLED = false;
-export declare const EVENTS_APPLE_SALES_ENABLED = false;
+export declare const BOOKINGS_APPLE_SALES_ENABLED = true;
+export declare const EVENTS_APPLE_SALES_ENABLED = true;
 /**
  * Whether Wix Stores items sell through the App Store, through wix-iap StartItemPayment
  * (catalyst-server #24496), which places the member's eCom order for one catalog item. OFF: that RPC

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/flows/iap-checkout/src/apple-iap-contract.d.ts

@@ -97,6 +97,16 @@ export type OrderAttempt = (
     noOrderCreated?: true;
 };
 export type AccessRead = "granted" | "pending" | "none" | "unavailable" | "sessionChanged";
+/** What a repeatable sale stores before an inventory write whose answer may be lost: the ids it
+ *  targets or created, and when Wix will itself have released anything it created. */
+export interface OpeningGuard {
+    verticalRef?: VerticalRef;
+    releaseAt?: number;
+}
+/** `released`: nothing the guarded write may have created can be sold twice, so the guard goes.
+ *  `held`: still unknown, and it blocks this sale. `unrelated`: still unknown, but it targets other
+ *  inventory than this sale's. */
+export type OpeningResolution = "released" | "held" | "unrelated" | "unavailable" | "sessionChanged";
 /** An item wix-iap can order itself (StartItemPayment): the item as eCom's catalog reference, and
  *  how the adapter finds the eCom order that call places again. */
 export interface ItemPayment {
@@ -113,8 +123,18 @@ export interface IapOrderAdapter {
     eligibility(item: IapOrderItem): IapEligibility;
     /** Opens, or reuses the vertical's own open, order for the signed-in member. */
     /** Repeatable adapters call beforeCreate immediately before their first inventory write,
-     *  after read-only checks, and abort without writing if it returns false. */
-    openOrder(item: IapOrderItem, bridge: SessionBoundBridge, beforeCreate?: () => boolean): Promise<OrderAttempt>;
+     *  after read-only checks, and abort without writing if it returns false. They call afterCreate
+     *  with the ids of each inventory write as soon as it answers, so a later failure can be undone. */
+    openOrder(item: IapOrderItem, bridge: SessionBoundBridge, beforeCreate?: (guard: OpeningGuard) => boolean, afterCreate?: (guard: OpeningGuard) => void): Promise<OrderAttempt>;
+    /** Settles an earlier attempt's guard before a new sale of the same item. `settled`: the attempt
+     *  that wrote it has had time to finish, so what it created may be undone; before then it may be
+     *  another screen's sale still in flight. `claim` must answer true immediately before anything
+     *  is undone: it takes the guard from that sale, which is then never charged. With no item (on
+     *  entry, not a sale) only `released` matters. Without it, a guard holds its item until its `releaseAt`. */
+    resolveOpening?(guard: OpeningGuard, item: IapOrderItem | undefined, bridge: SessionBoundBridge, options: {
+        settled: boolean;
+        claim(): boolean;
+    }): Promise<OpeningResolution>;
     /** Re-reads an order opened earlier; `open` only while it can still be paid. */
     reopenOrder(order: {
         cashierOrderId: string;
@@ -157,6 +177,8 @@ export interface OrderRef {
     appleTransactionId?: string;
     /** The StoreKit token StartPayment minted for this payment (D61): recovery finds the order by it. */
     appAccountToken?: string;
+    /** For `openingOrder`: when anything its write created has been released by Wix. */
+    releaseAt?: number;
     updatedAt: number;
 }
 export interface OrderRefPartition {

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/flows/iap-checkout/src/order-refs.d.ts

@@ -1,4 +1,4 @@
-import type { OrderRefPartition, OrderRefStore } from "./apple-iap-contract.js";
+import type { IapOrderAdapter, IapOrderItem, OpeningResolution, OrderRef, OrderRefPartition, OrderRefStore, SessionBoundBridge } from "./apple-iap-contract.js";
 export interface KeyValueStorage {
     getItem(key: string): string | null;
     setItem(key: string, value: string): void;
@@ -12,9 +12,18 @@ export declare const NEEDS_SUPPORT_HOLD_MS = 604800000;
 export declare const ITEM_START_HOLD_MS = 3600000;
 /** Drops every hold older than its stage's hold time, whatever its key (an item, or a `payment:`
  *  with no local order), so holds never accumulate and lock the member out. A held proof still
- *  unfinished renews its hold on every retry, so only one Apple no longer delivers expires. Returns
- *  the keys it removed. */
+ *  unfinished renews its hold on every retry, so only one Apple no longer delivers expires. A
+ *  creation guard goes at its own `releaseAt`. Returns the keys it removed. */
 export declare function pruneExpiredHolds(partition: OrderRefPartition, now: number): string[];
+/** How long (5 minutes) a creation guard may belong to a sale still running in another screen's
+ *  worker, which shares these references but not that sale's coordinator: longer than any one
+ *  openOrder takes. Until then nothing it may have created is undone. A literal, as above. */
+export declare const OPENING_SETTLE_MS = 300000;
+/** Asks the guard's adapter to settle it. Before undoing anything the adapter claims the guard
+ *  (restamps it), so the sale that wrote it, should it still be running, is no longer charged. It
+ *  is dropped only while it is still the stored guard: a slow answer never removes what another
+ *  worker wrote under the key since. A guard changed meanwhile is judged again as it now is. */
+export declare function settleOpening(partition: OrderRefPartition, adapter: IapOrderAdapter, guard: OrderRef, item: IapOrderItem | undefined, bridge: SessionBoundBridge, now: number): Promise<OpeningResolution | "storageUnavailable">;
 /** References one member keeps at once. When full, the oldest reference from before Apple's sheet
  *  is evicted; a partition full of handed-over payments refuses new sales instead. */
 export declare const MAX_ORDER_REFS = 16;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/forms/src/extensions.d.ts

@@ -1 +1,83 @@
-export {};
+import { type WixCallOptions, type WixSubmission } from "./index.js";
+export interface WixFormSubmissionInput {
+    formId: string;
+    /** Keyed by each field's `target`; the value shape follows the field's `inputType`
+     *  ("About Submission Values"). A key that is no field's target fails the whole submission. */
+    submissions: Record<string, unknown>;
+}
+export interface WixCreateSubmissionRequest {
+    submission: WixFormSubmissionInput;
+    captchaToken?: string;
+}
+export interface WixCreateSubmissionResponse {
+    submission?: WixSubmission;
+}
+export interface WixSubmissionValidationError {
+    /** The field's `target`. */
+    errorPath?: string;
+    errorType?: string;
+    errorMessage?: string;
+    params?: Record<string, unknown>;
+}
+export interface WixValidateFormSubmissionResponse {
+    valid?: boolean;
+    violationErrors?: Array<{
+        name?: string;
+        description?: string;
+        ruleName?: string;
+        submissionValidationErrors?: {
+            errors?: WixSubmissionValidationError[];
+        };
+    }>;
+}
+/** The endpoint answered: `value` is what the call returns without `{ offline: "queue" }`. */
+export interface WixSent<T> {
+    status: "sent";
+    value: T;
+}
+/** The write waits in the device's offline outbox; `writeId` names it in
+ *  `wixApi.offline` events. */
+export interface WixQueued {
+    status: "queued";
+    writeId: string;
+    tag: string;
+}
+export type WixOfflineResult<T> = WixSent<T> | WixQueued;
+/** Per-call options of a write the runtime may queue offline. `offline: "queue"` opts this ONE
+ *  call into the outbox, and the answer becomes a `WixOfflineResult<T>`. It queues only if the
+ *  app declares a `queueOffline` cache rule for the endpoint; a form send has no server-side
+ *  dedupe (`unsentOnly`), so on web it is refused offline (`err.code === "offline_write_blocked"`). */
+export interface WixQueueCallOptions extends WixCallOptions {
+    offline?: "queue";
+}
+/**
+ * Sends a filled form. Creates a submission (and, through the form's contact mapping, a
+ * contact) on the site, so call it only on the submitter's explicit action. An anonymous
+ * visitor may call it. Keys of `submissions` are field targets; Wix rejects the whole
+ * submission for an unknown key or an invalid value, with per-field `submissionValidationErrors`.
+ * With `{ offline: "queue" }` the answer is an envelope: `sent`, or `queued` while the device is
+ * offline (native only — on web it is refused offline with `code: "offline_write_blocked"`).
+ *
+ * POST /form-submission-service/v4/submissions
+ */
+export declare function createSubmission(req: WixCreateSubmissionRequest, opts: WixQueueCallOptions & {
+    offline: "queue";
+}): Promise<WixOfflineResult<WixCreateSubmissionResponse>>;
+/**
+ * Sends a filled form. Creates a submission (and, through the form's contact mapping, a
+ * contact) on the site, so call it only on the submitter's explicit action. An anonymous
+ * visitor may call it. Keys of `submissions` are field targets; Wix rejects the whole
+ * submission for an unknown key or an invalid value, with per-field `submissionValidationErrors`.
+ * With `{ offline: "queue" }` the answer is an envelope: `sent`, or `queued` while the device is
+ * offline (native only — on web it is refused offline with `code: "offline_write_blocked"`).
+ *
+ * POST /form-submission-service/v4/submissions
+ */
+export declare function createSubmission(req: WixCreateSubmissionRequest, opts?: WixCallOptions): Promise<WixCreateSubmissionResponse>;
+/**
+ * Checks a filled form against the form's rules without creating anything. Answers
+ * `valid: false` with one `submissionValidationErrors.errors[]` entry per failed value.
+ *
+ * POST /form-submission-service/v4/submissions/validate
+ */
+export declare function validateFormSubmission(req: WixCreateSubmissionRequest, opts?: WixCallOptions): Promise<WixValidateFormSubmissionResponse>;

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

@@ -687,8 +687,8 @@ var sameReference = (value, reference) => isObject2(value) && value.kind === ref
 
 // ../../core/sdk/iap/src/wix-payments-contract.ts
 var HIMALAYA_SERVE_IAP_ROUTE = { prefix: "/himalaya-serve/v1/iap" };
-var BOOKINGS_APPLE_SALES_ENABLED = false;
-var EVENTS_APPLE_SALES_ENABLED = false;
+var BOOKINGS_APPLE_SALES_ENABLED = true;
+var EVENTS_APPLE_SALES_ENABLED = true;
 var ATTENDANCE_SALE_RULE = { appProductId: (id) => id, productType: "CONSUMABLE" };
 var STORES_ITEM_PAYMENT_ENABLED = false;
 var STORES_APPLE_SALES_ENABLED = true;
@@ -1428,10 +1428,13 @@ function locationType(raw) {
   return type === "CUSTOM" && addresses.every(describesNoPlace) ? ADDRESSLESS_CUSTOM : type;
 }
 function describesNoPlace(address) {
-  const parts = ["country", "subdivision", "city", "postalCode", "addressLine", "addressLine2", "streetAddress", "location"];
+  const parts = ["country", "subdivision", "city", "postalCode", "addressLine2", "streetAddress", "location"];
   if (parts.some((key) => address[key] !== void 0 && address[key] !== "")) return false;
-  const description = text(address.formattedAddress)?.trim() ?? "";
-  return description === "" || ONLINE_LABEL.test(description);
+  return [address.addressLine, address.formattedAddress].every((value) => {
+    if (value !== void 0 && typeof value !== "string") return false;
+    const description = value?.trim() ?? "";
+    return description === "" || ONLINE_LABEL.test(description);
+  });
 }
 var ONLINE_LABEL = /^(online|virtual)(\s+(class|classes|classroom|course|session|sessions|meeting|lesson|training|workshop|event))?$/i;
 function ticketAttendanceOf(event, definition) {
@@ -1701,9 +1704,33 @@ function isFinalRefusal(status) {
 var NEEDS_SUPPORT_HOLD_MS = 6048e5;
 var ITEM_START_HOLD_MS = 36e5;
 function pruneExpiredHolds(partition, now) {
-  const expired = partition.refs().filter((ref) => now - ref.updatedAt >= (HOLD_MS[ref.stage] ?? Infinity));
+  const expired = partition.refs().filter((ref) => now - ref.updatedAt >= (HOLD_MS[ref.stage] ?? Infinity) || released(ref, now));
   return expired.filter((ref) => partition.remove(ref.key)).map((ref) => ref.key);
 }
+var OPENING_SETTLE_MS = 3e5;
+async function settleOpening(partition, adapter, guard, item, bridge, now) {
+  const resolve = adapter.resolveOpening;
+  if (!resolve) return "held";
+  let current = guard;
+  const claim = () => {
+    const next = { ...current, updatedAt: now };
+    if (!isStoredGuard(partition, current) || !partition.put(next)) return false;
+    current = next;
+    return true;
+  };
+  const resolution = await resolve(guard, item, bridge, { settled: now - guard.updatedAt >= OPENING_SETTLE_MS, claim });
+  if (isStoredGuard(partition, current)) {
+    if (resolution !== "released") return resolution;
+    return partition.remove(guard.key) ? "released" : "storageUnavailable";
+  }
+  const stored = partition.refs().find((ref) => ref.key === guard.key);
+  if (!stored) return "released";
+  return stored.stage === "openingOrder" ? resolve(stored, item, bridge, { settled: false, claim: () => false }) : "held";
+}
+function isStoredGuard(partition, guard) {
+  const stored = partition.refs().find((ref) => ref.key === guard.key);
+  return stored?.stage === "openingOrder" && stored.updatedAt === guard.updatedAt;
+}
 var MAX_ORDER_REFS = 16;
 function createWorkerOrderRefStore(storage) {
   const kv = () => storage ?? hostStorage();
@@ -1780,10 +1807,14 @@ function writeVerified(store, location, value) {
 function isOrderRef(value) {
   if (!isObject6(value) || typeof value.key !== "string" || !STAGES.has(value.stage)) return false;
   if (typeof value.updatedAt !== "number") return false;
+  if (value.releaseAt !== void 0 && typeof value.releaseAt !== "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 released(ref, now) {
+  return ref.stage === "openingOrder" && ref.releaseAt !== void 0 && now >= ref.releaseAt;
+}
 function isPartitionKey(key) {
   return isUUID3(key.purchasesAppId) && isUUID3(key.siteId) && isUUID3(key.memberId);
 }
@@ -1920,6 +1951,8 @@ function createWixOrderBackend(deps) {
   async function getPurchaseContext(session, catalogRef) {
     const sale = await saleFor(session, catalogRef);
     if (isStop(sale)) return contextResult(catalogRef, sale);
+    const unresolved = await resolveOpenings(sale);
+    if (unresolved) return contextResult(catalogRef, unresolved);
     const blocked = saleBlocked(sale);
     if (blocked) return contextResult(catalogRef, blocked);
     const itemPayment2 = deps.itemPaymentEnabled ? sale.adapter.itemPayment?.(sale.item) : null;
@@ -1938,11 +1971,26 @@ function createWixOrderBackend(deps) {
     if (failure3) return stopWith("rejected", failure3);
     if (sale.adapter.repeatable) {
       const prefix = `${sale.item.reference.kind}:${sale.item.reference.id}#`;
-      const unresolved = sale.partition.refs().find((ref) => ref.key.startsWith(prefix) && ["openingOrder", "held", "needsSupport"].includes(ref.stage));
-      if (unresolved) return stopWith("rejected", unresolved.stage === "openingOrder" ? "outcomeUnknown" : "needsSupport");
+      const unresolved = sale.partition.refs().find((ref) => ref.key.startsWith(prefix) && !sale.unrelated.has(ref.key) && ["openingOrder", "held", "needsSupport"].includes(ref.stage));
+      if (unresolved) return stopWith("rejected", unresolved.stage === "openingOrder" ? "paymentInProgress" : "needsSupport");
     }
     return deps.productBusy?.(sale.appleProduct.productId) ? stopWith("rejected", "paymentInProgress") : null;
   }
+  async function resolveOpenings(sale) {
+    if (!sale.adapter.repeatable || !sale.adapter.resolveOpening) return null;
+    for (const guard of openingsOf(sale)) {
+      const resolution = await settleOpening(sale.partition, sale.adapter, guard, sale.item, sale.bridge, now());
+      if (!sale.bridge.isCurrent() || resolution === "sessionChanged") return STALE2;
+      if (resolution === "unavailable") return retry("unavailable");
+      if (resolution === "storageUnavailable") return stopWith("rejected", "storageUnavailable");
+      if (resolution === "unrelated") sale.unrelated.add(guard.key);
+    }
+    return null;
+  }
+  function openingsOf(sale) {
+    const prefix = `${sale.item.reference.kind}:${sale.item.reference.id}#`;
+    return sale.partition.refs().filter((ref) => ref.stage === "openingOrder" && ref.key.startsWith(prefix));
+  }
   async function saleFor(session, catalogRef) {
     const sold = deps.itemFor(catalogRef);
     const adapter = sold && adapterFor(sold.item.reference.kind);
@@ -1963,13 +2011,15 @@ function createWixOrderBackend(deps) {
       adapter,
       member,
       partition: member.partition,
-      bridge: bindBridge(session, deps.session, deps.bridge)
+      bridge: bindBridge(session, deps.session, deps.bridge),
+      unrelated: /* @__PURE__ */ new Set()
     };
   }
   async function orderFor(sale) {
     const existing = refAt(sale.partition, sale.catalogRef);
     let prevented;
-    const beforeCreate = () => {
+    let guarded;
+    const beforeCreate = (guard = {}) => {
       if (!sale.adapter.repeatable || existing) return true;
       if (!sale.bridge.isCurrent()) {
         prevented = STALE2;
@@ -1980,18 +2030,30 @@ function createWixOrderBackend(deps) {
         prevented = blocked;
         return false;
       }
-      const opening = persist(sale, { key: sale.catalogRef, kind: sale.adapter.kind, stage: "openingOrder", updatedAt: now() });
+      const opening = persist(sale, { ...guard, key: sale.catalogRef, kind: sale.adapter.kind, stage: "openingOrder", updatedAt: now() });
       if (isStop(opening)) {
         prevented = opening;
         return false;
       }
+      guarded = opening.updatedAt;
       return true;
     };
-    const attempt3 = existing?.cashierOrderId && existing.verticalRef ? await reopenOrOpen(sale, { cashierOrderId: existing.cashierOrderId, verticalRef: existing.verticalRef }) : await sale.adapter.openOrder(sale.item, sale.bridge, beforeCreate);
+    const afterCreate = (guard) => {
+      const opening = refAt(sale.partition, sale.catalogRef);
+      if (opening?.stage !== "openingOrder" || opening.updatedAt !== guarded) return;
+      const recorded = persist(sale, { ...opening, ...guard, verticalRef: { ...opening.verticalRef, ...guard.verticalRef }, updatedAt: now() });
+      if (!isStop(recorded)) guarded = recorded.updatedAt;
+    };
+    const attempt3 = existing?.cashierOrderId && existing.verticalRef ? await reopenOrOpen(sale, { cashierOrderId: existing.cashierOrderId, verticalRef: existing.verticalRef }) : await sale.adapter.openOrder(sale.item, sale.bridge, beforeCreate, afterCreate);
     if (prevented) return prevented;
+    if (guarded !== void 0 && attempt3.status === "open" && !stillGuarded(sale, guarded)) return retry("unavailable");
     const ref = recordOrder(sale, existing, attempt3);
     return isStop(ref) ? ref : { ref, placed: isPlaced(attempt3) };
   }
+  function stillGuarded(sale, guarded) {
+    const stored = refAt(sale.partition, sale.catalogRef);
+    return stored?.stage === "openingOrder" && stored.updatedAt === guarded;
+  }
   async function reopenOrOpen(sale, order) {
     const reopened = await sale.adapter.reopenOrder(order, sale.bridge);
     const closed = reopened.status === "refused" && reopened.reason === "orderClosed";
@@ -2234,8 +2296,9 @@ var NOT_CONFIGURED = { stop: true, result: "rejected", failure: "notConfigured"
 var UNAVAILABLE = { stop: true, result: "retryable", failure: "unavailable" };
 var OUTCOME_UNKNOWN = { stop: true, result: "rejected", failure: "outcomeUnknown" };
 var BLOCKING_STAGES = {
+  // A repeatable sale's guard settles on a later tap, so it keeps the action tappable.
   startingItem: "outcomeUnknown",
-  openingOrder: "outcomeUnknown",
+  openingOrder: "paymentInProgress",
   submitted: "paymentInProgress",
   held: "paymentHeld",
   needsSupport: "needsSupport"
@@ -2494,6 +2557,7 @@ function enabledCheckout(deps) {
     if (!tracked) return backOffDue();
     partitionRead = null;
     for (const key of pruneExpiredHolds(tracked.partition, deps.clock.now())) payments.delete(key);
+    if (!options.dueOnly) await settleOpenings(session, tracked.partition);
     for (const ref of tracked.partition.refs()) {
       if (!isCurrent(session)) return;
       if (ref.stage === "needsSupport") setPayment(ref.key, "needsSupport");
@@ -2509,6 +2573,13 @@ function enabledCheckout(deps) {
     }
     publish();
   }
+  async function settleOpenings(session, partition) {
+    for (const ref of partition.refs()) {
+      const adapter = deps.adapters.find((candidate) => candidate.kind === ref.kind);
+      if (ref.stage !== "openingOrder" || !adapter?.resolveOpening || !isCurrent(session)) continue;
+      await settleOpening(partition, adapter, ref, void 0, bindBridge(session, deps.session, bridge), deps.clock.now());
+    }
+  }
   async function trackedPartition(session) {
     const binding = await bindingOf(deps.binding);
     if (!binding || !isCurrent(session)) return binding === null ? "none" : null;
@@ -3322,6 +3393,12 @@ var BOOKING = "bookingsService";
 var TICKET = "eventsTicket";
 var NOT_ENABLED = { status: "refused", reason: "notEnabled" };
 var CHANGED = { status: "refused", reason: "productChanged" };
+var MINUTE_MS = 6e4;
+var RELEASE_MARGIN_MS = 3e5;
+var DEFAULT_RESERVATION_MINUTES = 60;
+var PAYMENT_TAKEN = ["PAID", "PARTIALLY_PAID", "EXEMPT", "REFUNDED"];
+var HAS_OFFSET = /(?:Z|[+-]\d{2}:?\d{2})$/i;
+var LATEST_ZONE_MS = 432e5;
 function attendanceOrdersWith(options) {
   const now = options.now ?? Date.now;
   return {
@@ -3329,7 +3406,8 @@ function attendanceOrdersWith(options) {
       kind: BOOKING,
       repeatable: true,
       eligibility: (item) => eligible(item, BOOKING, options.bookingsEnabled),
-      openOrder: (item, bridge, beforeCreate) => options.bookingsEnabled ? openBooking(item, bridge, beforeCreate) : Promise.resolve(NOT_ENABLED),
+      openOrder: (item, bridge, beforeCreate, afterCreate) => options.bookingsEnabled ? openBooking(item, bridge, beforeCreate, afterCreate) : Promise.resolve(NOT_ENABLED),
+      resolveOpening: resolveBookingOpening,
       readAccess: bookingAccess,
       reopenOrder: (order, bridge) => reopen(order, bridge, bookingAccess)
     },
@@ -3337,7 +3415,7 @@ function attendanceOrdersWith(options) {
       kind: TICKET,
       repeatable: true,
       eligibility: (item) => eligible(item, TICKET, options.eventsEnabled),
-      openOrder: (item, bridge, beforeCreate) => options.eventsEnabled ? openTicket(item, bridge, now, beforeCreate) : Promise.resolve(NOT_ENABLED),
+      openOrder: (item, bridge, beforeCreate, afterCreate) => options.eventsEnabled ? openTicket(item, bridge, now, beforeCreate, afterCreate) : Promise.resolve(NOT_ENABLED),
       readAccess: ticketAccess,
       reopenOrder: (order, bridge) => reopen(order, bridge, ticketAccess, now)
     }
@@ -3350,7 +3428,7 @@ function eligible(item, kind, enabled) {
   const selection = kind === BOOKING ? item.attendance.booking : item.attendance.ticket;
   return selection ? { eligible: true } : UNSUPPORTED;
 }
-async function openBooking(item, bridge, beforeCreate) {
+async function openBooking(item, bridge, beforeCreate, afterCreate) {
   if (!eligible(item, BOOKING, true).eligible) return notCreated(ORDER_REFUSED);
   const selected = item.attendance.booking;
   if (selected.slot.serviceId !== item.reference.id || !isNonEmpty3(selected.slot.startDate) || !isNonEmpty3(selected.slot.endDate)) return notCreated(ORDER_REFUSED);
@@ -3364,11 +3442,49 @@ async function openBooking(item, bridge, beforeCreate) {
   if (isRefusal(availability)) return notCreated(attemptRefused(availability));
   const entries = isObject7(availability.body) ? availability.body.availabilityEntries : void 0;
   if (!Array.isArray(entries) || !entries.some((entry) => isObject7(entry) && entry.bookable === true && matchesSlot(entry.slot, selected.slot))) return notCreated(CHANGED);
-  if (beforeCreate && !beforeCreate()) return notCreated({ status: "refused", reason: "storageUnavailable" });
+  if (beforeCreate && !beforeCreate(slotGuard(selected.slot))) return notCreated({ status: "refused", reason: "storageUnavailable" });
   const created = await bridge.call("POST", "/bookings/v2/bookings", { booking: { bookedEntity: { slot: selected.slot }, contactDetails: selected.contactDetails, totalParticipants: 1, selectedPaymentOption: "ONLINE", ...selected.formInfo ? { formInfo: selected.formInfo } : {} } });
   if (isRefusal(created)) return creationRefused(created);
   const bookingId = bodyObject(created, "booking")?.id;
-  return isNonEmpty3(bookingId) ? bookingCheckout(item, bookingId, bridge) : ORDER_REFUSED;
+  if (!isNonEmpty3(bookingId)) return ORDER_REFUSED;
+  afterCreate?.({ verticalRef: { bookingId } });
+  return bookingCheckout(item, bookingId, bridge);
+}
+function slotGuard(slot) {
+  const verticalRef = {};
+  for (const key of ["sessionId", "startDate"]) if (isNonEmpty3(slot[key])) verticalRef[key] = slot[key];
+  const ends = latestInstant(String(slot.endDate));
+  return Number.isFinite(ends) ? { verticalRef, releaseAt: ends + RELEASE_MARGIN_MS } : { verticalRef };
+}
+function latestInstant(value) {
+  if (HAS_OFFSET.test(value)) return Date.parse(value);
+  return Date.parse(`${value}Z`) + LATEST_ZONE_MS;
+}
+async function resolveBookingOpening(guard, item, bridge, options) {
+  const scope = sameSlot(guard.verticalRef, item?.attendance?.booking?.slot) ? "held" : "unrelated";
+  const bookingId = guard.verticalRef?.bookingId;
+  if (!bookingId || !options.settled) return scope;
+  const released2 = await releaseBooking(bookingId, bridge, options.claim);
+  return released2 === "held" || released2 === "unavailable" && scope === "unrelated" ? scope : released2;
+}
+async function releaseBooking(bookingId, bridge, claim) {
+  const read2 = await bridge.call("POST", "/bookings/v2/bookings/query", { query: { filter: { id: { $eq: bookingId } } } });
+  if (isRefusal(read2)) return read2.status === "http" && read2.httpStatus === 404 ? "released" : openingRefused(read2);
+  const rows = isObject7(read2.body) ? read2.body.bookings : void 0;
+  const booking = Array.isArray(rows) ? rows.find((b) => isObject7(b) && b.id === bookingId) : void 0;
+  if (!isObject7(booking)) return "held";
+  if (["CANCELED", "CANCELLED", "DECLINED"].includes(String(booking.status)) || PAYMENT_TAKEN.includes(String(booking.paymentStatus))) return "released";
+  if (booking.status !== "CREATED" || !claim()) return "held";
+  const cancelled = await bridge.call("POST", `/bookings/v2/bookings/${encodeURIComponent(bookingId)}/cancel`, { participantNotification: { notifyParticipants: false }, revision: booking.revision });
+  return isRefusal(cancelled) ? openingRefused(cancelled) : "released";
+}
+function openingRefused(refusal) {
+  if (refusal.status === "sessionChanged") return "sessionChanged";
+  return refusal.status === "unavailable" ? "unavailable" : "held";
+}
+function sameSlot(guarded, slot) {
+  if (!guarded || !slot) return true;
+  return guarded.sessionId === slot.sessionId && Date.parse(guarded.startDate ?? "") === Date.parse(String(slot.startDate));
 }
 async function bookingCheckout(item, bookingId, bridge) {
   const checkout = await bridge.call("POST", "/ecom/v1/checkouts", { lineItems: [{ quantity: 1, catalogReference: { appId: "13d21c63-b5ec-5912-8397-c3a5ddb27a97", catalogItemId: bookingId } }], channelType: "OTHER_PLATFORM" });
@@ -3397,7 +3513,7 @@ async function bookingAccess(ref, bridge) {
   if (booking.status === "CANCELED" || booking.status === "CANCELLED" || booking.status === "DECLINED") return "none";
   return payment === "PAID" && booking.status === "CONFIRMED" && booking.paymentStatus === "PAID" ? "granted" : "pending";
 }
-async function openTicket(item, bridge, now, beforeCreate) {
+async function openTicket(item, bridge, now, beforeCreate, afterCreate) {
   if (!eligible(item, TICKET, true).eligible) return notCreated(ORDER_REFUSED);
   const selected = item.attendance.ticket;
   if (!isNonEmpty3(selected.eventId)) return notCreated(ORDER_REFUSED);
@@ -3408,16 +3524,23 @@ async function openTicket(item, bridge, now, beforeCreate) {
   const definitions = isObject7(available.body) ? available.body.definitions : void 0;
   const live = Array.isArray(definitions) ? definitions.find((t) => isObject7(t) && t.id === item.reference.id && t.saleStatus === "SALE_STARTED") : void 0;
   if (!isObject7(live) || !samePrice(live.price, item)) return notCreated(CHANGED);
-  if (live.eventId !== selected.eventId || classifyForApple(availableTicketAttendanceOf(bodyObject(read2, "event"), live), item.attendance.currency) !== "appleIap") return notCreated(ORDER_REFUSED);
-  if (beforeCreate && !beforeCreate()) return notCreated({ status: "refused", reason: "storageUnavailable" });
-  return reserveTicket(item, bridge, now);
+  const event = bodyObject(read2, "event");
+  if (live.eventId !== selected.eventId || classifyForApple(availableTicketAttendanceOf(event, live), item.attendance.currency) !== "appleIap") return notCreated(ORDER_REFUSED);
+  if (beforeCreate && !beforeCreate({ releaseAt: now() + reservationMinutes(event) * MINUTE_MS + RELEASE_MARGIN_MS })) return notCreated({ status: "refused", reason: "storageUnavailable" });
+  return reserveTicket(item, bridge, now, afterCreate);
+}
+function reservationMinutes(event) {
+  const registration = isObject7(event?.registration) ? event.registration : void 0;
+  const minutes = isObject7(registration?.tickets) ? registration.tickets.reservationDurationInMinutes : void 0;
+  return typeof minutes === "number" && minutes > 0 ? minutes : DEFAULT_RESERVATION_MINUTES;
 }
-async function reserveTicket(item, bridge, now) {
+async function reserveTicket(item, bridge, now, afterCreate) {
   const selected = item.attendance.ticket;
   const held = await bridge.call("POST", "/events/v1/checkout/reservations", { eventId: selected.eventId, ticketQuantities: [{ ticketDefinitionId: item.reference.id, quantity: 1 }], ignoreLimits: false, allowHiddenTickets: false });
   if (isRefusal(held)) return creationRefused(held);
   const reservation = held.body;
   if (!isObject7(reservation) || !isNonEmpty3(reservation.id) || !future(reservation.expires, now)) return ORDER_CLOSED;
+  afterCreate?.({ verticalRef: { reservationId: reservation.id }, releaseAt: Date.parse(reservation.expires) + RELEASE_MARGIN_MS });
   if (!heldAsSelected(reservation, item)) return CHANGED;
   const placed = await bridge.call("POST", "/events/v1/checkout", { eventId: selected.eventId, reservationId: reservation.id, buyer: selected.buyer, ...selected.guests ? { guests: selected.guests } : {}, ...selected.buyerSubmission ? { buyerSubmission: selected.buyerSubmission } : {}, ...selected.guestSubmissions ? { guestSubmissions: selected.guestSubmissions } : {}, options: { silent: false, payInPerson: false, ignoreFormValidation: false, markAsPaid: false } });
   if (isRefusal(placed)) return attemptRefused(placed);

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

@@ -664,8 +664,8 @@ var IAP_CATALOG_KINDS = ["onlineProgram", "storesProduct", "pricingPlan", "booki
 
 // ../../core/sdk/iap/src/wix-payments-contract.ts
 var HIMALAYA_SERVE_IAP_ROUTE = { prefix: "/himalaya-serve/v1/iap" };
-var BOOKINGS_APPLE_SALES_ENABLED = false;
-var EVENTS_APPLE_SALES_ENABLED = false;
+var BOOKINGS_APPLE_SALES_ENABLED = true;
+var EVENTS_APPLE_SALES_ENABLED = true;
 var ATTENDANCE_SALE_RULE = { appProductId: (id) => id, productType: "CONSUMABLE" };
 var STORES_ITEM_PAYMENT_ENABLED = false;
 var STORES_APPLE_SALES_ENABLED = true;
@@ -1444,10 +1444,13 @@ function locationType(raw) {
   return type === "CUSTOM" && addresses.every(describesNoPlace) ? ADDRESSLESS_CUSTOM : type;
 }
 function describesNoPlace(address) {
-  const parts = ["country", "subdivision", "city", "postalCode", "addressLine", "addressLine2", "streetAddress", "location"];
+  const parts = ["country", "subdivision", "city", "postalCode", "addressLine2", "streetAddress", "location"];
   if (parts.some((key) => address[key] !== void 0 && address[key] !== "")) return false;
-  const description = text(address.formattedAddress)?.trim() ?? "";
-  return description === "" || ONLINE_LABEL.test(description);
+  return [address.addressLine, address.formattedAddress].every((value) => {
+    if (value !== void 0 && typeof value !== "string") return false;
+    const description = value?.trim() ?? "";
+    return description === "" || ONLINE_LABEL.test(description);
+  });
 }
 var ONLINE_LABEL = /^(online|virtual)(\s+(class|classes|classroom|course|session|sessions|meeting|lesson|training|workshop|event))?$/i;
 function ticketAttendanceOf(event, definition) {