@marktiderman/genesis-native 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,600 @@
+import { createNativeQueryClient, connectQueryLifecycle } from './chunk-MMTPWUWI.js';
+export { DAY_MS, connectQueryLifecycle, createNativeQueryClient } from './chunk-MMTPWUWI.js';
+import { createContext, useContext, useSyncExternalStore, Component, useRef, useEffect, useState } from 'react';
+import { View, Text, Pressable } from 'react-native';
+import { GenesisThemeProvider } from '@marktiderman/genesis-design-system/theme';
+import { createSupabaseProvider, GenesisProvider } from '@marktiderman/genesis-core/provider';
+import { renderSlot } from '@marktiderman/genesis-core/slots';
+import { KeyboardScrollProvider } from '@marktiderman/genesis-ui-native/layouts';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { NativeEmptyState, NativeButton } from '@marktiderman/genesis-ui-native/components';
+
+var BootTimeoutError = class extends Error {
+  step;
+  constructor(step, ms, reason = "did not finish") {
+    super(`Boot step "${step}" ${reason} within ${ms} ms.`);
+    this.name = "BootTimeoutError";
+    this.step = step;
+  }
+};
+var DEFAULT_TIMEOUT_MS = 1e4;
+function toError(value) {
+  if (value instanceof Error) return value;
+  return new Error(typeof value === "string" ? value : "Unknown error", { cause: value });
+}
+function settledWithin(promise, ms) {
+  let timer;
+  return Promise.race([
+    promise.then(
+      () => "settled",
+      () => "settled"
+    ),
+    new Promise((resolve) => {
+      timer = setTimeout(() => resolve("pending"), ms);
+    })
+  ]).finally(() => clearTimeout(timer));
+}
+function createBoot(steps, options = {}) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    if (seen.has(step.id)) throw new Error(`Boot step "${step.id}" is listed twice.`);
+    seen.add(step.id);
+  }
+  const { minimumMs = 0, timeoutMs = DEFAULT_TIMEOUT_MS } = options;
+  const listeners = /* @__PURE__ */ new Set();
+  let state = { status: "idle", error: null, failedStep: null, completed: [] };
+  let inFlight = null;
+  const abandoned = /* @__PURE__ */ new Map();
+  const runStep = async (step, ms) => {
+    const previous = abandoned.get(step.id);
+    if (previous) {
+      if (await settledWithin(previous, ms) === "pending") {
+        throw new BootTimeoutError(step.id, ms, "is still running from the last attempt");
+      }
+      abandoned.delete(step.id);
+      if (await previous === "ok") return;
+    }
+    const controller = new AbortController();
+    const running = Promise.resolve().then(() => step.run({ signal: controller.signal }));
+    if (await settledWithin(running, ms) === "pending") {
+      controller.abort();
+      abandoned.set(step.id, running.then(() => "ok", () => "failed"));
+      throw new BootTimeoutError(step.id, ms);
+    }
+    await running;
+  };
+  const set = (next) => {
+    state = { ...state, ...next };
+    for (const listener of listeners) listener();
+  };
+  const run = async () => {
+    const started = Date.now();
+    set({ status: "booting", error: null, failedStep: null });
+    for (const step of steps) {
+      if (state.completed.includes(step.id)) continue;
+      try {
+        await runStep(step, step.timeoutMs ?? timeoutMs);
+      } catch (error) {
+        set({ status: "failed", error: toError(error), failedStep: step.id });
+        return;
+      }
+      set({ completed: [...state.completed, step.id] });
+    }
+    const wait = minimumMs - (Date.now() - started);
+    if (wait > 0) await new Promise((resolve) => setTimeout(resolve, wait));
+    set({ status: "ready" });
+  };
+  const start = () => {
+    if (state.status === "ready") return Promise.resolve();
+    if (!inFlight) {
+      inFlight = run().finally(() => {
+        inFlight = null;
+      });
+    }
+    return inFlight;
+  };
+  return {
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    start,
+    retry: start
+  };
+}
+var BootContext = createContext(null);
+function BootProvider({ boot, children }) {
+  return /* @__PURE__ */ jsx(BootContext.Provider, { value: boot, children });
+}
+function useBoot() {
+  const boot = useContext(BootContext);
+  if (!boot) throw new Error("useBoot must be used inside <GenesisNativeApp> or <BootProvider>.");
+  const state = useSyncExternalStore(boot.subscribe, boot.getState, boot.getState);
+  return { ...state, retry: () => void boot.retry() };
+}
+function FatalScreen({ error, retry }) {
+  return /* @__PURE__ */ jsx(
+    NativeEmptyState,
+    {
+      variant: "error",
+      title: "Something went wrong",
+      body: "The app hit a problem. Try again, and if it keeps happening, close and reopen the app.",
+      details: error.message,
+      primaryAction: /* @__PURE__ */ jsx(NativeButton, { onPress: retry, testID: "genesis-fatal-retry", children: "Try again" }),
+      testID: "genesis-fatal"
+    }
+  );
+}
+function PlainFatalScreen({ error, retry }) {
+  return /* @__PURE__ */ jsxs(View, { testID: "genesis-fatal-plain", style: { flex: 1, justifyContent: "center", alignItems: "center", padding: 24, gap: 12 }, children: [
+    /* @__PURE__ */ jsx(Text, { accessibilityRole: "header", style: { fontSize: 17, fontWeight: "600" }, children: "Something went wrong" }),
+    /* @__PURE__ */ jsx(Text, { style: { textAlign: "center" }, children: error.message }),
+    /* @__PURE__ */ jsx(Pressable, { accessibilityRole: "button", onPress: retry, testID: "genesis-fatal-plain-retry", style: { padding: 12 }, children: /* @__PURE__ */ jsx(Text, { style: { fontSize: 17 }, children: "Try again" }) })
+  ] });
+}
+var GenesisErrorBoundary = class extends Component {
+  state = { error: null };
+  static getDerivedStateFromError(error) {
+    return { error: toError(error) };
+  }
+  componentDidCatch(error, info) {
+    this.props.onError?.(toError(error), { fatal: true, source: "boundary", componentStack: info.componentStack ?? void 0 });
+  }
+  componentDidUpdate(previous) {
+    if (this.state.error && previous.resetKey !== this.props.resetKey) this.setState({ error: null });
+  }
+  retry = () => {
+    this.setState({ error: null });
+    this.props.onRetry?.();
+  };
+  render() {
+    const { error } = this.state;
+    if (!error) return this.props.children ?? null;
+    const Fallback = this.props.fallback;
+    return /* @__PURE__ */ jsx(Fallback, { error, retry: this.retry });
+  }
+};
+function installGlobalErrorHandler({ errorUtils, onError, onFatal, alreadyFatal }) {
+  const previous = errorUtils.getGlobalHandler();
+  errorUtils.setGlobalHandler((raw, isFatal) => {
+    const error = toError(raw);
+    try {
+      onError?.(error, { fatal: Boolean(isFatal), source: "global" });
+    } catch {
+    }
+    if (isFatal && !alreadyFatal?.()) onFatal(error);
+    else previous?.(raw, isFatal);
+  });
+  return () => {
+    errorUtils.setGlobalHandler(previous ?? ((error) => console.error(error)));
+  };
+}
+function defaultErrorUtils() {
+  const candidate = globalThis.ErrorUtils;
+  return candidate && typeof candidate.setGlobalHandler === "function" ? candidate : void 0;
+}
+function defaultRejectionTracker() {
+  const hermes = globalThis.HermesInternal;
+  const enable = hermes?.enablePromiseRejectionTracker;
+  return typeof enable === "function" ? enable.bind(hermes) : void 0;
+}
+function installRejectionTracker({ enable, onError }) {
+  enable({
+    allRejections: true,
+    onUnhandled: (id, rejection) => {
+      const error = toError(rejection);
+      console.warn(`Uncaught (in promise, id: ${id}): ${error.message}`);
+      try {
+        onError(error, { fatal: false, source: "rejection" });
+      } catch {
+      }
+    },
+    onHandled: () => {
+    }
+  });
+}
+var DEFAULT_WAIT_MS = 5e3;
+function defaultUserId(session) {
+  const id = session?.user?.id;
+  return typeof id === "string" ? id : null;
+}
+function isNetworkError(error) {
+  const e = error;
+  return e?.name === "AuthRetryableFetchError" || e?.status === 0;
+}
+function storedSessionReader(client) {
+  return async () => {
+    const auth = client.auth;
+    if (!auth.storage || typeof auth.storageKey !== "string") return null;
+    const raw = await auth.storage.getItem(auth.storageKey);
+    if (typeof raw !== "string") return raw ?? null;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  };
+}
+function createSessionStore(client, options = {}) {
+  const { onUserChange, waitMs = DEFAULT_WAIT_MS, userIdOf = defaultUserId } = options;
+  const readStored = options.readStoredSession ?? storedSessionReader(client);
+  const listeners = /* @__PURE__ */ new Set();
+  let state = { status: "loading", session: null, userId: null, offline: false };
+  let version = 0;
+  const set = (session, offline = false) => {
+    const userId = session ? userIdOf(session) : null;
+    const previous = state;
+    if (previous.status !== "loading" && previous.session === session && previous.offline === offline) return;
+    state = { status: session ? "signedIn" : "signedOut", session, userId, offline };
+    for (const listener of listeners) listener();
+    if (previous.status !== "loading" && previous.userId !== userId) onUserChange?.(previous.userId, userId);
+  };
+  return {
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    async load() {
+      const startedAt = version;
+      let timer;
+      const timedOut = new Promise((resolve) => {
+        timer = setTimeout(() => resolve("timeout"), waitMs);
+      });
+      const result = await Promise.race([client.auth.getSession(), timedOut]).finally(() => clearTimeout(timer));
+      if (version !== startedAt) return;
+      if (result !== "timeout" && !result.error) return set(result.data.session);
+      if (result !== "timeout" && !isNetworkError(result.error)) {
+        const error = result.error;
+        throw error instanceof Error ? error : new Error("Could not read the session.", { cause: error });
+      }
+      const stored = await readStored().catch(() => null);
+      if (version !== startedAt) return;
+      set(stored, stored !== null);
+    },
+    start() {
+      const { data } = client.auth.onAuthStateChange((_event, session) => {
+        version++;
+        set(session);
+      });
+      return () => data.subscription.unsubscribe();
+    }
+  };
+}
+var SessionContext = createContext(null);
+function SessionProvider({ store, children }) {
+  return /* @__PURE__ */ jsx(SessionContext.Provider, { value: store, children });
+}
+function useSession() {
+  const store = useContext(SessionContext);
+  if (!store) throw new Error("useSession must be used inside <GenesisNativeApp> or <SessionProvider>.");
+  return useSyncExternalStore(store.subscribe, store.getState, store.getState);
+}
+function AuthGate({ signedIn, signedOut, loading = null }) {
+  const { status } = useSession();
+  if (status === "loading") return /* @__PURE__ */ jsx(Fragment, { children: loading });
+  return /* @__PURE__ */ jsx(Fragment, { children: status === "signedIn" ? signedIn : signedOut });
+}
+function createLinkHold() {
+  let held = null;
+  const listeners = /* @__PURE__ */ new Set();
+  const set = (next) => {
+    if (held === next) return;
+    held = next;
+    for (const listener of listeners) listener();
+  };
+  return {
+    hold: (path) => set(path),
+    peek: () => held,
+    take() {
+      const path = held;
+      set(null);
+      return path;
+    },
+    clear: () => set(null),
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+function useHeldLink(hold, { auth, onRelease }) {
+  const held = useSyncExternalStore(hold.subscribe, hold.peek, hold.peek);
+  const release = useRef(onRelease);
+  release.current = onRelease;
+  const waitedForSignIn = useRef(false);
+  useEffect(() => {
+    if (held === null) {
+      waitedForSignIn.current = false;
+      return;
+    }
+    if (auth === "signedOut") waitedForSignIn.current = true;
+    if (auth !== "signedIn") return;
+    const path = hold.take();
+    const follow = waitedForSignIn.current;
+    waitedForSignIn.current = false;
+    if (path !== null && follow) release.current(path);
+  }, [auth, held, hold]);
+  return held;
+}
+function BootScreen(_props) {
+  return /* @__PURE__ */ jsx(View, { testID: "genesis-boot", accessibilityRole: "progressbar", style: { flex: 1, justifyContent: "center", alignItems: "center" }, children: /* @__PURE__ */ jsx(Text, { children: "Loading\u2026" }) });
+}
+var PassThrough = ({ children }) => /* @__PURE__ */ jsx(Fragment, { children });
+var ThemeProvider = GenesisThemeProvider;
+function GenesisNativeApp(props) {
+  const [rootKey, setRootKey] = useState(0);
+  const onErrorRef = useRef(props.onError);
+  onErrorRef.current = props.onError;
+  return /* @__PURE__ */ jsx(
+    GenesisErrorBoundary,
+    {
+      fallback: PlainFatalScreen,
+      onError: (e, r) => onErrorRef.current?.(e, r),
+      onRetry: () => setRootKey((key) => key + 1),
+      children: /* @__PURE__ */ jsx(ThemedShell, { ...props })
+    },
+    rootKey
+  );
+}
+function ThemedShell(props) {
+  const { brand, keyboardScroll } = props;
+  const body = /* @__PURE__ */ jsx(Shell, { ...props });
+  return /* @__PURE__ */ jsx(ThemeProvider, { brand, syncNativeAppearance: true, children: keyboardScroll ? /* @__PURE__ */ jsx(KeyboardScrollProvider, { component: keyboardScroll, children: body }) : body });
+}
+var SESSION_STEP_MARGIN_MS = 15e3;
+function Shell(props) {
+  const { supabase, provider, queryClient: queryOptions, persist, splash, links, steps = [], bootOptions, sessionWaitMs = 5e3 } = props;
+  const { errorUtils, rejectionTracker, lifecycle, slots, slotProps, children } = props;
+  const latest = useRef(props);
+  latest.current = props;
+  const onError = (error, report) => latest.current.onError?.(error, report);
+  const fatalShown = useRef(0);
+  const [parts] = useState(() => {
+    const client2 = queryOptions?.client ?? createNativeQueryClient(queryOptions?.config);
+    const persistence2 = persist ? persist(client2) : null;
+    const session2 = createSessionStore(supabase, {
+      waitMs: sessionWaitMs,
+      // Another user (or nobody) now: nothing of the last user's may show or stay on disk.
+      onUserChange: (previous, next) => {
+        client2.clear();
+        void persistence2?.clear();
+        if (previous !== null && next === null) latest.current.onSignedOut?.();
+      }
+    });
+    const boot2 = createBoot(
+      [
+        ...steps,
+        // Settles within its own timeout and never throws: a policy that can't load never blocks the app.
+        ...props.updates ? [props.updates.bootStep] : [],
+        { id: "genesis:session", run: () => session2.load(), timeoutMs: sessionWaitMs + SESSION_STEP_MARGIN_MS },
+        // After the session, so only the cache saved for this user is restored.
+        ...persistence2 ? [{ id: "genesis:query-cache", run: () => persistence2.restore(session2.getState().userId ?? "") }] : []
+      ],
+      bootOptions
+    );
+    function FatalFallback2(fallbackProps) {
+      useEffect(() => {
+        fatalShown.current++;
+        return () => {
+          fatalShown.current--;
+        };
+      }, []);
+      const { slots: s, slotProps: sp } = latest.current;
+      return (
+        // A `fatal` slot that throws falls back to the plain screen.
+        /* @__PURE__ */ jsx(GenesisErrorBoundary, { fallback: PlainFatalScreen, onError, onRetry: fallbackProps.retry, children: renderSlot(FatalScreen, s?.fatal, fallbackProps, sp?.fatal) })
+      );
+    }
+    return { client: client2, persistence: persistence2, session: session2, boot: boot2, FatalFallback: FatalFallback2, updates: props.updates, provider: provider ?? createSupabaseProvider(supabase) };
+  });
+  const { boot, session, persistence, client, FatalFallback } = parts;
+  const bootState = useSyncExternalStore(boot.subscribe, boot.getState, boot.getState);
+  const sessionState = useSyncExternalStore(session.subscribe, session.getState, session.getState);
+  const [fatal, setFatal] = useState(null);
+  const [resetKey, setResetKey] = useState(0);
+  useEffect(() => session.start(), [session]);
+  useEffect(() => {
+    void boot.start();
+  }, [boot]);
+  useEffect(() => {
+    if (bootState.status === "failed" && bootState.error) onError(bootState.error, { fatal: true, source: "boot" });
+  }, [bootState.status, bootState.error]);
+  useEffect(() => {
+    if (bootState.status === "ready" && persistence) return persistence.subscribe(sessionState.userId ?? "");
+  }, [bootState.status, persistence, sessionState.userId]);
+  useEffect(() => {
+    const utils = errorUtils ?? defaultErrorUtils();
+    if (!utils) return;
+    return installGlobalErrorHandler({ errorUtils: utils, onError, onFatal: setFatal, alreadyFatal: () => fatalShown.current > 0 });
+  }, [errorUtils]);
+  useEffect(() => {
+    const enable = rejectionTracker === null ? void 0 : rejectionTracker ?? defaultRejectionTracker();
+    if (enable) installRejectionTracker({ enable, onError });
+  }, [rejectionTracker]);
+  useEffect(() => lifecycle ? connectQueryLifecycle(lifecycle) : void 0, [lifecycle]);
+  const settled = bootState.status === "ready" || bootState.status === "failed" || fatal !== null;
+  const splashHidden = useRef(false);
+  useEffect(() => {
+    if (!settled || !splash || splashHidden.current) return;
+    splashHidden.current = true;
+    splash.hideAsync().catch(() => {
+    });
+  }, [settled, splash]);
+  const auth = bootState.status !== "ready" || sessionState.status === "loading" ? "pending" : sessionState.status;
+  useHeldLink(links?.hold ?? NO_HOLD, { auth: links ? auth : "pending", onRelease: (path) => links?.onRelease(path) });
+  const retry = () => {
+    setFatal(null);
+    setResetKey((key) => key + 1);
+    if (boot.getState().status === "failed") void boot.retry();
+  };
+  let content;
+  if (fatal) {
+    content = /* @__PURE__ */ jsx(FatalFallback, { error: fatal, retry });
+  } else if (bootState.status === "failed" && bootState.error) {
+    content = /* @__PURE__ */ jsx(FatalFallback, { error: bootState.error, retry });
+  } else if (bootState.status !== "ready") {
+    content = renderSlot(BootScreen, slots?.boot, { status: bootState.status }, slotProps?.boot);
+  } else {
+    const screens = sessionState.status === "signedOut" ? renderSlot(PassThrough, slots?.signedOut, { children }, slotProps?.signedOut) : children;
+    const guarded = renderSlot(
+      GenesisErrorBoundary,
+      slots?.errorBoundary,
+      { fallback: FatalFallback, onError, resetKey, onRetry: retry, children: screens },
+      slotProps?.errorBoundary
+    );
+    const Updates = parts.updates?.Root;
+    content = Updates ? /* @__PURE__ */ jsx(Updates, { slots, slotProps, children: guarded }) : guarded;
+  }
+  return /* @__PURE__ */ jsx(GenesisProvider, { provider: parts.provider, queryClient: client, children: /* @__PURE__ */ jsx(SessionProvider, { store: session, children: /* @__PURE__ */ jsx(BootProvider, { boot, children: /* @__PURE__ */ jsx(GenesisErrorBoundary, { fallback: FatalFallback, onError, onRetry: retry, children: content }, resetKey) }) }) });
+}
+var NO_HOLD = {
+  hold: () => {
+  },
+  peek: () => null,
+  take: () => null,
+  clear: () => {
+  },
+  subscribe: () => () => {
+  }
+};
+
+// src/hydration-gate.ts
+function createHydrationGate({ onDroppedWrite } = {}) {
+  let hydrated = false;
+  let open;
+  const opened = new Promise((resolve) => {
+    open = resolve;
+  });
+  const gate = {
+    get hydrated() {
+      return hydrated;
+    },
+    markHydrated() {
+      if (hydrated) return;
+      hydrated = true;
+      open();
+    },
+    whenHydrated: () => opened,
+    async run(write) {
+      if (!hydrated) await opened;
+      return write();
+    },
+    storage(storage) {
+      const setItem = async (key, value) => {
+        if (!hydrated) return onDroppedWrite?.(key);
+        return storage.setItem(key, value);
+      };
+      const removeItem = async (key) => {
+        if (!hydrated) return onDroppedWrite?.(key);
+        return storage.removeItem(key);
+      };
+      return new Proxy(storage, {
+        get(target, property) {
+          if (property === "setItem") return setItem;
+          if (property === "removeItem") return removeItem;
+          const value = Reflect.get(target, property, target);
+          return typeof value === "function" ? value.bind(target) : value;
+        }
+      });
+    }
+  };
+  return gate;
+}
+
+// src/links.ts
+var URL_PATTERN = /^([a-z][a-z0-9+.-]*):\/\/([^/?#]*)([^?#]*)(\?[^#]*)?(#.*)?$/i;
+function parse(url, schemes, hosts) {
+  const trimmed = url.trim();
+  const match = URL_PATTERN.exec(trimmed);
+  if (!match) {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(trimmed)) return null;
+    const noHash = trimmed.split("#")[0] ?? "";
+    const at = noHash.indexOf("?");
+    return at < 0 ? { path: noHash, query: "" } : { path: noHash.slice(0, at), query: noHash.slice(at) };
+  }
+  const [, scheme = "", host = "", path = "", query = ""] = match;
+  const lowerScheme = scheme.toLowerCase();
+  if (lowerScheme === "http" || lowerScheme === "https") {
+    const bareHost = host.toLowerCase().replace(/:\d+$/, "");
+    if (!hosts.some((h) => h.toLowerCase() === bareHost)) return null;
+    return { path, query };
+  }
+  if (!schemes.some((s) => s.toLowerCase() === lowerScheme)) return null;
+  return { path: `/${host}${path}`, query };
+}
+function clean(path) {
+  const joined = `/${path}`.replace(/\/{2,}/g, "/");
+  return joined.length > 1 ? joined.replace(/\/$/, "") : joined;
+}
+function matchPattern(pattern, path) {
+  const want = clean(pattern).split("/").slice(1);
+  const have = path.split("/").slice(1);
+  const params = {};
+  for (let i = 0; i < want.length; i++) {
+    const segment = want[i];
+    if (segment === "*" && i === want.length - 1) {
+      params["*"] = have.slice(i).join("/");
+      return params;
+    }
+    const value = have[i];
+    if (value === void 0) return null;
+    if (segment.startsWith(":")) params[segment.slice(1)] = value;
+    else if (segment !== value) return null;
+  }
+  return want.length === have.length ? params : null;
+}
+function fill(target, params) {
+  if (typeof target === "function") return target(params);
+  return target.replace(
+    /:([A-Za-z_][A-Za-z0-9_]*)|\*$/g,
+    (token, name) => name === void 0 ? params["*"] ?? "" : params[name] ?? token
+  );
+}
+function isDotSegment(segment) {
+  let decoded = segment;
+  try {
+    decoded = decodeURIComponent(segment);
+  } catch {
+  }
+  return decoded === "." || decoded === "..";
+}
+function withQuery(path, query) {
+  if (!query || query === "?") return path;
+  return path.includes("?") ? `${path}&${query.slice(1)}` : `${path}${query}`;
+}
+function normalizeLink(url, options) {
+  const { schemes = [], hosts = [], map, ignore = [], onUnknown } = options;
+  const unknown = () => {
+    onUnknown?.(url);
+    return "/";
+  };
+  let parsed;
+  try {
+    parsed = parse(url, schemes, hosts);
+  } catch {
+    parsed = null;
+  }
+  if (!parsed) return unknown();
+  const path = clean(parsed.path);
+  if (path.split("/").some(isDotSegment)) {
+    return unknown();
+  }
+  if (ignore.some((pattern) => matchPattern(pattern, path))) return null;
+  if (path === "/") return withQuery("/", parsed.query);
+  for (const [pattern, target] of Object.entries(map)) {
+    const params = matchPattern(pattern, path);
+    if (!params) continue;
+    try {
+      return withQuery(fill(target, params), parsed.query);
+    } catch {
+      return unknown();
+    }
+  }
+  return unknown();
+}
+
+export { AuthGate, BootProvider, BootScreen, BootTimeoutError, FatalScreen, GenesisErrorBoundary, GenesisNativeApp, PlainFatalScreen, SessionProvider, createBoot, createHydrationGate, createLinkHold, createSessionStore, defaultErrorUtils, defaultRejectionTracker, installGlobalErrorHandler, installRejectionTracker, normalizeLink, useBoot, useHeldLink, useSession };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map