@bluelibs/runner 4.5.9 → 4.6.0-alpha

package/dist/{index.mjs → edge/index.mjs}

@@ -1,18 +1,11 @@
 import { LRUCache } from 'lru-cache';
 
 var __defProp = Object.defineProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
 
 // src/defs.ts
 var defs_exports = {};
@@ -230,7 +223,224 @@ __export(errors_exports, {
   ValidationError: () => ValidationError
 });
 
-// src/platform/index.ts
+// src/platform/adapters/node-als.ts
+async function loadAsyncLocalStorageClass() {
+  const mod = await import('async_hooks');
+  return mod.AsyncLocalStorage;
+}
+__name(loadAsyncLocalStorageClass, "loadAsyncLocalStorageClass");
+
+// src/platform/adapters/node.ts
+var NodePlatformAdapter = class {
+  constructor() {
+    this.setTimeout = globalThis.setTimeout;
+    this.clearTimeout = globalThis.clearTimeout;
+  }
+  static {
+    __name(this, "NodePlatformAdapter");
+  }
+  async init() {
+    this.alsClass = await loadAsyncLocalStorageClass();
+  }
+  onUncaughtException(handler) {
+    process.on("uncaughtException", handler);
+    return () => process.off("uncaughtException", handler);
+  }
+  onUnhandledRejection(handler) {
+    const h = /* @__PURE__ */ __name((reason) => handler(reason), "h");
+    process.on("unhandledRejection", h);
+    return () => process.off("unhandledRejection", h);
+  }
+  onShutdownSignal(handler) {
+    process.on("SIGINT", handler);
+    process.on("SIGTERM", handler);
+    return () => {
+      process.off("SIGINT", handler);
+      process.off("SIGTERM", handler);
+    };
+  }
+  exit(code) {
+    process.exit(code);
+  }
+  getEnv(key) {
+    return process.env[key];
+  }
+  hasAsyncLocalStorage() {
+    return true;
+  }
+  createAsyncLocalStorage() {
+    let instance;
+    const ensure = /* @__PURE__ */ __name(() => {
+      if (!this.alsClass) {
+        throw new PlatformUnsupportedFunction(
+          "createAsyncLocalStorage: Platform not initialized"
+        );
+      }
+      return instance ??= new this.alsClass();
+    }, "ensure");
+    return {
+      getStore: /* @__PURE__ */ __name(() => ensure().getStore(), "getStore"),
+      run: /* @__PURE__ */ __name((store2, callback) => ensure().run(store2, callback), "run")
+    };
+  }
+};
+
+// src/platform/adapters/browser.ts
+var BrowserPlatformAdapter = class {
+  constructor() {
+    this.setTimeout = globalThis.setTimeout;
+    this.clearTimeout = globalThis.clearTimeout;
+  }
+  static {
+    __name(this, "BrowserPlatformAdapter");
+  }
+  async init() {
+  }
+  onUncaughtException(handler) {
+    const target = globalThis.window ?? globalThis;
+    const h = /* @__PURE__ */ __name((e) => handler(e?.error ?? e), "h");
+    target.addEventListener?.("error", h);
+    return () => target.removeEventListener?.("error", h);
+  }
+  onUnhandledRejection(handler) {
+    const target = globalThis.window ?? globalThis;
+    const wrap = /* @__PURE__ */ __name((e) => handler(e?.reason ?? e), "wrap");
+    target.addEventListener?.("unhandledrejection", wrap);
+    return () => target.removeEventListener?.("unhandledrejection", wrap);
+  }
+  onShutdownSignal(handler) {
+    const win = globalThis.window ?? globalThis;
+    const handlers = {};
+    handlers.before = (e) => handler();
+    win.addEventListener?.("beforeunload", handlers.before);
+    const doc = globalThis.document;
+    if (doc && typeof win.addEventListener === "function") {
+      handlers.visibility = () => {
+        if (doc.visibilityState === "hidden") handler();
+      };
+      win.addEventListener?.("visibilitychange", handlers.visibility);
+    }
+    return () => {
+      win.removeEventListener?.("beforeunload", handlers.before);
+      if (handlers.visibility) win.removeEventListener?.("visibilitychange", handlers.visibility);
+    };
+  }
+  exit() {
+    throw new PlatformUnsupportedFunction("exit");
+  }
+  getEnv(key) {
+    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() {
+    return false;
+  }
+  createAsyncLocalStorage() {
+    return {
+      getStore: /* @__PURE__ */ __name(() => {
+        throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
+      }, "getStore"),
+      run: /* @__PURE__ */ __name(() => {
+        throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
+      }, "run")
+    };
+  }
+};
+
+// src/platform/adapters/edge.ts
+var EdgePlatformAdapter = class extends BrowserPlatformAdapter {
+  static {
+    __name(this, "EdgePlatformAdapter");
+  }
+  onShutdownSignal(handler) {
+    return () => {
+    };
+  }
+};
+
+// src/platform/adapters/universal-generic.ts
+var GenericUniversalPlatformAdapter = class {
+  constructor() {
+    this.setTimeout = globalThis.setTimeout;
+    this.clearTimeout = globalThis.clearTimeout;
+  }
+  static {
+    __name(this, "GenericUniversalPlatformAdapter");
+  }
+  async init() {
+  }
+  onUncaughtException(handler) {
+    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) {
+    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) {
+    const tgt = globalThis;
+    if (tgt.addEventListener) {
+      const handlers = {};
+      handlers.before = (e) => handler();
+      tgt.addEventListener("beforeunload", handlers.before);
+      const doc = globalThis.document;
+      if (doc) {
+        handlers.visibility = () => {
+          if (doc.visibilityState === "hidden") handler();
+        };
+        tgt.addEventListener?.("visibilitychange", handlers.visibility);
+      }
+      return () => {
+        tgt.removeEventListener?.("beforeunload", handlers.before);
+        if (handlers.visibility) tgt.removeEventListener?.("visibilitychange", handlers.visibility);
+      };
+    }
+    return () => {
+    };
+  }
+  exit() {
+    throw new PlatformUnsupportedFunction("exit");
+  }
+  getEnv(key) {
+    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() {
+    return false;
+  }
+  createAsyncLocalStorage() {
+    return {
+      getStore: /* @__PURE__ */ __name(() => {
+        throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
+      }, "getStore"),
+      run: /* @__PURE__ */ __name(() => {
+        throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
+      }, "run")
+    };
+  }
+};
+
+// src/platform/adapters/universal.ts
 function detectEnvironment() {
   if (typeof window !== "undefined" && typeof document !== "undefined") {
     return "browser";
@@ -238,211 +448,141 @@ function detectEnvironment() {
   if (typeof process !== "undefined" && process.versions && process.versions.node) {
     return "node";
   }
+  if (typeof globalThis.Deno !== "undefined") {
+    return "universal";
+  }
+  if (typeof globalThis.Bun !== "undefined" || typeof process !== "undefined" && process.versions?.bun) {
+    return "universal";
+  }
+  if (typeof globalThis.WorkerGlobalScope !== "undefined" && typeof self !== "undefined" && self instanceof globalThis.WorkerGlobalScope) {
+    return "edge";
+  }
   return "universal";
 }
 __name(detectEnvironment, "detectEnvironment");
-var _PlatformAdapter = class _PlatformAdapter {
-  constructor(env) {
-    this.isInitialized = false;
-    this.nodeALSClass = null;
-    // timers
+var UniversalPlatformAdapter = class {
+  constructor() {
+    this.inner = null;
     this.setTimeout = globalThis.setTimeout;
     this.clearTimeout = globalThis.clearTimeout;
-    this.env = env ?? detectEnvironment();
+  }
+  static {
+    __name(this, "UniversalPlatformAdapter");
   }
   async init() {
-    if (this.env === "node") {
-      {
-        {
-          const mod = await import('async_hooks');
-          this.nodeALSClass = mod.AsyncLocalStorage;
+    if (!this.inner) {
+      const kind = detectEnvironment();
+      if (typeof globalThis.document !== "undefined" || typeof globalThis.addEventListener === "function") {
+        this.inner = new BrowserPlatformAdapter();
+      } else {
+        switch (kind) {
+          case "node":
+            this.inner = new NodePlatformAdapter();
+            break;
+          // istanbul ignore next: this branch is unreachable in practice because detectEnvironment()
+          // returns "browser" only when document is defined; we keep it for completeness.
+          case "browser":
+            this.inner = new BrowserPlatformAdapter();
+            break;
+          case "edge":
+            this.inner = new EdgePlatformAdapter();
+            break;
+          default:
+            this.inner = new GenericUniversalPlatformAdapter();
         }
       }
     }
+    await this.inner.init();
   }
-  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);
+  get() {
+    if (!this.inner) {
+      const kind = detectEnvironment();
+      if (typeof globalThis.document !== "undefined" || typeof globalThis.addEventListener === "function") {
+        this.inner = new BrowserPlatformAdapter();
+      } else {
+        switch (kind) {
+          case "node":
+            this.inner = new NodePlatformAdapter();
+            break;
+          // istanbul ignore next: this branch is unreachable in practice because detectEnvironment()
+          // returns "browser" only when document is defined; we keep it for completeness.
+          case "browser":
+            this.inner = new BrowserPlatformAdapter();
+            break;
+          case "edge":
+            this.inner = new EdgePlatformAdapter();
+            break;
+          default:
+            this.inner = new GenericUniversalPlatformAdapter();
         }
-        return () => {
-        };
       }
     }
+    return this.inner;
+  }
+  onUncaughtException(handler) {
+    return this.get().onUncaughtException(handler);
   }
   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 () => {
-        };
-      }
-    }
+    return this.get().onUnhandledRejection(handler);
   }
   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());
-      }
-    }
+    return this.get().onShutdownSignal(handler);
   }
   exit(code) {
-    switch (this.env) {
-      case "node":
-        process.exit(code);
-        return;
-      default:
-        throw new PlatformUnsupportedFunction("exit");
-    }
+    return this.get().exit(code);
   }
   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;
-      }
-    }
+    return this.get().getEnv(key);
   }
   hasAsyncLocalStorage() {
-    switch (this.env) {
-      case "node":
-        return true;
-      // We'll try native, else polyfill
-      case "browser":
-      default:
-        return false;
-    }
+    return this.get().hasAsyncLocalStorage();
   }
   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")
