@mrrocket/sdk 0.4.0 → 0.8.0

package/dist/react-native/index.js

@@ -20,23 +20,28 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/native/index.tsx
 var native_exports = {};
 __export(native_exports, {
+  MRRocketFlows: () => MRRocketFlows,
   MRRocketProvider: () => MRRocketProvider,
   SDK_VERSION: () => SDK_VERSION,
   activeRouteName: () => activeRouteName,
   createMRRocket: () => createMRRocket,
   getMRRocket: () => getMRRocket,
+  useCancelFlow: () => useCancelFlow,
   useExpoRouterTracking: () => useExpoRouterTracking,
   useFlag: () => useFlag,
   useFlagVariant: () => useFlagVariant,
   useMRRocket: () => useMRRocket,
   useNavigationTracking: () => useNavigationTracking,
+  useOnboarding: () => useOnboarding,
+  usePush: () => usePush,
+  useText: () => useText,
   useVariant: () => useVariant
 });
 module.exports = __toCommonJS(native_exports);
-var import_react = require("react");
+var import_react2 = require("react");
 
 // src/core.ts
-var SDK_VERSION = "0.4.0";
+var SDK_VERSION = "0.8.0";
 var propOf = (person, name) => {
   const want = name.trim().toLowerCase();
   for (const [k, v] of Object.entries(person)) if (k.toLowerCase() === want) return v;
@@ -109,25 +114,25 @@ var parseQuery = (url) => {
   return out;
 };
 var hashUnit = (input) => {
-  let h = 2166136261;
+  let h2 = 2166136261;
   for (let i = 0; i < input.length; i++) {
-    h ^= input.charCodeAt(i);
-    h = Math.imul(h, 16777619);
+    h2 ^= input.charCodeAt(i);
+    h2 = Math.imul(h2, 16777619);
   }
-  return (h >>> 0) / 4294967296;
+  return (h2 >>> 0) / 4294967296;
 };
 var flagUnit = (input) => {
-  let h = 2166136261;
+  let h2 = 2166136261;
   for (let i = 0; i < input.length; i++) {
-    h ^= input.charCodeAt(i);
-    h = Math.imul(h, 16777619);
+    h2 ^= input.charCodeAt(i);
+    h2 = Math.imul(h2, 16777619);
   }
-  h ^= h >>> 16;
-  h = Math.imul(h, 2246822507);
-  h ^= h >>> 13;
-  h = Math.imul(h, 3266489909);
-  h ^= h >>> 16;
-  return (h >>> 0) / 4294967296;
+  h2 ^= h2 >>> 16;
+  h2 = Math.imul(h2, 2246822507);
+  h2 ^= h2 >>> 13;
+  h2 = Math.imul(h2, 3266489909);
+  h2 ^= h2 >>> 16;
+  return (h2 >>> 0) / 4294967296;
 };
 var assign = (experiment, distinctId) => {
   const control = experiment.variants[0]?.id ?? "control";
@@ -141,11 +146,21 @@ var assign = (experiment, distinctId) => {
   }
   return experiment.variants[experiment.variants.length - 1]?.id ?? control;
 };
+var experimentsOfText = (config, id) => (config?.experiments ?? []).filter((e) => e.variants.some((v) => v.changes && id in v.changes)).map((e) => e.key);
 var resolveVariant = (key, config, distinctId, preview) => {
   if (preview[key]) return preview[key];
   const experiment = config?.experiments.find((e) => e.key === key);
   return experiment ? assign(experiment, distinctId) : "control";
 };
+var textChanges = (config, distinctId, preview) => {
+  const out = { ...config?.texts ?? {} };
+  for (const experiment of config?.experiments ?? []) {
+    const id = resolveVariant(experiment.key, config, distinctId, preview);
+    if (id === (experiment.variants[0]?.id ?? "control")) continue;
+    Object.assign(out, experiment.variants.find((v) => v.id === id)?.changes ?? {});
+  }
+  return out;
+};
 var newDistinctId = () => typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `ck_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
 
 // src/batch.ts
@@ -203,6 +218,400 @@ var describeError = (error) => {
   }
 };
 
+// src/flows.ts
+var CANCEL_EVENT = "$cancel_flow";
+var ONBOARDING_EVENT = "$onboarding";
+var INAPP_EVENT = "$inapp";
+var PLAIN_CANCEL = {
+  version: 0,
+  question: "",
+  reasons: [],
+  offers: {},
+  confirm: { title: "Cancel your subscription?", body: "You keep access until the end of the billing period.", button: "Cancel subscription" },
+  offersFor: "business"
+};
+var FAILED = "Something went wrong. Please try again.";
+var PROGRESS_KEY = "mrrocket:onboarding";
+var eventSlug = (s) => s.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+var SIGNUP = /* @__PURE__ */ new Set(["signed_up", "signup", "sign_up", "registered", "account_created", "user_signed_up"]);
+var matchesTrigger = (trigger, event) => {
+  const t = eventSlug(trigger);
+  const e = eventSlug(event);
+  if (!t || !e) return false;
+  return t === e || SIGNUP.has(t) && SIGNUP.has(e);
+};
+var startsOnLoad = (trigger) => /^(first (launch|visit|open|session|login|sign ?in|app open)|app (opened|launched)|on load|every visit|always)?$/i.test(trigger.trim());
+var runId = () => `cf_${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`;
+var discounted = (amount, percent) => Math.round(amount * (1 - percent / 100) * 100) / 100;
+var money = (amount, currency) => {
+  try {
+    return new Intl.NumberFormat(void 0, { style: "currency", currency }).format(amount);
+  } catch {
+    return `${amount.toFixed(2)} ${currency}`;
+  }
+};
+var offerButton = (o) => o.kind === "contact" ? "Send to the team" : o.kind === "pause" ? "Pause instead" : o.kind === "downgrade" ? "Switch plan" : "Accept offer";
+var safeUrl = (url) => {
+  const u = (url ?? "").trim();
+  return /^https?:\/\//i.test(u) || /^\/(?!\/)/.test(u) ? u : void 0;
+};
+var createFlows = (env) => {
+  let config = null;
+  let cancel = null;
+  let active = null;
+  let messages = [];
+  let known = false;
+  let loading = null;
+  let loadedFor;
+  let progressFor = null;
+  const progress = /* @__PURE__ */ new Map();
+  const handled = /* @__PURE__ */ new Set();
+  const shown = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set();
+  const auto = env.auto !== false;
+  const flows = () => config?.onboarding ?? [];
+  const flowById = (id) => id ? flows().find((f) => f.id === id) : void 0;
+  const prog = (id) => {
+    let p = progress.get(id);
+    if (!p) progress.set(id, p = { done: /* @__PURE__ */ new Set(), dismissed: false });
+    return p;
+  };
+  const finished = (f) => {
+    const p = progress.get(f.id);
+    return !!p && (p.dismissed || f.steps.every((s) => p.done.has(s.id)));
+  };
+  const keyOf = (pid) => `${PROGRESS_KEY}:${pid ?? "visitor"}`;
+  const save = () => {
+    const store = env.storage?.();
+    if (!store) return;
+    const out = {};
+    for (const [id, p] of progress) out[id] = { done: [...p.done], ...p.dismissed ? { dismissed: true } : {} };
+    try {
+      store.set(keyOf(env.personId()), JSON.stringify(out));
+    } catch {
+    }
+  };
+  const merge = (state) => {
+    for (const [id, s] of Object.entries(state ?? {})) {
+      const p = prog(id);
+      for (const d of s.done ?? []) p.done.add(d);
+      if (s.dismissed) p.dismissed = true;
+    }
+  };
+  const onboardingView = () => {
+    const flow = flowById(active);
+    if (!flow) return null;
+    const p = prog(flow.id);
+    const at = flow.steps.findIndex((s) => !p.done.has(s.id));
+    if (at < 0 || p.dismissed) return null;
+    const step = flow.steps[at];
+    if (step.kind === "checklist") {
+      let from = at;
+      while (from > 0 && flow.steps[from - 1].kind === "checklist") from--;
+      let to = at;
+      while (to + 1 < flow.steps.length && flow.steps[to + 1].kind === "checklist") to++;
+      return { type: "checklist", flow, items: flow.steps.slice(from, to + 1).map((s) => ({ step: s, done: p.done.has(s.id) })) };
+    }
+    return { type: "step", flow, step, index: at, total: flow.steps.length, last: at === flow.steps.length - 1 };
+  };
+  const view = () => {
+    if (cancel) {
+      const offer = cancel.reason ? cancel.flow.offers[cancel.reason] : void 0;
+      return {
+        type: "cancel",
+        screen: cancel.screen,
+        flow: cancel.flow,
+        reason: cancel.reason,
+        offer: cancel.screen === "offer" ? offer : void 0,
+        price: cancel.options.price,
+        busy: cancel.busy,
+        error: cancel.error,
+        step: cancel.plain ? 1 : cancel.screen === "survey" ? 1 : cancel.screen === "offer" ? 2 : 3,
+        steps: cancel.plain ? 1 : 3
+      };
+    }
+    const ob = onboardingView();
+    if (ob) return ob;
+    if (active) active = null;
+    const m = messages.find((x) => !handled.has(x.id));
+    return m ? { type: "message", message: m } : null;
+  };
+  const emit = () => {
+    const v = view();
+    if (v?.type === "step" && !shown.has(`s:${v.step.id}`)) {
+      shown.add(`s:${v.step.id}`);
+      env.track(ONBOARDING_EVENT, { flow: v.flow.id, step: v.step.id, kind: v.step.kind, action: "shown" });
+    } else if (v?.type === "checklist") {
+      for (const i of v.items)
+        if (!i.done && !shown.has(`s:${i.step.id}`)) {
+          shown.add(`s:${i.step.id}`);
+          env.track(ONBOARDING_EVENT, { flow: v.flow.id, step: i.step.id, kind: "checklist", action: "shown" });
+        }
+    } else if (v?.type === "message" && !shown.has(`m:${v.message.id}`)) {
+      shown.add(`m:${v.message.id}`);
+      env.track(INAPP_EVENT, { message: v.message.id, journey: v.message.journey, action: "shown" });
+    }
+    for (const l of [...listeners]) {
+      try {
+        l();
+      } catch {
+      }
+    }
+  };
+  const start = (flow) => {
+    if (active === flow.id) return true;
+    if (active && flowById(active) && !finished(flowById(active))) return false;
+    active = flow.id;
+    env.track(ONBOARDING_EVENT, { flow: flow.id, action: "started" });
+    emit();
+    return true;
+  };
+  const autoStart = () => {
+    if (!auto || active || !known) return;
+    if (!env.personId() && !env.storage?.()) return;
+    const next = flows().find((f) => startsOnLoad(f.trigger) && f.steps.length && !finished(f));
+    if (next) start(next);
+  };
+  const refresh = () => {
+    const pid = env.personId();
+    if (progressFor !== null && progressFor !== pid) {
+      progress.clear();
+      handled.clear();
+      active = null;
+      loadedFor = void 0;
+    }
+    progressFor = pid;
+    const run = (async () => {
+      const store = env.storage?.();
+      if (store) {
+        try {
+          const raw = await store.get(keyOf(pid));
+          if (raw) merge(JSON.parse(raw));
+        } catch {
+        }
+      }
+      const wants = flows().length > 0 || !!config?.messages;
+      if (pid && wants && loadedFor !== pid) {
+        loadedFor = pid;
+        const state = await env.fetchInApp(pid).catch(() => null);
+        if (state && env.personId() === pid) {
+          merge(state.onboarding);
+          messages = (state.messages ?? []).filter((m) => m && m.id && m.title);
+        }
+      }
+      if (!pid) messages = [];
+      known = true;
+      autoStart();
+      emit();
+    })();
+    loading = run.finally(() => {
+      if (loading === run) loading = null;
+    });
+    return loading;
+  };
+  const result = (c, outcome, comment) => {
+    const offer = c.reason ? c.flow.offers[c.reason] : void 0;
+    return {
+      outcome,
+      run: c.run,
+      ...c.reason ? { reason: c.reason, reasonLabel: c.flow.reasons.find((r) => r.id === c.reason)?.label } : {},
+      ...outcome === "saved" && offer ? { offer } : {},
+      ...comment?.trim() ? { comment: comment.trim().slice(0, 500) } : {}
+    };
+  };
+  const finish = (c, r) => {
+    env.track(CANCEL_EVENT, {
+      action: "finished",
+      run: c.run,
+      version: c.flow.version,
+      outcome: r.outcome,
+      customer: c.options.customer ?? "consumer",
+      ...r.reason ? { reason: r.reason } : {},
+      ...r.offer ? { offer: r.offer.kind } : {},
+      ...r.comment ? { comment: r.comment } : {}
+    });
+    if (cancel === c) cancel = null;
+    c.resolve(r);
+    emit();
+  };
+  const settle = (c, outcome, comment) => {
+    if (c.busy) return;
+    const r = result(c, outcome, comment);
+    const fn = outcome === "saved" ? c.options.onSave : c.options.onCancel;
+    c.busy = true;
+    c.error = void 0;
+    emit();
+    Promise.resolve().then(() => fn?.(r)).then(
+      () => finish(c, r),
+      () => {
+        c.busy = false;
+        c.error = FAILED;
+        emit();
+      }
+    );
+  };
+  const openCancelFlow = (options = {}) => {
+    if (cancel) return cancel.promise;
+    const flow = config?.cancelFlow ?? PLAIN_CANCEL;
+    const plain = options.customer !== "business" || flow.reasons.length < 2;
+    let resolve = () => {
+    };
+    const promise = new Promise((r) => resolve = r);
+    const c = { flow, options, plain, screen: plain ? "confirm" : "survey", run: runId(), busy: false, resolve, promise };
+    cancel = c;
+    env.track(CANCEL_EVENT, { action: "shown", run: c.run, version: flow.version, customer: options.customer ?? "consumer", plain });
+    emit();
+    return promise;
+  };
+  const controller = {
+    setConfig: (c) => {
+      config = c;
+      if (active && !flowById(active)) active = null;
+      emit();
+    },
+    refresh,
+    onEvent: (name) => {
+      if (!name || name.startsWith("$")) return;
+      const flow = flowById(active);
+      let ticked = false;
+      if (flow) {
+        const p = prog(flow.id);
+        for (const s of flow.steps)
+          if (s.kind === "checklist" && s.event && !p.done.has(s.id) && matchesTrigger(s.event, name)) {
+            p.done.add(s.id);
+            ticked = true;
+            env.track(ONBOARDING_EVENT, { flow: flow.id, step: s.id, kind: s.kind, action: "completed" });
+          }
+      }
+      if (ticked) {
+        save();
+        emit();
+      }
+      if (!auto || !env.personId() && !env.storage?.()) return;
+      const next = flows().find((f) => f.steps.length && matchesTrigger(f.trigger, name) && !finished(f));
+      if (next) start(next);
+    },
+    openCancelFlow,
+    startOnboarding: (id) => {
+      const f = id ? flowById(id) : flows().find((x) => x.steps.length && !finished(x));
+      if (!f || !f.steps.length) return false;
+      const p = prog(f.id);
+      p.dismissed = false;
+      return start(f);
+    },
+    view,
+    subscribe: (l) => {
+      listeners.add(l);
+      return () => listeners.delete(l);
+    },
+    cancel: {
+      pick: (reason) => {
+        if (!cancel || cancel.busy || !cancel.flow.reasons.some((r) => r.id === reason)) return;
+        cancel.reason = reason;
+        cancel.error = void 0;
+        emit();
+      },
+      next: () => {
+        const c = cancel;
+        if (!c || c.screen !== "survey" || !c.reason) return;
+        env.track(CANCEL_EVENT, { action: "answered", run: c.run, version: c.flow.version, reason: c.reason });
+        c.screen = c.flow.offers[c.reason] ? "offer" : "confirm";
+        emit();
+      },
+      accept: (comment) => {
+        const c = cancel;
+        if (!c || c.screen !== "offer" || !c.reason) return;
+        const offer = c.flow.offers[c.reason];
+        if (!c.busy)
+          env.track(CANCEL_EVENT, {
+            action: "offer",
+            run: c.run,
+            version: c.flow.version,
+            reason: c.reason,
+            offer: offer?.kind,
+            outcome: "accepted"
+          });
+        settle(c, "saved", comment);
+      },
+      decline: () => {
+        const c = cancel;
+        if (!c || c.screen !== "offer" || c.busy) return;
+        env.track(CANCEL_EVENT, {
+          action: "offer",
+          run: c.run,
+          version: c.flow.version,
+          reason: c.reason,
+          offer: c.reason ? c.flow.offers[c.reason]?.kind : void 0,
+          outcome: "declined"
+        });
+        c.screen = "confirm";
+        c.error = void 0;
+        emit();
+      },
+      confirm: (comment) => {
+        const c = cancel;
+        if (!c || c.screen !== "confirm") return;
+        settle(c, "cancelled", comment);
+      },
+      close: () => {
+        const c = cancel;
+        if (!c || c.busy) return;
+        const r = result(c, "kept");
+        c.options.onClose?.(r);
+        finish(c, r);
+      }
+    },
+    onboarding: {
+      next: () => {
+        const v = onboardingView();
+        if (v?.type !== "step") return;
+        prog(v.flow.id).done.add(v.step.id);
+        env.track(ONBOARDING_EVENT, { flow: v.flow.id, step: v.step.id, kind: v.step.kind, action: "completed" });
+        save();
+        emit();
+      },
+      check: (stepId) => {
+        const v = onboardingView();
+        if (v?.type !== "checklist") return;
+        const item = v.items.find((i) => i.step.id === stepId);
+        if (!item || item.done) return;
+        prog(v.flow.id).done.add(stepId);
+        env.track(ONBOARDING_EVENT, { flow: v.flow.id, step: stepId, kind: "checklist", action: "completed" });
+        save();
+        emit();
+      },
+      dismiss: () => {
+        const v = onboardingView();
+        if (!v || v.type !== "step" && v.type !== "checklist") return;
+        prog(v.flow.id).dismissed = true;
+        env.track(ONBOARDING_EVENT, { flow: v.flow.id, ...v.type === "step" ? { step: v.step.id } : {}, action: "dismissed" });
+        active = null;
+        save();
+        emit();
+      }
+    },
+    message: {
+      click: () => {
+        const v = view();
+        if (v?.type !== "message") return;
+        handled.add(v.message.id);
+        env.track(INAPP_EVENT, { message: v.message.id, journey: v.message.journey, action: "clicked" });
+        const url = safeUrl(v.message.url);
+        emit();
+        if (url) env.openUrl?.(url);
+      },
+      dismiss: () => {
+        const v = view();
+        if (v?.type !== "message") return;
+        handled.add(v.message.id);
+        env.track(INAPP_EVENT, { message: v.message.id, journey: v.message.journey, action: "dismissed" });
+        emit();
+      }
+    }
+  };
+  return controller;
+};
+
 // src/referral.ts
 var REF_PARAM = "mrr_ref";
 var CLICK_PARAM = "mrr_click";
@@ -288,11 +697,37 @@ var createClient = (options, deps) => {
   let backgroundSince = null;
   const early = [];
   const exposed = /* @__PURE__ */ new Set();
+  let textsFor = null;
+  const texts = () => {
+    const id = distinctId();
+    if (!textsFor || textsFor.config !== config || textsFor.id !== id) textsFor = { config, id, texts: textChanges(config, id, {}) };
+    return textsFor.texts;
+  };
   const listeners = /* @__PURE__ */ new Set();
   const crumbs = [];
   const errorQueue = [];
   const errorsSeen = /* @__PURE__ */ new Set();
   let errorsSent = 0;
+  const flows = createFlows({
+    track: (event, props) => record(event, props),
+    personId: () => consent !== "off" ? identified : void 0,
+    auto: options.onboarding !== false,
+    storage: () => storage && consent === "persistent" ? {
+      get: (k) => get(k),
+      set: (k, v) => void set(k, v)
+    } : null,
+    openUrl: deps.openUrl,
+    fetchInApp: async (id) => {
+      if (!apiKey) return null;
+      const r = await deps.fetch(`${host}/api/sdk/inapp?key=${encodeURIComponent(apiKey)}&distinctId=${encodeURIComponent(id)}`, { method: "GET" });
+      return r.ok ? await r.json() : null;
+    }
+  });
+  const refreshFlows = () => {
+    if (!isReady || closed) return;
+    flows.setConfig(config);
+    void flows.refresh();
+  };
   const changed = () => {
     version++;
     for (const l of [...listeners]) {
@@ -526,6 +961,61 @@ var createClient = (options, deps) => {
       debug("Config not reachable; using the cached one.");
     }
   };
+  let pushToken = null;
+  let pushFor;
+  let pushOff = null;
+  const opened = /* @__PURE__ */ new Set();
+  const onPushOpen = (data) => {
+    const m = data?.mrrocket;
+    if (!m?.id || opened.has(m.id)) return;
+    opened.add(m.id);
+    record("$push", { action: "opened", message: m.id });
+    if (m.url && /^[a-z][a-z0-9+.-]*:/i.test(m.url)) deps.openUrl?.(m.url);
+  };
+  const listenForOpens = () => {
+    if (pushOff || !deps.push || closed) return;
+    try {
+      pushOff = deps.push.onOpen(onPushOpen);
+      void deps.push.lastOpen?.().then(onPushOpen).catch(() => void 0);
+    } catch {
+      pushOff = null;
+    }
+  };
+  const loadedNow = () => loaded ? Promise.resolve() : new Promise((resolve) => {
+    early.push(resolve);
+  });
+  const registerForPush = async (o = {}) => {
+    if (!deps.push) return { status: "unavailable", reason: "Install expo-notifications to receive push notifications." };
+    await loadedNow();
+    if (!apiKey || consent === "off") return { status: "error", reason: !apiKey ? "No public key." : "The consent is off." };
+    if (!identified) return { status: "not-signed-in" };
+    const who = identified;
+    try {
+      const permission = await deps.push.permission(o.ask !== false);
+      if (permission !== "granted") return { status: permission === "denied" ? "denied" : "not-asked" };
+      const token = await deps.push.token(o.projectId);
+      if (!token) return { status: "unavailable", reason: "This device has no push token (a simulator, or no EAS project id)." };
+      const status = await post("/api/sdk/push", JSON.stringify({ key: apiKey, distinctId: who, platform: "expo", token, app: context }));
+      if (status < 200 || status >= 300) {
+        warn(`Push registration was rejected with ${status || "no answer"}. Check the public key and the host.`);
+        return { status: "error", reason: `MRRocket answered ${status || "nothing"}.` };
+      }
+      pushToken = token;
+      pushFor = who;
+      listenForOpens();
+      debug("Registered for push.");
+      return { status: "registered", token };
+    } catch (e) {
+      return { status: "error", reason: e instanceof Error ? e.message : String(e) };
+    }
+  };
+  const unregisterForPush = async () => {
+    const token = pushToken;
+    if (!token || !apiKey) return false;
+    pushToken = null;
+    const status = await post("/api/sdk/push", JSON.stringify({ key: apiKey, distinctId: pushFor, platform: "expo", token, remove: true }));
+    return status >= 200 && status < 300;
+  };
   let resolveReady = () => {
   };
   const ready = new Promise((r) => {
@@ -601,10 +1091,12 @@ var createClient = (options, deps) => {
     for (const run of early.splice(0)) run();
     if (deps.appState) appStateSub = deps.appState.addEventListener("change", onAppState);
     installErrorHandler();
+    listenForOpens();
     if (appState === "active" || !deps.appState) startTimer();
     if (queue.length) void flush();
     await fetchConfig();
     markReady();
+    refreshFlows();
   };
   void start().catch(() => {
     loaded = true;
@@ -614,6 +1106,7 @@ var createClient = (options, deps) => {
     track: (event, props) => {
       if (typeof event !== "string" || !event) return;
       record(event, props);
+      flows.onEvent(event);
     },
     screen: (name, props) => {
       if (typeof name !== "string" || !name.trim()) return;
@@ -636,12 +1129,14 @@ var createClient = (options, deps) => {
       record("$identify", { ...props, id, ...previous && previous !== id ? { previousId: previous } : {} });
       if (consent === "persistent") void set(KEYS.id, id);
       changed();
+      refreshFlows();
     },
     reset: () => {
       if (!loaded) {
         early.push(() => client.reset());
         return;
       }
+      if (pushToken) void unregisterForPush();
       identified = void 0;
       person = void 0;
       session = null;
@@ -653,6 +1148,7 @@ var createClient = (options, deps) => {
         void set(KEYS.id, installId);
       }
       changed();
+      refreshFlows();
     },
     setConsent: (next) => {
       if (next !== "anonymous" && next !== "persistent" && next !== "off") {
@@ -682,6 +1178,7 @@ var createClient = (options, deps) => {
       }
       if (before === "off" && currentScreen && loaded) record("$screen", { path: currentScreen, screen: currentScreen });
       changed();
+      refreshFlows();
     },
     captureError: (error) => capture(error, "manual"),
     getFlag: (key) => flagFor(key, config, distinctId(), { ...person }) !== false,
@@ -702,6 +1199,19 @@ var createClient = (options, deps) => {
       exposed.add(mark);
       record("$exposure", { experiment: key, variant });
     },
+    getText: (id, fallback) => {
+      client.exposeText(id);
+      return client.peekText(id) ?? fallback;
+    },
+    peekText: (id) => texts()[id],
+    exposeText: (id) => {
+      for (const key of experimentsOfText(config, id)) client.expose(key, resolveVariant(key, config, distinctId(), {}));
+    },
+    openCancelFlow: (o) => flows.openCancelFlow(o),
+    startOnboarding: (id) => flows.startOnboarding(id),
+    registerForPush,
+    unregisterForPush,
+    flows,
     flush,
     ready,
     isReady: () => isReady,
@@ -717,6 +1227,8 @@ var createClient = (options, deps) => {
       if (closed) return;
       stopTimer();
       appStateSub?.remove();
+      pushOff?.();
+      pushOff = null;
       if (handlerInstalled && deps.errorUtils && previousHandler) deps.errorUtils.setGlobalHandler(previousHandler);
       await flush();
       await sendErrors();
@@ -739,8 +1251,252 @@ var activeRouteName = (state) => {
   return name;
 };
 
-// src/native/platform.ts
+// src/native/flows-view.ts
+var import_react = require("react");
 var RN = require("react-native");
+var LIGHT = { bg: "#ffffff", fg: "#1c1d20", muted: "#5d6068", soft: "#f4f5f7", line: "#e4e5e8" };
+var DARK = { bg: "#17181b", fg: "#f1f2f4", muted: "#a9acb3", soft: "#232428", line: "#2e2f35" };
+var months = (n) => `${n} ${n === 1 ? "month" : "months"}`;
+var MRRocketFlows = ({ flows, appearance = {} }) => {
+  const scheme = RN.useColorScheme?.();
+  const dark = appearance.theme === "dark" || (appearance.theme ?? "auto") === "auto" && scheme === "dark";
+  const p = { ...dark ? DARK : LIGHT, accent: appearance.accent ?? "#3f76ff", danger: "#d92d20" };
+  const [, setTick] = (0, import_react.useState)(0);
+  (0, import_react.useEffect)(() => flows.subscribe(() => setTick((t) => t + 1)), [flows]);
+  const v = flows.view();
+  const [comment, setComment] = (0, import_react.useState)("");
+  const screen = v?.type === "cancel" ? v.screen : null;
+  (0, import_react.useEffect)(() => {
+    if (!screen) setComment("");
+  }, [screen]);
+  if (!v) return null;
+  const text2 = (children, style = {}) => (0, import_react.createElement)(RN.Text, { style: { color: p.fg, fontSize: 15, ...style } }, children);
+  const muted = (children, style = {}) => text2(children, { color: p.muted, fontSize: 13, ...style });
+  const title = (children) => (0, import_react.createElement)(RN.Text, { accessibilityRole: "header", style: { color: p.fg, fontSize: 18, fontWeight: "700" } }, children);
+  const btn = (label, kind, onPress, disabled = false) => (0, import_react.createElement)(
+    RN.Pressable,
+    {
+      key: label,
+      onPress,
+      disabled,
+      accessibilityRole: "button",
+      accessibilityState: { disabled },
+      style: {
+        height: kind === "quiet" ? 36 : 44,
+        borderRadius: 10,
+        alignItems: "center",
+        justifyContent: "center",
+        opacity: disabled ? 0.55 : 1,
+        backgroundColor: kind === "primary" ? p.accent : kind === "danger" ? p.danger : kind === "secondary" ? p.bg : "transparent",
+        borderWidth: kind === "secondary" ? 1 : 0,
+        borderColor: p.line
+      }
+    },
+    text2(label, {
+      color: kind === "primary" || kind === "danger" ? "#ffffff" : kind === "quiet" ? p.muted : p.fg,
+      fontWeight: kind === "quiet" ? "500" : "600"
+    })
+  );
+  const close = (label, onPress) => (0, import_react.createElement)(
+    RN.Pressable,
+    { onPress, accessibilityRole: "button", accessibilityLabel: label, hitSlop: 12, style: { marginLeft: "auto", padding: 4 } },
+    text2("\xD7", { fontSize: 22, color: p.muted })
+  );
+  const card = (children, style = {}) => (0, import_react.createElement)(
+    RN.View,
+    {
+      style: {
+        backgroundColor: p.bg,
+        borderRadius: 16,
+        padding: 20,
+        gap: 12,
+        shadowColor: "#000",
+        shadowOpacity: 0.18,
+        shadowRadius: 20,
+        elevation: 8,
+        ...style
+      }
+    },
+    ...children
+  );
+  const sheet = (children, onClose) => (0, import_react.createElement)(
+    RN.Modal,
+    { visible: true, transparent: true, animationType: "fade", onRequestClose: onClose },
+    (0, import_react.createElement)(
+      RN.View,
+      { style: { flex: 1, backgroundColor: "rgba(0,0,0,0.4)", justifyContent: "flex-end" } },
+      card(children, { borderBottomLeftRadius: 0, borderBottomRightRadius: 0, paddingBottom: 34 })
+    )
+  );
+  const input = (placeholder) => (0, import_react.createElement)(RN.TextInput, {
+    value: comment,
+    onChangeText: setComment,
+    placeholder,
+    placeholderTextColor: p.muted,
+    multiline: true,
+    maxLength: 500,
+    accessibilityLabel: placeholder,
+    style: { minHeight: 72, borderWidth: 1, borderColor: p.line, borderRadius: 10, padding: 10, color: p.fg, textAlignVertical: "top" }
+  });
+  if (v.type === "cancel") {
+    const top = (0, import_react.createElement)(
+      RN.View,
+      { style: { flexDirection: "row", alignItems: "center", gap: 4 } },
+      ...v.steps > 1 ? Array.from(
+        { length: v.steps },
+        (_, i) => (0, import_react.createElement)(RN.View, { key: i, style: { width: 16, height: 4, borderRadius: 4, backgroundColor: i < v.step ? p.accent : p.line } })
+      ) : [],
+      close("Close", flows.cancel.close)
+    );
+    const error = v.error ? text2(v.error, { color: p.danger, fontSize: 13 }) : null;
+    let body = [];
+    if (v.screen === "survey")
+      body = [
+        title(v.flow.question || "Why are you leaving?"),
+        (0, import_react.createElement)(
+          RN.ScrollView,
+          { style: { maxHeight: 320 }, contentContainerStyle: { gap: 6 }, accessibilityRole: "radiogroup" },
+          ...v.flow.reasons.map(
+            (r) => (0, import_react.createElement)(
+              RN.Pressable,
+              {
+                key: r.id,
+                onPress: () => flows.cancel.pick(r.id),
+                accessibilityRole: "radio",
+                accessibilityState: { checked: v.reason === r.id },
+                style: {
+                  minHeight: 44,
+                  paddingHorizontal: 12,
+                  borderRadius: 10,
+                  borderWidth: 1,
+                  borderColor: v.reason === r.id ? p.accent : p.line,
+                  backgroundColor: v.reason === r.id ? p.soft : p.bg,
+                  justifyContent: "center"
+                }
+              },
+              text2(r.label, { fontWeight: "500" })
+            )
+          )
+        ),
+        btn("Continue", "primary", flows.cancel.next, !v.reason),
+        btn("Never mind, keep my plan", "quiet", flows.cancel.close)
+      ];
+    else if (v.screen === "offer" && v.offer) {
+      const o = v.offer;
+      const label = v.flow.reasons.find((r) => r.id === v.reason)?.label;
+      const detail = o.kind === "discount" && o.percent ? v.price ? `${money(discounted(v.price.amount, o.percent), v.price.currency)} instead of ${money(v.price.amount, v.price.currency)}${o.months ? ` for ${months(o.months)}` : ""}` : `${o.percent}% off${o.months ? ` for ${months(o.months)}` : ""}` : o.kind === "pause" && o.months ? `Pause for up to ${months(o.months)}. Your data stays.` : o.kind === "downgrade" && o.planName ? o.planName : null;
+      body = [
+        label ? muted(`You said: ${label}`) : null,
+        title(o.headline),
+        detail ? (0, import_react.createElement)(RN.View, { style: { backgroundColor: p.soft, borderRadius: 10, padding: 12 } }, text2(detail, { fontWeight: "600" })) : null,
+        o.kind === "contact" ? input("What would make you stay?") : null,
+        btn(v.busy ? "One moment\u2026" : offerButton(o), "primary", () => flows.cancel.accept(comment), v.busy),
+        btn("No thanks, continue cancelling", "quiet", flows.cancel.decline, v.busy)
+      ];
+    } else
+      body = [
+        title(v.flow.confirm.title),
+        v.flow.confirm.body ? muted(v.flow.confirm.body, { fontSize: 15 }) : null,
+        v.steps > 1 ? input("Anything else we should know? (optional)") : null,
+        btn(v.busy ? "One moment\u2026" : v.flow.confirm.button, "danger", () => flows.cancel.confirm(comment), v.busy),
+        btn("Keep my plan", "secondary", flows.cancel.close, v.busy)
+      ];
+    return sheet([top, ...body, error], flows.cancel.close);
+  }
+  if (v.type === "step")
+    return sheet(
+      [
+        (0, import_react.createElement)(
+          RN.View,
+          { style: { flexDirection: "row", alignItems: "center" } },
+          v.total > 1 ? muted(`Step ${v.index + 1} of ${v.total}`) : null,
+          close("Close the tour", flows.onboarding.dismiss)
+        ),
+        title(v.step.title),
+        v.step.body ? muted(v.step.body, { fontSize: 15 }) : null,
+        btn(v.step.button || (v.last ? "Done" : "Next"), "primary", flows.onboarding.next)
+      ],
+      flows.onboarding.dismiss
+    );
+  if (v.type === "checklist") {
+    const done = v.items.filter((i) => i.done).length;
+    return (0, import_react.createElement)(
+      RN.View,
+      { pointerEvents: "box-none", style: { position: "absolute", left: 12, right: 12, bottom: 28 } },
+      card([
+        (0, import_react.createElement)(
+          RN.View,
+          { key: "t", style: { flexDirection: "row", alignItems: "center" } },
+          title(v.flow.name),
+          close("Hide the checklist", flows.onboarding.dismiss)
+        ),
+        muted(`${done} of ${v.items.length} done`),
+        ...v.items.map(
+          ({ step, done: d }) => (0, import_react.createElement)(
+            RN.Pressable,
+            {
+              key: step.id,
+              disabled: d || !!step.event,
+              onPress: () => flows.onboarding.check(step.id),
+              accessibilityRole: "checkbox",
+              accessibilityState: { checked: d },
+              style: { flexDirection: "row", gap: 10, alignItems: "flex-start", paddingVertical: 6 }
+            },
+            (0, import_react.createElement)(
+              RN.View,
+              {
+                style: {
+                  width: 20,
+                  height: 20,
+                  borderRadius: 10,
+                  borderWidth: 1.5,
+                  borderColor: d ? p.accent : p.line,
+                  backgroundColor: d ? p.accent : "transparent",
+                  alignItems: "center",
+                  justifyContent: "center"
+                }
+              },
+              d ? text2("\u2713", { color: "#fff", fontSize: 12 }) : null
+            ),
+            (0, import_react.createElement)(
+              RN.View,
+              { style: { flex: 1 } },
+              text2(step.title, { fontWeight: "600", color: d ? p.muted : p.fg, textDecorationLine: d ? "line-through" : "none" }),
+              step.body ? muted(step.body) : null
+            )
+          )
+        )
+      ])
+    );
+  }
+  const m = v.message;
+  if (m.style === "banner")
+    return (0, import_react.createElement)(
+      RN.View,
+      { pointerEvents: "box-none", style: { position: "absolute", left: 12, right: 12, top: 56 } },
+      card([
+        (0, import_react.createElement)(
+          RN.View,
+          { key: "t", style: { flexDirection: "row", alignItems: "center", gap: 8 } },
+          (0, import_react.createElement)(RN.View, { style: { flex: 1 } }, text2(m.title, { fontWeight: "700" }), m.body ? muted(m.body) : null),
+          close("Dismiss", flows.message.dismiss)
+        ),
+        m.button ? btn(m.button, "primary", flows.message.click) : null
+      ])
+    );
+  return sheet(
+    [
+      (0, import_react.createElement)(RN.View, { key: "t", style: { flexDirection: "row" } }, close("Dismiss", flows.message.dismiss)),
+      title(m.title),
+      m.body ? muted(m.body, { fontSize: 15 }) : null,
+      m.button ? btn(m.button, "primary", flows.message.click) : null
+    ],
+    flows.message.dismiss
+  );
+};
+
+// src/native/platform.ts
+var RN2 = require("react-native");
 var asyncStorageModule = null;
 try {
   asyncStorageModule = require("@react-native-async-storage/async-storage");
@@ -765,6 +1521,45 @@ try {
 } catch {
   expoLocalization = null;
 }
+var expoNotifications = null;
+try {
+  expoNotifications = require("expo-notifications");
+} catch {
+  expoNotifications = null;
+}
+var expoConstants = {};
+try {
+  expoConstants = require("expo-constants");
+} catch {
+  expoConstants = {};
+}
+var dataOf = (r) => r?.notification?.request?.content?.data ?? null;
+var expoPush = () => {
+  const n = expoNotifications;
+  if (!n || typeof n.getExpoPushTokenAsync !== "function") return null;
+  const constants = expoConstants.default ?? expoConstants;
+  return {
+    permission: async (ask) => {
+      const now = await n.getPermissionsAsync();
+      if (now.granted || now.status === "granted") return "granted";
+      if (now.status === "denied" || !ask) return now.status === "denied" ? "denied" : "undetermined";
+      const asked = await n.requestPermissionsAsync();
+      return asked.granted || asked.status === "granted" ? "granted" : asked.status === "denied" ? "denied" : "undetermined";
+    },
+    token: async (projectId) => {
+      if (RN2.Platform.OS === "android" && n.setNotificationChannelAsync)
+        await n.setNotificationChannelAsync("default", { name: "Default", importance: n.AndroidImportance?.HIGH ?? 4 });
+      const id = projectId ?? constants.expoConfig?.extra?.eas?.projectId ?? constants.easConfig?.projectId;
+      const t = await n.getExpoPushTokenAsync(id ? { projectId: id } : void 0);
+      return typeof t?.data === "string" && t.data ? t.data : null;
+    },
+    onOpen: (listener) => {
+      const sub = n.addNotificationResponseReceivedListener((r) => listener(dataOf(r) ?? {}));
+      return () => sub.remove();
+    },
+    lastOpen: async () => dataOf(await n.getLastNotificationResponseAsync?.())
+  };
+};
 var asyncStorage = () => {
   const m = asyncStorageModule;
   const s = m?.default ?? m;
@@ -773,7 +1568,7 @@ var asyncStorage = () => {
 var DEVICE_TYPES = { 1: "phone", 2: "tablet", 3: "desktop", 4: "tv" };
 var text = (v, max = 80) => typeof v === "string" && v.trim() ? v.trim().slice(0, max) : typeof v === "number" ? String(v) : void 0;
 var readContext = () => {
-  const p = RN.Platform;
+  const p = RN2.Platform;
   let locale;
   try {
     locale = text(expoLocalization?.getLocales?.()[0]?.languageTag, 35);
@@ -802,21 +1597,24 @@ var readContext = () => {
 var nativeDeps = (overrides = {}) => ({
   storage: overrides.storage !== void 0 ? overrides.storage : asyncStorage(),
   fetch: ((url, init) => fetch(url, init)),
-  appState: RN.AppState,
+  appState: RN2.AppState,
   errorUtils: globalThis.ErrorUtils ?? null,
   context: readContext,
   appId: text(expoApplication?.applicationId, 150),
   screen: () => {
-    const s = RN.Dimensions.get("screen");
+    const s = RN2.Dimensions.get("screen");
     return s ? { w: s.width, h: s.height } : void 0;
   },
-  initialUrl: () => RN.Linking.getInitialURL()
+  initialUrl: () => RN2.Linking.getInitialURL(),
+  openUrl: (url) => void RN2.Linking.openURL(url).catch(() => void 0),
+  push: expoPush()
 });
 var optionalModules = () => ({
   asyncStorage: !!asyncStorage(),
   expoDevice: !!expoDevice,
   expoApplication: !!expoApplication,
-  expoLocalization: !!expoLocalization
+  expoLocalization: !!expoLocalization,
+  expoNotifications: !!expoNotifications
 });
 
 // src/native/index.tsx
@@ -835,20 +1633,20 @@ var createMRRocket = (options) => {
   return shared;
 };
 var getMRRocket = () => shared;
-var Ctx = (0, import_react.createContext)(null);
-var MRRocketProvider = ({ client: given, children, consent, ...options }) => {
-  const [client] = (0, import_react.useState)(() => given ?? createMRRocket({ ...options, consent }));
-  (0, import_react.useEffect)(() => {
+var Ctx = (0, import_react2.createContext)(null);
+var MRRocketProvider = ({ client: given, children, consent, flows = true, appearance, ...options }) => {
+  const [client] = (0, import_react2.useState)(() => given ?? createMRRocket({ ...options, consent }));
+  (0, import_react2.useEffect)(() => {
     if (consent) client.setConsent(consent);
   }, [client, consent]);
-  return (0, import_react.createElement)(Ctx.Provider, { value: client }, children);
+  return (0, import_react2.createElement)(Ctx.Provider, { value: client }, children, flows ? (0, import_react2.createElement)(MRRocketFlows, { flows: client.flows, appearance }) : null);
 };
 var useClient = () => {
-  const c = (0, import_react.useContext)(Ctx);
+  const c = (0, import_react2.useContext)(Ctx);
   if (!c) throw new Error("MRRocket: wrap your app in <MRRocketProvider apiKey=\u2026>.");
   return c;
 };
-var useVersion = (client) => (0, import_react.useSyncExternalStore)(client.subscribe, client.getVersion, client.getVersion);
+var useVersion = (client) => (0, import_react2.useSyncExternalStore)(client.subscribe, client.getVersion, client.getVersion);
 var useMRRocket = () => {
   const client = useClient();
   useVersion(client);
@@ -865,6 +1663,18 @@ var useMRRocket = () => {
     ready: client.isReady()
   };
 };
+var useCancelFlow = () => {
+  const client = useClient();
+  return { open: client.openCancelFlow };
+};
+var usePush = () => {
+  const client = useClient();
+  return { register: client.registerForPush, unregister: client.unregisterForPush };
+};
+var useOnboarding = () => {
+  const client = useClient();
+  return { start: client.startOnboarding };
+};
 var useFlag = (key) => {
   const client = useClient();
   useVersion(client);
@@ -880,11 +1690,22 @@ var useVariant = (key) => {
   useVersion(client);
   const config = client.getConfig();
   const variant = client.peekVariant(key);
-  (0, import_react.useEffect)(() => {
+  (0, import_react2.useEffect)(() => {
     if (config) client.expose(key, variant);
   }, [client, config, key, variant]);
   return variant;
 };
+var useText = (id, fallback) => {
+  const client = useClient();
+  useVersion(client);
+  const config = client.getConfig();
+  const text2 = client.peekText(id);
+  const person = client.getDistinctId();
+  (0, import_react2.useEffect)(() => {
+    if (config) client.exposeText(id);
+  }, [client, config, id, person]);
+  return text2 ?? fallback;
+};
 var expoRouter;
 var loadExpoRouter = () => {
   if (expoRouter !== void 0) return expoRouter;
@@ -905,13 +1726,13 @@ var useExpoRouterTracking = () => {
     console.warn("[MRRocket] useExpoRouterTracking needs expo-router. With React Navigation use useNavigationTracking.");
   }
   const pathname = (router?.usePathname ?? noPathname)();
-  (0, import_react.useEffect)(() => {
+  (0, import_react2.useEffect)(() => {
     if (pathname) client.screen(pathname);
   }, [client, pathname]);
 };
 var useNavigationTracking = () => {
   const client = useClient();
-  return (0, import_react.useCallback)(
+  return (0, import_react2.useCallback)(
     (state) => {
       const name = activeRouteName(state);
       if (name) client.screen(name);