@eifi1/ui-kit 0.43.0 → 0.45.0

package/dist/tour/use-tour-progress.d.ts

@@ -15,20 +15,112 @@ import { type TourCompletions } from "./tour-info.js";
  *   a shape it recognises, `undefined` for any other — the kit's own shape included,
  *   which it then reads itself. keksdose: zustand's `{state: {completed}, version: 1}`;
  *   kastlan: an array of ids, completed without a date (`null`). It runs only on a stored
- *   text that is not the kit's shape already, once per text and key, whichever reader
- *   reads it first; its identity is ignored. **Define `migrate` once, at module level**,
- *   and hand every reader of the key the same one: readers of one key share one snapshot.
+ *   text that is not the kit's shape already, once per text and key. The FIRST `migrate`
+ *   any reader, `TourProvider` or {@link completeTour} passes for a key is remembered for
+ *   that key (later identities are ignored), so a reader without one, mounted first, no
+ *   longer hides the old marks from the rest (keksdose B-2). **Still, define the options
+ *   once, at module level, and hand the provider and every reader the same object.**
+ * - **Never overwritten unread** (keksdose B-1): a write (`complete`, the provider's,
+ *   `completeTour`) on a stored text that is neither empty nor the kit's shape, and that no
+ *   known `migrate` reads, THROWS instead of replacing the old marks.
  * - **Resetting the device** (settings §11): register the key with `reset: () =>
  *   resetTourProgress(storageKey)`, which clears storage and the page's memory and tells
  *   every reader in this tab.
  *
