@githolon/runtime 0.112.7 → 0.112.11

package/dist/nomos-runner-web.js

@@ -0,0 +1,145 @@
+"use strict";
+(() => {
+  // ../../platform-shells/browser/worker_page_entry.ts
+  var worker;
+  var booting;
+  var bootResolve;
+  var bootReject;
+  var nextId = 0;
+  var lastSnapshot;
+  var closing;
+  var closeResolve;
+  var closeReject;
+  var pending = /* @__PURE__ */ new Map();
+  var send = (message) => worker.postMessage(message);
+  var fail = (error) => {
+    bootReject?.(error);
+    bootResolve = void 0;
+    bootReject = void 0;
+    booting = void 0;
+    for (const waiting of pending.values()) waiting.reject(error);
+    pending.clear();
+    closeReject?.(error);
+    closeResolve = void 0;
+    closeReject = void 0;
+    closing = void 0;
+    worker?.terminate();
+    worker = void 0;
+  };
+  var receive = (message) => {
+    switch (message.kind) {
+      case "boot-progress":
+        console.debug("[nomos-peer-boot]", message.stage);
+        break;
+      case "custody-perf":
+        console.debug("[nomos-custody-perf]", JSON.stringify(message.timing));
+        break;
+      case "booted":
+        bootResolve?.();
+        bootResolve = void 0;
+        bootReject = void 0;
+        break;
+      case "boot-failed":
+        fail(new Error(message.error));
+        break;
+      case "disposed":
+        if (message.error) closeReject?.(new Error(message.error));
+        else closeResolve?.();
+        closeResolve = void 0;
+        closeReject = void 0;
+        closing = void 0;
+        worker?.terminate();
+        worker = void 0;
+        booting = void 0;
+        lastSnapshot = void 0;
+        break;
+      case "invoked": {
+        const waiting = pending.get(message.id);
+        if (!waiting) break;
+        pending.delete(message.id);
+        if (message.error) waiting.reject(new Error(message.error));
+        else if (message.frame !== void 0) waiting.resolve(message.frame);
+        else waiting.reject(new Error("Nomos peer returned no Runtime v2 frame"));
+        break;
+      }
+      case "effect":
+        void (async () => {
+          try {
+            if (!window.__nomosPerformEffect) throw new Error("The browser host cannot perform background effects. Update the application and reload.");
+            const receipt = await window.__nomosPerformEffect(message.pending);
+            send({ kind: "effect-receipt", id: message.id, receipt });
+          } catch (error) {
+            if (worker) send({ kind: "effect-receipt", id: message.id, error: error instanceof Error ? error.message : String(error) });
+          }
+        })();
+        break;
+      case "event":
+        window.__nomosOnMessage?.(`runtime-v2-event:${message.frame}`);
+        break;
+      case "kernel-work":
+        if (message.snapshot) lastSnapshot = message.snapshot;
+        try {
+          window.__nomosKernelWorkChanged?.(message.active);
+        } catch {
+        }
+        break;
+    }
+  };
+  window.__nomosBootRuntime = (base) => {
+    if (closing) return closing.then(() => window.__nomosBootRuntime(base));
+    if (worker && !bootResolve) return booting ?? Promise.resolve();
+    if (booting) return booting;
+    const url = window.__nomosWorkerUrl;
+    if (!url) return Promise.reject(new Error("Nomos Web Worker URL is not configured"));
+    try {
+      console.debug("[nomos-peer-boot]", "starting worker", url);
+      worker = new Worker(url);
+      worker.onmessage = (event) => receive(event.data);
+      worker.onerror = (event) => {
+        console.error("[nomos-peer-boot]", "worker error", event.message);
+        fail(new Error(`Nomos Web Worker failed: ${event.message}`));
+      };
+      worker.onmessageerror = () => fail(new Error("Nomos Web Worker sent an unreadable message"));
+      booting = new Promise((resolve, reject) => {
+        bootResolve = resolve;
+        bootReject = reject;
+      });
+      send({ kind: "boot", base });
+    } catch (error) {
+      fail(error instanceof Error ? error : new Error(String(error)));
+      return Promise.reject(error);
+    }
+    return booting;
+  };
+  window.__nomosInvokeFrame = (frameBase64) => {
+    if (!worker || bootResolve) return Promise.reject(new Error("Nomos peer runtime is not booted"));
+    const id = ++nextId;
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      send({ kind: "invoke", id, frame: frameBase64 });
+    });
+  };
+  window.__nomosKernelWorkSnapshot = () => lastSnapshot;
+  window.__nomosWorkerHosted = true;
+  window.__nomosDisposeRuntime = () => {
+    if (!worker) return Promise.resolve();
+    if (closing) return closing;
+    bootReject?.(new Error("Nomos peer runtime disposed during boot"));
+    bootResolve = void 0;
+    bootReject = void 0;
+    for (const waiting of pending.values()) waiting.reject(new Error("Nomos peer runtime disposed"));
+    pending.clear();
+    closing = new Promise((resolve, reject) => {
+      closeResolve = resolve;
+      closeReject = reject;
+    });
+    send({ kind: "dispose" });
+    return closing;
+  };
+  window.NomosRunner = {
+    version: 2,
+    dispose: () => {
+      void window.__nomosDisposeRuntime?.();
+    }
+  };
+})();