@thelol3882/sapar 0.0.0-stage → 0.3.0

package/dist/chunk-FM64UDKJ.js

@@ -0,0 +1,893 @@
+// src/core/capping.ts
+var SESSION_CAP_KEY = "sapar.session-interruption-spent";
+function hasSpentSessionInterruption(adapter) {
+  return adapter.session.get(SESSION_CAP_KEY) !== null;
+}
+function spendSessionInterruption(adapter) {
+  adapter.session.set(SESSION_CAP_KEY, String(adapter.now()));
+}
+
+// src/core/routes.ts
+function normalizeRoute(route, locales) {
+  const path = (route ?? "").split("#")[0].split("?")[0].trim();
+  const segments = path.split("/").filter((segment) => segment !== "");
+  if (segments.length > 0 && locales.includes(segments[0])) segments.shift();
+  return `/${segments.join("/")}`;
+}
+function routeMatches(pattern, route, locales) {
+  const trimmed = pattern.trim();
+  if (!pattern) return false;
+  if (trimmed === "*") return true;
+  const target = normalizeRoute(route, locales);
+  if (trimmed.endsWith("/*")) {
+    const prefix = normalizeRoute(trimmed.slice(0, -2), locales);
+    return prefix === "/" || target === prefix || target.startsWith(`${prefix}/`);
+  }
+  return normalizeRoute(trimmed, locales) === target;
+}
+function isValidRoutePattern(pattern) {
+  if (!pattern) return false;
+  if (pattern === "*") return true;
+  const body = pattern.endsWith("/*") ? pattern.slice(0, -2) : pattern;
+  return !body.includes("*");
+}
+
+// src/core/steps.ts
+var DEFAULT_ANCHOR_TIMEOUT_MS = 3e3;
+var DEFAULT_PRESENT_ANCHOR_TIMEOUT_MS = 300;
+var DEFAULT_AUTO_START_TIMEOUT_MS = 1e4;
+function requiresNavigation(step, adapter, locales) {
+  if (step.route === void 0) return false;
+  return normalizeRoute(step.route, locales) !== normalizeRoute(adapter.currentRoute(), locales);
+}
+async function findMissingAnchors(steps, adapter, locales) {
+  async function isMissing(step) {
+    if (step.anchor === void 0 || requiresNavigation(step, adapter, locales)) return false;
+    return await adapter.resolveAnchor(step.anchor, { timeoutMs: 0 }) === null;
+  }
+  const missing = await Promise.all(steps.map(isMissing));
+  return steps.filter((_, index) => missing[index]).map((step) => step.key);
+}
+
+// src/core/machine.ts
+var IDLE = { phase: "idle", tour: null, index: 0, handle: null, skipped: [], autoStarted: false };
+var noop = () => {
+};
+function createTourMachine(adapter, events, options = {}) {
+  const anchorTimeoutMs = options.anchorTimeoutMs ?? DEFAULT_ANCHOR_TIMEOUT_MS;
+  const presentAnchorTimeoutMs = options.presentAnchorTimeoutMs ?? DEFAULT_PRESENT_ANCHOR_TIMEOUT_MS;
+  const locales = options.locales ?? [];
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = IDLE;
+  let destroyed = false;
+  let stopListeningForPress = noop;
+  let transitionToken = 0;
+  function beginTransition() {
+    stopListeningForPress();
+    stopListeningForPress = noop;
+    return ++transitionToken;
+  }
+  function isCurrent(token) {
+    return !destroyed && token === transitionToken;
+  }
+  function commit(next2) {
+    snapshot = next2;
+    stopListeningForPress();
+    listenToCurrentStep();
+    listeners.forEach((listener) => listener());
+  }
+  function listenToCurrentStep() {
+    stopListeningForPress = listenForPress(snapshot);
+  }
+  function listenForPress({ phase, tour, index, handle }) {
+    if (phase !== "running" || tour?.steps[index]?.advanceOn !== "press" || !handle) return noop;
+    return handle.onPress(() => void next());
+  }
+  async function resolveTarget(step) {
+    let timeoutMs = presentAnchorTimeoutMs;
+    if (requiresNavigation(step, adapter, locales)) {
+      await adapter.navigate(step.route);
+      timeoutMs = anchorTimeoutMs;
+    }
+    if (step.anchor === void 0) return { handle: null };
+    const handle = await adapter.resolveAnchor(step.anchor, { timeoutMs });
+    return handle && { handle };
+  }
+  async function seek(token, tour, from, direction) {
+    const missed = [];
+    for (let index = from; ; index += direction) {
+      const step = tour.steps[index];
+      if (!step) return { kind: "exhausted" };
+      const target = await resolveTarget(step);
+      if (!isCurrent(token)) return null;
+      if (target) return { kind: "arrived", index, handle: target.handle, missed };
+      if (step.required) return { kind: "aborted" };
+      missed.push(step.key);
+    }
+  }
+  async function land(token, tour, arrival) {
+    const { index, handle, missed } = arrival;
+    if (handle) {
+      await adapter.scrollIntoView(handle, { reducedMotion: adapter.prefersReducedMotion() });
+      if (!isCurrent(token)) return "stopped";
+    }
+    const missingLater = await findMissingAnchors(tour.steps.slice(index + 1), adapter, locales);
+    if (!isCurrent(token)) return "stopped";
+    const known = /* @__PURE__ */ new Set([...snapshot.skipped, ...missed]);
+    const missingEarlier = tour.steps.slice(0, index).filter((step) => known.has(step.key)).map((step) => step.key);
+    const skipped = [...missingEarlier, ...missingLater];
+    commit({ phase: "running", tour, index, handle, skipped, autoStarted: snapshot.autoStarted });
+    return "landed";
+  }
+  async function travel(token, tour, from, direction) {
+    const found = await seek(token, tour, from, direction);
+    if (!found) return "stopped";
+    if (found.kind === "aborted") {
+      commit(IDLE);
+      return "stopped";
+    }
+    return found.kind === "exhausted" ? "exhausted" : land(token, tour, found);
+  }
+  async function guarded(token, transition) {
+    try {
+      await transition();
+    } catch (error) {
+      if (isCurrent(token)) commit(IDLE);
+      events.onError(error, "tour machine");
+    }
+  }
+  async function start(tour, { autoStarted }) {
+    if (destroyed) return;
+    const token = beginTransition();
+    commit({ ...IDLE, phase: "preparing", tour, autoStarted });
+    await guarded(token, async () => {
+      const outcome = await travel(token, tour, 0, 1);
+      if (outcome === "exhausted") commit(IDLE);
+      if (outcome === "landed") {
+        const { key, revision } = tour;
+        events.onProgress({ key, revision, status: "started", stepIndex: snapshot.index, autoStarted });
+      }
+    });
+  }
+  async function move(direction) {
+    const { phase, tour, index } = snapshot;
+    if (destroyed || phase !== "running" || !tour) return;
+    const token = beginTransition();
+    await guarded(token, async () => {
+      const outcome = await travel(token, tour, index + direction, direction);
+      if (outcome !== "exhausted") return;
+      if (direction === 1) finish();
+      else listenToCurrentStep();
+    });
+  }
+  const next = () => move(1);
+  const previous = () => move(-1);
+  function end(status) {
+    const { phase, tour, index, autoStarted } = snapshot;
+    if (destroyed || phase !== "running" || !tour) return;
+    beginTransition();
+    commit(IDLE);
+    events.onProgress({ key: tour.key, revision: tour.revision, status, stepIndex: index, autoStarted });
+  }
+  const finish = () => end("completed");
+  const skip = () => end("dismissed");
+  function destroy() {
+    if (destroyed) return;
+    beginTransition();
+    destroyed = true;
+    listeners.clear();
+  }
+  return {
+    subscribe(listener) {
+      if (destroyed) return noop;
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    getSnapshot: () => snapshot,
+    start,
+    next,
+    previous,
+    skip,
+    finish,
+    destroy
+  };
+}
+
+// src/core/controller.ts
+function withUnread(inbox, keys, unread) {
+  const flipped = inbox.items.filter((item) => keys.has(item.key) && item.unread !== unread);
+  if (flipped.length === 0) return inbox;
+  const countDelta = flipped.filter((item) => item.tier !== "silent").length * (unread ? 1 : -1);
+  return {
+    ...inbox,
+    unreadCount: inbox.unreadCount + countDelta,
+    items: inbox.items.map((item) => flipped.includes(item) ? { ...item, unread } : item)
+  };
+}
+function withoutInterruption(inbox, announcementKeys) {
+  const { interruption } = inbox;
+  const matches = interruption?.kind === "announcement" && announcementKeys.includes(interruption.announcement.key);
+  return matches ? { ...inbox, interruption: null } : inbox;
+}
+function createSaparController(options) {
+  const { source, adapter, locales = [], sessionCap = true } = options;
+  const autoStartTimeoutMs = options.autoStartTimeoutMs ?? DEFAULT_AUTO_START_TIMEOUT_MS;
+  const onError = options.onError ?? ((error, context) => console.error(`[sapar] ${context}`, error));
+  const listeners = /* @__PURE__ */ new Set();
+  const autoStartedKeys = /* @__PURE__ */ new Set();
+  let route;
+  let inboxRequestId = 0;
+  let surfacedAnnouncementKey = null;
+  let destroyed = false;
+  const machine = createTourMachine(
+    adapter,
+    { onProgress: handleProgress, onError },
+    {
+      anchorTimeoutMs: options.anchorTimeoutMs ?? DEFAULT_ANCHOR_TIMEOUT_MS,
+      presentAnchorTimeoutMs: options.presentAnchorTimeoutMs ?? DEFAULT_PRESENT_ANCHOR_TIMEOUT_MS,
+      locales
+    }
+  );
+  let snapshot = { inbox: null, inboxStatus: "idle", runner: machine.getSnapshot() };
+  machine.subscribe(() => update({ runner: machine.getSnapshot() }));
+  function update(patch) {
+    const changed = Object.keys(patch).some((name) => patch[name] !== snapshot[name]);
+    if (!changed) return;
+    snapshot = { ...snapshot, ...patch };
+    listeners.forEach((listener) => listener());
+  }
+  function applySessionCap(interruption) {
+    if (!interruption || !sessionCap) return interruption;
+    const isSurfaced = interruption.kind === "announcement" && interruption.announcement.key === surfacedAnnouncementKey;
+    if (isSurfaced) return interruption;
+    if (hasSpentSessionInterruption(adapter)) return null;
+    if (interruption.kind === "announcement") {
+      surfacedAnnouncementKey = interruption.announcement.key;
+      spendSessionInterruption(adapter);
+    }
+    return interruption;
+  }
+  async function waitForPage(tour) {
+    const first = tour.steps.find((step) => step.anchor !== void 0);
+    if (first?.anchor === void 0 || requiresNavigation(first, adapter, locales)) return true;
+    return await adapter.resolveAnchor(first.anchor, { timeoutMs: autoStartTimeoutMs }) !== null;
+  }
+  async function autoStart(tour) {
+    if (snapshot.runner.phase !== "idle" || autoStartedKeys.has(tour.key)) return;
+    autoStartedKeys.add(tour.key);
+    const ready = await waitForPage(tour).catch((error) => {
+      onError(error, "autoStart");
+      return false;
+    });
+    if (!ready || destroyed || snapshot.runner.phase !== "idle") {
+      autoStartedKeys.delete(tour.key);
+      return;
+    }
+    await machine.start(tour, { autoStarted: true });
+  }
+  function handleProgress(input) {
+    if (input.status === "started" && input.autoStarted && sessionCap) spendSessionInterruption(adapter);
+    void reportProgress(input);
+  }
+  async function reportProgress(input) {
+    try {
+      await source.recordProgress(input);
+    } catch (error) {
+      onError(error, "progress");
+      return;
+    }
+    if (input.status !== "started") await refresh();
+  }
+  async function refresh() {
+    if (destroyed) return;
+    const requestId = ++inboxRequestId;
+    const query = { route: route === void 0 ? void 0 : normalizeRoute(route, locales), platform: adapter.platform };
+    if (!snapshot.inbox) update({ inboxStatus: "loading" });
+    try {
+      const inbox = await source.getInbox(query);
+      if (destroyed || requestId !== inboxRequestId) return;
+      const interruption = applySessionCap(inbox.interruption);
+      update({ inbox: { ...inbox, interruption }, inboxStatus: "ready" });
+      if (interruption?.kind === "tour") void autoStart(interruption.tour);
+    } catch (error) {
+      if (destroyed || requestId !== inboxRequestId) return;
+      update({ inboxStatus: "error" });
+      onError(error, "inbox");
+    }
+  }
+  async function loadTour(tourOrKey) {
+    if (typeof tourOrKey !== "string") return tourOrKey;
+    const tour = await source.getTour(tourOrKey);
+    if (!tour) onError(new Error(`No tour with key "${tourOrKey}".`), "startTour");
+    return tour;
+  }
+  async function startTour(tourOrKey) {
+    try {
+      const tour = await loadTour(tourOrKey);
+      if (tour && !destroyed) await machine.start(tour, { autoStarted: false });
+    } catch (error) {
+      onError(error, "startTour");
+    }
+  }
+  async function markSeen(keys) {
+    const flippedKeys = new Set(
+      snapshot.inbox?.items.filter((item) => item.unread && keys.includes(item.key)).map((item) => item.key)
+    );
+    if (snapshot.inbox) update({ inbox: withoutInterruption(withUnread(snapshot.inbox, flippedKeys, false), keys) });
+    try {
+      await source.markSeen(keys);
+    } catch (error) {
+      if (snapshot.inbox) update({ inbox: withUnread(snapshot.inbox, flippedKeys, true) });
+      onError(error, "markSeen");
+    }
+  }
+  async function dismiss(key) {
+    if (snapshot.inbox) update({ inbox: withoutInterruption(snapshot.inbox, [key]) });
+    try {
+      await source.dismiss(key);
+    } catch (error) {
+      onError(error, "dismiss");
+      return;
+    }
+    await refresh();
+  }
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    getSnapshot: () => snapshot,
+    setRoute(nextRoute) {
+      route = nextRoute;
+      void refresh();
+    },
+    refresh,
+    startTour,
+    next: () => machine.next(),
+    previous: () => machine.previous(),
+    skip: () => machine.skip(),
+    markSeen,
+    dismiss,
+    recordClick(key) {
+      source.recordClick(key).catch((error) => onError(error, "recordClick"));
+    },
+    destroy() {
+      destroyed = true;
+      machine.destroy();
+      listeners.clear();
+    }
+  };
+}
+
+// src/core/define.ts
+var KEY_PATTERN = /^[a-z0-9_]+(\.[a-z0-9_]+)*$/;
+function assertKey(kind, key) {
+  if (!KEY_PATTERN.test(key)) {
+    throw new Error(`Invalid ${kind} key "${key}": use lowercase letters, digits and underscores, dot-separated.`);
+  }
+}
+function assertUnique(kind, keys) {
+  const duplicate = keys.find((key, index) => keys.indexOf(key) !== index);
+  if (duplicate !== void 0) throw new Error(`Duplicate ${kind} key "${duplicate}".`);
+}
+function defineStep(input, tourKey) {
+  assertKey(`step in tour "${tourKey}"`, input.key);
+  if (input.anchor !== void 0) assertKey(`anchor of step "${input.key}"`, input.anchor);
+  const { placement = "auto", padding = 8, required = false, advanceOn = "next", ...rest } = input;
+  return { ...rest, placement, padding, required, advanceOn };
+}
+function defineTour(input) {
+  assertKey("tour", input.key);
+  const { revision = 1, trigger = "manual" } = input;
+  if (!Number.isInteger(revision) || revision < 1) {
+    throw new Error(`Tour "${input.key}" needs a positive integer revision, got ${revision}.`);
+  }
+  if (input.steps.length === 0) throw new Error(`Tour "${input.key}" needs at least one step.`);
+  if (trigger !== "manual" && !isValidRoutePattern(trigger.route)) {
+    throw new Error(`Tour "${input.key}" has an invalid route pattern "${trigger.route}".`);
+  }
+  const steps = input.steps.map((step) => defineStep(step, input.key));
+  assertUnique(`step in tour "${input.key}"`, steps.map((step) => step.key));
+  return { key: input.key, revision, title: input.title, trigger, steps, ...input.platforms && { platforms: input.platforms } };
+}
+function defineAnnouncement(input) {
+  if (Number.isNaN(Date.parse(input.publishedAt))) {
+    throw new Error(`Announcement "${input.key}" has an invalid publishedAt "${input.publishedAt}".`);
+  }
+  const { tier = "feed", ...rest } = input;
+  return { ...rest, tier };
+}
+function defineAnchors(keys) {
+  keys.forEach((key) => assertKey("anchor", key));
+  assertUnique("anchor", keys);
+  return keys;
+}
+function resolveText(text, locale, fallbackLocale) {
+  if (typeof text === "string") return text;
+  return text[locale] ?? text[fallbackLocale] ?? "";
+}
+function resolveStep(step, { locale, fallbackLocale }) {
+  return {
+    ...step,
+    title: resolveText(step.title, locale, fallbackLocale),
+    body: resolveText(step.body, locale, fallbackLocale)
+  };
+}
+function resolveTour(tour, textLocale) {
+  return {
+    ...tour,
+    title: resolveText(tour.title, textLocale.locale, textLocale.fallbackLocale),
+    steps: tour.steps.map((step) => resolveStep(step, textLocale))
+  };
+}
+function resolveAnnouncement(announcement, { locale, fallbackLocale }, unread) {
+  const { cta, ...rest } = announcement;
+  return {
+    ...rest,
+    title: resolveText(announcement.title, locale, fallbackLocale),
+    body: resolveText(announcement.body, locale, fallbackLocale),
+    ...cta && { cta: { label: resolveText(cta.label, locale, fallbackLocale), url: cta.url } },
+    unread
+  };
+}
+
+// src/core/policy.ts
+var DEFAULT_POLICY = {
+  newUserGraceDays: 3,
+  cooldownHours: 24,
+  dismissalBackoffDays: 30
+};
+var HOUR_MS = 60 * 60 * 1e3;
+var DAY_MS = 24 * HOUR_MS;
+function isWithin(now, since, windowMs) {
+  return since !== null && now - since < windowMs;
+}
+function interruptionsAllowed({ policy, now, registeredAt, lastAutoInterruptionAt }) {
+  const inGrace = policy.newUserGraceDays > 0 && isWithin(now, registeredAt, policy.newUserGraceDays * DAY_MS);
+  const coolingDown = policy.cooldownHours > 0 && isWithin(now, lastAutoInterruptionAt, policy.cooldownHours * HOUR_MS);
+  return !inGrace && !coolingDown;
+}
+function isTourOfferable({ policy, now, state, revision }) {
+  if (!state || state.revision !== revision) return true;
+  if (state.status === "completed") return false;
+  if (state.status === "started") return true;
+  if (policy.dismissalBackoffDays <= 0) return true;
+  return state.dismissedAt !== null && !isWithin(now, state.dismissedAt, policy.dismissalBackoffDays * DAY_MS);
+}
+function pickTour(budget, { route, locales, tours, stateOf }) {
+  if (route === void 0) return void 0;
+  return tours.filter(
+    (tour) => typeof tour.trigger === "object" && routeMatches(tour.trigger.route, route, locales) && isTourOfferable({ ...budget, state: stateOf(tour), revision: tour.revision })
+  ).sort((a, b) => a.key < b.key ? -1 : 1)[0];
+}
+function pickInterruption(budget, candidates) {
+  if (!interruptionsAllowed(budget)) return null;
+  const tour = pickTour(budget, candidates);
+  if (tour) return { kind: "tour", tour };
+  const announcement = candidates.announcements.find(
+    (item) => item.tier === "modal" && item.unread && !candidates.dismissedKeys.has(item.key)
+  );
+  return announcement ? { kind: "announcement", announcement } : null;
+}
+
+// src/core/stores.ts
+function memoryStore() {
+  const values = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => values.get(key) ?? null,
+    set: (key, value) => {
+      values.set(key, value);
+    },
+    remove: (key) => {
+      values.delete(key);
+    }
+  };
+}
+
+// src/core/sources/memory.ts
+var isRecordMap = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+function parseJson(raw) {
+  try {
+    return raw === null ? void 0 : JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function storedCell(store, key, isValid, empty) {
+  return {
+    async read() {
+      const value = parseJson(await store.get(key));
+      return isValid(value) ? value : empty();
+    },
+    async write(value) {
+      await store.set(key, JSON.stringify(value));
+    }
+  };
+}
+function translateTour(tour, translate) {
+  return {
+    ...tour,
+    title: translate(tour.title),
+    steps: tour.steps.map((step) => ({ ...step, title: translate(step.title), body: translate(step.body) }))
+  };
+}
+function translateAnnouncement(announcement, translate) {
+  const { cta } = announcement;
+  return {
+    ...announcement,
+    title: translate(announcement.title),
+    body: translate(announcement.body),
+    ...cta && { cta: { ...cta, label: translate(cta.label) } }
+  };
+}
+var recordId = (key, revision) => `${key}@${revision}`;
+function toEpochMs(value) {
+  return value == null ? null : new Date(value).getTime();
+}
+function latestAutoStart(records) {
+  const starts = Object.values(records).filter((record) => record.autoStarted).map((record) => record.startedAt);
+  return starts.length > 0 ? Math.max(...starts) : null;
+}
+function memorySource(options) {
+  const { storage, namespace = "sapar", fallbackLocale = "en", translate = (text) => text } = options;
+  const policy = { ...DEFAULT_POLICY, ...options.policy };
+  const clock = options.now ?? Date.now;
+  const registeredAt = toEpochMs(options.registeredAt);
+  const announcementDefinitions = options.announcements ?? [];
+  const tourRecords = storedCell(storage, `${namespace}.tour-records`, isRecordMap, () => ({}));
+  const seenKeys = storedCell(storage, `${namespace}.seen`, isStringArray, () => []);
+  const dismissedKeys = storedCell(storage, `${namespace}.dismissed`, isStringArray, () => []);
+  let queue = Promise.resolve();
+  function serialized(task) {
+    const result = queue.then(task);
+    queue = result.catch(() => void 0);
+    return result;
+  }
+  function textLocale() {
+    const { locale = fallbackLocale } = options;
+    return { locale: typeof locale === "function" ? locale() : locale, fallbackLocale };
+  }
+  const readTour = (definition) => translateTour(resolveTour(definition, textLocale()), translate);
+  function findTour(key) {
+    const tour = options.tours.find((candidate) => candidate.key === key);
+    if (!tour) throw new Error(`No tour with key "${key}".`);
+    return tour;
+  }
+  const isKnownAnnouncement = (key) => announcementDefinitions.some((announcement) => announcement.key === key);
+  function requireAnnouncement(key) {
+    if (!isKnownAnnouncement(key)) throw new Error(`No announcement with key "${key}".`);
+  }
+  async function publishedAnnouncements(now) {
+    const seen = new Set(await seenKeys.read());
+    const locale = textLocale();
+    return announcementDefinitions.filter((announcement) => Date.parse(announcement.publishedAt) <= now).sort((a, b) => Date.parse(b.publishedAt) - Date.parse(a.publishedAt) || (a.key < b.key ? -1 : 1)).map(
+      (announcement) => translateAnnouncement(resolveAnnouncement(announcement, locale, !seen.has(announcement.key)), translate)
+    );
+  }
+  async function addKeys(cell, keys) {
+    const merged = /* @__PURE__ */ new Set([...await cell.read(), ...keys]);
+    await cell.write([...merged]);
+  }
+  async function getInbox({ route, platform }) {
+    const now = clock();
+    const records = await tourRecords.read();
+    const items = await publishedAnnouncements(now);
+    const budget = { policy, now, registeredAt, lastAutoInterruptionAt: latestAutoStart(records) };
+    const interruption = pickInterruption(budget, {
+      route,
+      // The controller sends an already-normalized route.
+      locales: [],
+      tours: options.tours.filter((tour) => tour.platforms?.includes(platform) ?? true).map(readTour),
+      stateOf: (tour) => records[recordId(tour.key, tour.revision)],
+      announcements: items,
+      dismissedKeys: new Set(await dismissedKeys.read())
+    });
+    return {
+      unreadCount: items.filter((item) => item.unread && item.tier !== "silent").length,
+      items,
+      interruption
+    };
+  }
+  async function recordProgress({ key, revision, status, stepIndex, autoStarted }) {
+    findTour(key);
+    const records = await tourRecords.read();
+    const id = recordId(key, revision);
+    const existing = records[id];
+    const now = clock();
+    const finalStatus = existing?.status === "completed" ? "completed" : status;
+    records[id] = {
+      status: finalStatus,
+      revision,
+      lastStepIndex: Math.max(stepIndex, existing?.lastStepIndex ?? 0),
+      startedAt: existing?.startedAt ?? now,
+      dismissedAt: existing?.dismissedAt ?? (finalStatus === "dismissed" ? now : null),
+      autoStarted: autoStarted || (existing?.autoStarted ?? false)
+    };
+    await tourRecords.write(records);
+  }
+  async function markSeen(keys) {
+    await addKeys(seenKeys, keys.filter(isKnownAnnouncement));
+  }
+  return {
+    getInbox: (query) => serialized(() => getInbox(query)),
+    getTour: (key) => serialized(async () => {
+      const tour = options.tours.find((candidate) => candidate.key === key);
+      return tour ? readTour(tour) : null;
+    }),
+    recordProgress: (input) => serialized(() => recordProgress(input)),
+    markSeen: (keys) => serialized(() => markSeen(keys)),
+    dismiss: (key) => serialized(async () => {
+      requireAnnouncement(key);
+      await addKeys(seenKeys, [key]);
+      await addKeys(dismissedKeys, [key]);
+    }),
+    recordClick: (key) => serialized(async () => {
+      requireAnnouncement(key);
+      await addKeys(seenKeys, [key]);
+    }),
+    listAnnouncements: () => serialized(() => publishedAnnouncements(clock()))
+  };
+}
+
+// src/core/wire.ts
+function fromWireStep(step) {
+  return {
+    key: step.step_key,
+    ...step.anchor_key && { anchor: step.anchor_key },
+    ...step.route && { route: step.route },
+    title: step.title,
+    body: step.body,
+    placement: step.placement,
+    padding: step.spotlight_padding,
+    required: step.is_required,
+    advanceOn: "next"
+  };
+}
+function fromWireTour(tour) {
+  return {
+    key: tour.key,
+    revision: tour.revision,
+    title: tour.title,
+    trigger: tour.trigger === "route" ? { route: "*" } : "manual",
+    steps: [...tour.steps].sort((a, b) => a.order - b.order).map(fromWireStep)
+  };
+}
+function fromWireAnnouncement(announcement) {
+  return {
+    key: announcement.key,
+    tier: announcement.tier,
+    title: announcement.title,
+    body: announcement.body,
+    ...announcement.image_url && { imageUrl: announcement.image_url },
+    ...announcement.cta_url && { cta: { label: announcement.cta_label, url: announcement.cta_url } },
+    publishedAt: announcement.published_at,
+    ...announcement.tour_key && { tourKey: announcement.tour_key },
+    unread: announcement.is_unread
+  };
+}
+function fromWireInterruption({ kind, tour, announcement }) {
+  if (kind === "tour" && tour) return { kind, tour: fromWireTour(tour) };
+  if (kind === "announcement" && announcement) return { kind, announcement: fromWireAnnouncement(announcement) };
+  return null;
+}
+function fromWireInbox(inbox) {
+  return {
+    unreadCount: inbox.unread_count,
+    items: inbox.items.map(fromWireAnnouncement),
+    interruption: inbox.interruption && fromWireInterruption(inbox.interruption)
+  };
+}
+function toWireProgress({ status, stepIndex, autoStarted }) {
+  return { status, step_index: stepIndex, auto_started: autoStarted };
+}
+
+// src/core/sources/http.ts
+var SaparHttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "SaparHttpError";
+  }
+  status;
+};
+function resolveValue(value) {
+  return typeof value === "function" ? value() : value;
+}
+function buildUrl(baseUrl, path, query) {
+  const params = new URLSearchParams();
+  Object.entries(query).forEach(([name, value]) => value !== void 0 && params.set(name, value));
+  const search = params.toString();
+  return `${baseUrl.replace(/\/+$/, "")}/${path}${search && `?${search}`}`;
+}
+function httpSource(options) {
+  async function send(method, path, query = {}, body) {
+    const headers = new Headers(await resolveValue(options.headers ?? {}));
+    headers.set("Accept", "application/json");
+    if (body !== void 0) headers.set("Content-Type", "application/json");
+    const response = await (options.fetch ?? fetch)(buildUrl(options.baseUrl, path, query), {
+      method,
+      headers,
+      credentials: options.credentials,
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    if (!response.ok) throw new SaparHttpError(response.status, `${method} ${path} failed with ${response.status}`);
+    return response;
+  }
+  async function getJson(path, query = {}) {
+    const lang = options.locale === void 0 ? void 0 : resolveValue(options.locale);
+    const response = await send("GET", path, { lang, ...query });
+    return await response.json();
+  }
+  async function post(path, body) {
+    await send("POST", path, {}, body);
+  }
+  const tourPath = (key) => `tours/${encodeURIComponent(key)}/`;
+  return {
+    async getInbox({ route, platform }) {
+      return fromWireInbox(await getJson("inbox/", { route, platform }));
+    },
+    async getTour(key) {
+      try {
+        return fromWireTour(await getJson(tourPath(key)));
+      } catch (error) {
+        if (error instanceof SaparHttpError && error.status === 404) return null;
+        throw error;
+      }
+    },
+    recordProgress: (input) => post(`${tourPath(input.key)}progress/`, toWireProgress(input)),
+    markSeen: (keys) => post("seen/", { keys }),
+    dismiss: (key) => post("dismiss/", { key }),
+    recordClick: (key) => post(`announcements/${encodeURIComponent(key)}/click/`),
+    async listAnnouncements() {
+      return (await getJson("announcements/")).map(fromWireAnnouncement);
+    }
+  };
+}
+
+// src/core/testing.ts
+var RECT = { x: 0, y: 0, width: 100, height: 40 };
+function createAnchorHandle(key) {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    key,
+    measure: async () => RECT,
+    onPress(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    press: () => [...listeners].forEach((listener) => listener()),
+    pressListenerCount: () => listeners.size
+  };
+}
+function createTestAdapter(options = {}) {
+  const anchors = /* @__PURE__ */ new Map();
+  const waiting = /* @__PURE__ */ new Map();
+  const delayed = new Set(options.delayedAnchors);
+  const sessionValues = /* @__PURE__ */ new Map();
+  let route = options.route ?? "/";
+  let now = options.now ?? 0;
+  function showAnchor(key) {
+    const handle = anchors.get(key) ?? createAnchorHandle(key);
+    anchors.set(key, handle);
+    waiting.get(key)?.forEach((resolve) => resolve(handle));
+    waiting.delete(key);
+    return handle;
+  }
+  function waitForAnchor(key, timeoutMs) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => resolve(null), timeoutMs);
+      waiting.set(key, [
+        ...waiting.get(key) ?? [],
+        (handle) => {
+          clearTimeout(timer);
+          resolve(handle);
+        }
+      ]);
+    });
+  }
+  options.anchors?.forEach(showAnchor);
+  return {
+    platform: options.platform ?? "web",
+    anchors,
+    navigations: [],
+    scrolls: [],
+    resolveRequests: [],
+    sessionValues,
+    showAnchor,
+    hideAnchor: (key) => void anchors.delete(key),
+    setRoute: (next) => {
+      route = next;
+    },
+    advanceTime: (ms) => {
+      now += ms;
+    },
+    async resolveAnchor(key, { timeoutMs }) {
+      this.resolveRequests.push({ key, timeoutMs });
+      const present = anchors.get(key);
+      if (present) return present;
+      return delayed.has(key) ? waitForAnchor(key, timeoutMs) : null;
+    },
+    async scrollIntoView(handle, { reducedMotion }) {
+      this.scrolls.push({ handle, reducedMotion });
+    },
+    currentRoute: () => route,
+    async navigate(destination) {
+      this.navigations.push(destination);
+      route = destination;
+    },
+    prefersReducedMotion: () => options.reducedMotion ?? false,
+    isCompact: () => options.compact ?? false,
+    session: {
+      get: (key) => sessionValues.get(key) ?? null,
+      set: (key, value) => void sessionValues.set(key, value)
+    },
+    now: () => now
+  };
+}
+
+// src/core/spotlightPath.ts
+function roundedRectPath(x, y, width, height, requestedRadius) {
+  const r = Math.max(0, Math.min(requestedRadius, width / 2, height / 2));
+  return [
+    `M${x + r},${y}`,
+    `H${x + width - r}`,
+    `A${r},${r} 0 0 1 ${x + width},${y + r}`,
+    `V${y + height - r}`,
+    `A${r},${r} 0 0 1 ${x + width - r},${y + height}`,
+    `H${x + r}`,
+    `A${r},${r} 0 0 1 ${x},${y + height - r}`,
+    `V${y + r}`,
+    `A${r},${r} 0 0 1 ${x + r},${y}`,
+    "Z"
+  ].join(" ");
+}
+function spotlightPath({ rect, padding, radius, bounds }) {
+  const outer = `M0,0 H${bounds.width} V${bounds.height} H0 Z`;
+  if (!rect) return outer;
+  const cutout = roundedRectPath(rect.x - padding, rect.y - padding, rect.width + padding * 2, rect.height + padding * 2, radius);
+  return `${outer} ${cutout}`;
+}
+
+// src/core/presentation.ts
+function resolvePresentation({ presentation, compact, fits }) {
+  if (presentation !== "auto") return presentation;
+  return compact || fits === false ? "sheet" : "anchored";
+}
+
+export {
+  SESSION_CAP_KEY,
+  hasSpentSessionInterruption,
+  spendSessionInterruption,
+  normalizeRoute,
+  routeMatches,
+  isValidRoutePattern,
+  DEFAULT_ANCHOR_TIMEOUT_MS,
+  DEFAULT_PRESENT_ANCHOR_TIMEOUT_MS,
+  DEFAULT_AUTO_START_TIMEOUT_MS,
+  createTourMachine,
+  createSaparController,
+  KEY_PATTERN,
+  defineTour,
+  defineAnnouncement,
+  defineAnchors,
+  resolveText,
+  resolveTour,
+  resolveAnnouncement,
+  DEFAULT_POLICY,
+  interruptionsAllowed,
+  isTourOfferable,
+  pickInterruption,
+  memoryStore,
+  memorySource,
+  fromWireTour,
+  fromWireAnnouncement,
+  fromWireInbox,
+  toWireProgress,
+  SaparHttpError,
+  httpSource,
+  createTestAdapter,
+  spotlightPath,
+  resolvePresentation
+};
+//# sourceMappingURL=chunk-FM64UDKJ.js.map