From 120c88028f6d2026c8fab2daabf1b9e73321d912 Mon Sep 17 00:00:00 2001
From: John Obelenus <jobelenus@systeminit.com>
Date: Mon, 8 Dec 2025 16:17:54 -0500
Subject: [PATCH] web experience backstop & telemetry

there is an outside chance that the system will fail to send a wsevent
(incident, poor timing of a deploy, etc etc)
to the web worker that tells it the index has been built successfully
so we have a backup cold start interval here
to prevent a user from being stuck in the lobby perpetually

make sure we end a span in a no-op case

bring back a disconnect notification for only SI cohort

emit span events for when we open and close ws connections

every 30 seconds, if we have not gotten index update messages, try to cold start, just in case
this is a fail safe for clients that are not receiving messages.
yes, in a quiet workspace this will make calls that result in nothing much happening.
but its hitting a cache and its a small price to pay.
30 seconds might be the wrong number, but its something.
---
 app/web/src/newhotness/Workspace.vue          | 42 +++++++--
 .../src/newhotness/nav/NavbarPanelCenter.vue  |  9 +-
 app/web/src/newhotness/util.ts                | 46 ----------
 app/web/src/store/feature_flags.store.ts      |  1 +
 app/web/src/store/realtime/heimdall.ts        | 90 +++++++++++++++---
 app/web/src/workers/shared_webworker.ts       | 17 ++++
 app/web/src/workers/types/dbinterface.ts      |  4 +
 app/web/src/workers/utils.ts                  | 92 +++++++++++++++++++
 app/web/src/workers/webworker.ts              | 51 +++++++---
 9 files changed, 273 insertions(+), 79 deletions(-)
 create mode 100644 app/web/src/workers/utils.ts

diff --git a/app/web/src/newhotness/Workspace.vue b/app/web/src/newhotness/Workspace.vue
index 917fa84845..fab521ffa3 100644
--- a/app/web/src/newhotness/Workspace.vue
+++ b/app/web/src/newhotness/Workspace.vue
@@ -33,7 +33,7 @@
         :changeSetId="changeSetId"
         :componentId="componentId"
         :viewId="viewId"
-        connected
+        :connected="haveWSConn"
       />
 
       <!-- Right -->
@@ -236,10 +236,9 @@ const changeSetId = computed(() => props.changeSetId);
 
 const coldStartInProgress = computed(() => heimdall.muspelheimInProgress.value);
 
-// const haveWSConn = computed<boolean>(() => {
-//   if (!heimdall.initCompleted.value) return true; // dont show error if we havent gotten started
-//   return !!heimdall.wsConnections.value[props.workspacePk];
-// });
+const haveWSConn = computed<boolean>(() => {
+  return !!heimdall.wsConnections.value[props.workspacePk];
+});
 
 // no tan stack queries hitting sqlite until after the cold start has finished
 const queriesEnabled = computed(
@@ -637,11 +636,42 @@ watch(
         return;
       }
       await heimdall.registerBearerToken(newWorkspacePk, workspaceToken);
-      heimdall.niflheim(newWorkspacePk, newChangeSetId, true, false);
+      await heimdall.niflheim(newWorkspacePk, newChangeSetId, true, false);
     }
   },
 );
 
