@bluelibs/runner 4.5.6 → 4.5.8

package/dist/index.d.ts

@@ -1692,11 +1692,7 @@ declare function buildTestFacade(deps: {
 declare const globals: {
     events: {
         readonly ready: IEvent<{
-            root: IResource<any, any, any, any>;
-        }>;
-        readonly unhandledError: IEvent<{
-            kind: "task" | "middleware" | "resourceInit" | "hook" | "process" | "run";
-            error: any;
+            root: IResource<any, any, any, any, any, any, any>;
         }>;
     };
     resources: {

package/dist/index.mjs

@@ -229,6 +229,211 @@ __export(errors_exports, {
   UnknownItemTypeError: () => UnknownItemTypeError,
   ValidationError: () => ValidationError
 });
+
+// src/platform/index.ts
+function detectEnvironment() {
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    return "browser";
+  }
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    return "node";
+  }
+  return "universal";
+}
+__name(detectEnvironment, "detectEnvironment");
+var _PlatformAdapter = class _PlatformAdapter {
+  constructor(env) {
+    this.isInitialized = false;
+    this.nodeALSClass = null;
+    // timers
+    this.setTimeout = globalThis.setTimeout;
+    this.clearTimeout = globalThis.clearTimeout;
+    this.env = env ?? detectEnvironment();
+  }
+  async init() {
+    if (this.env === "node") {
+      {
+        {
+          const mod = await import('async_hooks');
+          this.nodeALSClass = mod.AsyncLocalStorage;
+        }
+      }
+    }
+  }
+  onUncaughtException(handler) {
+    switch (this.env) {
+      case "node": {
+        process.on("uncaughtException", handler);
+        return () => process.off("uncaughtException", handler);
+      }
+      case "browser": {
+        const target = globalThis.window ?? globalThis;
+        const h = /* @__PURE__ */ __name((e) => handler(e?.error ?? e), "h");
+        target.addEventListener?.("error", h);
+        return () => target.removeEventListener?.("error", h);
+      }
+      default: {
+        const tgt = globalThis;
+        if (tgt.addEventListener) {
+          const h = /* @__PURE__ */ __name((e) => handler(e?.error ?? e), "h");
+          tgt.addEventListener("error", h);
+          return () => tgt.removeEventListener("error", h);
+        }
+        return () => {
+        };
+      }
+    }
+  }
+  onUnhandledRejection(handler) {
+    switch (this.env) {
+      case "node": {
+        const h = /* @__PURE__ */ __name((reason) => handler(reason), "h");
+        process.on("unhandledRejection", h);
+        return () => process.off("unhandledRejection", h);
+      }
+      case "browser": {
+        const target = globalThis.window;
+        const wrap = /* @__PURE__ */ __name((e) => handler(e.reason), "wrap");
+        target.addEventListener?.("unhandledrejection", wrap);
+        return () => target.removeEventListener?.("unhandledrejection", wrap);
+      }
+      default: {
+        const tgt = globalThis;
+        if (tgt.addEventListener) {
+          const wrap = /* @__PURE__ */ __name((e) => handler(e.reason ?? e), "wrap");
+          tgt.addEventListener("unhandledrejection", wrap);
+          return () => tgt.removeEventListener("unhandledrejection", wrap);
+        }
+        return () => {
+        };
+      }
+    }
+  }
+  onShutdownSignal(handler) {
+    switch (this.env) {
+      case "node": {
+        process.on("SIGINT", handler);
+        process.on("SIGTERM", handler);
+        return () => {
+          process.off("SIGINT", handler);
+          process.off("SIGTERM", handler);
+        };
+      }
+      case "browser": {
+        const win = window;
+        win.addEventListener?.("beforeunload", handler);
+        return () => {
+          win.removeEventListener?.("beforeunload", handler);
+        };
+      }
+      default: {
+        const tgt = globalThis;
+        const cleanup = [];
+        if (tgt.addEventListener) {
+          tgt.addEventListener("beforeunload", handler);
+          cleanup.push(
+            () => tgt.removeEventListener?.("beforeunload", handler)
+          );
+          const vis = /* @__PURE__ */ __name(() => {
+            const doc = globalThis.document;
+            if (doc && doc.visibilityState === "hidden") handler();
+          }, "vis");
+          tgt.addEventListener("visibilitychange", vis);
+          cleanup.push(
+            () => tgt.removeEventListener?.("visibilitychange", vis)
+          );
+        }
+        if (typeof process !== "undefined" && process.on) {
+          process.on("SIGINT", handler);
+          process.on("SIGTERM", handler);
+          cleanup.push(() => {
+            process.off?.("SIGINT", handler);
+            process.off?.("SIGTERM", handler);
+          });
+        }
+        return () => cleanup.forEach((fn) => fn());
+      }
+    }
+  }
+  exit(code) {
+    switch (this.env) {
+      case "node":
+        process.exit(code);
+        return;
+      default:
+        throw new PlatformUnsupportedFunction("exit");
+    }
+  }
+  getEnv(key) {
+    switch (this.env) {
+      case "node":
+        return process.env[key];
+      default: {
+        const g = globalThis;
+        if (g.__ENV__ && typeof g.__ENV__ === "object") return g.__ENV__[key];
+        if (typeof process !== "undefined" && process.env)
+          return process.env[key];
+        if (g.env && typeof g.env === "object") return g.env[key];
+        return void 0;
+      }
+    }
+  }
+  hasAsyncLocalStorage() {
+    switch (this.env) {
+      case "node":
+        return true;
+      // We'll try native, else polyfill
+      case "browser":
+      default:
+        return false;
+    }
+  }
+  createAsyncLocalStorage() {
+    switch (this.env) {
+      case "node": {
+        let instance;
+        const get = /* @__PURE__ */ __name(() => {
+          if (!instance) {
+            if (!this.nodeALSClass) {
+              throw new PlatformUnsupportedFunction(
+                "createAsyncLocalStorage: Platform not initialized"
+              );
+            }
+            instance = new this.nodeALSClass();
+          }
+          return instance;
+        }, "get");
+        return {
+          getStore: /* @__PURE__ */ __name(() => get().getStore(), "getStore"),
+          run: /* @__PURE__ */ __name((store2, callback) => get().run(store2, callback), "run")
+        };
+      }
+      case "browser":
+      default:
+        return {
+          getStore: /* @__PURE__ */ __name(() => {
+            throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
+          }, "getStore"),
+          run: /* @__PURE__ */ __name(() => {
+            throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
+          }, "run")
+        };
+    }
+  }
+};
+__name(_PlatformAdapter, "PlatformAdapter");
+var PlatformAdapter = _PlatformAdapter;
+var platformInstance = null;
+function getPlatform() {
+  if (!platformInstance) {
+    const env = detectEnvironment();
+    platformInstance = new PlatformAdapter(env);
+  }
+  return platformInstance;
+}
+__name(getPlatform, "getPlatform");
+
+// src/errors.ts
 var _RuntimeError = class _RuntimeError extends Error {
   constructor(message) {
     super(message);
@@ -387,7 +592,7 @@ var EventEmissionCycleError = _EventEmissionCycleError;
 var _PlatformUnsupportedFunction = class _PlatformUnsupportedFunction extends RuntimeError {
   constructor(functionName) {
     super(
-      `Platform function not supported in this environment: ${functionName}`
+      `Platform function not supported in this environment: ${functionName}. Detected platform: ${detectEnvironment()}.`
     );
     this.name = "PlatformUnsupportedFunction";
   }
@@ -685,202 +890,6 @@ function isOptional(definition) {
 }
 __name(isOptional, "isOptional");
 
-// src/platform/index.ts
-function detectEnvironment() {
-  if (typeof window !== "undefined" && typeof document !== "undefined") {
-    return "browser";
-  }
-  if (typeof process !== "undefined" && process.versions && process.versions.node) {
-    return "node";
-  }
-  return "universal";
-}
-__name(detectEnvironment, "detectEnvironment");
-var _PlatformAdapter = class _PlatformAdapter {
-  constructor(env) {
-    this.isInitialized = false;
-    this.nodeALSClass = null;
-    // timers
-    this.setTimeout = globalThis.setTimeout;
-    this.clearTimeout = globalThis.clearTimeout;
-    this.env = env ?? detectEnvironment();
-  }
-  async init() {
-    if (this.env === "node") ;
-  }
-  onUncaughtException(handler) {
-    switch (this.env) {
-      case "node": {
-        process.on("uncaughtException", handler);
-        return () => process.off("uncaughtException", handler);
-      }
-      case "browser": {
-        const target = globalThis.window ?? globalThis;
-        const h = /* @__PURE__ */ __name((e) => handler(e?.error ?? e), "h");
-        target.addEventListener?.("error", h);
-        return () => target.removeEventListener?.("error", h);
-      }
-      default: {
-        const tgt = globalThis;
-        if (tgt.addEventListener) {
-          const h = /* @__PURE__ */ __name((e) => handler(e?.error ?? e), "h");
-          tgt.addEventListener("error", h);
-          return () => tgt.removeEventListener("error", h);
-        }
-        return () => {
-        };
-      }
-    }
-  }
-  onUnhandledRejection(handler) {
-    switch (this.env) {
-      case "node": {
-        const h = /* @__PURE__ */ __name((reason) => handler(reason), "h");
-        process.on("unhandledRejection", h);
-        return () => process.off("unhandledRejection", h);
-      }
-      case "browser": {
-        const target = globalThis.window;
-        const wrap = /* @__PURE__ */ __name((e) => handler(e.reason), "wrap");
-        target.addEventListener?.("unhandledrejection", wrap);
-        return () => target.removeEventListener?.("unhandledrejection", wrap);
-      }
-      default: {
-        const tgt = globalThis;
-        if (tgt.addEventListener) {
-          const wrap = /* @__PURE__ */ __name((e) => handler(e.reason ?? e), "wrap");
-          tgt.addEventListener("unhandledrejection", wrap);
-          return () => tgt.removeEventListener("unhandledrejection", wrap);
-        }
-        return () => {
-        };
-      }
-    }
-  }
-  onShutdownSignal(handler) {
-    switch (this.env) {
-      case "node": {
-        process.on("SIGINT", handler);
-        process.on("SIGTERM", handler);
-        return () => {
-          process.off("SIGINT", handler);
-          process.off("SIGTERM", handler);
-        };
-      }
-      case "browser": {
-        const win = window;
-        win.addEventListener?.("beforeunload", handler);
-        return () => {
-          win.removeEventListener?.("beforeunload", handler);
-        };
-      }
-      default: {
-        const tgt = globalThis;
-        const cleanup = [];
-        if (tgt.addEventListener) {
-          tgt.addEventListener("beforeunload", handler);
-          cleanup.push(
-            () => tgt.removeEventListener?.("beforeunload", handler)
-          );
-          const vis = /* @__PURE__ */ __name(() => {
-            const doc = globalThis.document;
-            if (doc && doc.visibilityState === "hidden") handler();
-          }, "vis");
-          tgt.addEventListener("visibilitychange", vis);
-          cleanup.push(
-            () => tgt.removeEventListener?.("visibilitychange", vis)
-          );
-        }
-        if (typeof process !== "undefined" && process.on) {
-          process.on("SIGINT", handler);
-          process.on("SIGTERM", handler);
-          cleanup.push(() => {
-            process.off?.("SIGINT", handler);
-            process.off?.("SIGTERM", handler);
-          });
-        }
-        return () => cleanup.forEach((fn) => fn());
-      }
-    }
-  }
-  exit(code) {
-    switch (this.env) {
-      case "node":
-        process.exit(code);
-        return;
-      default:
-        throw new PlatformUnsupportedFunction("exit");
-    }
-  }
-  getEnv(key) {
-    switch (this.env) {
-      case "node":
-        return process.env[key];
-      default: {
-        const g = globalThis;
-        if (g.__ENV__ && typeof g.__ENV__ === "object") return g.__ENV__[key];
-        if (typeof process !== "undefined" && process.env)
-          return process.env[key];
-        if (g.env && typeof g.env === "object") return g.env[key];
-        return void 0;
-      }
-    }
-  }
-  hasAsyncLocalStorage() {
-    switch (this.env) {
-      case "node":
-        return true;
-      // We'll try native, else polyfill
-      case "browser":
-      default:
-        return false;
-    }
-  }
-  createAsyncLocalStorage() {
-    switch (this.env) {
-      case "node": {
-        let instance;
-        const get = /* @__PURE__ */ __name(() => {
-          if (!instance) {
-            if (!this.nodeALSClass) {
-              throw new PlatformUnsupportedFunction(
-                "createAsyncLocalStorage: Platform not initialized"
-              );
-            }
-            instance = new this.nodeALSClass();
-          }
-          return instance;
-        }, "get");
-        return {
-          getStore: /* @__PURE__ */ __name(() => get().getStore(), "getStore"),
-          run: /* @__PURE__ */ __name((store2, callback) => get().run(store2, callback), "run")
-        };
-      }
-      case "browser":
-      default:
-        return {
-          getStore: /* @__PURE__ */ __name(() => {
-            throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
-          }, "getStore"),
-          run: /* @__PURE__ */ __name(() => {
-            throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
-          }, "run")
-        };
-    }
-  }
-};
-__name(_PlatformAdapter, "PlatformAdapter");
-var PlatformAdapter = _PlatformAdapter;
-var platformInstance = null;
-function getPlatform() {
-  if (!platformInstance) {
-    const env = detectEnvironment();
-    platformInstance = new PlatformAdapter(env);
-  }
-  return platformInstance;
-}
-__name(getPlatform, "getPlatform");
-
 // src/globals/middleware/requireContext.middleware.ts
 var requireContextTaskMiddleware = defineTaskMiddleware({
   id: "globals.middleware.requireContext",
@@ -965,7 +974,7 @@ var globalTags = {
 };
 
 // src/globals/globalEvents.ts
-var systemTag = globalTags.system;
+globalTags.system;
 var globalEvents = {
   // Minimal core events retained if any (custom events can still be defined by users)
   /**
@@ -977,17 +986,6 @@ var globalEvents = {
       title: "System Ready",
       description: "Emitted when the system has completed boot and is ready for listeners to start work.This runs right before returning value for run()."
     }
-  }),
-  /**
-   * Central error boundary event for any thrown error across the runner.
-   */
-  unhandledError: defineEvent({
-    id: "globals.events.unhandledError",
-    meta: {
-      title: "Unhandled Error",
-      description: "Central error boundary event for any thrown error across the runner."
-    },
-    tags: [systemTag, globalTags.excludeFromGlobalHooks]
   })
 };
 var globalEventsArray = [globalEvents.ready];