@churnkey/react 0.1.0

package/dist/chunk-IFVMM2LB.js

@@ -0,0 +1,1054 @@
+// src/core/api.ts
+var DEFAULT_BASE_URL = "https://api.churnkey.co/v1";
+var ChurnkeyApi = class {
+  creds;
+  baseUrl;
+  constructor(creds, baseUrl) {
+    this.creds = creds;
+    this.baseUrl = baseUrl ?? DEFAULT_BASE_URL;
+  }
+  get headers() {
+    const h = {
+      "Content-Type": "application/json",
+      "x-ck-app": this.creds.appId,
+      "x-ck-customer": this.creds.customerId,
+      "x-ck-authorization": this.creds.authHash,
+      "x-ck-mode": this.creds.mode
+    };
+    if (this.creds.subscriptionId) {
+      h["x-ck-subscription"] = this.creds.subscriptionId;
+    }
+    return h;
+  }
+  orgUrl(path) {
+    return `${this.baseUrl}/api/orgs/${this.creds.appId}/${path}`;
+  }
+  // Action methods discard the response body, so don't parse JSON here —
+  // a server returning an empty 201 would otherwise blow up res.json() and
+  // surface as an error even though the action committed.
+  async request(url, body) {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: this.headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Churnkey API error (${res.status}): ${text}`);
+    }
+    return res;
+  }
+  async fetchConfig() {
+    const res = await this.request(this.orgUrl("cancel-flow/config"));
+    return await res.json();
+  }
+  async applyDiscount(couponId, blueprintId) {
+    await this.request(this.orgUrl("cancel-flow/actions/discount"), {
+      coupon: couponId,
+      blueprintId
+    });
+  }
+  async pause(params) {
+    await this.request(this.orgUrl("cancel-flow/actions/pause"), {
+      duration: params.duration,
+      interval: params.interval
+    });
+  }
+  async cancelSubscription() {
+    await this.request(this.orgUrl("cancel-flow/actions/cancel"), { cancelAtPeriodEnd: true });
+  }
+  async changePlan(planId) {
+    await this.request(this.orgUrl("cancel-flow/actions/change-plan"), { planId });
+  }
+  async extendTrial(days, blueprintId) {
+    await this.request(this.orgUrl("cancel-flow/actions/extend-trial"), { days, blueprintId });
+  }
+  async createSession(payload) {
+    await this.request(`${this.baseUrl}/api/sessions/sdk`, payload);
+  }
+};
+var AnalyticsClient = class {
+  appId;
+  baseUrl;
+  constructor(appId, baseUrl) {
+    this.appId = appId;
+    this.baseUrl = baseUrl ?? DEFAULT_BASE_URL;
+  }
+  // Fire-and-forget. Non-2xx responses are ignored — analytics failures
+  // should never surface into the host app's flow.
+  async createSession(payload) {
+    await fetch(`${this.baseUrl}/api/sessions/sdk`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-ck-app": this.appId
+      },
+      body: JSON.stringify(payload)
+    });
+  }
+};
+function toIsoString(value) {
+  if (value == null) return void 0;
+  return value instanceof Date ? value.toISOString() : String(value);
+}
+function toApiBillingInterval(interval) {
+  if (!interval) return void 0;
+  return interval.toUpperCase();
+}
+function directDataToSessionCustomer(customer, subscriptions) {
+  const sub = subscriptions?.[0];
+  const price = sub?.items[0]?.price;
+  return {
+    id: customer.id,
+    email: customer.email,
+    subscriptionId: sub?.id,
+    planId: price?.id,
+    planPrice: price?.amount.value,
+    currency: price?.amount.currency ?? customer.currency,
+    billingInterval: toApiBillingInterval(price?.duration?.interval),
+    created: toIsoString(sub?.start),
+    onTrial: sub ? sub.status.name === "trial" : void 0,
+    customAttributes: customer.metadata
+  };
+}
+
+// src/core/merge-fields.ts
+var MERGE_FIELD_PATTERN = /{{([a-zA-Z0-9_.]+)\|([^}]*)}}/g;
+function buildMergeAttrs(customer) {
+  if (!customer) return {};
+  const attrs = {};
+  const first = customer.name;
+  const last = customer.lastName;
+  const fullName = [first, last].filter(Boolean).join(" ") || void 0;
+  if (fullName) attrs.CUSTOMER_NAME = fullName;
+  if (first) attrs["CUSTOMER_NAME.FIRST"] = first;
+  if (last) attrs["CUSTOMER_NAME.LAST"] = last;
+  if (customer.email) attrs.CUSTOMER_EMAIL = customer.email;
+  for (const [key, value] of Object.entries(customer.metadata ?? {})) {
+    if (value != null) attrs[key] = String(value);
+  }
+  return attrs;
+}
+function applyMergeFields(text, attrs) {
+  if (!text?.includes("{{")) return text;
+  return text.replace(MERGE_FIELD_PATTERN, (_match, field, fallback) => attrs[field] ?? fallback);
+}
+function applyMergeFieldsToSteps(steps, customer) {
+  const attrs = buildMergeAttrs(customer);
+  return steps.map((step) => mergeStep(step, attrs));
+}
+function mergeStep(step, attrs) {
+  switch (step.type) {
+    case "survey": {
+      const s = step;
+      return {
+        ...s,
+        title: maybeMerge(s.title, attrs),
+        description: maybeMerge(s.description, attrs),
+        reasons: s.reasons.map((r) => mergeReason(r, attrs))
+      };
+    }
+    case "offer": {
+      const s = step;
+      return {
+        ...s,
+        title: maybeMerge(s.title, attrs),
+        description: maybeMerge(s.description, attrs),
+        offer: s.offer ? mergeOfferDecision(s.offer, attrs) : void 0
+      };
+    }
+    case "feedback": {
+      const s = step;
+      return {
+        ...s,
+        title: maybeMerge(s.title, attrs),
+        description: maybeMerge(s.description, attrs),
+        placeholder: maybeMerge(s.placeholder, attrs)
+      };
+    }
+    case "success":
+      return step;
+    default: {
+      const s = step;
+      return { ...step, title: maybeMerge(s.title, attrs), description: maybeMerge(s.description, attrs) };
+    }
+  }
+}
+function mergeReason(r, attrs) {
+  return { ...r, label: applyMergeFields(r.label, attrs) };
+}
+function mergeOfferDecision(o, attrs) {
+  return {
+    ...o,
+    copy: {
+      headline: applyMergeFields(o.copy.headline, attrs),
+      body: applyMergeFields(o.copy.body, attrs),
+      cta: applyMergeFields(o.copy.cta, attrs),
+      declineCta: applyMergeFields(o.copy.declineCta, attrs)
+    }
+  };
+}
+function maybeMerge(text, attrs) {
+  return text ? applyMergeFields(text, attrs) : text;
+}
+
+// src/core/step-graph.ts
+var EMPTY_GRAPH = { stepMap: {}, firstStepId: "", orderedStepIds: [] };
+function buildStepGraph(steps, defaultOfferCopy2) {
+  if (steps.length === 0) return EMPTY_GRAPH;
+  const resolved = steps.map((step, i) => normalizeStep(step, i));
+  linkNeighbors(resolved);
+  const stepMap = {};
+  for (const step of resolved) stepMap[step.guid] = step;
+  const surveyStep = resolved.find((s) => s.type === "survey");
+  if (surveyStep?.reasons) {
+    surveyStep.offersAttached = {};
+    for (const reason of surveyStep.reasons) {
+      if (!reason.offer) continue;
+      const offerGuid = `${surveyStep.guid}:offer:${reason.id}`;
+      stepMap[offerGuid] = {
+        guid: offerGuid,
+        type: "offer",
+        surveyOffer: true,
+        offer: toDecision(reason.offer, defaultOfferCopy2),
+        // Decline/next from the synthetic offer skips the survey entirely;
+        // back returns to the survey so the user can pick a different reason.
+        defaultNextStep: surveyStep.defaultNextStep,
+        defaultPreviousStep: surveyStep.guid
+      };
+      surveyStep.offersAttached[reason.id] = offerGuid;
+    }
+  }
+  return {
+    stepMap,
+    firstStepId: resolved[0].guid,
+    orderedStepIds: resolved.map((s) => s.guid),
+    surveyStepId: surveyStep?.guid
+  };
+}
+function normalizeStep(step, index) {
+  const guid = step.guid ?? `step-${index}-${step.type}`;
+  const base = { guid, type: step.type };
+  switch (step.type) {
+    case "survey": {
+      const s = step;
+      return {
+        ...base,
+        title: s.title,
+        description: s.description,
+        reasons: s.reasons,
+        numChoices: s.reasons.length,
+        classNames: s.classNames
+      };
+    }
+    case "offer": {
+      const s = step;
+      return {
+        ...base,
+        title: s.title,
+        description: s.description,
+        offer: s.offer,
+        classNames: s.classNames
+      };
+    }
+    case "feedback": {
+      const s = step;
+      return {
+        ...base,
+        title: s.title,
+        description: s.description,
+        placeholder: s.placeholder,
+        required: s.required,
+        minLength: s.minLength,
+        classNames: s.classNames
+      };
+    }
+    case "confirm": {
+      const s = step;
+      return {
+        ...base,
+        title: s.title,
+        description: s.description,
+        classNames: s.classNames
+      };
+    }
+    case "success": {
+      const s = step;
+      return {
+        ...base,
+        savedTitle: s.savedTitle,
+        savedDescription: s.savedDescription,
+        cancelledTitle: s.cancelledTitle,
+        cancelledDescription: s.cancelledDescription,
+        classNames: s.classNames
+      };
+    }
+    default: {
+      const s = step;
+      return {
+        ...base,
+        title: s.title,
+        description: s.description,
+        data: s.data
+      };
+    }
+  }
+}
+function linkNeighbors(steps) {
+  for (let i = 0; i < steps.length; i++) {
+    if (i < steps.length - 1) steps[i].defaultNextStep = steps[i + 1].guid;
+    if (i > 0) steps[i].defaultPreviousStep = steps[i - 1].guid;
+  }
+}
+function toDecision(offer, defaultCopy) {
+  return "copy" in offer ? offer : { ...offer, copy: defaultCopy(offer) };
+}
+
+// src/core/transform.ts
+function transformSdkConfig(config) {
+  return {
+    steps: config.steps.map(transformStep),
+    blueprintId: config.blueprintId,
+    metadata: {
+      autoOptimizationKey: config.autoOptimizationKey
+    }
+  };
+}
+function transformStep(step) {
+  switch (step.type) {
+    case "survey":
+      return {
+        type: "survey",
+        guid: step.guid,
+        title: step.title,
+        description: step.description,
+        reasons: step.reasons.map(transformReason)
+      };
+    case "offer":
+      return {
+        type: "offer",
+        guid: step.guid,
+        title: step.title,
+        description: step.description,
+        offer: transformOfferDecision(step.offer)
+      };
+    case "feedback":
+      return {
+        type: "feedback",
+        guid: step.guid,
+        title: step.title,
+        description: step.description,
+        placeholder: step.placeholder,
+        required: step.required,
+        minLength: step.minLength
+      };
+    case "confirm":
+      return {
+        type: "confirm",
+        guid: step.guid,
+        title: step.title,
+        description: step.description
+      };
+  }
+}
+function transformReason(r) {
+  const out = {
+    id: r.id,
+    label: r.label,
+    freeform: r.freeform
+  };
+  if (r.offer) out.offer = transformOfferConfig(r.offer);
+  return out;
+}
+function transformOfferDecision(o) {
+  return { ...transformOfferConfig(o), copy: o.copy, decisionId: o.decisionId };
+}
+function transformOfferConfig(o) {
+  switch (o.type) {
+    case "discount": {
+      const d = o;
+      return {
+        type: "discount",
+        couponId: d.couponId,
+        percentOff: d.percentOff,
+        amountOff: d.amountOff,
+        currency: d.currency,
+        durationInMonths: d.durationInMonths
+      };
+    }
+    case "pause":
+      return {
+        type: "pause",
+        months: o.months,
+        interval: o.interval,
+        datePicker: o.datePicker
+      };
+    case "plan_change":
+      return {
+        type: "plan_change",
+        plans: o.plans
+      };
+    case "trial_extension":
+      return {
+        type: "trial_extension",
+        days: o.days
+      };
+    case "redirect":
+      return {
+        type: "redirect",
+        url: o.url,
+        label: o.label ?? ""
+      };
+    case "contact":
+      return {
+        type: "contact",
+        url: o.url,
+        label: o.label
+      };
+  }
+}
+function defaultOfferCopy(offer) {
+  const o = offer;
+  switch (o.type) {
+    case "discount":
+      return {
+        headline: o.percentOff != null ? `How about ${o.percentOff}% off?` : "Special offer",
+        body: discountBody(o),
+        cta: "Accept offer",
+        declineCta: "No thanks"
+      };
+    case "pause":
+      return {
+        headline: "Take a break instead?",
+        body: `Pause your subscription for up to ${o.months} month${o.months === 1 ? "" : "s"}.`,
+        cta: "Pause subscription",
+        declineCta: "No thanks"
+      };
+    case "plan_change":
+      return {
+        headline: "Switch to a different plan?",
+        body: "We have other plans that might be a better fit.",
+        cta: "Switch plan",
+        declineCta: "No thanks"
+      };
+    case "trial_extension":
+      return {
+        headline: "Need more time?",
+        body: `We'll extend your trial by ${o.days} day${o.days === 1 ? "" : "s"}.`,
+        cta: "Extend trial",
+        declineCta: "No thanks"
+      };
+    case "contact":
+      return {
+        headline: "Talk to us first?",
+        body: "Our team would love to help resolve any issues.",
+        cta: o.label ?? "Contact support",
+        declineCta: "No thanks"
+      };
+    case "redirect":
+      return {
+        headline: "Before you go...",
+        body: "Check this out \u2014 it might change your mind.",
+        cta: o.label,
+        declineCta: "No thanks"
+      };
+    default:
+      return {
+        headline: "Before you go...",
+        body: "We'd like to offer you something.",
+        cta: "Accept",
+        declineCta: "No thanks"
+      };
+  }
+}
+function discountBody(o) {
+  if (o.percentOff == null) return "We'd like to offer you a discount.";
+  const months = o.durationInMonths ?? 1;
+  return `We'd like to offer you ${o.percentOff}% off for ${months} month${months === 1 ? "" : "s"}.`;
+}
+
+// src/core/machine.ts
+function handlerFor(offerType, cb) {
+  switch (offerType) {
+    case "discount":
+      return cb.handleDiscount;
+    case "pause":
+      return cb.handlePause;
+    case "plan_change":
+      return cb.handlePlanChange;
+    case "trial_extension":
+      return cb.handleTrialExtension;
+    default:
+      return void 0;
+  }
+}
+function listenerFor(offerType, cb) {
+  switch (offerType) {
+    case "discount":
+      return cb.onDiscount;
+    case "pause":
+      return cb.onPause;
+    case "plan_change":
+      return cb.onPlanChange;
+    case "trial_extension":
+      return cb.onTrialExtension;
+    default:
+      return void 0;
+  }
+}
+function runListener(listener, offer, customer) {
+  return Promise.resolve(listener(offer, customer)).catch((e) => {
+    console.error("Error in offer listener:", e);
+  });
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+var STEP_TYPE_API_MAP = {
+  survey: "SURVEY",
+  offer: "OFFER",
+  feedback: "FREEFORM",
+  confirm: "CONFIRM"
+};
+var OFFER_TYPE_API_MAP = {
+  discount: "DISCOUNT",
+  pause: "PAUSE",
+  plan_change: "PLAN_CHANGE",
+  trial_extension: "TRIAL_EXTENSION",
+  contact: "CONTACT",
+  redirect: "REDIRECT"
+};
+function toApiStepType(step) {
+  if (step === "success") return null;
+  const builtIn = STEP_TYPE_API_MAP[step];
+  if (builtIn) return { stepType: builtIn };
+  return { stepType: "CUSTOM", customStepType: step };
+}
+function toApiOfferType(type) {
+  const builtIn = OFFER_TYPE_API_MAP[type];
+  if (builtIn) return { offerType: builtIn };
+  return { offerType: "CUSTOM", customOfferType: type };
+}
+function toApiPauseInterval(interval) {
+  return interval === "week" ? "WEEK" : "MONTH";
+}
+function toPresentedOfferConfig(rec) {
+  const base = toApiOfferType(rec.type);
+  if (base.offerType === "CUSTOM") return base;
+  const o = rec;
+  switch (o.type) {
+    case "discount":
+      return {
+        ...base,
+        discountConfig: { couponId: o.couponId, customAmount: o.percentOff }
+      };
+    case "pause":
+      return {
+        ...base,
+        pauseConfig: {
+          maxPauseLength: o.months,
+          pauseInterval: toApiPauseInterval(o.interval)
+        }
+      };
+    case "plan_change":
+      return { ...base, planChangeConfig: {} };
+    case "trial_extension":
+      return { ...base, trialExtensionConfig: { trialExtensionDays: o.days } };
+    case "redirect":
+      return {
+        ...base,
+        redirectConfig: { redirectUrl: o.url, redirectLabel: o.label }
+      };
+    case "contact":
+      return { ...base, contactConfig: {} };
+    default:
+      return base;
+  }
+}
+function toAcceptedOfferPayload(rec, result) {
+  const base = { guid: rec.decisionId, ...toApiOfferType(rec.type) };
+  if (base.offerType === "CUSTOM") {
+    return result ? { ...base, customOfferResult: result } : base;
+  }
+  const o = rec;
+  switch (o.type) {
+    case "discount":
+      return {
+        ...base,
+        couponId: o.couponId,
+        couponAmount: o.percentOff,
+        couponType: "PERCENT",
+        couponDuration: o.durationInMonths
+      };
+    case "pause":
+      return {
+        ...base,
+        pauseDuration: o.months,
+        pauseInterval: toApiPauseInterval(o.interval)
+      };
+    case "plan_change":
+      return {
+        ...base,
+        newPlanId: o.plans?.[0]?.id,
+        newPlanPrice: o.plans?.[0]?.amount.value
+      };
+    case "trial_extension":
+      return { ...base, trialExtensionDays: o.days };
+    case "redirect":
+      return { ...base, redirectUrl: o.url };
+    default:
+      return base;
+  }
+}
+var CancelFlowMachine = class {
+  state;
+  cachedSnapshot;
+  callbacks;
+  graph = { stepMap: {}, firstStepId: "", orderedStepIds: [] };
+  listeners = /* @__PURE__ */ new Set();
+  apiClient = null;
+  analyticsClient = null;
+  directCustomer = null;
+  directSubscriptions = null;
+  creds = null;
+  config = null;
+  blueprintId = null;
+  localSteps = null;
+  stepsViewed = [];
+  presentedOffers = [];
+  customStepResults = {};
+  configMode = "live";
+  stepEnteredAt = Date.now();
+  aborted = false;
+  // Visited-step stack. `back` pops this so it lands on the actually-seen
+  // previous step (including synthetic offers a survey choice spawned),
+  // not the previous step in declared graph order.
+  history = [];
+  constructor(config) {
+    this.callbacks = config;
+    if (config.mode) this.configMode = config.mode;
+    if (config.appId && config.customer) {
+      this.analyticsClient = new AnalyticsClient(config.appId, config.apiBaseUrl);
+      this.directCustomer = config.customer;
+      this.directSubscriptions = config.subscriptions ?? null;
+    }
+    if (config.session) {
+      if (config.steps) this.localSteps = config.steps;
+    } else if (config.steps) {
+      const merged = applyMergeFieldsToSteps(config.steps, this.directCustomer);
+      this.graph = buildStepGraph(merged, defaultOfferCopy);
+    }
+    this.state = this.buildInitialState(null);
+    this.cachedSnapshot = { ...this.state };
+    const first = this.firstStep();
+    if (!config.session && first) this.trackStepEnter(first);
+  }
+  // Public methods are arrow-bound so consumers can pass them directly
+  // (`<button onClick={flow.next}>`) and so useSyncExternalStore sees
+  // stable references between renders.
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  getSnapshot = () => {
+    return this.cachedSnapshot;
+  };
+  get reasons() {
+    return this.surveyStep()?.reasons ?? [];
+  }
+  get currentStep() {
+    return this.graph.stepMap[this.state.currentStepId];
+  }
+  /** The offer on the current step, or null. Always derived — no separate slot to drift. */
+  get currentOffer() {
+    return this.currentStep?.offer ?? null;
+  }
+  /** Whether `back()` would move anywhere — false on the first step and on success. */
+  get canGoBack() {
+    if (this.state.step === "success") return false;
+    return this.history.length > 0 || Boolean(this.currentStep?.defaultPreviousStep);
+  }
+  /**
+   * First step of a given type. Fine for the common "one step per type" case;
+   * flows with multiple of a type should key on currentStepId instead.
+   */
+  getStepConfig(stepType) {
+    return Object.values(this.graph.stepMap).find((s) => s.type === stepType);
+  }
+  /** Progress indicator index. Synthetic offers share their survey's slot. */
+  get stepIndex() {
+    const current = this.currentStep;
+    if (!current) return 0;
+    if (current.surveyOffer) {
+      const surveyId = current.defaultPreviousStep;
+      return surveyId ? this.graph.orderedStepIds.indexOf(surveyId) : 0;
+    }
+    return Math.max(0, this.graph.orderedStepIds.indexOf(current.guid));
+  }
+  get totalSteps() {
+    return this.graph.orderedStepIds.length;
+  }
+  selectReason = (id) => {
+    if (!this.reasons.find((r) => r.id === id)) return;
+    this.setState({ selectedReason: id });
+  };
+  next = (result) => {
+    if (isPlainObject(result)) {
+      this.customStepResults[this.state.step] = result;
+    }
+    const nextId = this.projectedNextStepId();
+    if (!nextId) return;
+    this.transitionTo(nextId, { recordHistory: true });
+  };
+  back = () => {
+    const popped = this.history.pop();
+    if (popped) {
+      this.transitionTo(popped);
+      return;
+    }
+    const prevId = this.currentStep?.defaultPreviousStep;
+    if (prevId) this.transitionTo(prevId);
+  };
+  accept = async (result) => {
+    const offer = this.currentOffer;
+    if (!offer) return;
+    const safeResult = isPlainObject(result) ? result : void 0;
+    this.setState({ isProcessing: true, error: null });
+    try {
+      const acceptedOffer = this.buildAcceptedOffer(offer, safeResult);
+      const customer = this.state.customer;
+      const handler = handlerFor(offer.type, this.callbacks);
+      if (handler) {
+        await handler(acceptedOffer, customer);
+      } else if (this.isTokenMode()) {
+        await this.executeTokenAction(acceptedOffer);
+      }
+      const listener = listenerFor(offer.type, this.callbacks);
+      if (listener) await runListener(listener, acceptedOffer, customer);
+      await this.callbacks.onAccept?.(acceptedOffer, customer);
+      this.markCurrentOfferAccepted();
+      this.enterSuccessStep("saved");
+      this.recordOutcome("saved", offer, safeResult);
+    } catch (error) {
+      this.setState({ isProcessing: false, error });
+    }
+  };
+  decline = () => {
+    this.markCurrentOfferDeclined();
+    const nextId = this.currentStep?.defaultNextStep;
+    if (nextId) this.transitionTo(nextId, { recordHistory: true });
+  };
+  setFeedback = (text) => {
+    this.setState({ feedback: text });
+  };
+  cancel = async () => {
+    this.setState({ isProcessing: true, error: null });
+    try {
+      const customer = this.state.customer;
+      if (this.callbacks.handleCancel) {
+        await this.callbacks.handleCancel(customer);
+      } else if (this.isTokenMode()) {
+        await this.apiClient.cancelSubscription();
+      }
+      await this.callbacks.onCancel?.(customer);
+      this.enterSuccessStep("cancelled");
+      this.recordOutcome("cancelled");
+    } catch (error) {
+      this.setState({ isProcessing: false, error });
+    }
+  };
+  close = () => {
+    if (this.state.outcome === null && !this.aborted) {
+      this.aborted = true;
+      this.recordAbort();
+    }
+    this.callbacks.onClose?.();
+  };
+  destroy() {
+    this.listeners.clear();
+  }
+  // Callbacks are wired through the constructor; this only takes the
+  // server-supplied config so callers can't accidentally clobber them.
+  initializeFromConfig(config, apiClient, creds) {
+    this.apiClient = apiClient;
+    this.creds = creds;
+    this.config = config;
+    const result = transformSdkConfig(config);
+    this.blueprintId = result.blueprintId;
+    const merged = this.localSteps ? mergeLocalSteps(result.steps, this.localSteps) : result.steps;
+    const steps = applyMergeFieldsToSteps(merged, config.customer ?? null);
+    this.graph = buildStepGraph(steps, defaultOfferCopy);
+    this.state = this.buildInitialState(config.customer ?? null);
+    this.cachedSnapshot = { ...this.state };
+    const first = this.firstStep();
+    if (first) this.trackStepEnter(first);
+    this.notify();
+  }
+  // --- Internal helpers ---
+  isTokenMode() {
+    return this.apiClient != null;
+  }
+  firstStep() {
+    return this.graph.stepMap[this.graph.firstStepId];
+  }
+  surveyStep() {
+    return this.graph.surveyStepId ? this.graph.stepMap[this.graph.surveyStepId] : void 0;
+  }
+  buildInitialState(customer) {
+    const first = this.firstStep();
+    return {
+      step: first?.type ?? "survey",
+      currentStepId: this.graph.firstStepId,
+      selectedReason: null,
+      feedback: "",
+      outcome: null,
+      isProcessing: false,
+      error: null,
+      customer
+    };
+  }
+  // On a survey step with a selected reason that has an attached offer,
+  // jump to that offer's synthetic step; otherwise follow the default
+  // forward pointer.
+  projectedNextStepId() {
+    const current = this.currentStep;
+    if (!current) return void 0;
+    if (current.offersAttached && this.state.selectedReason) {
+      const override = current.offersAttached[this.state.selectedReason];
+      if (override) return override;
+    }
+    return current.defaultNextStep;
+  }
+  // Single entry point for step changes. All navigation flows through here so
+  // view-timing and presentation tracking stay in one place. Forward callers
+  // pass recordHistory; `back` omits it so popping isn't reversed.
+  transitionTo(stepId, opts = {}) {
+    const step = this.graph.stepMap[stepId];
+    if (!step) return;
+    if (opts.recordHistory && this.state.currentStepId && this.state.currentStepId !== stepId) {
+      this.history.push(this.state.currentStepId);
+    }
+    this.setState({ step: step.type, currentStepId: stepId });
+  }
+  setState(partial) {
+    const prevStep = this.state.step;
+    this.state = { ...this.state, ...partial };
+    this.cachedSnapshot = { ...this.state };
+    if (partial.step && partial.step !== prevStep) {
+      this.finalizeStepView(prevStep);
+      const step = this.graph.stepMap[this.state.currentStepId];
+      if (step?.type === partial.step) this.trackStepEnter(step);
+      else this.trackStepView(partial.step);
+      this.callbacks.onStepChange?.(partial.step, prevStep);
+    }
+    this.notify();
+  }
+  trackStepEnter(step) {
+    this.trackStepView(step.type, step.guid, step.numChoices);
+    if (step.type === "offer") this.recordOfferPresented();
+  }
+  recordOfferPresented() {
+    const offer = this.currentOffer;
+    if (!offer) return;
+    this.presentedOffers.push({
+      ...toPresentedOfferConfig(offer),
+      guid: offer.decisionId,
+      accepted: false,
+      presentedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  markCurrentOfferAccepted() {
+    const last = this.presentedOffers[this.presentedOffers.length - 1];
+    if (!last || last.acceptedAt || last.declinedAt) return;
+    last.accepted = true;
+    last.acceptedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  markCurrentOfferDeclined() {
+    const last = this.presentedOffers[this.presentedOffers.length - 1];
+    if (!last || last.acceptedAt || last.declinedAt) return;
+    last.declinedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  notify() {
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+  async executeTokenAction(offer) {
+    if (!this.apiClient) return;
+    const o = offer;
+    switch (o.type) {
+      case "discount":
+        if (o.couponId) {
+          await this.apiClient.applyDiscount(o.couponId, this.blueprintId ?? void 0);
+        }
+        break;
+      case "pause":
+        await this.apiClient.pause({ duration: o.months, interval: o.interval ?? "month" });
+        break;
+      case "plan_change":
+        await this.apiClient.changePlan(o.plans[0]?.id);
+        break;
+      case "trial_extension":
+        await this.apiClient.extendTrial(o.days, this.blueprintId ?? void 0);
+        break;
+    }
+  }
+  trackStepView(stepType, guid, numChoices) {
+    this.stepEnteredAt = Date.now();
+    const mapped = toApiStepType(stepType);
+    if (!mapped) return;
+    const entry = {
+      ...mapped,
+      start: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (guid) entry.guid = guid;
+    if (numChoices != null) entry.numChoices = numChoices;
+    this.stepsViewed.push(entry);
+  }
+  finalizeStepView(step) {
+    const mapped = toApiStepType(step);
+    if (!mapped) return;
+    const entry = [...this.stepsViewed].reverse().find((s) => s.stepType === mapped.stepType && s.customStepType === mapped.customStepType);
+    if (entry) {
+      entry.end = (/* @__PURE__ */ new Date()).toISOString();
+      entry.duration = Date.now() - this.stepEnteredAt;
+    }
+  }
+  // Offer passed in so accept() can capture it before enterSuccessStep
+  // potentially moves currentStepId off the offer step.
+  buildAcceptedOffer(offer, result) {
+    const { copy: _, ...offerConfig } = offer;
+    return {
+      ...offerConfig,
+      reasonId: this.state.selectedReason,
+      ...result ? { result } : {}
+    };
+  }
+  // Terminal transition. Prefer moving currentStepId to a declared success
+  // step so the developer's savedTitle / classNames / custom component
+  // applies; otherwise stay put and the renderer's defaults cover it.
+  enterSuccessStep(outcome) {
+    const success = this.getStepConfig("success");
+    const partial = { step: "success", outcome, isProcessing: false };
+    if (success) partial.currentStepId = success.guid;
+    this.setState(partial);
+  }
+  resolveSessionCustomer() {
+    const direct = this.directCustomer ? directDataToSessionCustomer(this.directCustomer, this.directSubscriptions ?? void 0) : void 0;
+    if (this.creds) {
+      return { ...direct, id: this.creds.customerId, subscriptionId: this.creds.subscriptionId };
+    }
+    return direct;
+  }
+  buildBasePayload() {
+    const selectedReason = this.reasons.find((r) => r.id === this.state.selectedReason);
+    const payload = {
+      blueprintId: this.blueprintId ?? void 0,
+      customer: this.resolveSessionCustomer(),
+      canceled: false,
+      surveyChoiceId: this.state.selectedReason ?? void 0,
+      surveyChoiceValue: selectedReason?.label,
+      feedback: this.state.feedback || void 0,
+      presentedOffers: this.presentedOffers,
+      stepsViewed: this.stepsViewed,
+      customStepResults: Object.keys(this.customStepResults).length > 0 ? this.customStepResults : void 0,
+      // Token's signed mode wins — the client can't override it.
+      mode: (this.creds?.mode ?? this.configMode) === "test" ? "TEST" : "LIVE",
+      provider: this.isTokenMode() ? void 0 : "sdk-react",
+      embedVersion: "sdk-react"
+    };
+    if (this.config) {
+      const surveyStep = this.config.steps.find((s) => s.type === "survey");
+      payload.surveyId = surveyStep?.guid;
+      payload.clickToCancelEnabled = this.config.settings.clickToCancelEnabled;
+      payload.strictFTCComplianceEnabled = this.config.settings.strictFTCComplianceEnabled;
+      payload.usedClickToCancel = false;
+      payload.autoOptimizationUsed = !!this.config.autoOptimizationKey;
+      payload.autoOptimizationKey = this.config.autoOptimizationKey;
+      payload.discountCooldown = this.config.settings.discountCooldown;
+      payload.pauseCooldown = this.config.settings.pauseCooldown;
+      payload.discountCooldownApplied = false;
+      payload.pauseCooldownApplied = false;
+    }
+    return payload;
+  }
+  recordAbort() {
+    const client = this.apiClient ?? this.analyticsClient;
+    if (!client) return;
+    this.finalizeStepView(this.state.step);
+    client.createSession({ ...this.buildBasePayload(), aborted: true }).catch(() => {
+    });
+  }
+  // acceptedOffer is a parameter so callers capture it before enterSuccessStep
+  // moves currentStepId off the offer step. setState already finalized the
+  // step view on the way to 'success', so no extra finalize call here.
+  recordOutcome(outcome, acceptedOffer, result) {
+    const client = this.apiClient ?? this.analyticsClient;
+    if (!client) return;
+    const payload = this.buildBasePayload();
+    payload.canceled = outcome === "cancelled";
+    if (outcome === "saved" && acceptedOffer) {
+      payload.acceptedOffer = toAcceptedOfferPayload(acceptedOffer, result);
+    }
+    client.createSession(payload).catch(() => {
+    });
+  }
+};
+function mergeLocalSteps(serverSteps, localSteps) {
+  const localByType = new Map(localSteps.map((s) => [s.type, s]));
+  const merged = serverSteps.map((serverStep) => {
+    const local = localByType.get(serverStep.type);
+    if (!local) return serverStep;
+    localByType.delete(serverStep.type);
+    return { ...serverStep, ...local };
+  });
+  for (const [, step] of localByType) merged.push(step);
+  return merged;
+}
+
+// src/core/token.ts
+function decodeSessionToken(token) {
+  if (!token.startsWith("ck_")) {
+    throw new Error('Invalid token: must start with "ck_"');
+  }
+  const encoded = token.slice(3);
+  let json;
+  try {
+    const base64 = encoded.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+    json = atob(padded);
+  } catch {
+    throw new Error("Invalid token: malformed base64");
+  }
+  let payload;
+  try {
+    payload = JSON.parse(json);
+  } catch {
+    throw new Error("Invalid token: malformed JSON");
+  }
+  if (typeof payload.a !== "string" || !payload.a) {
+    throw new Error("Invalid token: missing appId");
+  }
+  if (typeof payload.c !== "string" || !payload.c) {
+    throw new Error("Invalid token: missing customerId");
+  }
+  if (typeof payload.h !== "string" || !payload.h) {
+    throw new Error("Invalid token: missing authHash");
+  }
+  return {
+    appId: payload.a,
+    customerId: payload.c,
+    subscriptionId: typeof payload.s === "string" ? payload.s : void 0,
+    authHash: payload.h,
+    mode: payload.m === "test" ? "test" : "live",
+    issuedAt: typeof payload.t === "number" ? payload.t : 0
+  };
+}
+
+export { AnalyticsClient, CancelFlowMachine, ChurnkeyApi, decodeSessionToken };
+//# sourceMappingURL=chunk-IFVMM2LB.js.map
+//# sourceMappingURL=chunk-IFVMM2LB.js.map