Use inline workers (?worker&inline) for simulation and language server

Vite library mode emits worker assets as separate files that consumers
can't resolve. Using ?worker&inline inlines the compiled worker code as
a string and creates a Blob URL at runtime, making workers self-contained
in the library bundle.

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

Author: kube

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

@@ -12,6 +12,15 @@ import type {
   SignatureHelp,
 } from "./protocol";
 
+/** Dynamically import and instantiate the language server worker (inlined as blob URL). */
+async function createLanguageServerWorker() {
+  const LanguageServerWorker = await import(
+    "./language-server.worker.ts?worker&inline"
+  );
+  // eslint-disable-next-line new-cap
+  return new LanguageServerWorker.default();
+}
+
 type Pending = {
   resolve: (result: never) => void;
   reject: (error: Error) => void;
@@ -56,40 +65,38 @@ export function useLanguageClient(): LanguageClientApi {
   >(null);
 
   useEffect(() => {
-    const worker = new Worker(
-      new URL("./language-server.worker.ts", import.meta.url),
-      {
-        type: "module",
-      },
-    );
-
-    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;
+    void (async () => {
+      const worker = await createLanguageServerWorker();
+
+      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);
+
+          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);
         }
-        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);
-      }
-    };
+      workerRef.current = worker;
+    })();
 
-    workerRef.current = worker;
     const pending = pendingRef.current;
 
     return () => {
-      worker.terminate();
+      workerRef.current?.terminate();
       workerRef.current = null;
       for (const entry of pending.values()) {
         entry.reject(new Error("Worker terminated"));

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

@@ -16,6 +16,13 @@ import type { SDCPN } from "../../core/types/sdcpn";
 import type { InitialMarking, SimulationFrame } from "../context";
 import type { ToMainMessage, ToWorkerMessage } from "./messages";
 
+/** Dynamically import and instantiate the simulation worker (inlined as blob URL). */
+async function createSimulationWorker(): Promise<Worker> {
+  const SimulationWorker = await import("./simulation.worker.ts?worker&inline");
+  // eslint-disable-next-line new-cap
+  return new SimulationWorker.default();
+}
+
 /**
  * Status of the simulation worker.
  */
@@ -127,84 +134,83 @@ export function useSimulationWorker(): {
 
   // Initialize worker on mount
   useEffect(() => {
-    const worker = new Worker(
-      new URL("./simulation.worker.ts", import.meta.url),
-      { type: "module" },
-    );
-
-    worker.onmessage = (event: MessageEvent<ToMainMessage>) => {
-      const message = event.data;
-
-      switch (message.type) {
-        case "ready":
-          setState((prev) => ({
-            ...prev,
-            status: prev.status === "initializing" ? "ready" : prev.status,
-          }));
-          // Resolve pending initialization promise
-          if (pendingInitRef.current) {
-            pendingInitRef.current.resolve();
-            pendingInitRef.current = null;
-          }
-          break;
-
-        case "frame":
-          setState((prev) => ({
-            ...prev,
-            frames: [...prev.frames, message.frame],
-          }));
-          break;
-
-        case "frames":
-          setState((prev) => ({
-            ...prev,
-            frames: [...prev.frames, ...message.frames],
-          }));
-          break;
-
-        case "complete":
-          setState((prev) => ({
-            ...prev,
-            status: "complete",
-          }));
-          break;
-
-        case "paused":
-          setState((prev) => ({
-            ...prev,
-            status: "paused",
-          }));
-          break;
-
-        case "error":
-          setState((prev) => ({
-            ...prev,
-            status: "error",
-            error: message.message,
-            errorItemId: message.itemId,
-          }));
-          // Reject pending initialization promise if this error occurred during init
-          if (pendingInitRef.current) {
-            pendingInitRef.current.reject(new Error(message.message));
-            pendingInitRef.current = null;
-          }
-          break;
-      }
-    };
-
-    worker.onerror = (error) => {
-      setState((prev) => ({
-        ...prev,
-        status: "error",
-        error: error.message || "Worker error",
-        errorItemId: null,
-      }));
-    };
-
-    workerRef.current = worker;
+    void (async () => {
+      const worker = await createSimulationWorker();
+
+      worker.onmessage = (event: MessageEvent<ToMainMessage>) => {
+        const message = event.data;
+
+        switch (message.type) {
+          case "ready":
+            setState((prev) => ({
+              ...prev,
+              status: prev.status === "initializing" ? "ready" : prev.status,
+            }));
+            // Resolve pending initialization promise
+            if (pendingInitRef.current) {
+              pendingInitRef.current.resolve();
+              pendingInitRef.current = null;
+            }
+            break;
+
+          case "frame":
+            setState((prev) => ({
+              ...prev,
+              frames: [...prev.frames, message.frame],
+            }));
+            break;
+
+          case "frames":
+            setState((prev) => ({
+              ...prev,
+              frames: [...prev.frames, ...message.frames],
+            }));
+            break;
+
+          case "complete":
+            setState((prev) => ({
+              ...prev,
+              status: "complete",
+            }));
+            break;
+
+          case "paused":
+            setState((prev) => ({
+              ...prev,
+              status: "paused",
+            }));
+            break;
+
+          case "error":
+            setState((prev) => ({
+              ...prev,
+              status: "error",
+              error: message.message,
+              errorItemId: message.itemId,
+            }));
+            // Reject pending initialization promise if this error occurred during init
+            if (pendingInitRef.current) {
+              pendingInitRef.current.reject(new Error(message.message));
+              pendingInitRef.current = null;
+            }
+            break;
+        }
+      };
+
+      worker.onerror = (error) => {
+        setState((prev) => ({
+          ...prev,
+          status: "error",
+          error: error.message || "Worker error",
+          errorItemId: null,
+        }));
+      };
+
+      workerRef.current = worker;
+    })();
 
     return () => {
-      worker.terminate();
+      workerRef.current?.terminate();
     };
   }, []);