@mandujs/core 0.53.3 → 0.54.0

package/src/desktop/worker.ts

@@ -1,180 +1,180 @@
-/**
- * @mandujs/core/desktop — Worker entry
- *
- * Canonical Worker body that owns a single Webview instance. Import as a
- * module URL to spawn alongside a Mandu HTTP server on the main thread:
- *
- * @example
- * ```ts
- * // main.ts  — main thread owns the Bun.serve() instance
- * import { startServer } from "@mandujs/core";
- * import manifest from "../../.mandu/manifest.json" with { type: "json" };
- *
- * const server = startServer(manifest, { port: 0, hostname: "127.0.0.1" });
- *
- * // Worker owns the Webview — its blocking `run()` never competes with
- * // `Bun.serve()` for the event loop on the main thread.
- * const worker = new Worker(
- *   new URL("@mandujs/core/desktop/worker", import.meta.url),
- * );
- *
- * worker.postMessage({
- *   type: "open",
- *   options: {
- *     url: `http://127.0.0.1:${server.server.port}`,
- *     title: "Mandu Desktop",
- *     width: 1280,
- *     height: 800,
- *   },
- * });
- *
- * worker.onmessage = (ev) => {
- *   if (ev.data?.type === "closed") {
- *     server.stop();
- *     process.exit(0);
- *   }
- * };
- * ```
- *
- * Protocol — exact shapes in `./types.ts`:
- *   - Parent → Worker: `{ type: "open", options }` | `{ type: "close" }` | `{ type: "eval", js }`
- *   - Worker → Parent: `{ type: "ready" }` | `{ type: "closed" }` | `{ type: "error", message }`
- *                    | `{ type: "bind-call", name, args, seq }` — reserved for bidirectional bind bridges
- *
- * Functions (bind handlers, onReady, onClose) do NOT cross the `postMessage`
- * boundary — structured clone cannot serialize them. Authoring a Worker with
- * bound handlers requires copying this file into the app and registering
- * handlers locally inside the Worker thread.
- */
-
-import type { WorkerInbound, WorkerOutbound } from "./types.js";
-import { createWindow } from "./window.js";
-import type { WindowHandle } from "./types.js";
-
-/**
- * Safely post a message to the parent. Bun's Worker global type does not
- * export `postMessage` on `self` in all strictness modes, so we gate on it.
- *
- * @internal
- */
-export function _postToParent(msg: WorkerOutbound): void {
-  const gPost = (globalThis as { postMessage?: (msg: unknown) => void })
-    .postMessage;
-  if (typeof gPost === "function") {
-    gPost(msg);
-  }
-}
-
-/**
- * Install the worker message handler. Split out so tests can construct a
- * mock message-event emitter without actually spawning a Worker.
- *
- * @internal
- */
-export function _installHandler(
-  addListener: (
-    cb: (ev: { data: WorkerInbound }) => Promise<void> | void,
-  ) => void,
-  createWindowImpl: typeof createWindow = createWindow,
-): { getHandle: () => WindowHandle | null } {
-  let handle: WindowHandle | null = null;
-  let running = false;
-
-  addListener(async (ev) => {
-    const msg = ev?.data;
-    if (!msg || typeof msg !== "object") return;
-
-    try {
-      switch (msg.type) {
-        case "open": {
-          if (handle) {
-            _postToParent({
-              type: "error",
-              message: "Window already open — ignoring duplicate 'open'.",
-            });
-            return;
-          }
-          handle = await createWindowImpl(msg.options);
-          _postToParent({ type: "ready" });
-
-          // Block the Worker thread on `run()`. When the window closes we
-          // report back and let the parent decide whether to process.exit().
-          // We wrap in a microtask to unblock the postMessage pipeline; the
-          // subsequent `run()` is synchronous-blocking by design.
-          if (!running) {
-            running = true;
-            queueMicrotask(() => {
-              try {
-                handle!.run();
-              } catch (error) {
-                _postToParent({
-                  type: "error",
-                  message: `window.run() threw: ${
-                    error instanceof Error ? error.message : String(error)
-                  }`,
-                });
-              } finally {
-                _postToParent({ type: "closed" });
-              }
-            });
-          }
-          return;
-        }
-
-        case "close": {
-          if (!handle) return;
-          await handle.close();
-          return;
-        }
-
-        case "eval": {
-          if (!handle) {
-            _postToParent({
-              type: "error",
-              message: "eval received before 'open'.",
-            });
-            return;
-          }
-          await handle.eval(msg.js);
-          return;
-        }
-
-        default: {
-          const unknownType = (msg as { type?: string }).type ?? "<missing>";
-          _postToParent({
-            type: "error",
-            message: `Unknown message type: ${unknownType}`,
-          });
-        }
-      }
-    } catch (error) {
-      _postToParent({
-        type: "error",
-        message: error instanceof Error ? error.message : String(error),
-      });
-    }
-  });
-
-  return {
-    getHandle() {
-      return handle;
-    },
-  };
-}
-
-// Install the handler on module evaluation — Bun Worker entries run this
-// module body on spawn. We gate on `addEventListener` presence so the file
-// can still be imported from a non-Worker context (tests, type-checking).
-// Bun's Worker global has `addEventListener("message", ...)` but omits the
-// `on`-prefixed shim; we use the standard DOM-style name.
-{
-  const gAdd = (globalThis as {
-    addEventListener?: (
-      type: string,
-      listener: (ev: { data: WorkerInbound }) => void | Promise<void>,
-    ) => void;
-  }).addEventListener;
-  if (typeof gAdd === "function") {
-    _installHandler((cb) => gAdd.call(globalThis, "message", cb));
-  }
-}
+/**
+ * @mandujs/core/desktop — Worker entry
+ *
+ * Canonical Worker body that owns a single Webview instance. Import as a
+ * module URL to spawn alongside a Mandu HTTP server on the main thread:
+ *
+ * @example
+ * ```ts
+ * // main.ts  — main thread owns the Bun.serve() instance
+ * import { startServer } from "@mandujs/core";
+ * import manifest from "../../.mandu/manifest.json" with { type: "json" };
+ *
+ * const server = startServer(manifest, { port: 0, hostname: "127.0.0.1" });
+ *
+ * // Worker owns the Webview — its blocking `run()` never competes with
+ * // `Bun.serve()` for the event loop on the main thread.
+ * const worker = new Worker(
+ *   new URL("@mandujs/core/desktop/worker", import.meta.url),
+ * );
+ *
+ * worker.postMessage({
+ *   type: "open",
+ *   options: {
+ *     url: `http://127.0.0.1:${server.server.port}`,
+ *     title: "Mandu Desktop",
+ *     width: 1280,
+ *     height: 800,
+ *   },
+ * });
+ *
+ * worker.onmessage = (ev) => {
+ *   if (ev.data?.type === "closed") {
+ *     server.stop();
+ *     process.exit(0);
+ *   }
+ * };
+ * ```
+ *
+ * Protocol — exact shapes in `./types.ts`:
+ *   - Parent → Worker: `{ type: "open", options }` | `{ type: "close" }` | `{ type: "eval", js }`
+ *   - Worker → Parent: `{ type: "ready" }` | `{ type: "closed" }` | `{ type: "error", message }`
+ *                    | `{ type: "bind-call", name, args, seq }` — reserved for bidirectional bind bridges
+ *
+ * Functions (bind handlers, onReady, onClose) do NOT cross the `postMessage`
+ * boundary — structured clone cannot serialize them. Authoring a Worker with
+ * bound handlers requires copying this file into the app and registering
+ * handlers locally inside the Worker thread.
+ */
+
+import type { WorkerInbound, WorkerOutbound } from "./types.js";
+import { createWindow } from "./window.js";
+import type { WindowHandle } from "./types.js";
+
+/**
+ * Safely post a message to the parent. Bun's Worker global type does not
+ * export `postMessage` on `self` in all strictness modes, so we gate on it.
+ *
+ * @internal
+ */
+export function _postToParent(msg: WorkerOutbound): void {
+  const gPost = (globalThis as { postMessage?: (msg: unknown) => void })
+    .postMessage;
+  if (typeof gPost === "function") {
+    gPost(msg);
+  }
+}
+
+/**
+ * Install the worker message handler. Split out so tests can construct a
+ * mock message-event emitter without actually spawning a Worker.
+ *
+ * @internal
+ */
+export function _installHandler(
+  addListener: (
+    cb: (ev: { data: WorkerInbound }) => Promise<void> | void,
+  ) => void,
+  createWindowImpl: typeof createWindow = createWindow,
+): { getHandle: () => WindowHandle | null } {
+  let handle: WindowHandle | null = null;
+  let running = false;
+
+  addListener(async (ev) => {
+    const msg = ev?.data;
+    if (!msg || typeof msg !== "object") return;
+
+    try {
+      switch (msg.type) {
+        case "open": {
+          if (handle) {
+            _postToParent({
+              type: "error",
+              message: "Window already open — ignoring duplicate 'open'.",
+            });
+            return;
+          }
+          handle = await createWindowImpl(msg.options);
+          _postToParent({ type: "ready" });
+
+          // Block the Worker thread on `run()`. When the window closes we
+          // report back and let the parent decide whether to process.exit().
+          // We wrap in a microtask to unblock the postMessage pipeline; the
+          // subsequent `run()` is synchronous-blocking by design.
+          if (!running) {
+            running = true;
+            queueMicrotask(() => {
+              try {
+                handle!.run();
+              } catch (error) {
+                _postToParent({
+                  type: "error",
+                  message: `window.run() threw: ${
+                    error instanceof Error ? error.message : String(error)
+                  }`,
+                });
+              } finally {
+                _postToParent({ type: "closed" });
+              }
+            });
+          }
+          return;
+        }
+
+        case "close": {
+          if (!handle) return;
+          await handle.close();
+          return;
+        }
+
+        case "eval": {
+          if (!handle) {
+            _postToParent({
+              type: "error",
+              message: "eval received before 'open'.",
+            });
+            return;
+          }
+          await handle.eval(msg.js);
+          return;
+        }
+
+        default: {
+          const unknownType = (msg as { type?: string }).type ?? "<missing>";
+          _postToParent({
+            type: "error",
+            message: `Unknown message type: ${unknownType}`,
+          });
+        }
+      }
+    } catch (error) {
+      _postToParent({
+        type: "error",
+        message: error instanceof Error ? error.message : String(error),
+      });
+    }
+  });
+
+  return {
+    getHandle() {
+      return handle;
+    },
+  };
+}
+
+// Install the handler on module evaluation — Bun Worker entries run this
+// module body on spawn. We gate on `addEventListener` presence so the file
+// can still be imported from a non-Worker context (tests, type-checking).
+// Bun's Worker global has `addEventListener("message", ...)` but omits the
+// `on`-prefixed shim; we use the standard DOM-style name.
+{
+  const gAdd = (globalThis as {
+    addEventListener?: (
+      type: string,
+      listener: (ev: { data: WorkerInbound }) => void | Promise<void>,
+    ) => void;
+  }).addEventListener;
+  if (typeof gAdd === "function") {
+    _installHandler((cb) => gAdd.call(globalThis, "message", cb));
+  }
+}