@xenide-io/suite-client 0.5.0 → 0.6.1

package/dist/index.js

@@ -26,6 +26,8 @@ __export(index_exports, {
   ERROR_RETRYABLE: () => ERROR_RETRYABLE,
   FREE_PLAN_SEAT_HELP: () => FREE_PLAN_SEAT_HELP,
   ORGANISATION_SEAT_HELP: () => ORGANISATION_SEAT_HELP,
+  SUITE_APP_QUERY_CACHES: () => SUITE_APP_QUERY_CACHES,
+  SUITE_QUERY_CACHE_MAX_AGE_MS: () => SUITE_QUERY_CACHE_MAX_AGE_MS,
   TIDES_ACCESS_HELP: () => TIDES_ACCESS_HELP,
   TURTLETIME_ACCESS_HELP: () => TURTLETIME_ACCESS_HELP,
   WEBHOOK_ACTIVITY_ACTIONS: () => WEBHOOK_ACTIVITY_ACTIONS,
@@ -53,9 +55,12 @@ __export(index_exports, {
   formatAppError: () => formatAppError,
   hasAppAccess: () => hasAppAccess,
   isErrorCode: () => isErrorCode,
+  nextRevisionTick: () => nextRevisionTick,
   normalizeError: () => normalizeError,
   normalizeThrown: () => normalizeThrown,
+  persistSuiteQueries: () => persistSuiteQueries,
   planSeatSummary: () => planSeatSummary,
+  readJsonSnapshot: () => readJsonSnapshot,
   resolveSubscriptionTier: () => resolveSubscriptionTier,
   seatTypeDescription: () => seatTypeDescription,
   seatTypeFromFlags: () => seatTypeFromFlags,
@@ -63,11 +68,15 @@ __export(index_exports, {
   selectedToWebhookActions: () => selectedToWebhookActions,
   sortedSuiteAiEvents: () => sortedSuiteAiEvents,
   suiteAiEventSummary: () => suiteAiEventSummary,
+  suiteCacheBuster: () => suiteCacheBuster,
   tierAllowsTidesOnlySeats: () => tierAllowsTidesOnlySeats,
   tierAllowsTurtletime: () => tierAllowsTurtletime,
   tierLabel: () => tierLabel,
+  useEmailNotificationPreference: () => useEmailNotificationPreference,
   useIsNight: () => useIsNight,
-  webhookActionsToSelected: () => webhookActionsToSelected
+  useSuiteRevisions: () => useSuiteRevisions,
+  webhookActionsToSelected: () => webhookActionsToSelected,
+  writeJsonSnapshot: () => writeJsonSnapshot
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -9490,8 +9499,12 @@ function createAnalyticsClient(config) {
       defaults,
       person_profiles: "identified_only",
       autocapture: true,
-      capture_pageview: true,
-      capture_pageleave: true,
+      // Pageviews are captured explicitly via `pageview()` (mount + route
+      // change) so every `$pageview` carries the app/super-properties and the
+      // behaviour is identical across all apps. The SDK's own pageview capture
+      // is disabled to avoid double-counting and `defaults`-dependent behaviour.
+      capture_pageview: false,
+      capture_pageleave: false,
       persistence: "localStorage+cookie",
       cross_subdomain_cookie: true
     });
@@ -9549,6 +9562,7 @@ function createAnalyticsClient(config) {
     if (sessionId) headers["X-POSTHOG-SESSION-ID"] = sessionId;
     return headers;
   }
+  if (isBrowser()) init();
   return {
     init,
     identify,
@@ -9575,6 +9589,8 @@ function createApiClient(config) {
   let accessToken = null;
   let refreshToken = null;
   let activeWorkspaceId = null;
+  const etagBodies = /* @__PURE__ */ new Map();
+  const pendingGets = /* @__PURE__ */ new Map();
   let authFailureHandler = null;
   let authFailureFired = false;
   let refreshPromise = null;
@@ -9666,6 +9682,7 @@ function createApiClient(config) {
         window.localStorage.removeItem(WORKSPACE_KEY);
       }
       if (changed) {
+        etagBodies.clear();
         config.onWorkspaceChange?.(id2);
         if (id2 && previousWorkspaceId) {
           track("Workspace Switched", {
@@ -9699,6 +9716,8 @@ function createApiClient(config) {
     accessToken = null;
     refreshToken = null;
     activeWorkspaceId = null;
+    etagBodies.clear();
+    pendingGets.clear();
     if (typeof window !== "undefined") {
       window.localStorage.removeItem(ACCESS_KEY);
       window.localStorage.removeItem(REFRESH_KEY);
@@ -9767,6 +9786,30 @@ function createApiClient(config) {
     }
   }
   async function apiFetch(path, init = {}) {
+    if ((init.method ?? "GET").toUpperCase() !== "GET") {
+      pendingGets.clear();
+      try {
+        return await apiFetchInternal(path, init);
+      } finally {
+        pendingGets.clear();
+      }
+    }
+    if (Object.keys(init).length > 0) return apiFetchInternal(path, init);
+    const key = JSON.stringify([
+      getAccessToken(),
+      getActiveWorkspaceId(),
+      path
+    ]);
+    let pending = pendingGets.get(key);
+    if (!pending) {
+      pending = apiFetchInternal(path, init).finally(() => {
+        if (pendingGets.get(key) === pending) pendingGets.delete(key);
+      });
+      pendingGets.set(key, pending);
+    }
+    return (await pending).clone();
+  }
+  async function apiFetchInternal(path, init = {}) {
     const { skipAuth, ...requestInit } = init;
     const token = getAccessToken();
     const headers = {
@@ -9786,6 +9829,12 @@ function createApiClient(config) {
       headers["X-Active-Workspace-Id"] = wsId;
     }
     applyContextHeaders(headers);
+    const method = (requestInit.method ?? "GET").toUpperCase();
+    const etagKey = `${method}:${wsId ?? ""}:${path}`;
+    if (method === "GET") {
+      const hit = etagBodies.get(etagKey);
+      if (hit) headers["If-None-Match"] = hit.etag;
+    }
     const url = path.startsWith("http") ? path : `${API_URL}${path}`;
     if (config.enforceSameOrigin && !skipAuth && path.startsWith("http") && !url.startsWith(API_URL)) {
       throw new Error("Refusing to send the session to an unexpected origin.");
@@ -9817,6 +9866,26 @@ function createApiClient(config) {
         triggerAuthFailure();
       }
     }
+    if (method === "GET" && res.status === 304) {
+      const hit = etagBodies.get(etagKey);
+      if (hit) {
+        return new Response(hit.body, {
+          status: 200,
+          headers: { "Content-Type": "application/json", ETag: hit.etag }
+        });
+      }
+    }
+    if (method === "GET" && res.ok) {
+      const etag = res.headers.get("ETag");
+      if (etag) {
+        const cachedBody = await res.clone().text();
+        if (etagBodies.size >= 40) {
+          const oldest = etagBodies.keys().next().value;
+          if (oldest) etagBodies.delete(oldest);
+        }
+        etagBodies.set(etagKey, { etag, body: cachedBody });
+      }
+    }
     return res;
   }
   async function parseApiError(res) {
@@ -9911,8 +9980,6 @@ function createAuthReturnPath(config) {
     }
   }
   function readPortalHandoff(fallbackNext = DEFAULT_NEXT) {
-    const cached = cachedHandoff(fallbackNext);
-    if (cached) return cached;
     const hash = new URLSearchParams(window.location.hash.replace(/^#/, ""));
     const query = new URLSearchParams(window.location.search);
     const nextRaw = hash.get("next") || query.get("next");
@@ -9925,19 +9992,18 @@ function createAuthReturnPath(config) {
     if (result.code || result.token) {
       sessionStorage.setItem(HANDOFF_KEY, JSON.stringify(result));
     }
-    return result;
+    return result.code || result.token ? result : cachedHandoff(fallbackNext) ?? result;
   }
   let redeemInflight = null;
+  let redeemKey = "";
   function track(event, properties) {
     try {
       config.onAnalyticsEvent?.(event, properties);
     } catch {
     }
   }
-  async function redeemPortalHandoff(apiUrl, fallbackNext = DEFAULT_NEXT) {
-    redeemInflight ?? (redeemInflight = (async () => {
-      const { code, token, refresh, next } = readPortalHandoff(fallbackNext);
-      if (!code) return { code: null, token, refresh, next };
+  async function requestSwitchCode(apiUrl, code) {
+    try {
       const response = await fetch(`${apiUrl.replace(/\/$/, "")}${REDEEM_PATH}`, {
         method: "POST",
         headers: {
@@ -9946,21 +10012,57 @@ function createAuthReturnPath(config) {
         },
         body: JSON.stringify({ code })
       });
-      if (!response.ok) {
+      if (!response.ok) return "dead";
+      return await response.json();
+    } catch {
+      return "retry";
+    }
+  }
+  async function redeemPortalHandoff(apiUrl, fallbackNext = DEFAULT_NEXT) {
+    const handoff = readPortalHandoff(fallbackNext);
+    const key = JSON.stringify([apiUrl, handoff]);
+    if (redeemInflight && redeemKey === key) {
+      return redeemInflight.then((result) => {
+        if (result.token) sessionStorage.removeItem(HANDOFF_KEY);
+        return result;
+      });
+    }
+    redeemKey = key;
+    const { code, token, refresh, next } = handoff;
+    redeemInflight = (async () => {
+      if (!code) {
+        sessionStorage.removeItem(HANDOFF_KEY);
+        return { code: null, token, refresh, next };
+      }
+      let outcome = await requestSwitchCode(apiUrl, code);
+      if (outcome === "retry") outcome = await requestSwitchCode(apiUrl, code);
+      if (outcome === "retry") {
+        track("Cross-App Switch", { success: false });
+        return { code: null, token: null, refresh: null, next };
+      }
+      if (outcome === "dead") {
+        sessionStorage.removeItem(HANDOFF_KEY);
+        track("Cross-App Switch", { success: false });
+        return { code: null, token: null, refresh: null, next };
+      }
+      const redeemedToken = outcome.token || outcome.access || null;
+      if (!redeemedToken) {
+        sessionStorage.removeItem(HANDOFF_KEY);
         track("Cross-App Switch", { success: false });
         return { code: null, token: null, refresh: null, next };
       }
-      const data = await response.json();
       sessionStorage.removeItem(HANDOFF_KEY);
-      const redeemedToken = data.token || data.access || null;
-      track("Cross-App Switch", { success: Boolean(redeemedToken) });
+      track("Cross-App Switch", { success: true });
       return {
         code: null,
         token: redeemedToken,
-        refresh: data.refresh || null,
+        refresh: outcome.refresh || null,
         next
       };
-    })());
+    })().then((result) => {
+      if (!result.token && redeemKey === key) redeemInflight = null;
+      return result;
+    });
     return redeemInflight;
   }
   function readAuthReturnPath() {
@@ -10272,6 +10374,165 @@ function createWorkspaceAppearanceApi(config) {
   };
 }
 
+// src/cache/persist-query-cache.ts
+var SUITE_QUERY_CACHE_MAX_AGE_MS = 30 * 60 * 1e3;
+var MAX_SNAPSHOT_CHARS = 15e5;
+function suiteCacheBuster(tokenKey, workspaceKey) {
+  if (typeof window === "undefined") return "";
+  let token = null;
+  let workspace = null;
+  try {
+    token = window.localStorage.getItem(tokenKey);
+    workspace = window.localStorage.getItem(workspaceKey) || readCookie("xenide_active_workspace_id");
+  } catch {
+    return "";
+  }
+  const subject = subjectFromAccessToken(token);
+  if (!subject || !workspace) return "";
+  return `${subject}:${workspace}`;
+}
+function readJsonSnapshot(key, buster, maxAgeMs) {
+  if (typeof window === "undefined" || !buster) return null;
+  try {
+    const raw = window.localStorage.getItem(key);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (parsed.buster !== buster || typeof parsed.savedAt !== "number") return null;
+    if (Date.now() - parsed.savedAt > maxAgeMs) return null;
+    return parsed.value ?? null;
+  } catch {
+    return null;
+  }
+}
+function writeJsonSnapshot(key, buster, value) {
+  if (typeof window === "undefined" || !buster) return;
+  try {
+    const raw = JSON.stringify({ buster, savedAt: Date.now(), value });
+    if (raw.length > MAX_SNAPSHOT_CHARS) return;
+    window.localStorage.setItem(key, raw);
+  } catch {
+  }
+}
+function persistSuiteQueries(queryClient, options) {
+  const maxAgeMs = options.maxAgeMs ?? SUITE_QUERY_CACHE_MAX_AGE_MS;
+  restore(queryClient, options, maxAgeMs);
+  let timer = 0;
+  const unsubscribe = queryClient.getQueryCache().subscribe(() => {
+    if (typeof window === "undefined") return;
+    window.clearTimeout(timer);
+    timer = window.setTimeout(() => save(queryClient, options), 400);
+  });
+  return () => {
+    if (typeof window !== "undefined") window.clearTimeout(timer);
+    unsubscribe();
+  };
+}
+function restore(queryClient, options, maxAgeMs) {
+  const buster = suiteCacheBuster(options.tokenKey, options.workspaceKey);
+  const stored = readJsonSnapshot(
+    options.storageKey,
+    buster,
+    maxAgeMs
+  );
+  if (!Array.isArray(stored)) return;
+  for (const entry of stored) {
+    if (!entry || !Array.isArray(entry.queryKey) || !allowed(entry.queryKey, options.allow)) {
+      continue;
+    }
+    queryClient.setQueryData(entry.queryKey, entry.data);
+    void queryClient.invalidateQueries({
+      queryKey: entry.queryKey,
+      refetchType: "none"
+    });
+  }
+}
+function save(queryClient, options) {
+  const buster = suiteCacheBuster(options.tokenKey, options.workspaceKey);
+  if (!buster) return;
+  const queries = queryClient.getQueryCache().getAll().filter(
+    (query) => query.state.status === "success" && query.state.data !== void 0 && allowed(query.queryKey, options.allow)
+  ).map((query) => ({ queryKey: query.queryKey, data: query.state.data }));
+  writeJsonSnapshot(options.storageKey, buster, queries);
+}
+function allowed(queryKey, allow) {
+  return allow.some((rule) => {
+    if (typeof rule === "string") return queryKey[0] === rule;
+    return rule.every((part, index) => queryKey[index] === part);
+  });
+}
+function readCookie(name) {
+  if (typeof document === "undefined") return null;
+  const prefix = `${name}=`;
+  const entry = document.cookie.split("; ").find((item) => item.startsWith(prefix));
+  if (!entry) return null;
+  try {
+    return decodeURIComponent(entry.slice(prefix.length)) || null;
+  } catch {
+    return entry.slice(prefix.length) || null;
+  }
+}
+function subjectFromAccessToken(token) {
+  if (!token) return "";
+  const segment = token.split(".")[1];
+  if (!segment) return "";
+  try {
+    const base64 = segment.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+    const json = JSON.parse(atob(padded));
+    return typeof json.sub === "string" ? json.sub : "";
+  } catch {
+    return "";
+  }
+}
+var SUITE_APP_QUERY_CACHES = {
+  kraken: {
+    storageKey: "kraken-query-cache:v1",
+    tokenKey: "kraken_access_token",
+    workspaceKey: "kraken_active_workspace_id",
+    allow: ["kraken-sidebar"]
+  },
+  shellstack: {
+    storageKey: "shellstack-query-cache:v1",
+    tokenKey: "portal_access_token",
+    workspaceKey: "portal_active_workspace_id",
+    allow: ["calendar-events", "org-workspaces", "organisation", "org-team", "directory"]
+  },
+  tides: {
+    storageKey: "tides-query-cache:v1",
+    tokenKey: "tides_access_token",
+    workspaceKey: "tides_active_workspace_id",
+    allow: [
+      ["tides", "projects"],
+      ["tides", "clients"],
+      ["tides", "workspace-members"],
+      ["tides", "workspace-tags"],
+      ["tides", "project-statuses"]
+    ]
+  },
+  turtletime: {
+    storageKey: "tt-query-cache:v1",
+    tokenKey: "tt_access_token",
+    workspaceKey: "tt_active_workspace_id",
+    allow: [
+      ["tt", "tracker-catalog"],
+      ["tt", "projects"],
+      ["tt", "clients"],
+      ["tt", "categories"]
+    ]
+  },
+  shelly: {
+    storageKey: "shelly-query-cache:v1",
+    tokenKey: "shelly_access_token",
+    workspaceKey: "shelly_active_workspace_id",
+    allow: [
+      ["shelly", "skills"],
+      ["shelly", "crews"],
+      ["shelly", "mcp-servers"],
+      ["shelly", "models"]
+    ]
+  }
+};
+
 // src/sync/create-cross-app-sync.ts
 function createCrossAppSync(config) {
   const pollMs = config.pollMs ?? 5e3;
@@ -10283,40 +10544,49 @@ function createCrossAppSync(config) {
   const subscribers = [];
   let pollInterval = null;
   let pollListeners = 0;
+  let inFlight = false;
+  let primed = false;
+  let scope;
+  let lastRequestedScope;
+  let lastRequestedAt;
   async function fetchCheckpoint() {
+    if (inFlight || document.visibilityState !== "visible") return null;
+    const requestScope = config.getScope?.();
+    if (requestScope === lastRequestedScope && lastRequestedAt !== void 0 && Date.now() - lastRequestedAt < pollMs)
+      return null;
+    inFlight = true;
+    lastRequestedScope = requestScope;
+    lastRequestedAt = Date.now();
     try {
       const res = await config.api.get(config.checkpointPath);
       if (!res.ok) return null;
-      return await res.json();
+      const data = await res.json();
+      if (requestScope !== config.getScope?.()) return null;
+      if (scope !== requestScope) {
+        primed = false;
+        scope = requestScope;
+      }
+      return data;
     } catch {
       return null;
-    }
-  }
-  function notify(topic) {
-    for (const sub of subscribers) {
-      if (!sub.topic || sub.topic === topic) {
-        if (lastKnown[topic] > sub.lastSync) {
-          sub.lastSync = lastKnown[topic];
-          sub.callback();
-        }
-      }
+    } finally {
+      inFlight = false;
     }
   }
   function checkAndNotify(data) {
-    const tasks = data.tasks_synced_at || 0;
-    const time = data.time_synced_at || 0;
-    const integration = data.integration_synced_at || 0;
-    if (tasks > lastKnown.tasks) {
-      lastKnown.tasks = tasks;
-      notify("tasks");
-    }
-    if (time > lastKnown.time) {
-      lastKnown.time = time;
-      notify("time");
-    }
-    if (integration > lastKnown.integration) {
-      lastKnown.integration = integration;
-      notify("integration");
+    const next = {
+      tasks: data.tasks_synced_at || 0,
+      time: data.time_synced_at || 0,
+      integration: data.integration_synced_at || 0
+    };
+    const changed = ["tasks", "time", "integration"].filter(
+      (topic) => primed && next[topic] > lastKnown[topic]
+    );
+    Object.assign(lastKnown, next);
+    primed = true;
+    for (const sub of subscribers) {
+      if (changed.some((topic) => !sub.topic || sub.topic === topic))
+        sub.callback();
     }
   }
   function startPolling() {
@@ -10343,8 +10613,7 @@ function createCrossAppSync(config) {
     };
     const sub = {
       topic,
-      callback: onSync,
-      lastSync: lastKnown[topic || "tasks"]
+      callback: onSync
     };
     subscribers.push(sub);
     pollListeners += 1;
@@ -10415,6 +10684,80 @@ function createLiveRefresh(sync) {
   return { subscribeLiveRefresh, hasPendingCrossAppSync };
 }
 
+// src/sync/use-suite-revisions.ts
+var import_react = require("react");
+function nextRevisionTick(seen, ready, data) {
+  if (!data) return { seen, ready, changed: [] };
+  const next = { ...seen };
+  if (!ready) {
+    for (const [topic, value] of Object.entries(data)) {
+      if (typeof value === "number") next[topic] = value;
+    }
+    return { seen: next, ready: true, changed: [] };
+  }
+  const changed = [];
+  for (const [topic, value] of Object.entries(data)) {
+    if (typeof value !== "number" || next[topic] === value) continue;
+    next[topic] = value;
+    changed.push(topic);
+  }
+  return { seen: next, ready: true, changed };
+}
+function useSuiteRevisions(options) {
+  const loadRef = (0, import_react.useRef)(options.load);
+  const onTopicRef = (0, import_react.useRef)(options.onTopic);
+  loadRef.current = options.load;
+  onTopicRef.current = options.onTopic;
+  const pollMs = options.pollMs ?? 15e3;
+  const scope = options.scope ?? "";
+  const seenScope = (0, import_react.useRef)(null);
+  (0, import_react.useEffect)(() => {
+    if (!options.enabled || typeof window === "undefined") return;
+    const switching = seenScope.current !== null && seenScope.current !== scope;
+    seenScope.current = scope;
+    let seen = {};
+    let ready = switching;
+    let timer;
+    let inFlight = false;
+    let disposed = false;
+    const tick = async () => {
+      if (inFlight || disposed) return;
+      inFlight = true;
+      try {
+        const data = await loadRef.current();
+        if (disposed) return;
+        const step = nextRevisionTick(seen, ready, data);
+        seen = step.seen;
+        ready = step.ready;
+        for (const topic of step.changed) onTopicRef.current(topic);
+      } catch {
+      } finally {
+        inFlight = false;
+      }
+    };
+    const stop = () => {
+      if (timer !== void 0) window.clearInterval(timer);
+      timer = void 0;
+    };
+    const start = () => {
+      if (timer !== void 0) return;
+      void tick();
+      timer = window.setInterval(() => void tick(), pollMs);
+    };
+    const onVisibility = () => {
+      if (document.visibilityState === "visible") start();
+      else stop();
+    };
+    if (document.visibilityState === "visible") start();
+    document.addEventListener("visibilitychange", onVisibility);
+    return () => {
+      disposed = true;
+      stop();
+      document.removeEventListener("visibilitychange", onVisibility);
+    };
+  }, [options.enabled, pollMs, scope]);
+}
+
 // src/notifications/create-notifications-client.ts
 function createNotificationsClient(config) {
   const { api, parseApiError } = config;
@@ -10560,6 +10903,47 @@ function createWebPushClient(config) {
   return { supported, getState, enable, disable };
 }
 
+// src/notifications/use-email-notification-preference.ts
+var import_react2 = require("react");
+var EMAIL_PREFERENCE_PATH = "/api/notifications/email/";
+function useEmailNotificationPreference(api, parseApiError) {
+  const [enabled, setEnabled] = (0, import_react2.useState)(false);
+  const [busy, setBusy] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)("");
+  (0, import_react2.useEffect)(() => {
+    let cancelled = false;
+    api.get(EMAIL_PREFERENCE_PATH).then(async (res) => {
+      if (!res.ok || cancelled) return;
+      const data = await res.json();
+      if (!cancelled) setEnabled(Boolean(data.enabled));
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [api]);
+  const onChange = (0, import_react2.useCallback)(
+    (next) => {
+      setBusy(true);
+      setError("");
+      setEnabled(next);
+      api.patch(EMAIL_PREFERENCE_PATH, { enabled: next }).then(async (res) => {
+        if (!res.ok) {
+          setEnabled(!next);
+          setError(await parseApiError(res));
+        }
+      }).catch((err) => {
+        setEnabled(!next);
+        setError(
+          err instanceof Error ? err.message : "Could not save email notifications."
+        );
+      }).finally(() => setBusy(false));
+    },
+    [api, parseApiError]
+  );
+  return { enabled, busy, error, onChange };
+}
+
 // src/ai/suite-ai-job.ts
 function activeSuiteAiJobs(jobs) {
   return jobs.filter(
@@ -10641,12 +11025,12 @@ function createJsonLd(config) {
 }
 
 // src/hooks/use-is-night.ts
-var import_react = require("react");
+var import_react3 = require("react");
 var NIGHT_START_HOUR = 18;
 var NIGHT_END_HOUR = 6;
 function useIsNight() {
-  const [isNight, setIsNight] = (0, import_react.useState)(false);
-  (0, import_react.useEffect)(() => {
+  const [isNight, setIsNight] = (0, import_react3.useState)(false);
+  (0, import_react3.useEffect)(() => {
     const check = () => {
       const hour = (/* @__PURE__ */ new Date()).getHours();
       return hour >= NIGHT_START_HOUR || hour < NIGHT_END_HOUR;
@@ -10671,6 +11055,8 @@ function useIsNight() {
   ERROR_RETRYABLE,
   FREE_PLAN_SEAT_HELP,
   ORGANISATION_SEAT_HELP,
+  SUITE_APP_QUERY_CACHES,
+  SUITE_QUERY_CACHE_MAX_AGE_MS,
   TIDES_ACCESS_HELP,
   TURTLETIME_ACCESS_HELP,
   WEBHOOK_ACTIVITY_ACTIONS,
@@ -10698,9 +11084,12 @@ function useIsNight() {
   formatAppError,
   hasAppAccess,
   isErrorCode,
+  nextRevisionTick,
   normalizeError,
   normalizeThrown,
+  persistSuiteQueries,
   planSeatSummary,
+  readJsonSnapshot,
   resolveSubscriptionTier,
   seatTypeDescription,
   seatTypeFromFlags,
@@ -10708,10 +11097,14 @@ function useIsNight() {
   selectedToWebhookActions,
   sortedSuiteAiEvents,
   suiteAiEventSummary,
+  suiteCacheBuster,
   tierAllowsTidesOnlySeats,
   tierAllowsTurtletime,
   tierLabel,
+  useEmailNotificationPreference,
   useIsNight,
-  webhookActionsToSelected
+  useSuiteRevisions,
+  webhookActionsToSelected,
+  writeJsonSnapshot
 });
 //# sourceMappingURL=index.js.map