@marktiderman/genesis-native 0.0.0-stage → 0.2.0

package/dist/updates.js

@@ -0,0 +1,813 @@
+import { createContext, useContext, useEffect, useSyncExternalStore, useMemo, useState } from 'react';
+import { View } from 'react-native';
+import { renderSlot } from '@marktiderman/genesis-core/slots';
+import { SafeAreaView } from 'react-native-safe-area-context';
+import { NativeEmptyState, NativeButton, NativeBanner, NativeSheet, NativeText } from '@marktiderman/genesis-ui-native/components';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/updates/block.tsx
+
+// src/updates/store.ts
+function createStore(initial) {
+  let state = initial;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    getState: () => state,
+    setState(next) {
+      const merged = { ...state, ...next };
+      if (Object.keys(merged).every((key) => Object.is(merged[key], state[key]))) return;
+      state = merged;
+      for (const listener of [...listeners]) listener();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    if (Number.isFinite(ms)) setTimeout(resolve, Math.max(0, ms));
+  });
+}
+
+// src/updates/modules.ts
+function toError(value) {
+  return value instanceof Error ? value : new Error(typeof value === "string" ? value : "Unknown error");
+}
+function manifestField(manifest, field) {
+  if (!manifest || typeof manifest !== "object") return null;
+  const value = manifest[field];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+// src/updates/checker.ts
+function createReloadGuard(canReload) {
+  let blockers = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const listener of [...listeners]) listener();
+  };
+  return {
+    block() {
+      blockers++;
+      notify();
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        blockers--;
+        notify();
+      };
+    },
+    canReload() {
+      if (blockers > 0) return false;
+      try {
+        return canReload ? canReload() === true : true;
+      } catch {
+        return false;
+      }
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+function createUpdateChecker(options) {
+  const { updates, guard, reloadScreenOptions, now = Date.now, onError } = options;
+  const enabled = Boolean(updates?.isEnabled);
+  const store = createStore({
+    status: enabled ? "idle" : "disabled",
+    updateId: null,
+    dismissed: false,
+    blocked: false,
+    error: null
+  });
+  let inflight = null;
+  let lastCheck = null;
+  const report = (error, from) => {
+    try {
+      onError?.(error, from);
+    } catch {
+    }
+  };
+  const stopGuard = guard.subscribe(() => {
+    if (store.getState().blocked && guard.canReload()) store.setState({ blocked: false });
+  });
+  const check = () => {
+    if (!updates || !enabled) return Promise.resolve();
+    const { status } = store.getState();
+    if (inflight || status === "ready" || status === "reloading") return inflight ?? Promise.resolve();
+    lastCheck = now();
+    let run;
+    run = (async () => {
+      await null;
+      try {
+        store.setState({ status: "checking", error: null });
+        const result = await updates.checkForUpdateAsync();
+        if (!result.isAvailable && !result.isRollBackToEmbedded) {
+          store.setState({ status: "idle" });
+          return;
+        }
+        const runtime = manifestField(result.manifest, "runtimeVersion");
+        if (runtime && updates.runtimeVersion && runtime !== updates.runtimeVersion) {
+          store.setState({ status: "idle" });
+          return;
+        }
+        store.setState({ status: "downloading" });
+        const fetched = await updates.fetchUpdateAsync();
+        const updateId = manifestField(fetched.manifest, "id") ?? manifestField(result.manifest, "id");
+        if ((fetched.isNew || fetched.isRollBackToEmbedded) && !(updateId && updateId === updates.updateId)) {
+          store.setState({ status: "ready", updateId, dismissed: false });
+        } else {
+          store.setState({ status: "idle" });
+        }
+      } catch (raw) {
+        const error = toError(raw);
+        report(error, "check");
+        store.setState({ status: "error", error });
+      } finally {
+        if (inflight === run) inflight = null;
+      }
+    })();
+    inflight = run;
+    return run;
+  };
+  return {
+    getState: store.getState,
+    subscribe: store.subscribe,
+    check,
+    checkIfDue(minIntervalMs) {
+      const at = now();
+      if (lastCheck !== null && at >= lastCheck && at - lastCheck < minIntervalMs) return Promise.resolve();
+      return check();
+    },
+    async reload() {
+      if (!updates || store.getState().status !== "ready") return false;
+      if (!guard.canReload()) {
+        store.setState({ blocked: true });
+        return false;
+      }
+      store.setState({ status: "reloading", blocked: false });
+      try {
+        await updates.reloadAsync(reloadScreenOptions ? { reloadScreenOptions } : void 0);
+        return true;
+      } catch (raw) {
+        const error = toError(raw);
+        report(error, "reload");
+        store.setState({ status: "ready", error });
+        return false;
+      }
+    },
+    dismiss() {
+      store.setState({ dismissed: true, blocked: false });
+    },
+    dispose: stopGuard
+  };
+}
+
+// src/updates/channels.ts
+var CHANNEL = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,99}$/;
+function createChannelSwitcher(options) {
+  const { updates, enabled, guard, storage, storageKey = "genesis:updates:channel", reloadScreenOptions, onError } = options;
+  const report = (error) => {
+    try {
+      onError?.(error, "channel");
+    } catch {
+    }
+  };
+  const unavailable = () => {
+    if (!updates?.isEnabled) return { kind: "unavailable", reason: "Updates are off in this build (development or Expo Go)." };
+    if (typeof updates.setUpdateRequestHeadersOverride !== "function") {
+      return { kind: "unavailable", reason: "This expo-updates can't override the channel." };
+    }
+    return null;
+  };
+  const save = async (channel) => {
+    if (!storage) return;
+    try {
+      if (channel === null) await (storage.removeItem ? storage.removeItem(storageKey) : storage.setItem(storageKey, ""));
+      else await storage.setItem(storageKey, channel);
+    } catch (error) {
+      report(toError(error));
+    }
+  };
+  const apply = async () => {
+    const u = updates;
+    try {
+      const check = await u.checkForUpdateAsync();
+      if (check.isAvailable || check.isRollBackToEmbedded) await u.fetchUpdateAsync();
+      if (!guard.canReload()) return { kind: "blocked" };
+      await u.reloadAsync(reloadScreenOptions ? { reloadScreenOptions } : void 0);
+      return { kind: "reloading" };
+    } catch (raw) {
+      const error = toError(raw);
+      report(error);
+      return { kind: "error", error };
+    }
+  };
+  return {
+    enabled,
+    async switchTo(channel) {
+      if (enabled !== true) {
+        throw new Error("Channel switching is off. Pass `channels: { enabled: true }` only in development and preview builds.");
+      }
+      const name = channel.trim();
+      if (!CHANNEL.test(name)) throw new Error(`Not a channel name: "${channel}"`);
+      const off = unavailable();
+      if (off) return off;
+      updates.setUpdateRequestHeadersOverride({ "expo-channel-name": name });
+      await save(name === updates.channel ? null : name);
+      return apply();
+    },
+    async reset() {
+      const off = unavailable();
+      if (off) {
+        await save(null);
+        return off;
+      }
+      updates.setUpdateRequestHeadersOverride(null);
+      await save(null);
+      return apply();
+    },
+    async requested() {
+      if (!storage) return null;
+      try {
+        const value = await storage.getItem(storageKey);
+        return value ? value : null;
+      } catch (error) {
+        report(toError(error));
+        return null;
+      }
+    }
+  };
+}
+
+// src/updates/version.ts
+var VERSION = /^\d+(?:\.\d+){0,3}$/;
+function parseVersion(value) {
+  if (typeof value !== "string") return null;
+  const text = value.trim();
+  if (!VERSION.test(text)) return null;
+  const parts = text.split(".").map(Number);
+  if (parts.some((part) => !Number.isSafeInteger(part))) return null;
+  while (parts.length < 4) parts.push(0);
+  return parts;
+}
+function compareVersions(a, b) {
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  if (!left || !right) return null;
+  for (let i = 0; i < 4; i++) {
+    const l = left[i] ?? 0;
+    const r = right[i] ?? 0;
+    if (l !== r) return l < r ? -1 : 1;
+  }
+  return 0;
+}
+function isBelowMinimum(installed, minimum) {
+  return compareVersions(installed, minimum) === -1;
+}
+
+// src/updates/policy.ts
+function staticPolicySource(policy) {
+  return { load: async () => policy };
+}
+var COLUMNS = "min_version_ios,min_version_android,store_url_ios,store_url_android,maintenance,maintenance_message,notes";
+function supabasePolicySource(client, options = {}) {
+  const { appId = "default", table = "app_release_policy" } = options;
+  return {
+    async load() {
+      const query = client.from(table);
+      const { data, error } = await query.select(COLUMNS).eq("app_id", appId).maybeSingle();
+      if (error) throw toError(error instanceof Error ? error : error.message ?? error);
+      if (!data || typeof data !== "object") return {};
+      const row = data;
+      return {
+        minimumVersion: pick({ ios: row.min_version_ios, android: row.min_version_android }),
+        storeUrl: pick({ ios: row.store_url_ios, android: row.store_url_android }),
+        maintenance: { active: row.maintenance === true, message: typeof row.maintenance_message === "string" ? row.maintenance_message : null },
+        notes: Array.isArray(row.notes) ? row.notes : []
+      };
+    }
+  };
+}
+function pick(values) {
+  const out = {};
+  for (const platform of ["ios", "android"]) {
+    const value = values[platform];
+    if (typeof value === "string" && value.trim() !== "") out[platform] = value.trim();
+  }
+  return out;
+}
+var STORE_URL = /^(https:\/\/|itms-apps:\/\/|market:\/\/)/i;
+function sanitizePolicy(raw) {
+  if (raw === null || raw === void 0) return {};
+  if (typeof raw !== "object" || Array.isArray(raw)) throw new Error("The release policy is not an object");
+  const value = raw;
+  const policy = {};
+  const minimum = value.minimumVersion && typeof value.minimumVersion === "object" ? value.minimumVersion : null;
+  if (minimum) policy.minimumVersion = pick(minimum);
+  const store = value.storeUrl && typeof value.storeUrl === "object" ? pick(value.storeUrl) : null;
+  if (store) {
+    for (const platform of ["ios", "android"]) if (store[platform] && !STORE_URL.test(store[platform])) delete store[platform];
+    policy.storeUrl = store;
+  }
+  const maintenance = value.maintenance;
+  if (maintenance && typeof maintenance === "object") {
+    policy.maintenance = {
+      active: maintenance.active === true,
+      message: typeof maintenance.message === "string" && maintenance.message.trim() !== "" ? maintenance.message : null
+    };
+  }
+  if (Array.isArray(value.notes)) {
+    policy.notes = value.notes.flatMap((note) => {
+      if (!note || typeof note !== "object") return [];
+      const { version, title, body } = note;
+      if (typeof version !== "string" || typeof body !== "string") return [];
+      return [{ version: version.trim(), body, ...typeof title === "string" ? { title } : {} }];
+    });
+  }
+  return policy;
+}
+function createPolicyStore(options) {
+  const { source, storage, cacheKey = "genesis:updates:policy", now = Date.now, onError } = options;
+  const timeoutMs = validTimeout(options.timeoutMs, 3e3);
+  const store = createStore({ status: "loading", policy: null, origin: "none", fetchedAt: null, error: null, refreshing: false });
+  let inflight = null;
+  let firstLoad = null;
+  let lastAttempt = null;
+  const report = (error, from) => {
+    try {
+      onError?.(toError(error), from);
+    } catch {
+    }
+  };
+  const fetchNetwork = () => {
+    if (inflight) return inflight;
+    lastAttempt = now();
+    store.setState({ refreshing: true });
+    let run;
+    run = (async () => {
+      await null;
+      try {
+        const policy = sanitizePolicy(await source.load());
+        const fetchedAt = now();
+        store.setState({ status: "ready", policy, origin: "network", fetchedAt, error: null });
+        if (storage) {
+          const entry = { v: 1, savedAt: fetchedAt, policy };
+          Promise.resolve().then(() => storage.setItem(cacheKey, JSON.stringify(entry))).catch((error) => report(error, "storage"));
+        }
+        return true;
+      } catch (error) {
+        report(error, "policy");
+        store.setState({ error: toError(error) });
+        return false;
+      } finally {
+        if (inflight === run) inflight = null;
+        store.setState({ refreshing: false });
+      }
+    })();
+    inflight = run;
+    return run;
+  };
+  const readCache = async () => {
+    if (!storage) return;
+    try {
+      const entry = parseCache(await storage.getItem(cacheKey));
+      if (entry && store.getState().origin !== "network") {
+        store.setState({ policy: entry.policy, origin: "cache", fetchedAt: entry.savedAt });
+      }
+    } catch (error) {
+      report(error, "storage");
+    }
+  };
+  return {
+    getState: store.getState,
+    subscribe: store.subscribe,
+    load() {
+      firstLoad ??= (async () => {
+        const cache = readCache();
+        const network = fetchNetwork();
+        const answered = network.then(async (ok) => {
+          if (!ok) await cache;
+        });
+        await Promise.race([answered, delay(timeoutMs)]);
+        store.setState({ status: "ready" });
+      })();
+      return firstLoad;
+    },
+    refresh: fetchNetwork,
+    refreshIfDue(minIntervalMs) {
+      const at = now();
+      if (lastAttempt !== null && at >= lastAttempt && at - lastAttempt < minIntervalMs) return Promise.resolve(false);
+      return fetchNetwork();
+    }
+  };
+}
+function validTimeout(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function parseCache(raw) {
+  if (!raw) return null;
+  try {
+    const entry = JSON.parse(raw);
+    if (entry?.v !== 1 || typeof entry.savedAt !== "number" || !Number.isFinite(entry.savedAt)) return null;
+    return { v: 1, savedAt: entry.savedAt, policy: sanitizePolicy(entry.policy) };
+  } catch {
+    return null;
+  }
+}
+var CLOCK_SKEW_MS = 5 * 6e4;
+var WEEK_MS = 7 * 24 * 60 * 6e4;
+function evaluatePolicy(state, options) {
+  const { policy, origin, fetchedAt } = state;
+  if (!policy) return { kind: "ok" };
+  const { platform, installedVersion, now, cacheMaxAgeMs = WEEK_MS } = options;
+  const age = fetchedAt === null ? null : now - fetchedAt;
+  const trusted = origin === "network" || origin === "cache" && age !== null && age >= -CLOCK_SKEW_MS && age <= cacheMaxAgeMs;
+  if (trusted && (platform === "ios" || platform === "android")) {
+    const minimum = policy.minimumVersion?.[platform];
+    const storeUrl = policy.storeUrl?.[platform];
+    if (minimum && storeUrl && installedVersion && isBelowMinimum(installedVersion, minimum)) {
+      return { kind: "forceUpgrade", minimumVersion: minimum.trim(), installedVersion, storeUrl };
+    }
+  }
+  if (origin === "network" && policy.maintenance?.active === true) {
+    return { kind: "maintenance", message: policy.maintenance.message };
+  }
+  return { kind: "ok" };
+}
+
+// src/updates/signature.ts
+var UNKNOWN = "unknown";
+function versionSignature({ application, updates, platform, requestedChannel = null }) {
+  const version = application?.nativeApplicationVersion ?? null;
+  const build = application?.nativeBuildVersion ?? null;
+  const on = Boolean(updates?.isEnabled);
+  const channel = on ? updates?.channel ?? null : null;
+  const updateId = on ? updates?.updateId ?? null : null;
+  const runtimeVersion = updates?.runtimeVersion ?? null;
+  const launch = !on ? "off" : updates?.isEmbeddedLaunch ? "embedded" : "update";
+  const emergency = on && updates?.isEmergencyLaunch === true;
+  const shownChannel = requestedChannel ?? channel;
+  const head = `${version ?? UNKNOWN} (${build ?? UNKNOWN})`;
+  const parts = [head];
+  if (launch === "off") {
+    parts.push("updates off");
+  } else {
+    parts.push(shownChannel ?? "no channel");
+    parts.push(launch === "embedded" ? "embedded" : updateId?.slice(0, 8) ?? UNKNOWN);
+  }
+  if (emergency) parts.push("emergency launch");
+  const short = parts.join(" \xB7 ");
+  const lines = [
+    `Version ${head}`,
+    `Platform ${platform}`,
+    `Channel ${channel ?? (on ? UNKNOWN : "none")}${requestedChannel && requestedChannel !== channel ? ` (switched to ${requestedChannel})` : ""}`,
+    `Runtime ${runtimeVersion ?? UNKNOWN}`,
+    `Update ${launch === "off" ? "updates off" : launch === "embedded" ? "embedded" : updateId ?? UNKNOWN}`
+  ];
+  if (emergency) lines.push(`Emergency launch: ${updates?.emergencyLaunchReason ?? UNKNOWN}`);
+  return { version, build, platform, channel, requestedChannel, runtimeVersion, updateId, launch, emergency, short, text: lines.join("\n") };
+}
+
+// src/updates/whats-new.ts
+function notesSince(notes, seen, version) {
+  return notes.filter((note) => {
+    if (note.version === version) return seen !== version;
+    const afterSeen = compareVersions(note.version, seen);
+    const upToNow = compareVersions(note.version, version);
+    return afterSeen === 1 && (upToNow === -1 || upToNow === 0);
+  }).sort((a, b) => compareVersions(b.version, a.version) ?? 0);
+}
+function createWhatsNewStore(options) {
+  const { storage, version, storageKey = "genesis:updates:seen-version", onError } = options;
+  const store = createStore({ status: "loading", notes: [] });
+  let seen;
+  let loading = null;
+  let pending = null;
+  const remember = () => {
+    if (!storage || !version) return;
+    seen = version;
+    Promise.resolve().then(() => storage.setItem(storageKey, version)).catch((error) => {
+      try {
+        onError?.(toError(error), "storage");
+      } catch {
+      }
+    });
+  };
+  const compute = (notes, final) => {
+    if (seen === void 0) {
+      pending = { notes, final };
+      return;
+    }
+    if (!version || seen === false) return store.setState({ status: "hidden", notes: [] });
+    if (seen === null) {
+      remember();
+      return store.setState({ status: "hidden", notes: [] });
+    }
+    const due = notesSince(notes, seen, version);
+    if (due.length > 0) return store.setState({ status: "showing", notes: due });
+    if (final && seen !== version) remember();
+    store.setState({ status: "hidden", notes: [] });
+  };
+  return {
+    getState: store.getState,
+    subscribe: store.subscribe,
+    load() {
+      loading ??= (async () => {
+        if (!storage || !version) {
+          seen = false;
+        } else {
+          try {
+            seen = await storage.getItem(storageKey);
+          } catch (error) {
+            seen = false;
+            try {
+              onError?.(toError(error), "storage");
+            } catch {
+            }
+          }
+        }
+        const next = pending ?? { notes: [], final: false };
+        pending = null;
+        compute(next.notes, next.final);
+      })();
+      return loading;
+    },
+    update: compute,
+    dismiss() {
+      remember();
+      store.setState({ status: "hidden", notes: [] });
+    }
+  };
+}
+function ForceUpgradeScreen({ minimumVersion, installedVersion, openStore, retry, checking }) {
+  return /* @__PURE__ */ jsx(View, { testID: "genesis-force-upgrade", className: "flex-1 justify-center bg-background", children: /* @__PURE__ */ jsx(
+    NativeEmptyState,
+    {
+      variant: "first-run",
+      title: "Update required",
+      body: `This version (${installedVersion}) is no longer supported. Update to ${minimumVersion} or later to keep going.`,
+      primaryAction: /* @__PURE__ */ jsx(NativeButton, { onPress: openStore, testID: "genesis-force-upgrade-store", children: "Update" }),
+      secondaryAction: /* @__PURE__ */ jsx(NativeButton, { variant: "ghost", onPress: retry, loading: checking, testID: "genesis-force-upgrade-retry", children: "Check again" }),
+      testID: "genesis-force-upgrade-state"
+    }
+  ) });
+}
+function MaintenanceScreen({ message, retry, retrying }) {
+  return /* @__PURE__ */ jsx(View, { testID: "genesis-maintenance", className: "flex-1 justify-center bg-background", children: /* @__PURE__ */ jsx(
+    NativeEmptyState,
+    {
+      variant: "first-run",
+      title: "Down for maintenance",
+      body: message ?? "We're doing some work on the app. Try again in a few minutes.",
+      primaryAction: /* @__PURE__ */ jsx(NativeButton, { onPress: retry, loading: retrying, testID: "genesis-maintenance-retry", children: "Try again" }),
+      testID: "genesis-maintenance-state"
+    }
+  ) });
+}
+function UpdateBanner({ reload, dismiss, canReload, blocked, reloading }) {
+  return /* @__PURE__ */ jsx(SafeAreaView, { edges: ["top"], pointerEvents: "box-none", style: { position: "absolute", top: 0, left: 0, right: 0 }, children: /* @__PURE__ */ jsxs(View, { testID: "genesis-update-banner", className: "mx-3 mt-2 overflow-hidden rounded-lg border border-border bg-secondary", children: [
+    /* @__PURE__ */ jsx(
+      NativeBanner,
+      {
+        variant: "info",
+        title: "An update is ready",
+        description: blocked || !canReload ? "Finish what you're doing, then restart to use it." : "Restart to use the latest version.",
+        className: "border-b-0",
+        testID: "genesis-update-banner-message"
+      }
+    ),
+    /* @__PURE__ */ jsxs(View, { className: "flex-row justify-end gap-2 px-4 pb-3", children: [
+      /* @__PURE__ */ jsx(NativeButton, { variant: "ghost", size: "sm", onPress: dismiss, testID: "genesis-update-banner-later", children: "Later" }),
+      /* @__PURE__ */ jsx(NativeButton, { size: "sm", onPress: reload, disabled: !canReload, loading: reloading, testID: "genesis-update-banner-restart", children: "Restart" })
+    ] })
+  ] }) });
+}
+function WhatsNewSheet({ notes, dismiss }) {
+  return /* @__PURE__ */ jsx(NativeSheet, { open: true, onOpenChange: (open) => open ? void 0 : dismiss(), testID: "genesis-whats-new", children: /* @__PURE__ */ jsxs(View, { className: "gap-4 p-6", children: [
+    /* @__PURE__ */ jsx(NativeText, { preset: "h3", accessibilityRole: "header", children: "What's new" }),
+    notes.map((note) => /* @__PURE__ */ jsxs(View, { className: "gap-1", testID: `genesis-whats-new-${note.version}`, children: [
+      /* @__PURE__ */ jsx(NativeText, { preset: "label", children: note.title ?? `Version ${note.version}` }),
+      /* @__PURE__ */ jsx(NativeText, { preset: "body-sm", className: "text-muted-foreground", children: note.body })
+    ] }, note.version)),
+    /* @__PURE__ */ jsx(NativeButton, { onPress: dismiss, testID: "genesis-whats-new-done", children: "Got it" })
+  ] }) });
+}
+function createUpdates(options) {
+  const {
+    platform,
+    application,
+    updates,
+    policy: source,
+    storage,
+    appState,
+    canReload,
+    channels,
+    policyRefreshMs = 5 * 6e4,
+    checkIntervalMs = 15 * 6e4,
+    reloadScreenOptions,
+    storageKeyPrefix = "genesis:updates",
+    onError,
+    now = Date.now
+  } = options;
+  const policyTimeoutMs = validTimeout(options.policyTimeoutMs, 3e3);
+  const guard = createReloadGuard(canReload);
+  const policy = createPolicyStore({
+    source: source ?? { load: async () => null },
+    storage: source ? storage : void 0,
+    cacheKey: `${storageKeyPrefix}:policy`,
+    timeoutMs: policyTimeoutMs,
+    now,
+    onError
+  });
+  const checker = createUpdateChecker({ updates, guard, reloadScreenOptions, now, onError });
+  const whatsNew = createWhatsNewStore({
+    storage: options.whatsNew === false ? void 0 : storage,
+    version: options.whatsNew === false ? null : application?.nativeApplicationVersion ?? null,
+    storageKey: `${storageKeyPrefix}:seen-version`,
+    onError
+  });
+  const switcher = createChannelSwitcher({
+    updates,
+    enabled: channels?.enabled === true,
+    guard,
+    storage,
+    storageKey: `${storageKeyPrefix}:channel`,
+    reloadScreenOptions,
+    onError
+  });
+  const signature = versionSignature({ application, updates, platform });
+  const allNotes = () => [...options.notes ?? [], ...policy.getState().policy?.notes ?? []];
+  const syncNotes = () => {
+    const state = policy.getState();
+    whatsNew.update(allNotes(), !source || state.origin === "network");
+  };
+  policy.subscribe(syncNotes);
+  let loaded = null;
+  const load = () => {
+    loaded ??= Promise.race([Promise.all([policy.load(), whatsNew.load()]), delay(policyTimeoutMs)]).then(syncNotes).catch((error) => {
+      try {
+        onError?.(toError(error), "storage");
+      } catch {
+      }
+    });
+    return loaded;
+  };
+  const block = {
+    options,
+    policy,
+    checker,
+    guard,
+    whatsNew,
+    channels: switcher,
+    signature,
+    bootStep: { id: "genesis:updates", run: load, timeoutMs: policyTimeoutMs + 5e3 },
+    start() {
+      void load();
+      void checker.check();
+      const subscription = appState?.addEventListener("change", (state) => {
+        if (state !== "active") return;
+        void policy.refreshIfDue(policyRefreshMs);
+        void checker.checkIfDue(checkIntervalMs);
+      });
+      return () => subscription?.remove();
+    },
+    Root: function UpdatesBlockRoot(props) {
+      return /* @__PURE__ */ jsx(UpdatesRoot, { block, ...props });
+    }
+  };
+  return block;
+}
+var UpdatesContext = createContext(null);
+function UpdatesProvider({ block, children }) {
+  return /* @__PURE__ */ jsx(UpdatesContext.Provider, { value: block, children });
+}
+function useUpdates() {
+  const block = useContext(UpdatesContext);
+  if (!block) throw new Error("useUpdates: no updates block. Pass `updates={createUpdates(\u2026)}` to GenesisNativeApp, or wrap in <UpdatesProvider>.");
+  return block;
+}
+function useBlockReload(active) {
+  const block = useContext(UpdatesContext);
+  useEffect(() => active && block ? block.guard.block() : void 0, [active, block]);
+}
+function useUpdatePolicy() {
+  const { policy } = useUpdates();
+  return useSyncExternalStore(policy.subscribe, policy.getState, policy.getState);
+}
+function useUpdateVerdict() {
+  const block = useUpdates();
+  const state = useUpdatePolicy();
+  const { platform, application, cacheMaxAgeMs = WEEK_MS, now = Date.now } = block.options;
+  return useMemo(
+    () => evaluatePolicy(state, { platform, installedVersion: application?.nativeApplicationVersion ?? null, now: now(), cacheMaxAgeMs }),
+    [state, platform, application, cacheMaxAgeMs, now]
+  );
+}
+function useForceUpgrade() {
+  const block = useUpdates();
+  const verdict = useUpdateVerdict();
+  const { refreshing } = useUpdatePolicy();
+  if (verdict.kind !== "forceUpgrade") return null;
+  const { storeUrl } = verdict;
+  return {
+    minimumVersion: verdict.minimumVersion,
+    installedVersion: verdict.installedVersion,
+    storeUrl,
+    checking: refreshing,
+    retry: () => void block.policy.refresh(),
+    openStore: () => {
+      if (!block.options.openURL) return;
+      Promise.resolve().then(() => block.options.openURL?.(storeUrl)).catch((error) => block.options.onError?.(toError(error), "policy"));
+    }
+  };
+}
+function useMaintenance() {
+  const block = useUpdates();
+  const verdict = useUpdateVerdict();
+  const { refreshing } = useUpdatePolicy();
+  if (verdict.kind !== "maintenance") return null;
+  return { message: verdict.message, retrying: refreshing, retry: () => void block.policy.refresh() };
+}
+function useUpdateCheck() {
+  const { checker } = useUpdates();
+  return useSyncExternalStore(checker.subscribe, checker.getState, checker.getState);
+}
+function useCanReload() {
+  const { guard } = useUpdates();
+  return useSyncExternalStore(guard.subscribe, guard.canReload, guard.canReload);
+}
+function useUpdateBanner() {
+  const { checker } = useUpdates();
+  const state = useUpdateCheck();
+  const canReload = useCanReload();
+  if (state.status !== "ready" && state.status !== "reloading" || state.dismissed) return null;
+  return {
+    canReload,
+    blocked: state.blocked,
+    reloading: state.status === "reloading",
+    reload: () => void checker.reload(),
+    dismiss: () => checker.dismiss()
+  };
+}
+function useWhatsNew() {
+  const block = useUpdates();
+  const state = useSyncExternalStore(block.whatsNew.subscribe, block.whatsNew.getState, block.whatsNew.getState);
+  if (state.status !== "showing") return null;
+  return { notes: state.notes, version: block.options.application?.nativeApplicationVersion ?? null, dismiss: () => block.whatsNew.dismiss() };
+}
+function useVersionSignature() {
+  const block = useUpdates();
+  const [requested, setRequested] = useState(null);
+  useEffect(() => {
+    let alive = true;
+    void block.channels.requested().then((value) => alive && setRequested(value));
+    return () => {
+      alive = false;
+    };
+  }, [block]);
+  return useMemo(() => {
+    if (!requested) return block.signature;
+    const { application, updates, platform } = block.options;
+    return versionSignature({ application, updates, platform, requestedChannel: requested });
+  }, [block, requested]);
+}
+function UpdatesRoot({ block, slots, slotProps, children }) {
+  useEffect(() => block.start(), [block]);
+  return /* @__PURE__ */ jsx(UpdatesProvider, { block, children: /* @__PURE__ */ jsx(UpdatesParts, { slots, slotProps, children }) });
+}
+var FILL = { position: "absolute", top: 0, right: 0, bottom: 0, left: 0 };
+function UpdatesParts({ slots, slotProps, children }) {
+  const forceUpgrade = useForceUpgrade();
+  const maintenance = useMaintenance();
+  const banner = useUpdateBanner();
+  const whatsNew = useWhatsNew();
+  const blocking = forceUpgrade && slots?.forceUpgrade !== null ? renderSlot(ForceUpgradeScreen, slots?.forceUpgrade, forceUpgrade, slotProps?.forceUpgrade) : maintenance && slots?.maintenance !== null ? renderSlot(MaintenanceScreen, slots?.maintenance, maintenance, slotProps?.maintenance) : null;
+  return /* @__PURE__ */ jsxs(View, { style: { flex: 1 }, children: [
+    /* @__PURE__ */ jsx(
+      View,
+      {
+        style: { flex: 1 },
+        pointerEvents: blocking ? "none" : "auto",
+        accessibilityElementsHidden: Boolean(blocking),
+        importantForAccessibility: blocking ? "no-hide-descendants" : "auto",
+        children
+      }
+    ),
+    !blocking && banner ? renderSlot(UpdateBanner, slots?.updateBanner, banner, slotProps?.updateBanner) : null,
+    !blocking && whatsNew ? renderSlot(WhatsNewSheet, slots?.whatsNew, whatsNew, slotProps?.whatsNew) : null,
+    blocking ? /* @__PURE__ */ jsx(View, { style: FILL, testID: "genesis-updates-blocking", children: blocking }) : null
+  ] });
+}
+
+export { CLOCK_SKEW_MS, ForceUpgradeScreen, MaintenanceScreen, UpdateBanner, UpdatesProvider, UpdatesRoot, WEEK_MS, WhatsNewSheet, compareVersions, createChannelSwitcher, createPolicyStore, createReloadGuard, createUpdateChecker, createUpdates, createWhatsNewStore, evaluatePolicy, isBelowMinimum, notesSince, parseVersion, sanitizePolicy, staticPolicySource, supabasePolicySource, useBlockReload, useCanReload, useForceUpgrade, useMaintenance, useUpdateBanner, useUpdateCheck, useUpdatePolicy, useUpdateVerdict, useUpdates, useVersionSignature, useWhatsNew, versionSignature };
+//# sourceMappingURL=updates.js.map
+//# sourceMappingURL=updates.js.map