@marktiderman/genesis-native 0.2.0 → 0.4.0

package/dist/push.js

@@ -0,0 +1,1069 @@
+import { normalizeLink } from './chunk-VKTIHNAV.js';
+import { createStore, delay } from './chunk-XE7LC7K6.js';
+export { RICH_PUSH_IMAGE_FIELDS, isRichPushUrl, richPushMessage } from './chunk-ONAXQHNG.js';
+import { useSession } from './chunk-NGYNYJPL.js';
+import { createContext, useSyncExternalStore, useContext, useRef, useEffect, useMemo } from 'react';
+import { View } from 'react-native';
+import { renderSlot } from '@marktiderman/genesis-core/slots';
+import { defineBlock } from '@marktiderman/genesis-features/blocks';
+import { NativeSheet, NativeText, NativeButton, NativeTimePicker, NativeSwitch } from '@marktiderman/genesis-ui-native/components';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { SettingsPage } from '@marktiderman/genesis-ui-native/layouts';
+
+// src/push/modules.ts
+function toError(value) {
+  if (value instanceof Error) return value;
+  const message = value?.message;
+  return new Error(typeof message === "string" ? message : typeof value === "string" ? value : "Unknown error");
+}
+function report(onError, error, source) {
+  try {
+    onError?.(toError(error), source);
+  } catch {
+  }
+}
+
+// src/push/permission.ts
+var IOS_PROVISIONAL = 3;
+var IOS_EPHEMERAL = 4;
+function statusOf(response) {
+  const ios = response.ios?.status;
+  if (ios === IOS_PROVISIONAL) return "provisional";
+  if (response.granted || response.status === "granted" || ios === IOS_EPHEMERAL) return "granted";
+  if (response.status === "undetermined" || response.canAskAgain) return "undetermined";
+  return "denied";
+}
+var canPush = (status) => status === "granted" || status === "provisional";
+function createPermissionStore(options) {
+  const { notifications, onError } = options;
+  const store = createStore({ status: notifications ? "unknown" : "unavailable", requesting: false });
+  return {
+    ...store,
+    async refresh() {
+      if (!notifications) return "unavailable";
+      try {
+        const status = statusOf(await notifications.getPermissionsAsync());
+        store.setState({ status });
+        return status;
+      } catch (error) {
+        report(onError, error, "permission");
+        return store.getState().status;
+      }
+    },
+    async request() {
+      if (!notifications) return "unavailable";
+      if (store.getState().requesting) return store.getState().status;
+      store.setState({ requesting: true });
+      try {
+        await options.beforeRequest?.().catch((error) => report(onError, error, "channels"));
+        const status = statusOf(await notifications.requestPermissionsAsync(options.request ?? DEFAULT_REQUEST));
+        store.setState({ status });
+        return status;
+      } catch (error) {
+        report(onError, error, "permission");
+        return store.getState().status;
+      } finally {
+        store.setState({ requesting: false });
+      }
+    }
+  };
+}
+var DEFAULT_REQUEST = { ios: { allowAlert: true, allowBadge: true, allowSound: true } };
+function createPromptStore(options) {
+  const { permission, storage, storageKey, now, onError } = options;
+  const cooldownMs = options.cooldownMs ?? 3 * 24 * 60 * 6e4;
+  const maxDeclines = options.maxDeclines ?? 3;
+  const launchGraceMs = options.launchGraceMs ?? 1e4;
+  const store = createStore({ visible: false, reason: null });
+  let memory = { count: 0, at: 0 };
+  const readDeclines = async () => {
+    if (!storage) return memory;
+    try {
+      const raw = await storage.getItem(storageKey);
+      const parsed = raw ? JSON.parse(raw) : null;
+      return { count: Number(parsed?.count) || 0, at: Number(parsed?.at) || 0 };
+    } catch (error) {
+      report(onError, error, "storage");
+      return memory;
+    }
+  };
+  return {
+    ...store,
+    async offer(reason) {
+      if (store.getState().visible) return true;
+      const started = options.startedAt();
+      if (started === null || now() - started < launchGraceMs) return false;
+      if (!options.signedIn()) return false;
+      const status = permission.getState().status === "unknown" ? await permission.refresh() : permission.getState().status;
+      if (status !== "undetermined") return false;
+      const declines = await readDeclines();
+      if (declines.count >= maxDeclines || declines.count > 0 && now() - declines.at < cooldownMs) return false;
+      if (!options.signedIn()) return false;
+      store.setState({ visible: true, reason: reason ?? null });
+      return true;
+    },
+    async accept() {
+      store.setState({ visible: false });
+      return permission.request();
+    },
+    async decline() {
+      if (!store.getState().visible) return;
+      store.setState({ visible: false });
+      const declines = await readDeclines();
+      memory = { count: declines.count + 1, at: now() };
+      try {
+        await storage?.setItem(storageKey, JSON.stringify(memory));
+      } catch (error) {
+        report(onError, error, "storage");
+      }
+    },
+    hide() {
+      store.setState({ visible: false, reason: null });
+    }
+  };
+}
+
+// src/push/backend.ts
+var DEFAULT_PREFERENCES = {
+  categories: {},
+  quietHours: { enabled: false, start: "22:00", end: "07:00", timeZone: null },
+  hidePreviews: false
+};
+var PushBackendError = class extends Error {
+  constructor(operation, code) {
+    super(`${operation} failed${code ? ` (${code})` : ""}`);
+    this.operation = operation;
+    this.code = code;
+    this.name = "PushBackendError";
+  }
+  operation;
+  code;
+};
+var COLUMNS = "categories, quiet_hours_enabled, quiet_hours_start, quiet_hours_end, time_zone, hide_previews";
+function clock(value, fallback) {
+  const match = typeof value === "string" ? /^(\d{2}):(\d{2})/.exec(value) : null;
+  return match ? `${match[1]}:${match[2]}` : fallback;
+}
+function fromRow(row) {
+  const categories = {};
+  const raw = row.categories;
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    for (const [id, on] of Object.entries(raw)) if (typeof on === "boolean") categories[id] = on;
+  }
+  return {
+    categories,
+    quietHours: {
+      enabled: row.quiet_hours_enabled === true,
+      start: clock(row.quiet_hours_start, DEFAULT_PREFERENCES.quietHours.start),
+      end: clock(row.quiet_hours_end, DEFAULT_PREFERENCES.quietHours.end),
+      timeZone: typeof row.time_zone === "string" ? row.time_zone : null
+    },
+    hidePreviews: row.hide_previews === true
+  };
+}
+function supabasePushBackend(client) {
+  const must = (operation, result) => {
+    if (result.error) throw new PushBackendError(operation, result.error.code ?? null);
+    return result.data;
+  };
+  return {
+    async register(token, platform, appVersion) {
+      must("genesis_push_register", await client.rpc("genesis_push_register", { p_token: token, p_platform: platform, p_app_version: appVersion }));
+    },
+    async forget(token) {
+      must("genesis_push_forget", await client.rpc("genesis_push_forget", { p_token: token }));
+    },
+    async loadPreferences(userId) {
+      const data = must("notification_preferences", await client.from("notification_preferences").select(COLUMNS).eq("user_id", userId).maybeSingle());
+      return data && typeof data === "object" ? fromRow(data) : null;
+    },
+    async savePreferences(userId, p) {
+      const row = {
+        user_id: userId,
+        categories: p.categories,
+        quiet_hours_enabled: p.quietHours.enabled,
+        quiet_hours_start: p.quietHours.start,
+        quiet_hours_end: p.quietHours.end,
+        time_zone: p.quietHours.timeZone,
+        hide_previews: p.hidePreviews
+      };
+      const data = must("notification_preferences", await client.from("notification_preferences").upsert(row, { onConflict: "user_id" }).select("user_id"));
+      if (!Array.isArray(data) || data.length !== 1) throw new PushBackendError("notification_preferences", "no_rows");
+    }
+  };
+}
+
+// src/push/quiet-hours.ts
+var CLOCK = /^([01]\d|2[0-3]):([0-5]\d)$/;
+function parseClock(value) {
+  const match = CLOCK.exec(value);
+  return match ? Number(match[1]) * 60 + Number(match[2]) : null;
+}
+function formatClock(minutes) {
+  const m = (Math.round(minutes) % 1440 + 1440) % 1440;
+  return `${String(Math.floor(m / 60)).padStart(2, "0")}:${String(m % 60).padStart(2, "0")}`;
+}
+function clockOf(date) {
+  return formatClock(date.getHours() * 60 + date.getMinutes());
+}
+function dateAt(clock2, today = /* @__PURE__ */ new Date()) {
+  const minutes = parseClock(clock2) ?? 0;
+  const d = new Date(today);
+  d.setHours(Math.floor(minutes / 60), minutes % 60, 0, 0);
+  return d;
+}
+function deviceTimeZone() {
+  try {
+    const zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    return typeof zone === "string" && zone.length > 0 ? zone : null;
+  } catch {
+    return null;
+  }
+}
+function minutesIn(timeZone, at) {
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", { timeZone, hour: "2-digit", minute: "2-digit", hourCycle: "h23" }).formatToParts(at);
+    const hour = Number(parts.find((p) => p.type === "hour")?.value);
+    const minute = Number(parts.find((p) => p.type === "minute")?.value);
+    return Number.isFinite(hour) && Number.isFinite(minute) ? hour % 24 * 60 + minute : null;
+  } catch {
+    return null;
+  }
+}
+function isQuietAt(quiet, at = /* @__PURE__ */ new Date()) {
+  if (!quiet.enabled || !quiet.timeZone) return false;
+  const start = parseClock(quiet.start);
+  const end = parseClock(quiet.end);
+  if (start === null || end === null || start === end) return false;
+  const now = minutesIn(quiet.timeZone, at);
+  if (now === null) return false;
+  return start < end ? now >= start && now < end : now >= start || now < end;
+}
+
+// src/push/preferences.ts
+var CATEGORY_ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+function validPreferences(p) {
+  const q = p.quietHours;
+  if (parseClock(q.start) === null || parseClock(q.end) === null) return false;
+  if (q.enabled && !q.timeZone) return false;
+  return Object.keys(p.categories).every((id) => CATEGORY_ID.test(id));
+}
+function createPreferencesStore(options) {
+  const { backend, categories, onError } = options;
+  for (const category of categories) {
+    if (!CATEGORY_ID.test(category.id)) throw new Error(`createPush: category id "${category.id}" must be lower case letters, digits, ".", "_" or "-"`);
+  }
+  const store = createStore({ status: "idle", preferences: DEFAULT_PREFERENCES, saving: false, error: null });
+  let userId = null;
+  let generation = 0;
+  let saves = Promise.resolve();
+  let confirmed = DEFAULT_PREFERENCES;
+  let pending = 0;
+  return {
+    ...store,
+    async load(id) {
+      const mine = ++generation;
+      userId = id;
+      pending = 0;
+      store.setState({ status: "loading", saving: false, error: null });
+      try {
+        const loaded = await backend.loadPreferences(id) ?? DEFAULT_PREFERENCES;
+        if (mine !== generation) return;
+        confirmed = loaded;
+        store.setState({ status: "ready", preferences: loaded });
+      } catch (error) {
+        if (mine !== generation) return;
+        report(onError, error, "preferences");
+        store.setState({ status: "error", error: error instanceof Error ? error : new Error("Couldn't load notification settings") });
+      }
+    },
+    update(change) {
+      const id = userId;
+      const mine = generation;
+      if (!id || store.getState().status !== "ready") return Promise.resolve(false);
+      const next = change(store.getState().preferences);
+      if (!validPreferences(next)) return Promise.resolve(false);
+      pending++;
+      store.setState({ preferences: next, saving: true, error: null });
+      const save = saves.then(async () => {
+        if (mine !== generation) return false;
+        let ok = false;
+        try {
+          await backend.savePreferences(id, next);
+          ok = true;
+          if (mine === generation) confirmed = next;
+        } catch (error) {
+          if (mine === generation) {
+            report(onError, error, "preferences");
+            store.setState({ error: error instanceof Error ? error : new Error("Couldn't save notification settings") });
+          }
+        }
+        if (mine !== generation) return false;
+        pending--;
+        if (pending === 0) store.setState({ preferences: confirmed, saving: false });
+        return ok;
+      });
+      saves = save.catch(() => false);
+      return save;
+    },
+    reset() {
+      generation++;
+      userId = null;
+      pending = 0;
+      confirmed = DEFAULT_PREFERENCES;
+      store.setState({ status: "idle", preferences: DEFAULT_PREFERENCES, saving: false, error: null });
+    },
+    isOn(categoryId) {
+      const chosen = store.getState().preferences.categories[categoryId];
+      if (typeof chosen === "boolean") return chosen;
+      return categories.find((c) => c.id === categoryId)?.defaultOn ?? true;
+    }
+  };
+}
+
+// src/push/registration.ts
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function makeUUID(maker) {
+  try {
+    const made = maker?.() ?? globalThis.crypto?.randomUUID?.();
+    if (typeof made === "string" && UUID.test(made)) return made.toLowerCase();
+    const bytes = globalThis.crypto?.getRandomValues?.(new Uint8Array(16));
+    if (!bytes) return void 0;
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  } catch {
+    return void 0;
+  }
+}
+var REFRESH_MS = 60 * 6e4;
+function createRegistration(options) {
+  const { notifications, backend, storage, storageKeyPrefix, onError, now } = options;
+  const savedKey = `${storageKeyPrefix}:device`;
+  const pendingKey = `${storageKeyPrefix}:forget`;
+  const installationKey = `${storageKeyPrefix}:installation`;
+  let installation = null;
+  const store = createStore({ status: "idle", problem: null });
+  let current = null;
+  let queue = Promise.resolve();
+  let warnedNoProject = false;
+  const run = (step) => {
+    const next = queue.then(step, step);
+    queue = next.catch(() => {
+    });
+    return next;
+  };
+  const read = async (key, fallback) => {
+    if (!storage) return fallback;
+    try {
+      const raw = await storage.getItem(key);
+      return raw ? JSON.parse(raw) : fallback;
+    } catch (error) {
+      report(onError, error, "storage");
+      return fallback;
+    }
+  };
+  const write = async (key, value) => {
+    try {
+      if (value === null) await storage?.removeItem?.(key);
+      else await storage?.setItem(key, JSON.stringify(value));
+    } catch (error) {
+      report(onError, error, "storage");
+    }
+  };
+  const installationId = async () => {
+    if (installation) return installation;
+    const saved = await read(installationKey, null);
+    if (typeof saved === "string" && UUID.test(saved)) return installation = saved;
+    const made = makeUUID(options.randomUUID);
+    if (!made) return void 0;
+    installation = made;
+    await write(installationKey, made);
+    return made;
+  };
+  const forgetToken = async (token) => {
+    try {
+      await backend.forget(token);
+      return true;
+    } catch (error) {
+      report(onError, error, "forget");
+      return false;
+    }
+  };
+  const queuePending = async (token) => {
+    const pending = await read(pendingKey, []);
+    if (!pending.includes(token)) await write(pendingKey, [...pending, token].slice(-10));
+  };
+  return {
+    ...store,
+    token: () => current,
+    sync(userId, { force = false } = {}) {
+      return run(async () => {
+        if (!notifications || !options.isCurrent(userId)) return;
+        if (!options.projectId) {
+          store.setState({ status: "unavailable", problem: "no_project_id" });
+          if (!warnedNoProject) {
+            warnedNoProject = true;
+            report(onError, new Error("push: no EAS project id (projectId), so this build gets no push token. Run `eas init` and pass Constants.expoConfig.extra.eas.projectId."), "setup");
+          }
+          return;
+        }
+        store.setState({ status: "registering", problem: null });
+        await options.ensureChannels().catch((error) => report(onError, error, "channels"));
+        let token;
+        try {
+          token = (await notifications.getExpoPushTokenAsync({ projectId: options.projectId })).data;
+        } catch (error) {
+          report(onError, error, "register");
+          store.setState({ status: "error", problem: "no_token" });
+          return;
+        }
+        if (typeof token !== "string" || token.length === 0) {
+          store.setState({ status: "error", problem: "no_token" });
+          return;
+        }
+        current = token;
+        const saved = await read(savedKey, null);
+        if (saved && saved.userId !== userId && saved.token !== token && !await forgetToken(saved.token)) await queuePending(saved.token);
+        if (!force && saved && saved.token === token && saved.userId === userId && now() - saved.at < REFRESH_MS) {
+          store.setState({ status: "registered", problem: null });
+          return;
+        }
+        if (!options.isCurrent(userId)) return;
+        try {
+          const platform = options.platform === "ios" ? "ios" : "android";
+          if (backend.usesInstallationId) await backend.register(token, platform, options.appVersion ?? null, await installationId());
+          else await backend.register(token, platform, options.appVersion ?? null);
+        } catch (error) {
+          report(onError, error, "register");
+          store.setState({ status: "error", problem: "backend" });
+          return;
+        }
+        if (saved && saved.token !== token && saved.userId === userId && !await forgetToken(saved.token)) await queuePending(saved.token);
+        await write(savedKey, { token, userId, at: now() });
+        const pending = await read(pendingKey, []);
+        if (pending.includes(token)) await write(pendingKey, pending.filter((t) => t !== token).length ? pending.filter((t) => t !== token) : null);
+        store.setState({ status: "registered", problem: null });
+      });
+    },
+    forget() {
+      return run(async () => {
+        const saved = await read(savedKey, null);
+        const token = saved?.token ?? current;
+        await write(savedKey, null);
+        store.setState({ status: "idle", problem: null });
+        if (!token) return;
+        if (!await forgetToken(token)) await queuePending(token);
+      });
+    },
+    flush() {
+      return run(async () => {
+        const pending = await read(pendingKey, []);
+        if (pending.length === 0) return;
+        const left = [];
+        const registered = (await read(savedKey, null))?.token;
+        for (const token of pending) {
+          if (token === registered) continue;
+          if (!await forgetToken(token)) left.push(token);
+        }
+        await write(pendingKey, left.length ? left : null);
+      });
+    }
+  };
+}
+
+// src/push/routing.ts
+var ANY_PATH = { map: { "/*": "/*" } };
+function notificationData(notification) {
+  const data = notification.request?.content?.data;
+  return data && typeof data === "object" && !Array.isArray(data) ? data : {};
+}
+function pathForResponse(response, links) {
+  const url = notificationData(response.notification).url;
+  if (typeof url !== "string" || url.length === 0 || url.length > 2048) return null;
+  if (links) return normalizeLink(url, links);
+  if (!url.startsWith("/") || url.startsWith("//") || url.includes("\\")) return null;
+  const path = normalizeLink(url, ANY_PATH);
+  return path === "/" && url.split(/[?#]/)[0] !== "/" ? null : path;
+}
+function notificationAction(response, defaultActionId = "expo.modules.notifications.actions.DEFAULT") {
+  const id = response.actionIdentifier;
+  if (!id || id === defaultActionId || id === "com.apple.UNNotificationDismissActionIdentifier") return null;
+  const data = notificationData(response.notification);
+  return {
+    actionId: id,
+    notificationId: typeof data.notification_id === "string" ? data.notification_id : null,
+    text: typeof response.userText === "string" ? response.userText : null,
+    url: typeof data.url === "string" ? data.url : null,
+    data
+  };
+}
+var PROMPT_CONTENT = { flexGrow: 1, justifyContent: "center", gap: 16, padding: 24 };
+function PushPromptSheet({ reason, accept, decline, title, body, acceptLabel, declineLabel }) {
+  return /* @__PURE__ */ jsx(NativeSheet, { open: true, onOpenChange: (open) => open ? void 0 : decline(), testID: "genesis-push-prompt", children: /* @__PURE__ */ jsxs(View, { style: PROMPT_CONTENT, testID: "genesis-push-prompt-content", children: [
+    /* @__PURE__ */ jsx(NativeText, { preset: "h3", accessibilityRole: "header", children: title ?? "Turn on notifications?" }),
+    /* @__PURE__ */ jsx(NativeText, { preset: "body", className: "text-muted-foreground", testID: "genesis-push-prompt-body", children: body ?? (reason ? `Get a notification ${reason}. You can change this any time in Settings.` : "Get a notification when something needs you. You can change this any time in Settings.") }),
+    /* @__PURE__ */ jsx(NativeButton, { onPress: accept, testID: "genesis-push-prompt-accept", children: acceptLabel ?? "Turn on" }),
+    /* @__PURE__ */ jsx(NativeButton, { variant: "ghost", onPress: decline, testID: "genesis-push-prompt-decline", children: declineLabel ?? "Not now" })
+  ] }) });
+}
+var PUSH_BLOCK_ID = "push";
+var PUSH_STATUS_LABELS = {
+  unknown: "Checking\u2026",
+  undetermined: "Off",
+  granted: "On",
+  provisional: "Delivered quietly",
+  denied: "Off in Settings",
+  unavailable: "Not available on this device"
+};
+var IMPORTANCE = { min: 3, low: 4, default: 5, high: 6, max: 7 };
+var VISIBILITY_PRIVATE = 2;
+function createPush(options) {
+  const { notifications, platform, storage, onError, now = Date.now } = options;
+  const prefix = options.storageKeyPrefix ?? "genesis:push";
+  const categories = options.categories ?? [];
+  let userId = null;
+  let startedAt = null;
+  let channelsMade = null;
+  const suppressors = /* @__PURE__ */ new Set();
+  const ensureChannels = () => {
+    if (!notifications || platform !== "android") return Promise.resolve();
+    channelsMade ??= (async () => {
+      const all = [
+        { id: "default", name: "Notifications", importance: "default", description: void 0 },
+        ...categories.map((c) => ({ id: c.id, name: c.title, importance: c.importance ?? "default", description: c.description })),
+        ...(options.channels ?? []).map((c) => ({ ...c, importance: c.importance ?? "default" }))
+      ];
+      for (const channel of all) {
+        await notifications.setNotificationChannelAsync(channel.id, {
+          name: channel.name,
+          importance: IMPORTANCE[channel.importance],
+          description: channel.description ?? null,
+          lockscreenVisibility: VISIBILITY_PRIVATE,
+          showBadge: true
+        });
+      }
+    })().catch((error) => {
+      channelsMade = null;
+      throw error;
+    });
+    return channelsMade;
+  };
+  let categoriesMade = false;
+  const registerDeviceCategories = async () => {
+    const set = notifications?.setNotificationCategoryAsync;
+    if (categoriesMade || !notifications || !set || !options.deviceCategories?.length) return;
+    categoriesMade = true;
+    for (const c of options.deviceCategories) {
+      try {
+        await set.call(
+          notifications,
+          c.identifier,
+          c.actions.map((a) => ({
+            identifier: a.id,
+            buttonTitle: a.title,
+            ...a.textInput ? { textInput: { placeholder: a.textInput.placeholder ?? "", submitButtonTitle: a.textInput.submitTitle ?? a.title } } : {},
+            options: { opensAppToForeground: a.opensApp ?? false, isDestructive: a.destructive ?? false, isAuthenticationRequired: a.requiresAuth ?? false }
+          })),
+          c.previewPlaceholder ? { previewPlaceholder: c.previewPlaceholder } : void 0
+        );
+      } catch (error) {
+        categoriesMade = false;
+        report(onError, error, "categories");
+      }
+    }
+  };
+  const permission = createPermissionStore({ notifications, request: options.permissions, beforeRequest: ensureChannels, onError });
+  const registration = createRegistration({
+    notifications,
+    backend: options.backend,
+    projectId: options.projectId,
+    platform,
+    appVersion: options.appVersion,
+    storage,
+    storageKeyPrefix: prefix,
+    ensureChannels,
+    isCurrent: (id) => userId === id,
+    now,
+    randomUUID: options.randomUUID,
+    onError
+  });
+  const preferences = createPreferencesStore({ backend: options.backend, categories, onError });
+  const prompt = createPromptStore({
+    ...options.prompt,
+    permission,
+    storage,
+    storageKey: `${prefix}:prompt`,
+    signedIn: () => userId !== null,
+    startedAt: () => startedAt,
+    now,
+    onError
+  });
+  const badge = {
+    async set(count) {
+      try {
+        await notifications?.setBadgeCountAsync(Math.max(0, Math.floor(count)));
+      } catch (error) {
+        report(onError, error, "badge");
+      }
+    },
+    clear: () => badge.set(0)
+  };
+  let lastStatus = permission.getState().status;
+  permission.subscribe(() => {
+    const status = permission.getState().status;
+    if (status !== lastStatus && lastStatus !== "unknown" && canPush(status) && userId) void registration.sync(userId);
+    lastStatus = status;
+  });
+  const row = options.settingsRow;
+  const labels = { ...PUSH_STATUS_LABELS, ...options.statusLabels };
+  const declaration = defineBlock({
+    id: PUSH_BLOCK_ID,
+    platforms: ["native"],
+    contributes: {
+      settings: row === false ? [] : [
+        {
+          id: "notifications",
+          section: row?.section ?? "notifications",
+          title: row?.title ?? "Notifications",
+          href: row?.href ?? "/settings/notifications",
+          testID: "genesis-push-settings",
+          // Bound to this block, so it needs no provider above the Settings screen.
+          useSubtitle: () => labels[useSyncExternalStore(permission.subscribe, permission.getState, permission.getState).status]
+        }
+      ],
+      routes: [{ path: row === false ? "/settings/notifications" : row?.href ?? "/settings/notifications", description: "Notification settings: categories, quiet hours, previews", signedIn: true }],
+      migrations: [
+        { package: "@marktiderman/genesis-supabase", file: "migrations/0005_genesis_push.sql", test: "migrations/tests/0005_genesis_push.test.sql" }
+      ],
+      privacy: {
+        collects: [{ type: "device ID", purposes: ["app functionality"], linked: true, tracking: false }],
+        notes: [
+          "Keeps this device's push token against the signed-in person, to send them notifications; forgotten on sign-out and account deletion.",
+          "Keeps notification preferences (categories, quiet hours and time zone, previews) per person."
+        ]
+      }
+    }
+  });
+  const bootStep = {
+    id: "genesis:push",
+    // Bounded and never rejects (refresh reports its own errors), so it can't fail or hold the boot.
+    run: () => Promise.race([permission.refresh(), delay(1e3)]).then(() => void 0),
+    timeoutMs: 3e3
+  };
+  const block = {
+    ...declaration,
+    bootSteps: [bootStep],
+    options,
+    permission,
+    registration,
+    preferences,
+    prompt,
+    categories,
+    badge,
+    ensureChannels,
+    setUser(next) {
+      if (next === userId) return;
+      const previous = userId;
+      userId = next;
+      if (previous !== null) {
+        void registration.forget();
+        void badge.clear();
+        preferences.reset();
+        prompt.hide();
+      }
+      if (next !== null) {
+        void preferences.load(next);
+        void permission.refresh().then((status) => {
+          if (canPush(status) && userId === next) void registration.sync(next);
+        });
+      }
+    },
+    suppress(match) {
+      suppressors.add(match);
+      return () => {
+        suppressors.delete(match);
+      };
+    },
+    start() {
+      startedAt = now();
+      if (!notifications) return () => {
+      };
+      notifications.setNotificationHandler({
+        handleNotification: async (notification) => {
+          let show = true;
+          try {
+            const data = notificationData(notification);
+            show = !userId ? false : ![...suppressors].some((match) => match(data, notification)) && (options.foreground?.(notification) ?? true);
+          } catch (error) {
+            report(onError, error, "routing");
+          }
+          return { shouldShowBanner: show, shouldShowList: show, shouldPlaySound: show, shouldSetBadge: show };
+        }
+      });
+      void registration.flush();
+      void permission.refresh();
+      void registerDeviceCategories();
+      let deviceToken;
+      const tokenSubscription = notifications.addPushTokenListener((token) => {
+        const next = token?.data;
+        const seen = deviceToken;
+        deviceToken = next;
+        if (!userId || next === seen) return;
+        void registration.sync(userId, { force: seen !== void 0 });
+      });
+      const appSubscription = options.appState?.addEventListener("change", (state) => {
+        if (state !== "active") return;
+        void registration.flush();
+        void permission.refresh().then((status) => {
+          if (canPush(status) && userId) void registration.sync(userId);
+        });
+        if (options.clearBadgeOnForeground && userId) void badge.clear();
+      });
+      return () => {
+        startedAt = null;
+        notifications.setNotificationHandler(null);
+        tokenSubscription.remove();
+        appSubscription?.remove();
+      };
+    },
+    Root: function PushBlockRoot({ slots, slotProps, children }) {
+      return /* @__PURE__ */ jsx(PushRoot, { block, slots, slotProps, children });
+    }
+  };
+  return block;
+}
+var PushContext = createContext(null);
+function PushProvider({ block, children }) {
+  return /* @__PURE__ */ jsx(PushContext.Provider, { value: block, children });
+}
+function usePush() {
+  const block = useContext(PushContext);
+  if (!block) throw new Error("usePush: no push block. Put `createPush(\u2026)` in GenesisNativeApp's `blocks`, or wrap in <PushProvider>.");
+  return block;
+}
+function useOptionalPush() {
+  return useContext(PushContext);
+}
+function usePushPermissionState() {
+  const { permission } = usePush();
+  return useSyncExternalStore(permission.subscribe, permission.getState, permission.getState);
+}
+function usePushRegistration() {
+  const { registration } = usePush();
+  return useSyncExternalStore(registration.subscribe, registration.getState, registration.getState);
+}
+function useNotificationPreferences() {
+  const { preferences } = usePush();
+  const state = useSyncExternalStore(preferences.subscribe, preferences.getState, preferences.getState);
+  return { ...state, update: preferences.update };
+}
+function usePushPrompt() {
+  const { prompt } = usePush();
+  const state = useSyncExternalStore(prompt.subscribe, prompt.getState, prompt.getState);
+  return { ...state, offer: prompt.offer, accept: prompt.accept, decline: prompt.decline };
+}
+function useBadge() {
+  return usePush().badge;
+}
+function useSuppressNotifications(match) {
+  const block = useOptionalPush();
+  const latest = useRef(match);
+  latest.current = match;
+  const active = match !== null;
+  useEffect(() => block && active ? block.suppress((data) => latest.current?.(data) ?? false) : void 0, [block, active]);
+}
+function PushRoot({ block, hold, onOpen, slots, slotProps, children }) {
+  const { status, userId } = useSession();
+  useEffect(() => block.start(), [block]);
+  useEffect(() => {
+    if (status === "loading") return;
+    block.setUser(status === "signedIn" ? userId : null);
+  }, [block, status, userId]);
+  useTapRouting(block, status, hold, onOpen);
+  return /* @__PURE__ */ jsx(PushProvider, { block, children: /* @__PURE__ */ jsxs(View, { style: { flex: 1 }, children: [
+    children,
+    /* @__PURE__ */ jsx(PushPromptPart, { slots, slotProps })
+  ] }) });
+}
+function PushPromptPart({ slots, slotProps }) {
+  const prompt = usePushPrompt();
+  if (!prompt.visible) return null;
+  return renderSlot(
+    PushPromptSheet,
+    slots?.pushPrompt,
+    { reason: prompt.reason, accept: () => void prompt.accept(), decline: () => void prompt.decline() },
+    slotProps?.pushPrompt
+  );
+}
+function useTapRouting(block, status, hold, onOpen) {
+  const auth = useRef(status);
+  auth.current = status;
+  const latest = useRef({ hold, onOpen });
+  latest.current = { hold, onOpen };
+  const waiting = useRef(null);
+  const follow = (path) => {
+    const open = block.options.onOpen ?? latest.current.onOpen;
+    if (auth.current === "signedIn") {
+      if (!open) {
+        report(block.options.onError, new Error("push: a tapped notification has nowhere to go; pass `onOpen` to createPush (router.push)."), "setup");
+        return;
+      }
+      setTimeout(() => {
+        try {
+          open(path);
+        } catch (error) {
+          report(block.options.onError, error, "routing");
+        }
+      }, 0);
+    } else if (auth.current === "signedOut") {
+      const hold2 = block.options.hold ?? latest.current.hold;
+      if (hold2) hold2.hold(path);
+      else report(block.options.onError, new Error("push: a notification tapped while signed out was dropped; pass `hold` (your linkHold) to createPush."), "setup");
+    } else {
+      waiting.current = path;
+    }
+  };
+  useEffect(() => {
+    if (status === "loading" || waiting.current === null) return;
+    const path = waiting.current;
+    waiting.current = null;
+    follow(path);
+  }, [status]);
+  useEffect(() => {
+    const notifications = block.options.notifications;
+    if (!notifications) return;
+    const seen = /* @__PURE__ */ new Set();
+    const handle = (response) => {
+      if (!response) return;
+      try {
+        const id = response.notification.request.identifier;
+        if (seen.has(id)) return;
+        seen.add(id);
+        if (response.actionIdentifier === notifications.DEFAULT_ACTION_IDENTIFIER) {
+          const path = pathForResponse(response, block.options.links);
+          if (path) follow(path);
+        }
+        block.options.onResponse?.(response);
+      } catch (error) {
+        report(block.options.onError, error, "routing");
+      }
+    };
+    try {
+      handle(notifications.getLastNotificationResponse());
+      notifications.clearLastNotificationResponse();
+    } catch (error) {
+      report(block.options.onError, error, "routing");
+    }
+    const subscription = notifications.addNotificationResponseReceivedListener(handle);
+    return () => subscription.remove();
+  }, [block]);
+}
+var notificationSettingsCopy = {
+  permissionSection: "Notifications",
+  allow: "Allow notifications",
+  status: PUSH_STATUS_LABELS,
+  turnOn: "Turn on",
+  openSettings: "Open Settings",
+  noProjectId: "This build can't get notifications: it has no EAS project id.",
+  noToken: "This phone didn't give the app a push token. Try again on a device with a network connection.",
+  registerFailed: "Couldn't turn notifications on for this phone. They'll be tried again next time you open the app.",
+  categoriesSection: "Notify me about",
+  categoriesFootnote: "Applies to every phone you're signed in on.",
+  quietHoursSection: "Quiet hours",
+  quietHours: "Quiet hours",
+  quietHoursOnNow: "On now",
+  from: "From",
+  to: "To",
+  timeZone: "Time zone",
+  useDeviceTimeZone: "Tap to use this phone's",
+  noTimeZone: "This phone didn't say its time zone, so quiet hours can't be placed in your day.",
+  quietHoursFootnote: "Notifications that arrive during quiet hours wait until they end. Urgent ones still come through.",
+  privacySection: "Privacy",
+  showPreviews: "Show previews",
+  previewsFootnote: "When off, notifications say only that there's something new; what they say stays on the server, off your lock screen.",
+  saveFailed: "Couldn't save that change. Check your connection and try again.",
+  loadFailed: "Couldn't load your notification settings, so they can't be changed yet. Check your connection; they load again when you come back here."
+};
+var DEFAULT_COPY = notificationSettingsCopy;
+function usePushPermission(copy = DEFAULT_COPY) {
+  const block = usePush();
+  const { status, requesting } = usePushPermissionState();
+  const { problem } = usePushRegistration();
+  const open = block.options.openSettings;
+  return {
+    status,
+    requesting,
+    request: () => void block.permission.request(),
+    openSettings: open ? () => {
+      Promise.resolve().then(open).catch((error) => block.options.onError?.(error instanceof Error ? error : new Error("openSettings failed"), "permission"));
+    } : null,
+    problem: problem === "no_project_id" ? copy.noProjectId : problem === "no_token" ? copy.noToken : problem === "backend" ? copy.registerFailed : null,
+    copy
+  };
+}
+function useNotificationCategories(copy = DEFAULT_COPY) {
+  const block = usePush();
+  const { preferences, saving, update, status } = useNotificationPreferences();
+  const categories = useMemo(
+    () => block.categories.map((c) => ({
+      id: c.id,
+      title: c.title,
+      description: c.description,
+      on: typeof preferences.categories[c.id] === "boolean" ? preferences.categories[c.id] : c.defaultOn ?? true
+    })),
+    [block.categories, preferences.categories]
+  );
+  return {
+    categories,
+    setOn: (id, on) => void update((p) => ({ ...p, categories: { ...p.categories, [id]: on } })),
+    saving,
+    disabled: status !== "ready",
+    copy
+  };
+}
+function useQuietHours(copy = DEFAULT_COPY) {
+  const { preferences, saving, update, status } = useNotificationPreferences();
+  const q = preferences.quietHours;
+  const device = deviceTimeZone();
+  const minute = useMinute();
+  const setQuiet = (change) => void update((p) => ({ ...p, quietHours: { ...p.quietHours, ...change } }));
+  return {
+    enabled: q.enabled,
+    start: q.start,
+    end: q.end,
+    timeZone: q.timeZone,
+    deviceTimeZone: device && device !== q.timeZone ? device : null,
+    activeNow: isQuietAt(q, new Date(minute)),
+    // Turning quiet hours on fills in this phone's zone if none was saved.
+    setEnabled: (on) => setQuiet(on ? { enabled: true, timeZone: q.timeZone ?? device } : { enabled: false }),
+    setStart: (start) => setQuiet({ start }),
+    setEnd: (end) => setQuiet({ end }),
+    adoptDeviceTimeZone: () => device ? setQuiet({ timeZone: device }) : void 0,
+    saving,
+    disabled: status !== "ready",
+    copy
+  };
+}
+function usePrivacyPreviews(copy = DEFAULT_COPY) {
+  const { preferences, saving, update, status } = useNotificationPreferences();
+  return {
+    hidePreviews: preferences.hidePreviews,
+    setHidePreviews: (hidePreviews) => void update((p) => ({ ...p, hidePreviews })),
+    saving,
+    disabled: status !== "ready",
+    copy
+  };
+}
+var minuteStore = {
+  subscribe(listener) {
+    const timer = setInterval(listener, 3e4);
+    return () => clearInterval(timer);
+  },
+  get: () => Math.floor(Date.now() / 6e4) * 6e4
+};
+function useMinute() {
+  return useSyncExternalStore(minuteStore.subscribe, minuteStore.get, minuteStore.get);
+}
+function toggle(id, label, checked, onChange, disabled = false) {
+  return /* @__PURE__ */ jsx(
+    NativeSwitch,
+    {
+      testID: `notification-settings-${id}-switch`,
+      accessibilityLabel: label,
+      checked,
+      onCheckedChange: onChange,
+      disabled
+    }
+  );
+}
+function permissionRows(p) {
+  const { status, copy } = p;
+  const row = { id: "allow", title: copy.allow, subtitle: copy.status[status], testID: "notification-settings-allow" };
+  if (status === "undetermined") {
+    return [{ ...row, showChevron: true, onPress: p.requesting ? void 0 : p.request, disabled: p.requesting, subtitle: `${copy.status.undetermined} \xB7 ${copy.turnOn}` }];
+  }
+  if (status === "denied" && p.openSettings) {
+    return [{ ...row, showChevron: true, onPress: p.openSettings, subtitle: `${copy.status.denied} \xB7 ${copy.openSettings}` }];
+  }
+  return [row];
+}
+function categoryRows(p) {
+  return p.categories.map((c) => ({
+    id: `category-${c.id}`,
+    title: c.title,
+    subtitle: c.description,
+    testID: `notification-settings-category-${c.id}`,
+    trailing: toggle(`category-${c.id}`, c.title, c.on, (on) => p.setOn(c.id, on), p.disabled)
+  }));
+}
+function quietHoursRows(p) {
+  const { copy } = p;
+  const rows = [
+    {
+      id: "quiet-hours",
+      title: copy.quietHours,
+      subtitle: p.enabled && p.activeNow ? copy.quietHoursOnNow : void 0,
+      testID: "notification-settings-quiet-hours",
+      trailing: toggle("quiet-hours", copy.quietHours, p.enabled, p.setEnabled, p.disabled || !p.enabled && !p.timeZone && !p.deviceTimeZone)
+    }
+  ];
+  if (!p.enabled) return rows;
+  const picker = (id, label, value, set) => /* @__PURE__ */ jsx(NativeTimePicker, { testID: `notification-settings-${id}-time`, value: dateAt(value), onChange: (d) => set(clockOf(d)), formatLabel: () => value, disabled: p.disabled });
+  rows.push(
+    { id: "quiet-from", title: copy.from, testID: "notification-settings-quiet-from", trailing: picker("quiet-from", copy.from, p.start, p.setStart) },
+    { id: "quiet-to", title: copy.to, testID: "notification-settings-quiet-to", trailing: picker("quiet-to", copy.to, p.end, p.setEnd) },
+    {
+      id: "time-zone",
+      title: copy.timeZone,
+      subtitle: p.timeZone ? p.deviceTimeZone ? `${p.timeZone} \xB7 ${copy.useDeviceTimeZone} (${p.deviceTimeZone})` : p.timeZone : copy.noTimeZone,
+      testID: "notification-settings-time-zone",
+      ...p.deviceTimeZone && !p.disabled ? { onPress: p.adoptDeviceTimeZone, showChevron: true } : {}
+    }
+  );
+  return rows;
+}
+function privacyRows(p) {
+  return [
+    {
+      id: "previews",
+      title: p.copy.showPreviews,
+      testID: "notification-settings-previews",
+      trailing: toggle("previews", p.copy.showPreviews, !p.hidePreviews, (show) => p.setHidePreviews(!show), p.disabled)
+    }
+  ];
+}
+function section(id, title, footnote, props, rows, slot, extra) {
+  if (slot === null) return null;
+  const merged = { ...props, ...extra };
+  if (slot) {
+    const Part = slot;
+    return { id, title, footnote, rows: [], children: /* @__PURE__ */ jsx(Part, { ...merged }) };
+  }
+  return { id, title, footnote, rows: rows(merged) };
+}
+function NotificationSettings({ copy: overrides, slots = {}, slotProps = {}, page, children, testID = "notification-settings" }) {
+  const copy = useMemo(() => ({ ...DEFAULT_COPY, ...overrides, status: { ...DEFAULT_COPY.status, ...overrides?.status } }), [overrides]);
+  const block = usePush();
+  const permission = usePushPermission(copy);
+  const categories = useNotificationCategories(copy);
+  const quietHours = useQuietHours(copy);
+  const privacy = usePrivacyPreviews(copy);
+  const { error, status } = useNotificationPreferences();
+  const { userId } = useSession();
+  useEffect(() => {
+    if (block.preferences.getState().status === "error" && userId) void block.preferences.load(userId);
+  }, [block, userId]);
+  const sections = [
+    section("permission", copy.permissionSection, permission.problem ?? (status === "error" ? copy.loadFailed : error ? copy.saveFailed : void 0), permission, permissionRows, slots.permission, slotProps.permission),
+    block.categories.length > 0 ? section("categories", copy.categoriesSection, copy.categoriesFootnote, categories, categoryRows, slots.categories, slotProps.categories) : null,
+    section("quiet-hours", copy.quietHoursSection, copy.quietHoursFootnote, quietHours, quietHoursRows, slots.quietHours, slotProps.quietHours),
+    section("privacy", copy.privacySection, copy.previewsFootnote, privacy, privacyRows, slots.privacy, slotProps.privacy)
+  ].filter((s) => s !== null);
+  return /* @__PURE__ */ jsx(SettingsPage, { testID, ...page, sections, children });
+}
+
+export { DEFAULT_PREFERENCES, NotificationSettings, PushBackendError, PushPromptSheet, PushProvider, PushRoot, canPush, categoryRows, clockOf, createPermissionStore, createPreferencesStore, createPromptStore, createPush, createRegistration, dateAt, deviceTimeZone, formatClock, isQuietAt, minutesIn, notificationAction, notificationData, notificationSettingsCopy, parseClock, pathForResponse, permissionRows, privacyRows, quietHoursRows, statusOf, supabasePushBackend, useBadge, useNotificationCategories, useNotificationPreferences, useOptionalPush, usePrivacyPreviews, usePush, usePushPermission, usePushPermissionState, usePushPrompt, usePushRegistration, useQuietHours, useSuppressNotifications, validPreferences };
+//# sourceMappingURL=push.js.map
+//# sourceMappingURL=push.js.map