- * The kit's own shape is the record itself, `{ [id]: ISO | null }`; an empty string reads
- * as `null` (kastlan's record of 0.42).
+ * **The stored shape** (§9.3, §9.6.6), for an app's tests and seeds: the JSON record
+ * `{ [id]: ISO instant | "" }` under `storageKey`, where `""` is a completion without a
+ * date (a migrated record: kastlan's id list). That is the one written form; the hooks
+ * and callbacks (`completed`, `TourCompletions`) give `null` for `""`. A `null` read from
+ * storage (or returned by `migrate`) is accepted as the same thing and written back as
+ * `""`. To write a completion from outside a page, use {@link completeTour}.
+ *
+ * **On the account** (0.45, §10.2–§10.3): with `account`, the device key becomes the
+ * account's CACHE — see {@link TourProgressAccount}. Without it, nothing changes from 0.44.
  */
 export interface UseTourProgressOptions {
     storageKey: string;
     migrate?: (raw: unknown) => Record<string, string | null> | undefined;
+    /**
+     * 0.45: the account's record behind the device key (§10.2.4). Remembered per key like
+     * `migrate` (the FIRST one any reader or the provider passes wins). With it,
+     * `storageKey` must be per account (a prefix plus the user id), so build the options per
+     * account and keep ONE stable object per key — memoise them in a `Map` by user id — and
+     * let `load`/`save` read the current token when they run, never capture one:
+     *
+     *     const byUser = new Map<string, UseTourProgressOptions>();
+     *     function tourProgressFor(user: { id: string; isDemo: boolean } | null) {
+     *       if (!user || user.isDemo) return { storageKey: "app.tours.completions" }; // no account
+     *       let options = byUser.get(user.id);
+     *       if (!options) byUser.set(user.id, (options = { storageKey: `app.tours.completions:${user.id}`, account }));
+     *       return options;
+     *     }
+     *
+     * Signed out, and in a demo, pass none (and a fixed key): the device record works as in
+     * 0.44, and a demo neither PATCHes into a 403 nor leaves an orphan key per demo id.
+     */
+    account?: TourProgressAccount;
+}
+/** The record on the wire (§10.2.2): tour id → ISO instant, or `""` (done, no date). */
+type TourProgressWire = Record<string, string>;
+/** The `PATCH /tours/progress` body (§10.2.2): what to mark done, and what to forget.
+ *  An id is never in both. Either may be left out. */
+export interface TourProgressBody {
+    completed?: TourProgressWire;
+    forget?: string[];
+}
+/**
+ * Taking over a device-wide record from before the account (§10.2.5), on the FIRST load
+ * of the account key on this page:
+ * - `{storageKey, discard: true}` (kastlan): removes the old key and uploads nothing — a
+ *   shared PC must not hand one person another's marks. Removing an absent key is a no-op.
+ * - `{storageKey, migrate?}`: reads the old key once (through `migrate` for an older
+ *   shape), uploads it to the first account that signs in on this device, then removes it.
+ */
+export type TourProgressAdopt = {
+    storageKey: string;
+    discard: true;
+    migrate?: never;
+} | {
+    storageKey: string;
+    discard?: false;
+    migrate?: UseTourProgressOptions["migrate"];
+};
+/**
+ * The app's account record (§10.3): `load()` is its `GET /tours/progress`, `save(body)`
+ * its `PATCH`, each resolving to the parsed answer, `{completed}` — the whole record.
+ *
+ * - The page paints from the device key at once (and offline); the account is loaded on
+ *   the first reader of the key on this page, on `online`, and after each save, and its
+ *   answer replaces the cache.
+ * - A write (`complete`, the provider's finish, `reset`) goes to the cache at once and to
+ *   a PENDING record beside it, `<storageKey>:pending` (`{synced, completed, forget}`),
+ *   sent as one PATCH and cleared by its answer. A failure with no answer (offline, 5xx,
+ *   401) keeps it for the next load or `online`; a 402 (a lapsed plan) keeps it but sends it
+ *   no more on this page (the next session or page load tries again); a 403 or 422 drops
+ *   it and logs.
+ * - `awarded` stays the device's answer against the cache (§10.2.4).
+ * - The pending record is NOT the app's outbox: leave it out of any "N waiting" count
+ *   and any sign-out guard (losing a tour mark is acceptable).
+ * - A device record never synced (no `:pending` with `synced: true`) is uploaded whole on
+ *   its first load, by the server's merge rule (later completion wins).
+ * - On every end of a session call {@link signOutTourProgress}.
+ */
+export interface TourProgressAccount {
+    load: () => Promise<{
+        completed: TourProgressWire;
+    }>;
+    save: (body: TourProgressBody) => Promise<{
+        completed: TourProgressWire;
+    }>;
+    adopt?: TourProgressAdopt;
 }
+/** What `complete` takes: a tour id, or the tour (`{id, updated}`, a `TourInfo` fits). */
+type CompletedTour = string | {
+    id: string;
+    updated?: {
+        date: string;
+    } | null;
+};
 export interface TourProgress {
     /** Tour id → the completion's ISO timestamp, or `null` when recorded without a date. */
     completed: TourCompletions;
@@ -39,23 +131,84 @@ export interface TourProgress {
      *
      * Returns `true` when this counts as a new completion — the moment to award the tour's
      * points and show the app's toast (§6.1) — and `false` for a replay.
+     *
+     * A tour started with `start(steps, {tour})` under a `TourProvider` that has `progress`
+     * is recorded by the provider (§9.6.2): do not call this from that start's `onFinish`
+     * too, or the second write answers `false`.
      */
-    complete: (tour: string | {
-        id: string;
-        updated?: {
-            date: string;
-        } | null;
-    }) => boolean;
+    complete: (tour: CompletedTour) => boolean;
     /** "Mark as not done": forget the completion. */
     reset: (id: string) => void;
 }
+type Migrate = NonNullable<UseTourProgressOptions["migrate"]>;
+/**
+ * Remember `migrate` for `key` if it is the first one, and return the key's migrate. A
+ * snapshot parsed before the key had one is dropped and re-parsed, and the key's readers
+ * hear of it after this render (never from inside one).
+ * @internal Not part of the barrel; `TourProvider` registers its `progress` with it.
+ */
+export declare function rememberMigrate(key: string, migrate: UseTourProgressOptions["migrate"]): Migrate | undefined;
+/**
+ * Remember `account` for `key` if it is the first one, and return the key's account.
+ * @internal Not part of the barrel; `TourProvider` registers its `progress` with it.
+ */
+export declare function rememberAccount(key: string, account: TourProgressAccount | undefined): TourProgressAccount | undefined;
+/**
+ * The end of a session (§10.2.6) — sign-out, a 401 nothing could renew, the account's
+ * deletion, every path: removes the CACHE only (the device key and the page's snapshot;
+ * every reader in this tab moves), synchronously and with no request, and KEEPS
+ * `<storageKey>:pending`. That record sits under this person's own key, holds tour ids and
+ * dates only, and goes out on their next sign-in. An answer still on its way is ignored.
+ *
+ *     function logout() { …; signOutTourProgress(`app.tours:${user.id}`); }
+ */
+export declare function signOutTourProgress(storageKey: string): void;
 /**
  * Forget every tour completion under `storageKey` on this device: the stored key, what the
  * page kept in memory where storage refused it, and every reader in this tab moves at
  * once. For "Reset this device's settings" (settings §11):
  *
  *     registerDeviceSetting({ key: TOUR_KEY, kind: "view", reset: () => resetTourProgress(TOUR_KEY) });
+ *
+ * With an account (0.45) it clears the cache only: the account is never written, the
+ * pending record stays ("anything waiting to be sent", settings §11.2.2) and the next load
+ * refills the cache. Tour progress is never registered with the device reset (§10.2.8).
  */
 export declare function resetTourProgress(storageKey: string): void;
+/**
+ * Record a completion under `storageKey`, as {@link TourProgress.complete} does: through
+ * the one shared store and snapshot (never a copy), so every reader of the key moves.
+ * Returns `true` when it counts anew. `TourProvider` calls this on a tour's last step.
+ * @internal Not part of the barrel.
+ */
+export declare function completeStored(storageKey: string, migrate: UseTourProgressOptions["migrate"], tour: CompletedTour): boolean;
+/**
+ * Write a completion from outside a page (§9.2): for an app's tests, seeds and scripts,
+ * beside {@link resetTourProgress}. It writes the kit's stored shape (`{[id]: ISO | ""}`)
+ * under `storageKey`, keeps the other tours' marks, and notifies every reader of the key
+ * in this tab directly (the `storage` event reaches only OTHER tabs), so a mounted
+ * `useTourProgress` or `TourCatalogue` moves at once.
+ *
+ * Unlike `complete`, it always writes (over a readable text; see below): `at` is the
+ * completion's instant (an ISO string or a `Date`, default now), `null` a completion
+ * without a date (stored as `""`, read back as `null`).
+ *
+ *     completeTour(TOUR_KEY, "budget", "2026-09-01T10:00:00Z");
+ *
+ * A stored text in an app's older shape is read through `opts.migrate`, or else the
+ * migrate a reader or the provider registered for the key. If the text is neither empty
+ * nor the kit's shape and no migrate reads it, this THROWS and writes nothing (B-1):
+ *
+ *     completeTour(TOUR_KEY, "budget", undefined, { migrate: fromZustand });
+ *
+ * With an account on the key (0.45) it stays a device write — no request — and is marked
+ * pending, so the next load sends it.
+ */
+export declare function completeTour(storageKey: string, tour: string | {
+    id: string;
+}, at?: string | Date | null, opts?: {
+    migrate?: UseTourProgressOptions["migrate"];
+}): void;
 /** The device's tour completions under `storageKey`; see {@link UseTourProgressOptions}. */
-export declare function useTourProgress({ storageKey, migrate }: UseTourProgressOptions): TourProgress;
+export declare function useTourProgress({ storageKey, migrate, account }: UseTourProgressOptions): TourProgress;
+export {};

package/dist/tour/use-tour-progress.js

@@ -1,11 +1,20 @@
 "use client";
 import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from "react";
 import { readStored, removeStored, writeStored } from "../lib/safe-storage.js";
+import { httpStatusOf } from "../auth/auth-errors.js";
 import { isTourDone } from "./tour-info.js";
 const EMPTY = Object.freeze({});
 const listeners = /* @__PURE__ */ new Map();
 const memory = /* @__PURE__ */ new Map();
 const cache = /* @__PURE__ */ new Map();
+const migrates = /* @__PURE__ */ new Map();
+function rememberMigrate(key, migrate) {
+  if (migrate && !migrates.has(key)) {
+    migrates.set(key, migrate);
+    if (cache.delete(key)) queueMicrotask(() => emit(key));
+  }
+  return migrates.get(key);
+}
 function emit(key) {
   listeners.get(key)?.forEach((listener) => listener());
 }
@@ -26,7 +35,7 @@ function fromRecord(value) {
   return out;
 }
 function parse(raw, migrate) {
-  if (raw === null) return EMPTY;
+  if (raw === null || raw.trim() === "") return { value: EMPTY, readable: true };
   let value = raw;
   try {
     value = JSON.parse(raw);
@@ -34,28 +43,238 @@ function parse(raw, migrate) {
   }
   if (migrate && !isKitShape(value)) {
     try {
-      const migrated = migrate(value);
-      if (migrated !== void 0) return fromRecord(migrated) ?? EMPTY;
+      const migrated = fromRecord(migrate(value));
+      if (migrated !== void 0) return { value: migrated, readable: true };
     } catch {
     }
   }
-  return fromRecord(value) ?? EMPTY;
+  return { value: fromRecord(value) ?? EMPTY, readable: isKitShape(value) };
 }
 function snapshot(key, migrate) {
+  const known = rememberMigrate(key, migrate);
   const raw = rawOf(key);
   const hit = cache.get(key);
   if (hit && hit.raw === raw) return hit.value;
-  const value = parse(raw, migrate);
-  cache.set(key, { raw, value });
+  const parsed = parse(raw, known);
+  cache.set(key, { raw, ...parsed });
+  return parsed.value;
+}
+function readForWrite(key, migrate, own = false) {
+  const known = rememberMigrate(key, migrate);
+  const { value, readable } = own && migrate && known !== migrate ? parse(rawOf(key), migrate) : { value: snapshot(key, migrate), readable: cache.get(key)?.readable };
+  if (!readable) {
+    throw new Error(
+      `[ui-kit] tour progress: the text stored under "${key}" is not the kit's shape and no migrate reads it; refusing to overwrite it. Pass the key's migrate (the shared useTourProgress / TourProvider options, or completeTour's {migrate}).`
+    );
+  }
   return value;
 }
 function write(key, record) {
-  const raw = JSON.stringify(record);
+  const stored = {};
+  for (const [id, at] of Object.entries(record)) stored[id] = at ?? "";
+  const raw = JSON.stringify(stored);
   writeStored(key, raw);
   if (readStored(key) === raw) memory.delete(key);
   else memory.set(key, raw);
   emit(key);
 }
+const accounts = /* @__PURE__ */ new Map();
+const loaded = /* @__PURE__ */ new Set();
+const running = /* @__PURE__ */ new Set();
+const rerun = /* @__PURE__ */ new Set();
+const queued = /* @__PURE__ */ new Set();
+const epochs = /* @__PURE__ */ new Map();
+const parked = /* @__PURE__ */ new Set();
+const pendingMemory = /* @__PURE__ */ new Map();
+let onlineListening = false;
+const pendingKey = (key) => `${key}:pending`;
+function devWarn(message) {
+  if (import.meta.env?.DEV) console.warn(message);
+}
+function rememberAccount(key, account) {
+  if (account && !accounts.has(key)) {
+    accounts.set(key, account);
+    if (account.adopt && account.adopt.storageKey === key) {
+      devWarn(
+        `[ui-kit] tour progress: the account key "${key}" is the key \`adopt\` takes over. With an account the key must be per account (a prefix plus the user id), apart from the old device-wide key.`
+      );
+    }
+    if (!onlineListening && typeof window !== "undefined") {
+      onlineListening = true;
+      window.addEventListener("online", () => {
+        for (const known of loaded) void sync(known);
+      });
+    }
+  }
+  return accounts.get(key);
+}
+function readPending(key) {
+  const raw = pendingMemory.get(key) ?? readStored(pendingKey(key));
+  if (raw === null) return null;
+  try {
+    const value = JSON.parse(raw);
+    if (!value || typeof value !== "object") return null;
+    const completed = {};
+    for (const [id, at] of Object.entries(value.completed ?? {})) {
+      if (typeof at === "string") completed[id] = at;
+      else if (at === null) completed[id] = "";
+    }
+    const forget = Array.isArray(value.forget) ? value.forget.filter((id) => typeof id === "string") : [];
+    return { synced: value.synced === true, completed, forget };
+  } catch {
+    return null;
+  }
+}
+function writePending(key, record) {
+  const raw = JSON.stringify(record);
+  writeStored(pendingKey(key), raw);
+  if (readStored(pendingKey(key)) === raw) pendingMemory.delete(key);
+  else pendingMemory.set(key, raw);
+}
+const hasWork = (record) => Object.keys(record.completed).length > 0 || record.forget.length > 0;
+function later(a, b) {
+  if (a === void 0 || a === "") return b;
+  if (b === "") return a;
+  return Date.parse(b) > Date.parse(a) ? b : a;
+}
+function markPending(key, id, at, forget = false) {
+  const record = readPending(key) ?? { synced: false, completed: {}, forget: [] };
+  if (forget) {
+    delete record.completed[id];
+    if (!record.forget.includes(id)) record.forget.push(id);
+  } else {
+    record.completed[id] = at ?? "";
+    record.forget = record.forget.filter((other) => other !== id);
+  }
+  writePending(key, record);
+}
+function clearSent(key, sent, synced) {
+  const record = readPending(key) ?? { synced: false, completed: {}, forget: [] };
+  for (const [id, at] of Object.entries(sent.completed ?? {})) {
+    if (record.completed[id] === at) delete record.completed[id];
+  }
+  const forgotten = new Set(sent.forget ?? []);
+  record.forget = record.forget.filter((id) => !forgotten.has(id));
+  record.synced = record.synced || synced;
+  writePending(key, record);
+}
+function refill(key, answer) {
+  const next = {};
+  for (const [id, at] of Object.entries(fromRecord(answer?.completed) ?? {})) next[id] = at ?? "";
+  const waiting = readPending(key);
+  if (waiting) {
+    for (const [id, at] of Object.entries(waiting.completed)) next[id] = later(next[id], at);
+    for (const id of waiting.forget) delete next[id];
+  }
+  const record = {};
+  for (const [id, at] of Object.entries(next)) record[id] = at === "" ? null : at;
+  write(key, record);
+}
+function adoptOldRecord(key, account) {
+  const adopt = account.adopt;
+  if (!adopt || adopt.storageKey === key) return;
+  const old = adopt.storageKey;
+  if (!adopt.discard) {
+    const { value } = parse(rawOf(old), adopt.migrate ?? migrates.get(old));
+    const entries = Object.entries(value);
+    if (entries.length > 0) {
+      const record = readPending(key) ?? { synced: false, completed: {}, forget: [] };
+      for (const [id, at] of entries) record.completed[id] = later(record.completed[id], at ?? "");
+      writePending(key, record);
+    }
+  }
+  removeStored(old);
+  memory.delete(old);
+  cache.delete(old);
+  emit(old);
+}
+function uploadUnsynced(key) {
+  const record = readPending(key);
+  if (record?.synced) return;
+  const device = snapshot(key, migrates.get(key));
+  const entries = Object.entries(device);
+  const next = record ?? { synced: false, completed: {}, forget: [] };
+  if (entries.length === 0 && record) return;
+  for (const [id, at] of entries) {
+    if (!next.forget.includes(id)) next.completed[id] = later(next.completed[id], at ?? "");
+  }
+  writePending(key, next);
+}
+function prepare(key) {
+  loaded.add(key);
+  adoptOldRecord(key, accounts.get(key));
+  uploadUnsynced(key);
+}
+function queueSync(key) {
+  if (!loaded.has(key)) prepare(key);
+  if (queued.has(key)) return;
+  queued.add(key);
+  queueMicrotask(() => {
+    queued.delete(key);
+    void sync(key);
+  });
+}
+function ensureLoaded(key) {
+  if (!accounts.has(key) || loaded.has(key)) return;
+  prepare(key);
+  void sync(key);
+}
+async function sync(key) {
+  const account = accounts.get(key);
+  if (!account || !loaded.has(key)) return;
+  if (running.has(key)) {
+    rerun.add(key);
+    return;
+  }
+  if (typeof navigator !== "undefined" && navigator.onLine === false) return;
+  running.add(key);
+  const epoch = epochs.get(key) ?? 0;
+  try {
+    const waiting = readPending(key);
+    if (waiting && hasWork(waiting)) {
+      if (parked.has(key)) return;
+      const body = {};
+      if (Object.keys(waiting.completed).length > 0) body.completed = { ...waiting.completed };
+      if (waiting.forget.length > 0) body.forget = [...waiting.forget];
+      let answer;
+      try {
+        answer = await account.save(body);
+      } catch (error) {
+        const status = httpStatusOf(error);
+        if (status === 403 || status === 422) {
+          if ((epochs.get(key) ?? 0) === epoch) clearSent(key, body, false);
+          console.warn(`[ui-kit] tour progress: the account refused the pending record (${status}); dropped.`, error);
+        } else if (status === 402) {
+          parked.add(key);
+        }
+        return;
+      }
+      if ((epochs.get(key) ?? 0) !== epoch) return;
+      clearSent(key, body, true);
+      refill(key, answer);
+    } else {
+      const answer = await account.load();
+      if ((epochs.get(key) ?? 0) !== epoch) return;
+      if (waiting && !waiting.synced) writePending(key, { ...waiting, synced: true });
+      else if (!waiting) writePending(key, { synced: true, completed: {}, forget: [] });
+      refill(key, answer);
+    }
+  } catch {
+  } finally {
+    running.delete(key);
+    if (rerun.delete(key)) void sync(key);
+  }
+}
+function signOutTourProgress(storageKey) {
+  epochs.set(storageKey, (epochs.get(storageKey) ?? 0) + 1);
+  loaded.delete(storageKey);
+  rerun.delete(storageKey);
+  parked.delete(storageKey);
+  removeStored(storageKey);
+  memory.delete(storageKey);
+  cache.delete(storageKey);
+  emit(storageKey);
+}
 function subscribe(key, listener) {
   let set = listeners.get(key);
   if (!set) listeners.set(key, set = /* @__PURE__ */ new Set());
@@ -72,45 +291,72 @@ function subscribe(key, listener) {
   };
 }
 function resetTourProgress(storageKey) {
+  if (accounts.has(storageKey)) loaded.delete(storageKey);
   removeStored(storageKey);
   memory.delete(storageKey);
   cache.delete(storageKey);
   emit(storageKey);
 }
-function useTourProgress({ storageKey, migrate }) {
+function completeStored(storageKey, migrate, tour) {
+  const subject = typeof tour === "string" ? { id: tour } : tour;
+  const current = readForWrite(storageKey, migrate);
+  if (isTourDone(subject, current[subject.id])) return false;
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  write(storageKey, { ...current, [subject.id]: at });
+  if (accounts.has(storageKey)) {
+    markPending(storageKey, subject.id, at);
+    queueSync(storageKey);
+  }
+  return true;
+}
+function resetStored(storageKey, migrate, id) {
+  const current = snapshot(storageKey, migrate);
+  if (current[id] === void 0) return;
+  const next = { ...current };
+  delete next[id];
+  write(storageKey, next);
+  if (accounts.has(storageKey)) {
+    markPending(storageKey, id, void 0, true);
+    queueSync(storageKey);
+  }
+}
+function completeTour(storageKey, tour, at, opts) {
+  const id = typeof tour === "string" ? tour : tour.id;
+  const when = at === null ? null : at instanceof Date ? at.toISOString() : at ?? (/* @__PURE__ */ new Date()).toISOString();
+  write(storageKey, { ...readForWrite(storageKey, opts?.migrate, true), [id]: when });
+  if (accounts.has(storageKey)) markPending(storageKey, id, when);
+}
+function useTourProgress({ storageKey, migrate, account }) {
   const migrateRef = useRef(migrate);
   useEffect(() => {
     migrateRef.current = migrate;
   });
+  const accountRef = useRef(account);
+  useEffect(() => {
+    accountRef.current = account;
+  });
+  useEffect(() => {
+    if (rememberAccount(storageKey, accountRef.current)) ensureLoaded(storageKey);
+  }, [storageKey]);
   const completed = useSyncExternalStore(
     useCallback((listener) => subscribe(storageKey, listener), [storageKey]),
     () => snapshot(storageKey, migrateRef.current),
     () => EMPTY
   );
   const complete = useCallback(
-    (tour) => {
-      const subject = typeof tour === "string" ? { id: tour } : tour;
-      const current = snapshot(storageKey, migrateRef.current);
-      if (isTourDone(subject, current[subject.id])) return false;
-      write(storageKey, { ...current, [subject.id]: (/* @__PURE__ */ new Date()).toISOString() });
-      return true;
-    },
-    [storageKey]
-  );
-  const reset = useCallback(
-    (id) => {
-      const current = snapshot(storageKey, migrateRef.current);
-      if (current[id] === void 0) return;
-      const next = { ...current };
-      delete next[id];
-      write(storageKey, next);
-    },
+    (tour) => completeStored(storageKey, migrateRef.current, tour),
     [storageKey]
   );
+  const reset = useCallback((id) => resetStored(storageKey, migrateRef.current, id), [storageKey]);
   return useMemo(() => ({ completed, complete, reset }), [completed, complete, reset]);
 }
 export {
+  completeStored,
+  completeTour,
+  rememberAccount,
+  rememberMigrate,
   resetTourProgress,
+  signOutTourProgress,
   useTourProgress
 };
 //# sourceMappingURL=use-tour-progress.js.map