@drip-apex/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,645 @@
+// src/shopify-cart-events.ts
+var suppressNotifications = 0;
+function fetchWithoutShopifyCartMutationNotification(...args) {
+  suppressNotifications += 1;
+  try {
+    const activeFetch = typeof window.fetch === "function" ? window.fetch : globalThis.fetch;
+    return activeFetch.call(window, ...args);
+  } finally {
+    suppressNotifications -= 1;
+  }
+}
+
+// src/shopify-cart.ts
+function isShopifyStorefront() {
+  return typeof window !== "undefined" && !!window.Shopify;
+}
+function shopifyRoutesRoot() {
+  const configuredRoot = window.Shopify?.routes?.root;
+  if (typeof configuredRoot !== "string") return "/";
+  try {
+    const storefrontOrigin = window.location?.origin;
+    if (!storefrontOrigin) return "/";
+    const parsed = new URL(configuredRoot, storefrontOrigin);
+    if (parsed.origin !== storefrontOrigin || parsed.search || parsed.hash) return "/";
+    return parsed.pathname.endsWith("/") ? parsed.pathname : `${parsed.pathname}/`;
+  } catch {
+    return "/";
+  }
+}
+function shopifyCartPath() {
+  return `${shopifyRoutesRoot()}cart.js`;
+}
+
+// src/commerce-gift.ts
+var MARKER = "_apex_gwp";
+var DECLINE_PREFIX = "drip_gwp_declined:";
+var INSERTED_PREFIX = "drip_gwp_inserted:";
+var ANY_CART = "*";
+var inFlight = null;
+var queuedArgs = null;
+var insertedThisSession = /* @__PURE__ */ new Map();
+var selectedGiftOptions = /* @__PURE__ */ new Map();
+var dispatchedChoices = /* @__PURE__ */ new Set();
+var activeChoiceTier = /* @__PURE__ */ new Map();
+var choiceTierGeneration = 0;
+var latestArgs = null;
+function giftTiers(variant) {
+  const raw = Array.isArray(variant.tiers) && variant.tiers.length > 0 ? variant.tiers : [{ threshold: variant.threshold, gift_variant_gid: variant.gift_variant_gid }];
+  const tiers = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+    const tier = item;
+    if (typeof tier.threshold !== "string" || !/^\d+$/.test(tier.threshold) || typeof tier.gift_variant_gid !== "string" || // Malformed fixed-tier GIDs would reach choice dispatch with a null
+    // giftId and abort reconciliation mid-run; money-path config fails
+    // closed at parse time instead.
+    numericVariantId(tier.gift_variant_gid) === null) return null;
+    const choices = tier.gift_choice_variant_gids;
+    if (choices !== void 0 && (!Array.isArray(choices) || choices.length < 2 || choices.length > 4 || !choices.every((gid) => typeof gid === "string" && numericVariantId(gid) !== null))) return null;
+    tiers.push({
+      threshold: tier.threshold,
+      gift_variant_gid: tier.gift_variant_gid,
+      ...choices ? { gift_choice_variant_gids: choices } : {}
+    });
+  }
+  if (tiers.length < 1 || tiers.length > 3 || tiers.some((tier, index) => !Number.isSafeInteger(Number(tier.threshold)) || index > 0 && Number(tier.threshold) <= Number(tiers[index - 1].threshold))) return null;
+  return tiers;
+}
+function declined(experimentId) {
+  try {
+    return sessionStorage.getItem(`${DECLINE_PREFIX}${experimentId}`) === "1";
+  } catch {
+    return false;
+  }
+}
+function recordDecline(experimentId) {
+  try {
+    sessionStorage.setItem(`${DECLINE_PREFIX}${experimentId}`, "1");
+  } catch {
+  }
+}
+function insertionRecord(experimentId) {
+  try {
+    return localStorage.getItem(`${INSERTED_PREFIX}${experimentId}`) ?? insertedThisSession.get(experimentId) ?? null;
+  } catch {
+    return insertedThisSession.get(experimentId) ?? null;
+  }
+}
+function recordCart(record) {
+  if (!record.startsWith("{")) return record;
+  try {
+    const parsed = JSON.parse(record);
+    return typeof parsed.cart === "string" ? parsed.cart : record;
+  } catch {
+    return record;
+  }
+}
+function recordVariantGid(record) {
+  if (!record.startsWith("{")) return null;
+  try {
+    const parsed = JSON.parse(record);
+    return typeof parsed.variantGid === "string" ? parsed.variantGid : null;
+  } catch {
+    return null;
+  }
+}
+function recordTierThreshold(record) {
+  if (!record.startsWith("{")) return null;
+  try {
+    const parsed = JSON.parse(record);
+    return typeof parsed.tierThreshold === "string" ? parsed.tierThreshold : null;
+  } catch {
+    return null;
+  }
+}
+function insertionMatchesCart(record, cartToken) {
+  const token = recordCart(record);
+  return token === ANY_CART || cartToken == null || token === cartToken;
+}
+function recordInserted(experimentId, cartToken, variantGid, tierThreshold) {
+  const token = cartToken ?? ANY_CART;
+  const value = variantGid || tierThreshold ? JSON.stringify({ cart: token, variantGid, tierThreshold }) : token;
+  insertedThisSession.set(experimentId, value);
+  try {
+    localStorage.setItem(`${INSERTED_PREFIX}${experimentId}`, value);
+  } catch {
+  }
+  const selection = selectedGiftOptions.get(experimentId);
+  if (selection?.pending && selection.gid === variantGid) {
+    selectedGiftOptions.set(experimentId, {
+      gid: selection.gid,
+      tierThreshold: selection.tierThreshold
+    });
+  }
+}
+function clearInserted(experimentId) {
+  insertedThisSession.delete(experimentId);
+  try {
+    localStorage.removeItem(`${INSERTED_PREFIX}${experimentId}`);
+  } catch {
+  }
+}
+function clearDispatchedChoices(experimentId) {
+  dispatchedChoices.forEach((key) => {
+    if (key.startsWith(`${experimentId}:`)) dispatchedChoices.delete(key);
+  });
+}
+function listInsertionRecords() {
+  const ids = new Set(insertedThisSession.keys());
+  try {
+    for (let i = 0; i < localStorage.length; i += 1) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(INSERTED_PREFIX)) ids.add(key.slice(INSERTED_PREFIX.length));
+    }
+  } catch {
+  }
+  return [...ids];
+}
+function hasInsertionRecords() {
+  return listInsertionRecords().length > 0;
+}
+var teardownChecked = false;
+function markTeardownChecked() {
+  teardownChecked = true;
+}
+function numericVariantId(gid) {
+  const match = /^gid:\/\/shopify\/ProductVariant\/(\d+)$/.exec(gid);
+  if (!match) return null;
+  const id = Number(match[1]);
+  return Number.isSafeInteger(id) && id > 0 ? id : null;
+}
+function marker(line) {
+  if (!line.properties || typeof line.properties !== "object" || Array.isArray(line.properties)) return null;
+  const value = line.properties[MARKER];
+  return typeof value === "string" ? value : null;
+}
+function lineVariantId(line) {
+  if (typeof line.variant_id === "number" && Number.isSafeInteger(line.variant_id)) return String(line.variant_id);
+  if (typeof line.variant_id === "string" && /^\d+$/.test(line.variant_id)) return line.variant_id;
+  return null;
+}
+function lineAmount(line) {
+  const value = line.line_price;
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+async function mutate(path, body) {
+  try {
+    const response = await fetchWithoutShopifyCartMutationNotification(path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function run(settings, assignments, options, generation) {
+  if (!isShopifyStorefront() || typeof fetch !== "function") return false;
+  let response;
+  try {
+    response = await fetchWithoutShopifyCartMutationNotification(shopifyCartPath(), {
+      method: "GET",
+      headers: { Accept: "application/json" },
+      cache: "no-store"
+    });
+  } catch {
+    return false;
+  }
+  if (!response.ok) return false;
+  const cart = await response.json();
+  if (!Array.isArray(cart.items) || typeof cart.currency !== "string") return false;
+  let cartMutated = false;
+  const lines = cart.items.filter((item) => !!item && typeof item === "object");
+  const cartToken = typeof cart.token === "string" && cart.token ? cart.token : null;
+  const assigned = new Map(assignments.map((item) => [item.experimentId, item.variationId]));
+  const chargeOnlyExperimentIds = new Set(
+    assignments.filter((item) => item.commercePriceOnly).map((item) => item.experimentId)
+  );
+  const experiments = settings?.experiments ?? [];
+  const authorizedOfferExperimentIds = new Set(
+    settings?.authorization?.experimentIds ?? []
+  );
+  const root = shopifyRoutesRoot();
+  const changePath = `${root}cart/change.js`;
+  const insertedVariantIdsThisRun = /* @__PURE__ */ new Set();
+  const removedLineKeys = /* @__PURE__ */ new Set();
+  const removeLine = async (line) => {
+    if (typeof line.key !== "string") return false;
+    if (!await mutate(changePath, { id: line.key, quantity: 0 })) return false;
+    removedLineKeys.add(line.key);
+    cartMutated = true;
+    return true;
+  };
+  const linePresent = (line) => typeof line.key === "string" ? !removedLineKeys.has(line.key) : true;
+  const activeGiftExperiments = new Set(
+    experiments.filter((experiment) => {
+      const variationId = assigned.get(experiment.experiment_id);
+      const variant = variationId ? experiment.variants[variationId] : void 0;
+      if (!variant || typeof variant !== "object") return false;
+      if (options?.isArmProven) {
+        const assignment = assignments.find(
+          (candidate) => candidate.experimentId === experiment.experiment_id
+        );
+        if (!assignment || !options.isArmProven(assignment)) return false;
+      }
+      if ("control" in variant && variant.control === true) return true;
+      return "offer_type" in variant && variant.offer_type === "gwp_threshold" && giftTiers(variant) !== null;
+    }).map((experiment) => experiment.experiment_id)
+  );
+  for (const line of lines) {
+    const mark = marker(line);
+    if (mark == null || activeGiftExperiments.has(mark)) continue;
+    recordInserted(mark, cartToken);
+    if (await removeLine(line)) clearInserted(mark);
+  }
+  for (const experimentId of listInsertionRecords()) {
+    if (activeGiftExperiments.has(experimentId)) continue;
+    if (lines.some((line) => marker(line) === experimentId && linePresent(line))) continue;
+    clearInserted(experimentId);
+  }
+  if (settings && experiments.length === 0) markTeardownChecked();
+  for (const experiment of experiments) {
+    activeChoiceTier.delete(experiment.experiment_id);
+    const variationId = assigned.get(experiment.experiment_id);
+    if (!variationId) continue;
+    const variant = experiment.variants[variationId];
+    if (!variant || typeof variant !== "object") continue;
+    const managedLines = () => lines.filter(
+      (line) => marker(line) === experiment.experiment_id && linePresent(line)
+    );
+    const removeAllManaged = async () => {
+      let allRemoved = true;
+      for (const line of managedLines()) {
+        if (typeof line.key !== "string") continue;
+        if (!await removeLine(line)) {
+          allRemoved = false;
+          cartMutated = true;
+        }
+      }
+      return allRemoved;
+    };
+    if ("control" in variant && variant.control === true) {
+      if (await removeAllManaged()) clearInserted(experiment.experiment_id);
+      continue;
+    }
+    if (!("offer_type" in variant) || variant.offer_type !== "gwp_threshold") continue;
+    const tiers = giftTiers(variant);
+    if (!tiers) continue;
+    if (cart.currency.toUpperCase() !== experiment.currency.toUpperCase()) {
+      if (await removeAllManaged()) clearInserted(experiment.experiment_id);
+      continue;
+    }
+    const allGiftIds = new Set(tiers.flatMap((tier) => tier.gift_choice_variant_gids ?? [tier.gift_variant_gid]).map(numericVariantId).filter((id) => id !== null).map(String));
+    let subtotal = 0;
+    let valid = true;
+    for (const line of lines) {
+      if (!linePresent(line) || allGiftIds.has(lineVariantId(line) ?? "")) continue;
+      const amount = lineAmount(line);
+      if (amount == null || !Number.isSafeInteger(subtotal + amount)) {
+        valid = false;
+        break;
+      }
+      subtotal += amount;
+    }
+    const applicableTier = valid ? tiers.reduce((chosen, tier) => {
+      const threshold = Number(tier.threshold);
+      return Number.isSafeInteger(threshold) && threshold >= 0 && subtotal >= threshold ? tier : chosen;
+    }, null) : null;
+    if (!valid || tiers.some((tier) => !Number.isSafeInteger(Number(tier.threshold)))) {
+      for (const line of managedLines()) {
+        if (typeof line.key !== "string") continue;
+        await removeLine(line);
+      }
+      continue;
+    }
+    if (!applicableTier) {
+      clearDispatchedChoices(experiment.experiment_id);
+      activeChoiceTier.delete(experiment.experiment_id);
+      if (await removeAllManaged()) clearInserted(experiment.experiment_id);
+      continue;
+    }
+    const choiceGids = applicableTier.gift_choice_variant_gids;
+    if (generation === choiceTierGeneration) {
+      const currentKey = choiceGids ? `${experiment.experiment_id}:${applicableTier.threshold}:${choiceGids.join(",")}` : null;
+      dispatchedChoices.forEach((key) => {
+        if (key.startsWith(`${experiment.experiment_id}:`) && key !== currentKey) {
+          dispatchedChoices.delete(key);
+        }
+      });
+    }
+    const markChoicePromptLive = () => {
+      if (choiceGids && !options?.suppressInsertion && authorizedOfferExperimentIds.has(experiment.experiment_id) && !declined(experiment.experiment_id)) {
+        const assignment = assignments.find(
+          (candidate) => candidate.experimentId === experiment.experiment_id
+        );
+        if ((!options?.isArmProven || assignment && options.isArmProven(assignment)) && generation === choiceTierGeneration) {
+          activeChoiceTier.set(experiment.experiment_id, applicableTier.threshold);
+        }
+      }
+    };
+    const extendedRecord = Array.isArray(variant.tiers);
+    const persistedRecord = insertionRecord(experiment.experiment_id);
+    const persistedGid = persistedRecord && insertionMatchesCart(persistedRecord, cartToken) ? recordVariantGid(persistedRecord) : null;
+    const lowestChoiceTierThresholdFor = (gid) => gid == null ? void 0 : tiers.find((tier) => tier.gift_choice_variant_gids?.includes(gid))?.threshold;
+    const persistedTierThreshold = persistedRecord === null ? null : recordTierThreshold(persistedRecord);
+    const tierlessRecoveryAllowed = (gid) => lowestChoiceTierThresholdFor(gid) === applicableTier.threshold;
+    const inMemorySelection = selectedGiftOptions.get(experiment.experiment_id);
+    let inMemoryGid = inMemorySelection?.tierThreshold === applicableTier.threshold ? inMemorySelection.gid : void 0;
+    const markedCurrentTierGid = choiceGids?.find((gid) => {
+      const variantId = numericVariantId(gid);
+      return variantId !== null && lines.some((line) => linePresent(line) && marker(line) === experiment.experiment_id && lineVariantId(line) === String(variantId));
+    });
+    const persistedChoiceIsCurrentTier = persistedRecord !== null && (persistedTierThreshold === applicableTier.threshold || persistedTierThreshold === null && tierlessRecoveryAllowed(persistedGid ?? markedCurrentTierGid));
+    if (inMemorySelection && inMemoryGid) {
+      const persistedCurrentTierGid = persistedChoiceIsCurrentTier && choiceGids?.includes(persistedGid ?? "") ? persistedGid : null;
+      if (inMemorySelection.pending && persistedCurrentTierGid === inMemoryGid) {
+        selectedGiftOptions.set(experiment.experiment_id, {
+          gid: inMemorySelection.gid,
+          tierThreshold: inMemorySelection.tierThreshold
+        });
+      } else if (!inMemorySelection.pending && persistedCurrentTierGid && persistedCurrentTierGid !== inMemoryGid) {
+        selectedGiftOptions.delete(experiment.experiment_id);
+        inMemoryGid = void 0;
+      }
+    }
+    const selectedGid = choiceGids?.includes(inMemoryGid ?? "") ? inMemoryGid : persistedChoiceIsCurrentTier && choiceGids?.includes(persistedGid ?? "") ? persistedGid : persistedChoiceIsCurrentTier ? markedCurrentTierGid : void 0;
+    if (selectedGid) {
+      const priorPending = selectedGiftOptions.get(experiment.experiment_id)?.gid === selectedGid && selectedGiftOptions.get(experiment.experiment_id)?.pending === true;
+      selectedGiftOptions.set(experiment.experiment_id, {
+        gid: selectedGid,
+        tierThreshold: applicableTier.threshold,
+        ...priorPending ? { pending: true } : {}
+      });
+    }
+    const desiredGid = choiceGids ? selectedGid : applicableTier.gift_variant_gid;
+    const giftId = desiredGid ? numericVariantId(desiredGid) : null;
+    const allowedCurrentIds = new Set((choiceGids ?? [applicableTier.gift_variant_gid]).map(numericVariantId).filter((id) => id !== null).map(String));
+    let managed;
+    let staleRemovalFailed = false;
+    let removedStaleForExperiment = false;
+    for (const line of managedLines()) {
+      if (!managed && giftId !== null && lineVariantId(line) === String(giftId)) {
+        managed = line;
+        continue;
+      }
+      if (typeof line.key !== "string") continue;
+      if (await removeLine(line)) removedStaleForExperiment = true;
+      else staleRemovalFailed = true;
+    }
+    if (staleRemovalFailed) cartMutated = true;
+    if (staleRemovalFailed && !managed) continue;
+    if (!managed && removedStaleForExperiment) {
+      clearInserted(experiment.experiment_id);
+    }
+    if (managed && lines.some((line) => line !== managed && linePresent(line) && marker(line) !== experiment.experiment_id && allowedCurrentIds.has(lineVariantId(line) ?? ""))) {
+      if (typeof managed.key === "string" && await removeLine(managed)) {
+        clearInserted(experiment.experiment_id);
+      } else {
+        cartMutated = true;
+      }
+      continue;
+    }
+    if (!desiredGid || giftId === null) {
+      clearInserted(experiment.experiment_id);
+      markChoicePromptLive();
+      if (!options?.suppressInsertion && authorizedOfferExperimentIds.has(experiment.experiment_id) && !declined(experiment.experiment_id)) {
+        const assignment = assignments.find((candidate) => candidate.experimentId === experiment.experiment_id);
+        if (!options?.isArmProven || assignment && options.isArmProven(assignment)) {
+          const eventKey = `${experiment.experiment_id}:${applicableTier.threshold}:${choiceGids.join(",")}`;
+          if (generation === choiceTierGeneration) {
+            if (!dispatchedChoices.has(eventKey) && typeof window !== "undefined") {
+              dispatchedChoices.add(eventKey);
+              emitChoicePrompt({ experimentId: experiment.experiment_id, threshold: applicableTier.threshold, options: [...choiceGids] });
+            }
+          }
+        }
+      }
+      continue;
+    }
+    if (managed) {
+      markChoicePromptLive();
+      if (options?.suppressInsertion) {
+        const record2 = insertionRecord(experiment.experiment_id);
+        if (!record2 || !insertionMatchesCart(record2, cartToken)) {
+          if (await removeAllManaged()) clearInserted(experiment.experiment_id);
+          continue;
+        }
+      } else {
+        recordInserted(experiment.experiment_id, cartToken, extendedRecord ? desiredGid : void 0, extendedRecord ? applicableTier.threshold : void 0);
+      }
+      if (typeof managed.key === "string" && typeof managed.quantity === "number" && managed.quantity !== 1) {
+        cartMutated = true;
+        await mutate(changePath, { id: managed.key, quantity: 1 });
+      }
+      continue;
+    }
+    if (chargeOnlyExperimentIds.has(experiment.experiment_id)) {
+      if (insertionRecord(experiment.experiment_id) != null && lines.some(
+        (line) => !linePresent(line) && allowedCurrentIds.has(lineVariantId(line) ?? "")
+      )) {
+        clearInserted(experiment.experiment_id);
+      }
+      continue;
+    }
+    const satisfyingLine = lines.find(
+      (line) => linePresent(line) && allowedCurrentIds.has(lineVariantId(line) ?? "")
+    );
+    const insertedAllowedId = [...insertedVariantIdsThisRun].find((id) => allowedCurrentIds.has(id));
+    if (satisfyingLine || insertedAllowedId) {
+      markChoicePromptLive();
+      if (insertedAllowedId || satisfyingLine && marker(satisfyingLine) != null) {
+        const satisfyingGid = satisfyingLine ? choiceGids?.find((gid) => String(numericVariantId(gid)) === lineVariantId(satisfyingLine)) : choiceGids?.find((gid) => String(numericVariantId(gid)) === insertedAllowedId);
+        recordInserted(experiment.experiment_id, cartToken, extendedRecord ? satisfyingGid ?? desiredGid : void 0, extendedRecord ? applicableTier.threshold : void 0);
+      }
+      continue;
+    }
+    const record = insertionRecord(experiment.experiment_id);
+    if (record != null) {
+      clearInserted(experiment.experiment_id);
+      const removedByUsThisRun = lines.some(
+        (line) => !linePresent(line) && lineVariantId(line) === String(giftId)
+      );
+      if (!removedByUsThisRun && insertionMatchesCart(record, cartToken)) {
+        recordDecline(experiment.experiment_id);
+        continue;
+      }
+    }
+    if (declined(experiment.experiment_id)) continue;
+    if (options?.suppressInsertion) continue;
+    if (!authorizedOfferExperimentIds.has(experiment.experiment_id)) continue;
+    if (options?.isArmProven) {
+      const localAssignment = assignments.find(
+        (candidate) => candidate.experimentId === experiment.experiment_id
+      );
+      if (!localAssignment || !options.isArmProven(localAssignment)) continue;
+    }
+    const addResponse = await fetchWithoutShopifyCartMutationNotification(`${root}cart/add.js`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        items: [{ id: giftId, quantity: 1, properties: { [MARKER]: experiment.experiment_id } }]
+      })
+    }).catch(() => null);
+    if (!addResponse?.ok) {
+      const failedSelection = selectedGiftOptions.get(experiment.experiment_id);
+      if (choiceGids && failedSelection?.gid === desiredGid) {
+        selectedGiftOptions.delete(experiment.experiment_id);
+        clearDispatchedChoices(experiment.experiment_id);
+        markChoicePromptLive();
+        if (generation === choiceTierGeneration && typeof window !== "undefined") {
+          const retryKey = `${experiment.experiment_id}:${applicableTier.threshold}:${choiceGids.join(",")}`;
+          if (!dispatchedChoices.has(retryKey)) {
+            dispatchedChoices.add(retryKey);
+            emitChoicePrompt({ experimentId: experiment.experiment_id, threshold: applicableTier.threshold, options: [...choiceGids] });
+          }
+        }
+      }
+      continue;
+    }
+    if (addResponse?.ok) {
+      cartMutated = true;
+      recordInserted(experiment.experiment_id, cartToken, extendedRecord ? desiredGid : void 0, extendedRecord ? applicableTier.threshold : void 0);
+      insertedVariantIdsThisRun.add(String(giftId));
+      try {
+        const body = await addResponse.json();
+        const addedLine = Array.isArray(body.items) ? body.items.find((item) => !!item && typeof item === "object" && marker(item) === experiment.experiment_id) : void 0;
+        if (addedLine && typeof addedLine.key === "string" && typeof addedLine.quantity === "number" && addedLine.quantity > 1) {
+          cartMutated = true;
+          await mutate(changePath, { id: addedLine.key, quantity: 1 });
+        }
+      } catch {
+      }
+    }
+  }
+  return cartMutated;
+}
+function syncGiftWithPurchase(settings, assignments, options) {
+  latestArgs = { settings, assignments, options };
+  installChoiceRequestListener();
+  choiceTierGeneration += 1;
+  const batchGeneration = choiceTierGeneration;
+  activeChoiceTier.clear();
+  if (options?.recheckTeardown) teardownChecked = false;
+  if (!settings?.experiments.length && !hasInsertionRecords()) {
+    if (!settings || teardownChecked) return Promise.resolve();
+  }
+  if (inFlight) {
+    queuedArgs = { settings, assignments, options, generation: batchGeneration };
+    return inFlight;
+  }
+  const runToFixpoint = async (nextSettings, nextAssignments, nextOptions, generation) => {
+    let anyMutated = false;
+    for (let pass = 0; pass < 3; pass += 1) {
+      const mutated = await run(nextSettings, nextAssignments, nextOptions, generation).catch(() => false);
+      if (mutated) anyMutated = true;
+      if (!mutated) break;
+    }
+    if (anyMutated && typeof window !== "undefined") {
+      try {
+        window.dispatchEvent(
+          new CustomEvent("apex:cart:changed", { detail: { source: "gwp_gift" } })
+        );
+      } catch {
+      }
+    }
+  };
+  const pending = (async () => {
+    await runToFixpoint(settings, assignments, options, batchGeneration);
+    while (queuedArgs) {
+      const next = queuedArgs;
+      queuedArgs = null;
+      await runToFixpoint(next.settings, next.assignments, next.options, next.generation);
+    }
+    if (choiceReplayRequested) getPendingGiftChoices().forEach(emitChoicePrompt);
+    choiceReplayRequested = false;
+  })().finally(() => {
+    if (inFlight === pending) inFlight = null;
+    if (!inFlight && queuedArgs) {
+      const next = queuedArgs;
+      queuedArgs = null;
+      void syncGiftWithPurchase(next.settings, next.assignments, next.options);
+    }
+  });
+  inFlight = pending;
+  return pending;
+}
+function selectGiftOption(experimentId, variantGid) {
+  if (!latestArgs || numericVariantId(variantGid) === null) return Promise.resolve();
+  const experiment = latestArgs.settings?.experiments.find((item) => item.experiment_id === experimentId);
+  const variationId = latestArgs.assignments.find((item) => item.experimentId === experimentId)?.variationId;
+  const variant = variationId ? experiment?.variants[variationId] : void 0;
+  if (!variant || typeof variant !== "object") return Promise.resolve();
+  const tiers = giftTiers(variant);
+  const containingTiers = tiers?.filter((tier) => tier.gift_choice_variant_gids?.includes(variantGid)) ?? [];
+  const applicableThreshold = activeChoiceTier.get(experimentId);
+  const owningTier = containingTiers.find(
+    (tier) => tier.threshold === applicableThreshold
+  );
+  if (!owningTier) return Promise.resolve();
+  selectedGiftOptions.set(experimentId, {
+    gid: variantGid,
+    tierThreshold: owningTier.threshold,
+    pending: true
+  });
+  clearDispatchedChoices(experimentId);
+  return syncGiftWithPurchase(latestArgs.settings, latestArgs.assignments, latestArgs.options);
+}
+function emitChoicePrompt(detail) {
+  dispatchEvent(new CustomEvent("apex:gwp:choice", { detail }));
+}
+var choiceRequestListenerInstalled = false;
+var choiceReplayRequested = false;
+function installChoiceRequestListener() {
+  if (choiceRequestListenerInstalled || typeof window === "undefined") return;
+  choiceRequestListenerInstalled = true;
+  window.addEventListener("apex:gwp:choice:request", () => {
+    if (inFlight) choiceReplayRequested = true;
+    getPendingGiftChoices().forEach(emitChoicePrompt);
+  });
+}
+function getPendingGiftChoices(experimentId) {
+  if (!latestArgs) return [];
+  const prompts = [];
+  for (const [activeExperimentId, threshold] of activeChoiceTier) {
+    if (experimentId !== void 0 && activeExperimentId !== experimentId) continue;
+    const selected = selectedGiftOptions.get(activeExperimentId);
+    if (selected?.tierThreshold === threshold) continue;
+    const experiment = latestArgs.settings?.experiments.find(
+      (item) => item.experiment_id === activeExperimentId
+    );
+    const variationId = latestArgs.assignments.find(
+      (item) => item.experimentId === activeExperimentId
+    )?.variationId;
+    const variant = variationId ? experiment?.variants[variationId] : void 0;
+    if (!variant || typeof variant !== "object") continue;
+    const tier = giftTiers(variant)?.find(
+      (candidate) => candidate.threshold === threshold
+    );
+    if (!tier?.gift_choice_variant_gids) continue;
+    prompts.push({
+      experimentId: activeExperimentId,
+      threshold,
+      options: [...tier.gift_choice_variant_gids]
+    });
+  }
+  return prompts;
+}
+
+// src/module.ts
+function activeRuntime() {
+  return typeof window === "undefined" ? void 0 : window.drip;
+}
+function getPendingGiftChoices2(experimentId) {
+  const runtime = activeRuntime();
+  return runtime?.getPendingGiftChoices ? runtime.getPendingGiftChoices(experimentId) : getPendingGiftChoices(experimentId);
+}
+function selectGiftOption2(experimentId, variantGid) {
+  const runtime = activeRuntime();
+  return runtime?.selectGiftOption ? runtime.selectGiftOption(experimentId, variantGid) : selectGiftOption(experimentId, variantGid);
+}
+export {
+  getPendingGiftChoices2 as getPendingGiftChoices,
+  selectGiftOption2 as selectGiftOption
+};
+//# sourceMappingURL=index.mjs.map