-        };
-      }
+    return this.get().createAsyncLocalStorage();
+  }
+};
+
+// src/platform/factory.ts
+function createPlatformAdapter() {
+  {
+    switch ("edge") {
+      case "node":
+        return new NodePlatformAdapter();
       case "browser":
-      default:
-        return {
-          getStore: /* @__PURE__ */ __name(() => {
-            throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
-          }, "getStore"),
-          run: /* @__PURE__ */ __name(() => {
-            throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
-          }, "run")
-        };
+        return new BrowserPlatformAdapter();
+      case "edge":
+        return new EdgePlatformAdapter();
     }
   }
-};
-__name(_PlatformAdapter, "PlatformAdapter");
-var PlatformAdapter = _PlatformAdapter;
+  return new UniversalPlatformAdapter();
+}
+__name(createPlatformAdapter, "createPlatformAdapter");
+
+// src/platform/index.ts
 var platformInstance = null;
 function getPlatform() {
   if (!platformInstance) {
-    const env = detectEnvironment();
-    platformInstance = new PlatformAdapter(env);
+    platformInstance = createPlatformAdapter();
+    detectEnvironment();
   }
   return platformInstance;
 }
 __name(getPlatform, "getPlatform");
 
 // src/errors.ts
-var _RuntimeError = class _RuntimeError extends Error {
+var RuntimeError = class extends Error {
+  static {
+    __name(this, "RuntimeError");
+  }
   constructor(message) {
     super(message);
     this.name = "RuntimeError";
   }
 };
-__name(_RuntimeError, "RuntimeError");
-var RuntimeError = _RuntimeError;
-var _DuplicateRegistrationError = class _DuplicateRegistrationError extends RuntimeError {
+var DuplicateRegistrationError = class extends RuntimeError {
+  static {
+    __name(this, "DuplicateRegistrationError");
+  }
   constructor(type, id2) {
     super(
       `${type} "${id2.toString()}" already registered. You might have used the same 'id' in two different components or you may have registered the same element twice.`
@@ -450,9 +590,10 @@ var _DuplicateRegistrationError = class _DuplicateRegistrationError extends Runt
     this.name = "DuplicateRegistrationError";
   }
 };
-__name(_DuplicateRegistrationError, "DuplicateRegistrationError");
-var DuplicateRegistrationError = _DuplicateRegistrationError;
-var _DependencyNotFoundError = class _DependencyNotFoundError extends RuntimeError {
+var DependencyNotFoundError = class extends RuntimeError {
+  static {
+    __name(this, "DependencyNotFoundError");
+  }
   constructor(key) {
     super(
       `Dependency ${key.toString()} not found. Did you forget to register it through a resource?`
@@ -460,9 +601,10 @@ var _DependencyNotFoundError = class _DependencyNotFoundError extends RuntimeErr
     this.name = "DependencyNotFoundError";
   }
 };
-__name(_DependencyNotFoundError, "DependencyNotFoundError");
-var DependencyNotFoundError = _DependencyNotFoundError;
-var _UnknownItemTypeError = class _UnknownItemTypeError extends RuntimeError {
+var UnknownItemTypeError = class extends RuntimeError {
+  static {
+    __name(this, "UnknownItemTypeError");
+  }
   constructor(item) {
     super(
       `Unknown item type: ${item}. Please ensure you are not using different versions of '@bluelibs/runner'`
@@ -470,17 +612,19 @@ var _UnknownItemTypeError = class _UnknownItemTypeError extends RuntimeError {
     this.name = "UnknownItemTypeError";
   }
 };
-__name(_UnknownItemTypeError, "UnknownItemTypeError");
-var UnknownItemTypeError = _UnknownItemTypeError;
-var _ContextError = class _ContextError extends Error {
+var ContextError = class extends Error {
+  static {
+    __name(this, "ContextError");
+  }
   constructor(message) {
     super(message);
     this.name = "ContextError";
   }
 };
-__name(_ContextError, "ContextError");
-var ContextError = _ContextError;
-var _CircularDependenciesError = class _CircularDependenciesError extends RuntimeError {
+var CircularDependenciesError = class extends RuntimeError {
+  static {
+    __name(this, "CircularDependenciesError");
+  }
   constructor(cycles) {
     const cycleDetails = cycles.map((cycle) => `  \u2022 ${cycle}`).join("\n");
     const hasMiddleware = cycles.some((cycle) => cycle.includes("middleware"));
@@ -496,17 +640,19 @@ ${cycleDetails}${guidance}`);
     this.name = "CircularDependenciesError";
   }
 };
-__name(_CircularDependenciesError, "CircularDependenciesError");
-var CircularDependenciesError = _CircularDependenciesError;
-var _EventNotFoundError = class _EventNotFoundError extends RuntimeError {
+var EventNotFoundError = class extends RuntimeError {
+  static {
+    __name(this, "EventNotFoundError");
+  }
   constructor(id2) {
     super(`Event "${id2.toString()}" not found. Did you forget to register it?`);
     this.name = "EventNotFoundError";
   }
 };
-__name(_EventNotFoundError, "EventNotFoundError");
-var EventNotFoundError = _EventNotFoundError;
-var _ResourceNotFoundError = class _ResourceNotFoundError extends RuntimeError {
+var ResourceNotFoundError = class extends RuntimeError {
+  static {
+    __name(this, "ResourceNotFoundError");
+  }
   constructor(id2) {
     super(
       `Resource "${id2.toString()}" not found. Did you forget to register it or are you using the correct id?`
@@ -514,9 +660,10 @@ var _ResourceNotFoundError = class _ResourceNotFoundError extends RuntimeError {
     this.name = "ResourceNotFoundError";
   }
 };
-__name(_ResourceNotFoundError, "ResourceNotFoundError");
-var ResourceNotFoundError = _ResourceNotFoundError;
-var _MiddlewareNotRegisteredError = class _MiddlewareNotRegisteredError extends RuntimeError {
+var MiddlewareNotRegisteredError = class extends RuntimeError {
+  static {
+    __name(this, "MiddlewareNotRegisteredError");
+  }
   constructor(type, source, middlewareId) {
     super(
       `Middleware inside ${type} "${source}" depends on "${middlewareId}" but it's not registered. Did you forget to register it?`
@@ -524,9 +671,10 @@ var _MiddlewareNotRegisteredError = class _MiddlewareNotRegisteredError extends
     this.name = `MiddlewareNotRegisteredError: ${type} ${source} ${middlewareId}`;
   }
 };
-__name(_MiddlewareNotRegisteredError, "MiddlewareNotRegisteredError");
-var MiddlewareNotRegisteredError = _MiddlewareNotRegisteredError;
-var _TagNotFoundError = class _TagNotFoundError extends RuntimeError {
+var TagNotFoundError = class extends RuntimeError {
+  static {
+    __name(this, "TagNotFoundError");
+  }
   constructor(id2) {
     super(
       `Tag "${id2}" not registered. Did you forget to register it inside a resource?`
@@ -534,34 +682,38 @@ var _TagNotFoundError = class _TagNotFoundError extends RuntimeError {
     this.name = "TagNotRegisteredError";
   }
 };
-__name(_TagNotFoundError, "TagNotFoundError");
-var TagNotFoundError = _TagNotFoundError;
-var _LockedError = class _LockedError extends RuntimeError {
+var LockedError = class extends RuntimeError {
+  static {
+    __name(this, "LockedError");
+  }
   constructor(what) {
     super(`Cannot modify the ${what.toString()} when it is locked.`);
     this.name = "LockedError";
   }
 };
-__name(_LockedError, "LockedError");
-var LockedError = _LockedError;
-var _StoreAlreadyInitializedError = class _StoreAlreadyInitializedError extends RuntimeError {
+var StoreAlreadyInitializedError = class extends RuntimeError {
+  static {
+    __name(this, "StoreAlreadyInitializedError");
+  }
   constructor() {
     super("Store already initialized. Cannot reinitialize.");
     this.name = "StoreAlreadyInitializedError";
   }
 };
-__name(_StoreAlreadyInitializedError, "StoreAlreadyInitializedError");
-var StoreAlreadyInitializedError = _StoreAlreadyInitializedError;
-var _ValidationError = class _ValidationError extends RuntimeError {
+var ValidationError = class extends RuntimeError {
+  static {
+    __name(this, "ValidationError");
+  }
   constructor(type, id2, originalError) {
     const errorMessage = originalError instanceof Error ? originalError.message : String(originalError);
     super(`${type} validation failed for ${id2.toString()}: ${errorMessage}`);
     this.name = "ValidationError";
   }
 };
-__name(_ValidationError, "ValidationError");
-var ValidationError = _ValidationError;
-var _EventCycleError = class _EventCycleError extends RuntimeError {
+var EventCycleError = class extends RuntimeError {
+  static {
+    __name(this, "EventCycleError");
+  }
   constructor(path) {
     const chain = path.map((p) => `${p.id}\u2190${p.source}`).join("  ->  ");
     super(
@@ -573,9 +725,10 @@ Break the cycle by changing hook logic (avoid mutual emits) or gate with conditi
     this.name = "EventCycleError";
   }
 };
-__name(_EventCycleError, "EventCycleError");
-var EventCycleError = _EventCycleError;
-var _EventEmissionCycleError = class _EventEmissionCycleError extends RuntimeError {
+var EventEmissionCycleError = class extends RuntimeError {
+  static {
+    __name(this, "EventEmissionCycleError");
+  }
   constructor(cycles) {
     const list = cycles.map((c) => `  \u2022 ${c}`).join("\n");
     super(
@@ -587,9 +740,10 @@ This was detected at compile time (dry-run). Break the cycle by avoiding mutual
     this.name = "EventEmissionCycleError";
   }
 };
-__name(_EventEmissionCycleError, "EventEmissionCycleError");
-var EventEmissionCycleError = _EventEmissionCycleError;
-var _PlatformUnsupportedFunction = class _PlatformUnsupportedFunction extends RuntimeError {
+var PlatformUnsupportedFunction = class extends RuntimeError {
+  static {
+    __name(this, "PlatformUnsupportedFunction");
+  }
   constructor(functionName) {
     super(
       `Platform function not supported in this environment: ${functionName}. Detected platform: ${detectEnvironment()}.`
@@ -597,8 +751,6 @@ var _PlatformUnsupportedFunction = class _PlatformUnsupportedFunction extends Ru
     this.name = "PlatformUnsupportedFunction";
   }
 };
-__name(_PlatformUnsupportedFunction, "PlatformUnsupportedFunction");
-var PlatformUnsupportedFunction = _PlatformUnsupportedFunction;
 
 // src/definers/defineResource.ts
 function defineResource(constConfig) {
@@ -991,7 +1143,7 @@ var globalEvents = {
 var globalEventsArray = [globalEvents.ready];
 
 // src/models/Queue.ts
-var _Queue = class _Queue {
+var Queue = class {
   constructor() {
     this.tail = Promise.resolve();
     this.disposed = false;
@@ -1000,6 +1152,9 @@ var _Queue = class _Queue {
     this.executionContext = getPlatform().createAsyncLocalStorage();
     this.hasAsyncLocalStorage = getPlatform().hasAsyncLocalStorage();
   }
+  static {
+    __name(this, "Queue");
+  }
   /**
    * Schedule an asynchronous task.
    * @param task – receives an AbortSignal so it can cancel early if desired.
@@ -1038,8 +1193,6 @@ var _Queue = class _Queue {
     });
   }
 };
-__name(_Queue, "Queue");
-var Queue = _Queue;
 
 // src/globals/resources/queue.resource.ts
 var queueResource = defineResource({
@@ -1238,7 +1391,7 @@ var globalMiddlewares = {
 };
 
 // src/models/TaskRunner.ts
-var _TaskRunner = class _TaskRunner {
+var TaskRunner = class {
   constructor(store2, eventManager, logger) {
     this.store = store2;
     this.eventManager = eventManager;
@@ -1246,6 +1399,9 @@ var _TaskRunner = class _TaskRunner {
     this.runnerStore = /* @__PURE__ */ new Map();
     this.middlewareManager = this.store.getMiddlewareManager();
   }
+  static {
+    __name(this, "TaskRunner");
+  }
   /**
    * Begins the execution of an task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
    * This function can throw only if any of the event listeners or run function throws
@@ -1283,12 +1439,9 @@ var _TaskRunner = class _TaskRunner {
     return this.middlewareManager.composeTaskRunner(task);
   }
 };
-__name(_TaskRunner, "TaskRunner");
-var TaskRunner = _TaskRunner;
 
 // src/models/MiddlewareManager.ts
-var _isLocked;
-var _MiddlewareManager = class _MiddlewareManager {
+var MiddlewareManager = class {
   constructor(store2, eventManager, logger) {
     this.store = store2;
     this.eventManager = eventManager;
@@ -1300,25 +1453,29 @@ var _MiddlewareManager = class _MiddlewareManager {
     this.perMiddlewareInterceptors = /* @__PURE__ */ new Map();
     this.perResourceMiddlewareInterceptors = /* @__PURE__ */ new Map();
     // Locking mechanism to prevent modifications after initialization
-    __privateAdd(this, _isLocked, false);
+    this.#isLocked = false;
+  }
+  static {
+    __name(this, "MiddlewareManager");
   }
+  #isLocked;
   /**
    * Gets the current lock status of the MiddlewareManager
    */
   get isLocked() {
-    return __privateGet(this, _isLocked);
+    return this.#isLocked;
   }
   /**
    * Locks the MiddlewareManager, preventing any further modifications to interceptors
    */
   lock() {
-    __privateSet(this, _isLocked, true);
+    this.#isLocked = true;
   }
   /**
    * Throws an error if the MiddlewareManager is locked
    */
   checkLock() {
-    if (__privateGet(this, _isLocked)) {
+    if (this.#isLocked) {
       throw new LockedError("MiddlewareManager");
     }
   }
@@ -1649,12 +1806,9 @@ var _MiddlewareManager = class _MiddlewareManager {
     }).map((x) => x.middleware);
   }
 };
-_isLocked = new WeakMap();
-__name(_MiddlewareManager, "MiddlewareManager");
-var MiddlewareManager = _MiddlewareManager;
 
 // src/models/ResourceInitializer.ts
-var _ResourceInitializer = class _ResourceInitializer {
+var ResourceInitializer = class {
   constructor(store2, eventManager, logger) {
     this.store = store2;
     this.eventManager = eventManager;
@@ -1665,6 +1819,9 @@ var _ResourceInitializer = class _ResourceInitializer {
       this.logger
     );
   }
+  static {
+    __name(this, "ResourceInitializer");
+  }
   /**
    * Begins the execution of an task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
    * This function can throw only if any of the event listeners or run function throws
@@ -1695,8 +1852,6 @@ var _ResourceInitializer = class _ResourceInitializer {
     );
   }
 };
-__name(_ResourceInitializer, "ResourceInitializer");
-var ResourceInitializer = _ResourceInitializer;
 
 // src/models/utils/safeStringify.ts
 function safeStringify(value, space, options) {
@@ -1763,7 +1918,10 @@ var ICONS = {
   error: "\u2715",
   critical: "\u2588"
 };
-var _LogPrinter = class _LogPrinter {
+var LogPrinter = class _LogPrinter {
+  static {
+    __name(this, "LogPrinter");
+  }
   constructor(options) {
     this.strategy = options.strategy;
     if (options.strategy === "plain") {
@@ -1895,6 +2053,30 @@ var _LogPrinter = class _LogPrinter {
     }
     return normalized;
   }
+  static {
+    this.NO_COLORS = {
+      trace: "",
+      debug: "",
+      info: "",
+      warn: "",
+      error: "",
+      critical: "",
+      reset: "",
+      bold: "",
+      dim: "",
+      blue: "",
+      cyan: "",
+      gray: ""
+    };
+  }
+  static {
+    this.writers = {
+      // eslint-disable-next-line no-console
+      log: /* @__PURE__ */ __name((msg) => console.log(msg), "log"),
+      // eslint-disable-next-line no-console
+      error: /* @__PURE__ */ __name((msg) => console.error?.(msg), "error")
+    };
+  }
   static setWriters(writers) {
     _LogPrinter.writers = { ..._LogPrinter.writers, ...writers };
   }
@@ -1905,31 +2087,9 @@ var _LogPrinter = class _LogPrinter {
     };
   }
 };
-__name(_LogPrinter, "LogPrinter");
-_LogPrinter.NO_COLORS = {
-  trace: "",
-  debug: "",
-  info: "",
-  warn: "",
-  error: "",
-  critical: "",
-  reset: "",
-  bold: "",
-  dim: "",
-  blue: "",
-  cyan: "",
-  gray: ""
-};
-_LogPrinter.writers = {
-  // eslint-disable-next-line no-console
-  log: /* @__PURE__ */ __name((msg) => console.log(msg), "log"),
-  // eslint-disable-next-line no-console
-  error: /* @__PURE__ */ __name((msg) => console.error?.(msg), "error")
-};
-var LogPrinter = _LogPrinter;
 
 // src/models/Logger.ts
-var _Logger = class _Logger {
+var Logger = class _Logger {
   constructor(options, boundContext = {}, source, printer) {
     this.printThreshold = "info";
     this.printStrategy = "pretty";
@@ -1951,6 +2111,19 @@ var _Logger = class _Logger {
       useColors: this.useColors
     });
   }
+  static {
+    __name(this, "Logger");
+  }
+  static {
+    this.Severity = {
+      trace: 0,
+      debug: 1,
+      info: 2,
+      warn: 3,
+      error: 4,
+      critical: 5
+    };
+  }
   detectColorSupport() {
     const noColor = typeof process !== "undefined" && !!process.env.NO_COLOR;
     if (noColor) return false;
@@ -2101,19 +2274,9 @@ var _Logger = class _Logger {
     }
   }
 };
-__name(_Logger, "Logger");
-_Logger.Severity = {
-  trace: 0,
-  debug: 1,
-  info: 2,
-  warn: 3,
-  error: 4,
-  critical: 5
-};
-var Logger = _Logger;
 
 // src/models/DependencyProcessor.ts
-var _DependencyProcessor = class _DependencyProcessor {
+var DependencyProcessor = class {
   constructor(store2, eventManager, taskRunner, logger) {
     this.store = store2;
     this.eventManager = eventManager;
@@ -2125,6 +2288,9 @@ var _DependencyProcessor = class _DependencyProcessor {
       logger
     );
   }
+  static {
+    __name(this, "DependencyProcessor");
+  }
   /**
    * This function is going to go through all the resources, tasks and middleware to compute their required dependencies.
    */
@@ -2389,13 +2555,10 @@ var _DependencyProcessor = class _DependencyProcessor {
     return storeResource.value;
   }
 };
-__name(_DependencyProcessor, "DependencyProcessor");
-var DependencyProcessor = _DependencyProcessor;
 
 // src/models/EventManager.ts
 var HandlerOptionsDefaults = { order: 0 };
-var _isLocked2;
-var _EventManager = class _EventManager {
+var EventManager = class {
   constructor(options) {
     // Core storage for event listeners
     this.listeners = /* @__PURE__ */ new Map();
@@ -2407,7 +2570,7 @@ var _EventManager = class _EventManager {
     this.emissionInterceptors = [];
     this.hookInterceptors = [];
     // Locking mechanism to prevent modifications after initialization
-    __privateAdd(this, _isLocked2, false);
+    this.#isLocked = false;
     this.runtimeCycleDetection = options?.runtimeCycleDetection ?? true;
     if (getPlatform().hasAsyncLocalStorage() && this.runtimeCycleDetection) {
       this.emissionStack = getPlatform().createAsyncLocalStorage();
@@ -2418,18 +2581,22 @@ var _EventManager = class _EventManager {
       this.currentHookIdContext = null;
     }
   }
+  static {
+    __name(this, "EventManager");
+  }
+  #isLocked;
   // ==================== PUBLIC API ====================
   /**
    * Gets the current lock status of the EventManager
    */
   get isLocked() {
-    return __privateGet(this, _isLocked2);
+    return this.#isLocked;
   }
   /**
    * Locks the EventManager, preventing any further modifications to listeners
    */
   lock() {
-    __privateSet(this, _isLocked2, true);
+    this.#isLocked = true;
   }
   /**
    * Emits an event to all registered listeners for that event type.
@@ -2670,7 +2837,7 @@ var _EventManager = class _EventManager {
    * Throws an error if the EventManager is locked
    */
   checkLock() {
-    if (__privateGet(this, _isLocked2)) {
+    if (this.#isLocked) {
       throw new LockedError("EventManager");
     }
   }
@@ -2772,9 +2939,6 @@ var _EventManager = class _EventManager {
     }
   }
 };
-_isLocked2 = new WeakMap();
-__name(_EventManager, "EventManager");
-var EventManager = _EventManager;
 
 // src/models/utils/findCircularDependencies.ts
 function findCircularDependencies(nodes) {
@@ -2821,10 +2985,13 @@ function findCircularDependencies(nodes) {
 __name(findCircularDependencies, "findCircularDependencies");
 
 // src/models/StoreValidator.ts
-var _StoreValidator = class _StoreValidator {
+var StoreValidator = class {
   constructor(registry) {
     this.registry = registry;
   }
+  static {
+    __name(this, "StoreValidator");
+  }
   checkIfIDExists(id2) {
     if (this.registry.tasks.has(id2)) {
       throw new DuplicateRegistrationError("Task", id2);
@@ -2900,11 +3067,9 @@ var _StoreValidator = class _StoreValidator {
     }
   }
 };
-__name(_StoreValidator, "StoreValidator");
-var StoreValidator = _StoreValidator;
 
 // src/models/StoreRegistry.ts
-var _StoreRegistry = class _StoreRegistry {
+var StoreRegistry = class {
   constructor(store2) {
     this.store = store2;
     this.tasks = /* @__PURE__ */ new Map();
@@ -2916,6 +3081,9 @@ var _StoreRegistry = class _StoreRegistry {
     this.tags = /* @__PURE__ */ new Map();
     this.validator = new StoreValidator(this);
   }
+  static {
+    __name(this, "StoreRegistry");
+  }
   getValidator() {
     return this.validator;
   }
@@ -3255,16 +3423,17 @@ var _StoreRegistry = class _StoreRegistry {
     return currentItem;
   }
 };
-__name(_StoreRegistry, "StoreRegistry");
-var StoreRegistry = _StoreRegistry;
 
 // src/models/OverrideManager.ts
-var _OverrideManager = class _OverrideManager {
+var OverrideManager = class {
   constructor(registry) {
     this.registry = registry;
     this.overrides = /* @__PURE__ */ new Map();
     this.overrideRequests = /* @__PURE__ */ new Set();
   }
+  static {
+    __name(this, "OverrideManager");
+  }
   storeOverridesDeeply(element) {
     element.overrides.forEach((override) => {
       if (!override) {
@@ -3322,23 +3491,23 @@ var _OverrideManager = class _OverrideManager {
     }
   }
 };
-__name(_OverrideManager, "OverrideManager");
-var OverrideManager = _OverrideManager;
 
 // src/models/Store.ts
-var _isLocked3, _isInitialized;
-var _Store = class _Store {
+var Store = class {
   constructor(eventManager, logger, onUnhandledError) {
     this.eventManager = eventManager;
     this.logger = logger;
     this.onUnhandledError = onUnhandledError;
-    __privateAdd(this, _isLocked3, false);
-    __privateAdd(this, _isInitialized, false);
     this.registry = new StoreRegistry(this);
     this.validator = this.registry.getValidator();
     this.overrideManager = new OverrideManager(this.registry);
     this.middlewareManager = new MiddlewareManager(this, eventManager, logger);
   }
+  static {
+    __name(this, "Store");
+  }
+  #isLocked = false;
+  #isInitialized = false;
   // Delegate properties to registry
   get tasks() {
     return this.registry.tasks;
@@ -3373,13 +3542,13 @@ var _Store = class _Store {
     return this.middlewareManager;
   }
   get isLocked() {
-    return __privateGet(this, _isLocked3);
+    return this.#isLocked;
   }
   lock() {
-    __privateSet(this, _isLocked3, true);
+    this.#isLocked = true;
   }
   checkLock() {
-    if (__privateGet(this, _isLocked3)) {
+    if (this.#isLocked) {
       throw new Error("Cannot modify the Store when it is locked.");
     }
   }
@@ -3463,7 +3632,7 @@ var _Store = class _Store {
     }
   }
   initializeStore(root, config) {
-    if (__privateGet(this, _isInitialized)) {
+    if (this.#isInitialized) {
       throw new StoreAlreadyInitializedError();
     }
     this.registerGlobalComponents();
@@ -3472,7 +3641,7 @@ var _Store = class _Store {
     for (const resource of this.resources.values()) {
       this.overrideManager.storeOverridesDeeply(resource.resource);
     }
-    __privateSet(this, _isInitialized, true);
+    this.#isInitialized = true;
   }
   async dispose() {
     for (const resource of this.resources.values()) {
@@ -3517,10 +3686,6 @@ var _Store = class _Store {
     return this.registry.getResourcesWithTag(tag);
   }
 };
-_isLocked3 = new WeakMap();
-_isInitialized = new WeakMap();
-__name(_Store, "Store");
-var Store = _Store;
 
 // src/globals/resources/debug/types.ts
 var allFalse = Object.freeze({
@@ -3947,7 +4112,7 @@ async function safeReportUnhandledError(handler, info) {
 __name(safeReportUnhandledError, "safeReportUnhandledError");
 
 // src/models/RunResult.ts
-var _RunResult = class _RunResult {
+var RunResult = class {
   constructor(value, logger, store2, eventManager, taskRunner, disposeFn) {
     this.value = value;
     this.logger = logger;
@@ -4002,9 +4167,10 @@ var _RunResult = class _RunResult {
       return this.disposeFn();
     }, "dispose");
   }
+  static {
+    __name(this, "RunResult");
+  }
 };
-__name(_RunResult, "RunResult");
-var RunResult = _RunResult;
 
 // src/run.ts
 var platform3 = getPlatform();
@@ -4165,7 +4331,7 @@ function buildTestFacade(deps) {
 __name(buildTestFacade, "buildTestFacade");
 
 // src/models/Semaphore.ts
-var _Semaphore = class _Semaphore {
+var Semaphore = class {
   constructor(maxPermits) {
     this.waitingQueue = [];
     this.disposed = false;
@@ -4175,6 +4341,9 @@ var _Semaphore = class _Semaphore {
     this.permits = maxPermits;
     this.maxPermits = maxPermits;
   }
+  static {
+    __name(this, "Semaphore");
+  }
   /**
    * Acquire a permit. If no permits are available, waits until one becomes available.
    */
@@ -4309,8 +4478,6 @@ var _Semaphore = class _Semaphore {
     };
   }
 };
-__name(_Semaphore, "Semaphore");
-var Semaphore = _Semaphore;
 
 // src/index.ts
 var globals = {