Fix worker race conditions, use addEventListener, and clean up turbo config

- Add message queue in useLanguageClient so messages sent before async
  worker init are drained once the worker is ready
- Add terminated flag to both worker hooks to prevent leaking workers
  if the component unmounts before the dynamic import resolves
- Reject pending init promise on teardown in useSimulationWorker
- Switch worker.onmessage/onerror to addEventListener for eslint compliance
- Extract createSimulationWorker into its own module for clean test mocking
- Update test suite to use async mocks via vi.mock instead of vi.stubGlobal
- Set sideEffects: ["*.css"] instead of false to prevent CSS tree-shaking
- Remove stale build:site task from turbo.json

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: kube

libs/@hashintel/petrinaut/package.json

@@ -19,7 +19,9 @@
     "package.json"
   ],
   "type": "module",
-  "sideEffects": false,
+  "sideEffects": [
+    "*.css"
+  ],
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
   "scripts": {

libs/@hashintel/petrinaut/src/lsp/worker/use-language-client.ts

@@ -60,42 +60,58 @@ export function useLanguageClient(): LanguageClientApi {
   const workerRef = useRef<Worker | null>(null);
   const pendingRef = useRef(new Map<number, Pending>());
   const nextId = useRef(0);
+  const queueRef = useRef<object[]>([]);
   const diagnosticsCallbackRef = useRef<
     ((params: PublishDiagnosticsParams[]) => void) | null
   >(null);
 
   useEffect(() => {
-    void (async () => {
-      const worker = await createLanguageServerWorker();
+    let terminated = false;
 
-      worker.onmessage = (event: MessageEvent<ServerMessage>) => {
-        const msg = event.data;
-
-        if ("id" in msg) {
-          // Response to a request
-          const pending = pendingRef.current.get(msg.id);
-          if (!pending) {
-            return;
-          }
-          pendingRef.current.delete(msg.id);
+    void createLanguageServerWorker().then((worker) => {
+      if (terminated) {
+        worker.terminate();
+        return;
+      }
 
-          if ("error" in msg) {
-            pending.reject(new Error(msg.error.message));
-          } else {
-            pending.resolve(msg.result as never);
+      worker.addEventListener(
+        "message",
+        (event: MessageEvent<ServerMessage>) => {
+          const msg = event.data;
+
+          if ("id" in msg) {
+            // Response to a request
+            const pending = pendingRef.current.get(msg.id);
+            if (!pending) {
+              return;
+            }
+            pendingRef.current.delete(msg.id);
+
+            if ("error" in msg) {
+              pending.reject(new Error(msg.error.message));
+            } else {
+              pending.resolve(msg.result as never);
+            }
+          } else if ("method" in msg) {
+            // Server-pushed notification
+            diagnosticsCallbackRef.current?.(msg.params);
           }
-        } else if ("method" in msg) {
-          // Server-pushed notification
-          diagnosticsCallbackRef.current?.(msg.params);
-        }
-      };
+        },
+      );
 
       workerRef.current = worker;
-    })();
+
+      // Drain any messages queued before the worker was ready
+      for (const message of queueRef.current) {
+        worker.postMessage(message);
+      }
+      queueRef.current = [];
+    });
 
     const pending = pendingRef.current;
 
     return () => {
+      terminated = true;
       workerRef.current?.terminate();
       workerRef.current = null;
       for (const entry of pending.values()) {
@@ -108,7 +124,12 @@ export function useLanguageClient(): LanguageClientApi {
   // --- Notifications (fire-and-forget) ---
 
   const sendNotification = useCallback((message: Omit<ClientMessage, "id">) => {
-    workerRef.current?.postMessage(message);
+    const worker = workerRef.current;
+    if (worker) {
+      worker.postMessage(message);
+    } else {
+      queueRef.current.push(message);
+    }
   }, []);
 
   const initialize = useCallback(
@@ -147,17 +168,17 @@ export function useLanguageClient(): LanguageClientApi {
   // --- Requests (return Promise) ---
 
   const sendRequest = useCallback(<T>(message: ClientMessage): Promise<T> => {
-    const worker = workerRef.current;
-    if (!worker) {
-      return Promise.reject(new Error("Worker not initialized"));
-    }
-
     return new Promise<T>((resolve, reject) => {
       pendingRef.current.set((message as { id: number }).id, {
         resolve: resolve as (result: never) => void,
         reject,
       });
-      worker.postMessage(message);
+      const worker = workerRef.current;
+      if (worker) {
+        worker.postMessage(message);
+      } else {
+        queueRef.current.push(message);
+      }
     });
   }, []);
 

libs/@hashintel/petrinaut/src/simulation/worker/create-simulation-worker.ts

@@ -0,0 +1,6 @@
+/** Dynamically import and instantiate the simulation worker (inlined as blob URL). */
+export async function createSimulationWorker(): Promise<Worker> {
+  const SimulationWorker = await import("./simulation.worker.ts?worker&inline");
+  // eslint-disable-next-line new-cap
+  return new SimulationWorker.default();
+}