+const EVENTUALLY_CONSISTENT_TIME = 30 * 1000; // 30 seconds
+let indexInterval: NodeJS.Timeout;
+
+watch(
+  () => [props.changeSetId],
+  () => {
+    // clear any interval for other change set
+    if (indexInterval) clearInterval(indexInterval);
+
+    // set a new interval (note: above watcher fires first cold start from the user selection change)
+    indexInterval = setInterval(() => {
+      heimdall.syncAtoms(props.workspacePk, props.changeSetId);
+    }, EVENTUALLY_CONSISTENT_TIME);
+  },
+  { immediate: true },
+);
+
+watch(
+  () => heimdall.indexTouches.get(props.changeSetId),
+  () => {
+    if (lobby.value) return; // dont do anything when in the lobby
+    // each time we get index updates, clear the interval
+    if (indexInterval) clearInterval(indexInterval);
+    // and restart it
+    indexInterval = setInterval(() => {
+      heimdall.syncAtoms(props.workspacePk, props.changeSetId);
+    }, EVENTUALLY_CONSISTENT_TIME);
+  },
+  { immediate: true },
+);
+
 const indexFailedToLoad = computed(() => {
   // NOTE: this represents a 5XX error that was retried 5 times
   // if we get here its likely because the index could not be retrieved, or even built
diff --git a/app/web/src/newhotness/nav/NavbarPanelCenter.vue b/app/web/src/newhotness/nav/NavbarPanelCenter.vue
index 41474aa339..d7a3a363c3 100644
--- a/app/web/src/newhotness/nav/NavbarPanelCenter.vue
+++ b/app/web/src/newhotness/nav/NavbarPanelCenter.vue
@@ -2,7 +2,7 @@
   <div
     class="flex flex-row flex-none items-center h-full justify-center place-items-center mx-auto overflow-hidden"
   >
-    <template v-if="connected">
+    <template v-if="isConnected">
       <NavbarButton
         tooltipText="Compose"
         icon="grid"
@@ -65,10 +65,17 @@ import { computed } from "vue";
 import { useRoute } from "vue-router";
 import { themeClasses, Icon } from "@si/vue-lib/design-system";
 import NavbarButton from "@/components/layout/navbar/NavbarButton.vue";
+import { useFeatureFlagsStore } from "@/store/feature_flags.store";
 import { useContext } from "../logic_composables/context";
 
 const ctx = useContext();
 const route = useRoute();
+const ffStore = useFeatureFlagsStore();
+
+const isConnected = computed(() => {
+  if (ffStore.SHOW_WS_DISCONNECT) return props.connected;
+  return true;
+});
 
 const props = defineProps<{
   workspaceId: string;
diff --git a/app/web/src/newhotness/util.ts b/app/web/src/newhotness/util.ts
index d7023b0b2e..171d049a2f 100644
--- a/app/web/src/newhotness/util.ts
+++ b/app/web/src/newhotness/util.ts
@@ -1,4 +1,3 @@
-import * as _ from "lodash-es";
 import { Ref, unref } from "vue";
 import {
   BRAND_COLOR_FILTER_HEX_CODES,
@@ -123,51 +122,6 @@ export const openWorkspaceMigrationDocumentation = () => {
   );
 };
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type AnyFn = (...args: any[]) => any;
-
-export interface MemoizeDebouncedFn<F extends AnyFn>
-  extends _.DebouncedFunc<F> {
-  (...args: Parameters<F>): ReturnType<F> | undefined;
-  flush: (...args: Parameters<F>) => ReturnType<F> | undefined;
-  cancel: (...args: Parameters<F>) => void;
-}
-/**
- * Debounce based on args to the fn
- */
-export function memoizeDebounce<F extends AnyFn>(
-  func: F,
-  wait = 0,
-  options: _.DebounceSettings = {},
-  resolver?: (...args: Parameters<F>) => unknown,
-): MemoizeDebouncedFn<F> {
-  const dbMemo = _.memoize<(...args: Parameters<F>) => _.DebouncedFunc<F>>(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    (..._args: Parameters<F>) => _.debounce(func, wait, options),
-    resolver,
-  );
-
-  function wrappedFn(
-    this: MemoizeDebouncedFn<F>,
-    ...args: Parameters<F>
-  ): ReturnType<F> | undefined {
-    return dbMemo(...args)(...args);
-  }
-
-  const flush: MemoizeDebouncedFn<F>["flush"] = (...args) => {
-    return dbMemo(...args).flush();
-  };
-
-  const cancel: MemoizeDebouncedFn<F>["cancel"] = (...args) => {
-    return dbMemo(...args).cancel();
-  };
-
-  wrappedFn.flush = flush;
-  wrappedFn.cancel = cancel;
-
-  return wrappedFn;
-}
-
 /**
  * Escapes a string segment for use in a JSON Pointer (RFC 6901).
  * JSON Pointers use '~' as an escape character:
diff --git a/app/web/src/store/feature_flags.store.ts b/app/web/src/store/feature_flags.store.ts
index 6faff3eece..3476af9f42 100644
--- a/app/web/src/store/feature_flags.store.ts
+++ b/app/web/src/store/feature_flags.store.ts
@@ -17,6 +17,7 @@ const USER_FLAG_MAPPING = {
   SQLITE_TOOLS: "sqlite-tools",
   COMPONENT_HISTORY_FUNCS: "component-history-funcs",
   GOOGLE_CLOUD_UI: "google-cloud-ui",
+  SHOW_WS_DISCONNECT: "show-ws-disconnect",
 } as const;
 const WORKSPACE_FLAG_MAPPING: Record<string, string> = {
   // STORE_FLAG_NAME: "posthogFlagName",
diff --git a/app/web/src/store/realtime/heimdall.ts b/app/web/src/store/realtime/heimdall.ts
index 961d99424b..a322b234fe 100644
--- a/app/web/src/store/realtime/heimdall.ts
+++ b/app/web/src/store/realtime/heimdall.ts
@@ -43,7 +43,7 @@ import { DefaultMap } from "@/utils/defaultmap";
 import * as rainbow from "@/newhotness/logic_composables/rainbow_counter";
 import { sdfApiInstance as sdf } from "@/store/apis.web";
 import { WorkspaceMetadata, WorkspacePk } from "@/api/sdf/dal/workspace";
-import { memoizeDebounce } from "@/newhotness/util";
+import { memoizeDebounce } from "@/workers/utils";
 import {
   cachedAppEmitter,
   SHOW_CACHED_APP_NOTIFICATION_EVENT,
@@ -196,20 +196,24 @@ export const init = async (
 
   // If both tabs are refreshed at the same time, this can falsely indicate that
   // a tab has the lock, but that tab has actually been refreshed just *after*
-  // this call, so *we* now have the lock.  adding 2.5 second timeout here
+  // this call, so *we* now have the lock.  adding 0.2 second timeout here
   // ensures that there is enough time for the lock to be resolved in a multitab
   // scenario before we begin cold start. (This only matters if 2+ tabs are
   // refreshed at more or less the same time, in the normal scenario we will
   // indicate lock acquisition via the broadcast channel)
   //
-  setTimeout(async () => {
-    if (!lockAcquired.value) {
-      await detectLockAcquiredByOtherTab();
-    }
-  }, 2000);
+  const p = new Promise<void>((resolve) => {
+    setTimeout(async () => {
+      if (!lockAcquired.value) {
+        await detectLockAcquiredByOtherTab();
+      }
+      resolve();
+    }, 200);
+  });
+  await p;
 
   setTimeout(async () => {
-    // If after 5 seconds total, we have not detected lock acquisition, try
+    // If after 2 seconds total, we have not detected lock acquisition, try
     // and force a leader election
     if (!lockAcquired.value) {
       await detectLockAcquiredByOtherTab();
@@ -217,7 +221,7 @@ export const init = async (
         forceLeaderElectionBroadcastChannel.postMessage(FORCE_LEADER_ELECTION);
       }
     }
-  }, 5000);
+  }, 2000);
 };
 
 export const initCompleted = computed(
@@ -323,19 +327,36 @@ const updateCache = (
 export const wsConnections = ref<Record<string, boolean>>({});
 export const _wsConnections = ref<Record<string, boolean>>({});
 
-const updateConnectionStatus: ConnStatusFn = (
+// set the connections from the shared web worker
+// when i am the only tab, this is a no-op
+// and the WS starting up will fill me in below
+// when i am a second tab without a db lock, i wont get any new WS
+// so i need to learn what i am connected to
+db.getConnections().then((conns) => {
+  Object.entries(conns).forEach(([k, v]) => {
+    _wsConnections.value[k] = v;
+    wsConnections.value[k] = v;
+  });
+});
+
+const updateConnectionStatus: ConnStatusFn = async (
   workspaceId: WorkspacePk,
   connected: boolean,
   noBroadcast?: boolean,
 ) => {
   _wsConnections.value[workspaceId] = connected;
 
-  // prevent blips in the UI
+  // always update to connected
+  if (connected) wsConnections.value[workspaceId] = connected;
+
+  await db.setConnections({ ..._wsConnections.value });
+
+  // prevent blips in the UI from quick disconnect -> connect flips
   setTimeout(() => {
     Object.entries(_wsConnections.value).forEach(([k, v]) => {
       wsConnections.value[k] = v;
     });
-  }, 7 * 1000);
+  }, 3 * 1000);
 
   if (!noBroadcast) {
     db.broadcastMessage({
@@ -400,12 +421,16 @@ const atomUpdated: UpdateFn = (
 };
 
 export const indexFailures = reactive(new Set<string>());
+export const indexTouches = reactive(new Map<string, number>());
 
 const lobbyExit: LobbyExitFn = async (
   workspaceId: WorkspacePk,
   changeSetId: ChangeSetId,
   noBroadcast?: boolean,
 ) => {
+  // keep track of each change set's index touch
+  indexTouches.set(changeSetId, Date.now());
+
   // Only navigate away from lobby if user is currently in the lobby
   // for this change set
   if (muspelheimStatuses.value[changeSetId] === true) {
@@ -827,7 +852,7 @@ export const muspelheim = async (workspaceId: WorkspacePk, force?: boolean) => {
     muspelheimStatuses.value[changeSet.id] = false;
   }
 
-  await niflheim(workspaceId, baseChangeSetId, force);
+  await niflheim(workspaceId, baseChangeSetId, force, true);
 
   niflheimQueue.add(async () => {
     await vanaheim(workspaceId);
@@ -838,7 +863,7 @@ export const muspelheim = async (workspaceId: WorkspacePk, force?: boolean) => {
     }
 
     const run = async () => {
-      await niflheim(workspaceId, changeSet.id, force);
+      await niflheim(workspaceId, changeSet.id, force, true);
     };
     niflheimQueue.add(run);
   }
@@ -857,12 +882,24 @@ export const registerBearerToken = async (
   await db.setBearer(workspaceId, bearerToken);
 };
 
+export const syncAtoms = async (
+  workspaceId: WorkspacePk,
+  changeSetId: ChangeSetId,
+): Promise<void> => {
+  await waitForInitCompletion();
+  // eslint-disable-next-line no-console
+  await db.syncAtoms(workspaceId, changeSetId);
+};
+
 // cold start
+const FIVE_MIN = 1000 * 60 * 5;
+const buildingRetryIntervals = {} as Record<string, NodeJS.Timeout>;
 export const niflheim = async (
   workspaceId: WorkspacePk,
   changeSetId: ChangeSetId,
   force = false,
   lobbyOnFailure = true,
+  retryOnBuilding = false,
 ): Promise<-1 | 0 | 1> => {
   await waitForInitCompletion();
   const start = performance.now();
@@ -880,6 +917,27 @@ export const niflheim = async (
     // Index is being rebuilt and is not ready yet.
     if (success === 0 && lobbyOnFailure) {
       muspelheimStatuses.value[changeSetId] = false;
+      // there is an outside chance that the system will fail to send a wsevent
+      // (incident, poor timing of a deploy, etc etc)
+      // to the web worker that tells it the index has been built successfully
+      // so we have a backup cold start interval here
+      // to prevent a user from being stuck in the lobby perpetually
+      if (retryOnBuilding) {
+        const interval = setInterval(async () => {
+          const success = await niflheim(
+            workspaceId,
+            changeSetId,
+            force,
+            lobbyOnFailure,
+            false,
+          );
+          if (success === 1) {
+            const interval = buildingRetryIntervals[changeSetId];
+            clearInterval(interval);
+          }
+        }, FIVE_MIN);
+        buildingRetryIntervals[changeSetId] = interval;
+      }
     } else if (success === 1 || success === -1) {
       // add a failure state for this change set
       if (success === -1) indexFailures.add(changeSetId);
@@ -887,9 +945,13 @@ export const niflheim = async (
       // so we shouldn't block them in the lobby b/c this is never going to load.
       muspelheimStatuses.value[changeSetId] = true;
     }
+    const interval = buildingRetryIntervals[changeSetId];
+    if (success === 1 && interval) clearInterval(interval);
     return success;
   }
 
+  const interval = buildingRetryIntervals[changeSetId];
+  if (interval) clearInterval(interval);
   return 1;
 };
 
diff --git a/app/web/src/workers/shared_webworker.ts b/app/web/src/workers/shared_webworker.ts
index f51461b5a0..b3ba4711d3 100644
--- a/app/web/src/workers/shared_webworker.ts
+++ b/app/web/src/workers/shared_webworker.ts
@@ -120,6 +120,7 @@ async function withLeader<R>(
 }
 
 const clientInterest: Record<string, number> = {};
+const connectionStatus: Record<string, boolean> = {};
 
 const dbInterface: SharedDBInterface = {
   async broadcastMessage(message: BroadcastMessage) {
@@ -236,6 +237,16 @@ const dbInterface: SharedDBInterface = {
     });
   },
 
+  async setConnections(connections: Record<string, boolean>) {
+    Object.entries(connections).forEach(([k, v]) => {
+      connectionStatus[k] = v;
+    });
+  },
+
+  async getConnections() {
+    return connectionStatus;
+  },
+
   async initSocket(workspaceId: string): Promise<void> {
     await withLeader(async (remote) => await remote.initSocket(workspaceId));
   },
@@ -434,6 +445,12 @@ const dbInterface: SharedDBInterface = {
     );
   },
 
+  async syncAtoms(workspaceId: string, changeSetId: string): Promise<void> {
+    return await withLeader(
+      async (remote) => await remote.syncAtoms(workspaceId, changeSetId),
+    );
+  },
+
   async vanaheim(workspaceId: string): Promise<boolean> {
     return await withLeader(
       async (remote) => await remote.vanaheim(workspaceId),
diff --git a/app/web/src/workers/types/dbinterface.ts b/app/web/src/workers/types/dbinterface.ts
index c71890023c..199530fd75 100644
--- a/app/web/src/workers/types/dbinterface.ts
+++ b/app/web/src/workers/types/dbinterface.ts
@@ -254,12 +254,15 @@ export interface SharedDBInterface {
     checksum?: Checksum,
   ): Promise<void>;
   showInterest(workspaceId: string, changeSetId: ChangeSetId): Promise<void>;
+  setConnections(connections: Record<string, boolean>): Promise<void>;
+  getConnections(): Promise<Record<string, boolean>>;
 
   changeSetExists(
     workspaceId: string,
     changeSetId: ChangeSetId,
   ): Promise<boolean>;
   niflheim(workspaceId: string, changeSetId: ChangeSetId): Promise<-1 | 0 | 1>;
+  syncAtoms(workspaceId: string, changeSetId: ChangeSetId): Promise<void>;
   vanaheim(workspaceId: string): Promise<boolean>;
   exec(
     opts: ExecBaseOptions &
@@ -402,6 +405,7 @@ export interface TabDBInterface {
     changeSetId: ChangeSetId,
   ): Promise<boolean>;
   niflheim(workspaceId: string, changeSetId: ChangeSetId): Promise<-1 | 0 | 1>;
+  syncAtoms(workspaceId: string, changeSetId: ChangeSetId): Promise<void>;
   vanaheim(workspaceId: string): Promise<boolean>;
   pruneAtomsForClosedChangeSet(
     workspaceId: WorkspacePk,
diff --git a/app/web/src/workers/utils.ts b/app/web/src/workers/utils.ts
new file mode 100644
index 0000000000..9dcd216e57
--- /dev/null
+++ b/app/web/src/workers/utils.ts
@@ -0,0 +1,92 @@
+import * as _ from "lodash-es";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+type AnyFn = (...args: any[]) => any;
+
+export interface MemoizeDebouncedFn<F extends AnyFn>
+  extends _.DebouncedFunc<F> {
+  (...args: Parameters<F>): ReturnType<F> | undefined;
+  flush: (...args: Parameters<F>) => ReturnType<F> | undefined;
+  cancel: (...args: Parameters<F>) => void;
+}
+/**
+ * Debounce based on args to the fn
+ */
+export function memoizeDebounce<F extends AnyFn>(
+  func: F,
+  wait = 0,
+  options: _.DebounceSettings = {},
+  resolver?: (...args: Parameters<F>) => unknown,
+): MemoizeDebouncedFn<F> {
+  const dbMemo = _.memoize<(...args: Parameters<F>) => _.DebouncedFunc<F>>(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    (..._args: Parameters<F>) => _.debounce(func, wait, options),
+    resolver,
+  );
+
+  function wrappedFn(
+    this: MemoizeDebouncedFn<F>,
+    ...args: Parameters<F>
+  ): ReturnType<F> | undefined {
+    return dbMemo(...args)(...args);
+  }
+
+  const flush: MemoizeDebouncedFn<F>["flush"] = (...args) => {
+    return dbMemo(...args).flush();
+  };
+
+  const cancel: MemoizeDebouncedFn<F>["cancel"] = (...args) => {
+    return dbMemo(...args).cancel();
+  };
+
+  wrappedFn.flush = flush;
+  wrappedFn.cancel = cancel;
+
+  return wrappedFn;
+}
+
+/**
+ * Throttle based on args to the fn
+ */
+export function memoizeThrottle<F extends AnyFn>(
+  func: F,
+  wait = 0,
+  options: _.ThrottleSettings = {},
+  resolver?: (...args: Parameters<F>) => unknown,
+): MemoizeDebouncedFn<F> {
+  // const memoized = _.memoize((...args: Parameters<F>) => {
+  //   // The memoized key is used to create a new throttled instance
+  //   const throttled = _.throttle(func, wait, options);
+  //   return throttled(...args);
+  // }, resolver); // Use the resolver to define the cache key
+
+  // return memoized;
+
+  const throttleMemo = _.memoize<
+    (...args: Parameters<F>) => _.DebouncedFunc<F>
+  >(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    (..._args: Parameters<F>) => _.throttle(func, wait, options),
+    resolver,
+  );
+
+  function wrappedFn(
+    this: MemoizeDebouncedFn<F>,
+    ...args: Parameters<F>
+  ): ReturnType<F> | undefined {
+    return throttleMemo(...args)(...args);
+  }
+
+  const flush: MemoizeDebouncedFn<F>["flush"] = (...args) => {
+    return throttleMemo(...args).flush();
+  };
+
+  const cancel: MemoizeDebouncedFn<F>["cancel"] = (...args) => {
+    return throttleMemo(...args).cancel();
+  };
+
+  wrappedFn.flush = flush;
+  wrappedFn.cancel = cancel;
+
+  return wrappedFn;
+}
diff --git a/app/web/src/workers/webworker.ts b/app/web/src/workers/webworker.ts
index fa22cbf221..345ee4d78b 100644
--- a/app/web/src/workers/webworker.ts
+++ b/app/web/src/workers/webworker.ts
@@ -39,6 +39,7 @@ import { DefaultMap } from "@/utils/defaultmap";
 import { AttributePath, ComponentId } from "@/api/sdf/dal/component";
 import { WorkspacePk } from "@/api/sdf/dal/workspace";
 import { ViewId } from "@/api/sdf/dal/views";
+import { memoizeThrottle } from "@/workers/utils";
 import {
   WorkspaceAtom,
   AtomDocument,
@@ -1029,6 +1030,7 @@ const handleIndexMvPatch = async (db: Database, msg: WorkspaceIndexUpdate) => {
   await tracer.startActiveSpan("IndexMvPatch", async (span) => {
     if (!msg.patch) {
       span.setAttribute("no_patch", true);
+      span.end();
       return;
     }
 
@@ -2685,10 +2687,11 @@ const writeDeploymentAtoms = async (db: Database, atoms: AtomWithData[]) => {
   await dbWrite(db, { sql, bind });
 };
 
-const niflheim = async (
+const _niflheim = async (
   db: Database,
   workspaceId: string,
   changeSetId: ChangeSetId,
+  bootstrap = true,
 ): Promise<-1 | 0 | 1> => {
   // NOTE, we are using this integer return type because we can't handle exceptions over the thread boundary
   return await tracer.startActiveSpan("niflheim", async (span: Span) => {
@@ -2801,23 +2804,14 @@ const niflheim = async (
         false,
         false,
       );
-
-      await bustCacheAndReferences(
-        db,
-        workspaceId,
-        changeSetId,
-        atom.kind,
-        atom.id,
-        false,
-        true,
-      );
     };
 
     for (const atom of finalAtoms) {
       // Atom is in the database, but not in the index? Delete it
       if (!atomSet.has(atomCacheKey(atom))) {
         atomsToUnlink.push(atom);
-      } else {
+      } else if (bootstrap) {
+        // When we are not bootstrapping we dont need to pre process what we already have
         // Placing this in a promise to yield control back to the event loop
         await processAtom(atom);
       }
@@ -2867,6 +2861,25 @@ const niflheim = async (
   });
 };
 
+const niflheim = async (
+  db: Database,
+  workspaceId: string,
+  changeSetId: ChangeSetId,
+): Promise<-1 | 0 | 1> => _niflheim(db, workspaceId, changeSetId, true);
+
+type ColdStartArgs = Parameters<typeof niflheim>;
+const THIRY_SECONDS = 30 * 1000;
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const syncAtoms = (...args: ColdStartArgs) =>
+  memoizeThrottle(
+    (...args: ColdStartArgs): void => {
+      _niflheim(...args, false);
+    },
+    THIRY_SECONDS,
+    { trailing: true },
+    (...args: ColdStartArgs) => `${args[1]}-${args[2]}`,
+  );
+
 const ragnarok = async (
   db: Database,
   workspaceId: string,
@@ -4409,9 +4422,15 @@ const dbInterface: TabDBInterface = {
     let interval: NodeJS.Timeout;
     sockets[workspaceId]?.addEventListener("close", () => {
       if (interval) clearInterval(interval);
+      const span = tracer.startSpan("ws_close");
+      span.setAttributes({ workspaceId });
+      span.end();
       updateConnectionStatus(workspaceId, false);
     });
     sockets[workspaceId]?.addEventListener("open", () => {
+      const span = tracer.startSpan("ws_open");
+      span.setAttributes({ workspaceId });
+      span.end();
       updateConnectionStatus(workspaceId, true);
       // heartbeat ping
       interval = setInterval(() => {
@@ -4794,6 +4813,14 @@ const dbInterface: TabDBInterface = {
       async (db) => await niflheim(db, workspaceId, changeSetId),
     );
   },
+  async syncAtoms(workspaceId, changeSetId) {
+    if (!sqlite) {
+      throw new Error(DB_NOT_INIT_ERR);
+    }
+    return sqlite.transaction((db) => {
+      syncAtoms(db, workspaceId, changeSetId)(db, workspaceId, changeSetId);
+    });
+  },
   encodeDocumentForDB,
   decodeDocumentFromDB,
   handleDeploymentPatchMessage(data) {