@bluelibs/runner 4.5.0-alpha.2 → 4.5.0

package/dist/index.mjs

@@ -4,12 +4,7 @@ var __defProp = Object.defineProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
+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 });
@@ -43,34 +38,34 @@ __export(defs_exports, {
 });
 
 // src/types/symbols.ts
-var symbolTask = Symbol("runner.task");
-var symbolResource = Symbol("runner.resource");
-var symbolResourceWithConfig = Symbol(
+var symbolTask = Symbol.for("runner.task");
+var symbolResource = Symbol.for("runner.resource");
+var symbolResourceWithConfig = Symbol.for(
   "runner.resourceWithConfig"
 );
-var symbolEvent = Symbol("runner.event");
-var symbolMiddleware = Symbol("runner.middleware");
-var symbolTaskMiddleware = Symbol(
+var symbolEvent = Symbol.for("runner.event");
+var symbolMiddleware = Symbol.for("runner.middleware");
+var symbolTaskMiddleware = Symbol.for(
   "runner.taskMiddleware"
 );
-var symbolResourceMiddleware = Symbol(
+var symbolResourceMiddleware = Symbol.for(
   "runner.resourceMiddleware"
 );
-var symbolMiddlewareConfigured = Symbol(
+var symbolMiddlewareConfigured = Symbol.for(
   "runner.middlewareConfigured"
 );
-var symbolHook = Symbol("runner.hook");
-var symbolTag = Symbol("runner.tag");
-var symbolTagConfigured = Symbol(
+var symbolHook = Symbol.for("runner.hook");
+var symbolTag = Symbol.for("runner.tag");
+var symbolTagConfigured = Symbol.for(
   "runner.tagConfigured"
 );
-var symbolOptionalDependency = Symbol(
+var symbolOptionalDependency = Symbol.for(
   "runner.optionalDependency"
 );
-var symbolFilePath = Symbol("runner.filePath");
-var symbolDispose = Symbol("runner.dispose");
-var symbolStore = Symbol("runner.store");
-var symbolIndexResource = Symbol(
+var symbolFilePath = Symbol.for("runner.filePath");
+var symbolDispose = Symbol.for("runner.dispose");
+var symbolStore = Symbol.for("runner.store");
+var symbolIndexResource = Symbol.for(
   "runner.indexResource"
 );
 
@@ -78,14 +73,16 @@ var symbolIndexResource = Symbol(
 function onAnyOf(...defs) {
   return defs;
 }
+__name(onAnyOf, "onAnyOf");
 function isOneOf(emission, defs) {
   return defs.some((d) => d.id === emission.id);
 }
+__name(isOneOf, "isOneOf");
 var cacheFactoryTask = defineTask({
   id: "globals.tasks.cacheFactory",
-  run: async (options) => {
+  run: /* @__PURE__ */ __name(async (options) => {
     return new LRUCache(options);
-  }
+  }, "run")
 });
 var cacheResource = defineResource({
   id: "globals.resources.cache",
@@ -93,7 +90,7 @@ var cacheResource = defineResource({
   dependencies: {
     cacheFactoryTask
   },
-  init: async (config, { cacheFactoryTask: cacheFactoryTask2 }) => {
+  init: /* @__PURE__ */ __name(async (config, { cacheFactoryTask: cacheFactoryTask2 }) => {
     return {
       map: /* @__PURE__ */ new Map(),
       cacheFactoryTask: cacheFactoryTask2,
@@ -106,14 +103,14 @@ var cacheResource = defineResource({
         ...config.defaultOptions
       }
     };
-  },
-  dispose: async (cache) => {
+  }, "init"),
+  dispose: /* @__PURE__ */ __name(async (cache) => {
     for (const cacheInstance of cache.map.values()) {
       await cacheInstance.clear();
     }
-  }
+  }, "dispose")
 });
-var defaultKeyBuilder = (taskId, input) => `${taskId}-${JSON.stringify(input)}`;
+var defaultKeyBuilder = /* @__PURE__ */ __name((taskId, input) => `${taskId}-${JSON.stringify(input)}`, "defaultKeyBuilder");
 var cacheMiddleware = defineTaskMiddleware({
   id: "globals.middleware.cache",
   dependencies: { cache: cacheResource },
@@ -167,6 +164,7 @@ function getCallerFile() {
     Error.prepareStackTrace = originalFunc;
   }
 }
+__name(getCallerFile, "getCallerFile");
 
 // src/definers/defineTask.ts
 function defineTask(taskConfig) {
@@ -192,6 +190,7 @@ function defineTask(taskConfig) {
     }
   };
 }
+__name(defineTask, "defineTask");
 
 // src/definers/defineHook.ts
 function defineHook(hookDef) {
@@ -208,6 +207,7 @@ function defineHook(hookDef) {
     tags: hookDef.tags || []
   };
 }
+__name(defineHook, "defineHook");
 
 // src/errors.ts
 var errors_exports = {};
@@ -229,13 +229,15 @@ __export(errors_exports, {
   UnknownItemTypeError: () => UnknownItemTypeError,
   ValidationError: () => ValidationError
 });
-var RuntimeError = class extends Error {
+var _RuntimeError = class _RuntimeError extends Error {
   constructor(message) {
     super(message);
     this.name = "RuntimeError";
   }
 };
-var DuplicateRegistrationError = class extends RuntimeError {
+__name(_RuntimeError, "RuntimeError");
+var RuntimeError = _RuntimeError;
+var _DuplicateRegistrationError = class _DuplicateRegistrationError extends RuntimeError {
   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.`
@@ -243,7 +245,9 @@ var DuplicateRegistrationError = class extends RuntimeError {
     this.name = "DuplicateRegistrationError";
   }
 };
-var DependencyNotFoundError = class extends RuntimeError {
+__name(_DuplicateRegistrationError, "DuplicateRegistrationError");
+var DuplicateRegistrationError = _DuplicateRegistrationError;
+var _DependencyNotFoundError = class _DependencyNotFoundError extends RuntimeError {
   constructor(key) {
     super(
       `Dependency ${key.toString()} not found. Did you forget to register it through a resource?`
@@ -251,7 +255,9 @@ var DependencyNotFoundError = class extends RuntimeError {
     this.name = "DependencyNotFoundError";
   }
 };
-var UnknownItemTypeError = class extends RuntimeError {
+__name(_DependencyNotFoundError, "DependencyNotFoundError");
+var DependencyNotFoundError = _DependencyNotFoundError;
+var _UnknownItemTypeError = class _UnknownItemTypeError extends RuntimeError {
   constructor(item) {
     super(
       `Unknown item type: ${item}. Please ensure you are not using different versions of '@bluelibs/runner'`
@@ -259,13 +265,17 @@ var UnknownItemTypeError = class extends RuntimeError {
     this.name = "UnknownItemTypeError";
   }
 };
-var ContextError = class extends Error {
+__name(_UnknownItemTypeError, "UnknownItemTypeError");
+var UnknownItemTypeError = _UnknownItemTypeError;
+var _ContextError = class _ContextError extends Error {
   constructor(message) {
     super(message);
     this.name = "ContextError";
   }
 };
-var CircularDependenciesError = class extends RuntimeError {
+__name(_ContextError, "ContextError");
+var ContextError = _ContextError;
+var _CircularDependenciesError = class _CircularDependenciesError extends RuntimeError {
   constructor(cycles) {
     const cycleDetails = cycles.map((cycle) => `  \u2022 ${cycle}`).join("\n");
     const hasMiddleware = cycles.some((cycle) => cycle.includes("middleware"));
@@ -281,13 +291,17 @@ ${cycleDetails}${guidance}`);
     this.name = "CircularDependenciesError";
   }
 };
-var EventNotFoundError = class extends RuntimeError {
+__name(_CircularDependenciesError, "CircularDependenciesError");
+var CircularDependenciesError = _CircularDependenciesError;
+var _EventNotFoundError = class _EventNotFoundError extends RuntimeError {
   constructor(id2) {
     super(`Event "${id2.toString()}" not found. Did you forget to register it?`);
     this.name = "EventNotFoundError";
   }
 };
-var ResourceNotFoundError = class extends RuntimeError {
+__name(_EventNotFoundError, "EventNotFoundError");
+var EventNotFoundError = _EventNotFoundError;
+var _ResourceNotFoundError = class _ResourceNotFoundError extends RuntimeError {
   constructor(id2) {
     super(
       `Resource "${id2.toString()}" not found. Did you forget to register it or are you using the correct id?`
@@ -295,7 +309,9 @@ var ResourceNotFoundError = class extends RuntimeError {
     this.name = "ResourceNotFoundError";
   }
 };
-var MiddlewareNotRegisteredError = class extends RuntimeError {
+__name(_ResourceNotFoundError, "ResourceNotFoundError");
+var ResourceNotFoundError = _ResourceNotFoundError;
+var _MiddlewareNotRegisteredError = class _MiddlewareNotRegisteredError extends RuntimeError {
   constructor(type, source, middlewareId) {
     super(
       `Middleware inside ${type} "${source}" depends on "${middlewareId}" but it's not registered. Did you forget to register it?`
@@ -303,7 +319,9 @@ var MiddlewareNotRegisteredError = class extends RuntimeError {
     this.name = `MiddlewareNotRegisteredError: ${type} ${source} ${middlewareId}`;
   }
 };
-var TagNotFoundError = class extends RuntimeError {
+__name(_MiddlewareNotRegisteredError, "MiddlewareNotRegisteredError");
+var MiddlewareNotRegisteredError = _MiddlewareNotRegisteredError;
+var _TagNotFoundError = class _TagNotFoundError extends RuntimeError {
   constructor(id2) {
     super(
       `Tag "${id2}" not registered. Did you forget to register it inside a resource?`
@@ -311,26 +329,34 @@ var TagNotFoundError = class extends RuntimeError {
     this.name = "TagNotRegisteredError";
   }
 };
-var LockedError = class extends RuntimeError {
+__name(_TagNotFoundError, "TagNotFoundError");
+var TagNotFoundError = _TagNotFoundError;
+var _LockedError = class _LockedError extends RuntimeError {
   constructor(what) {
     super(`Cannot modify the ${what.toString()} when it is locked.`);
     this.name = "LockedError";
   }
 };
-var StoreAlreadyInitializedError = class extends RuntimeError {
+__name(_LockedError, "LockedError");
+var LockedError = _LockedError;
+var _StoreAlreadyInitializedError = class _StoreAlreadyInitializedError extends RuntimeError {
   constructor() {
     super("Store already initialized. Cannot reinitialize.");
     this.name = "StoreAlreadyInitializedError";
   }
 };
-var ValidationError = class extends RuntimeError {
+__name(_StoreAlreadyInitializedError, "StoreAlreadyInitializedError");
+var StoreAlreadyInitializedError = _StoreAlreadyInitializedError;
+var _ValidationError = class _ValidationError extends RuntimeError {
   constructor(type, id2, originalError) {
     const errorMessage = originalError instanceof Error ? originalError.message : String(originalError);
     super(`${type} validation failed for ${id2.toString()}: ${errorMessage}`);
     this.name = "ValidationError";
   }
 };
-var EventCycleError = class extends RuntimeError {
+__name(_ValidationError, "ValidationError");
+var ValidationError = _ValidationError;
+var _EventCycleError = class _EventCycleError extends RuntimeError {
   constructor(path) {
     const chain = path.map((p) => `${p.id}\u2190${p.source}`).join("  ->  ");
     super(
@@ -342,7 +368,9 @@ Break the cycle by changing hook logic (avoid mutual emits) or gate with conditi
     this.name = "EventCycleError";
   }
 };
-var EventEmissionCycleError = class extends RuntimeError {
+__name(_EventCycleError, "EventCycleError");
+var EventCycleError = _EventCycleError;
+var _EventEmissionCycleError = class _EventEmissionCycleError extends RuntimeError {
   constructor(cycles) {
     const list = cycles.map((c) => `  \u2022 ${c}`).join("\n");
     super(
@@ -354,7 +382,9 @@ This was detected at compile time (dry-run). Break the cycle by avoiding mutual
     this.name = "EventEmissionCycleError";
   }
 };
-var PlatformUnsupportedFunction = class extends RuntimeError {
+__name(_EventEmissionCycleError, "EventEmissionCycleError");
+var EventEmissionCycleError = _EventEmissionCycleError;
+var _PlatformUnsupportedFunction = class _PlatformUnsupportedFunction extends RuntimeError {
   constructor(functionName) {
     super(
       `Platform function not supported in this environment: ${functionName}`
@@ -362,6 +392,8 @@ var PlatformUnsupportedFunction = class extends RuntimeError {
     this.name = "PlatformUnsupportedFunction";
   }
 };
+__name(_PlatformUnsupportedFunction, "PlatformUnsupportedFunction");
+var PlatformUnsupportedFunction = _PlatformUnsupportedFunction;
 
 // src/definers/defineResource.ts
 function defineResource(constConfig) {
@@ -382,7 +414,7 @@ function defineResource(constConfig) {
     configSchema: constConfig.configSchema,
     resultSchema: constConfig.resultSchema,
     tags: constConfig.tags || [],
-    with: function(config) {
+    with: /* @__PURE__ */ __name(function(config) {
       if (constConfig.configSchema) {
         try {
           config = constConfig.configSchema.parse(config);
@@ -400,7 +432,7 @@ function defineResource(constConfig) {
         resource: this,
         config
       };
-    },
+    }, "with"),
     meta: constConfig.meta || {},
     middleware: constConfig.middleware || [],
     optional() {
@@ -411,6 +443,7 @@ function defineResource(constConfig) {
     }
   };
 }
+__name(defineResource, "defineResource");
 
 // src/definers/defineEvent.ts
 function defineEvent(config) {
@@ -431,6 +464,7 @@ function defineEvent(config) {
     }
   };
 }
+__name(defineEvent, "defineEvent");
 
 // src/definers/defineTaskMiddleware.ts
 function defineTaskMiddleware(middlewareDef) {
@@ -443,10 +477,10 @@ function defineTaskMiddleware(middlewareDef) {
     ...middlewareDef,
     dependencies: middlewareDef.dependencies || {}
   };
-  const wrap = (obj) => {
+  const wrap = /* @__PURE__ */ __name((obj) => {
     return {
       ...obj,
-      with: (config) => {
+      with: /* @__PURE__ */ __name((config) => {
         if (obj.configSchema) {
           try {
             config = obj.configSchema.parse(config);
@@ -466,11 +500,12 @@ function defineTaskMiddleware(middlewareDef) {
             ...config
           }
         });
-      }
+      }, "with")
     };
-  };
+  }, "wrap");
   return wrap(base);
 }
+__name(defineTaskMiddleware, "defineTaskMiddleware");
 
 // src/definers/defineResourceMiddleware.ts
 function defineResourceMiddleware(middlewareDef) {
@@ -483,10 +518,10 @@ function defineResourceMiddleware(middlewareDef) {
     ...middlewareDef,
     dependencies: middlewareDef.dependencies || {}
   };
-  const wrap = (obj) => {
+  const wrap = /* @__PURE__ */ __name((obj) => {
     return {
       ...obj,
-      with: (config) => {
+      with: /* @__PURE__ */ __name((config) => {
         if (obj.configSchema) {
           try {
             config = obj.configSchema.parse(config);
@@ -506,11 +541,12 @@ function defineResourceMiddleware(middlewareDef) {
             ...config
           }
         });
-      }
+      }, "with")
     };
-  };
+  }, "wrap");
   return wrap(base);
 }
+__name(defineResourceMiddleware, "defineResourceMiddleware");
 
 // src/definers/defineOverride.ts
 function defineOverride(base, patch) {
@@ -521,6 +557,7 @@ function defineOverride(base, patch) {
     id: base.id
   };
 }
+__name(defineOverride, "defineOverride");
 
 // src/definers/defineTag.ts
 function defineTag(definition) {
@@ -608,35 +645,45 @@ function defineTag(definition) {
     }
   };
 }
+__name(defineTag, "defineTag");
 
 // src/definers/tools.ts
 function isTask(definition) {
   return definition && definition[symbolTask];
 }
+__name(isTask, "isTask");
 function isResource(definition) {
   return definition && definition[symbolResource];
 }
+__name(isResource, "isResource");
 function isResourceWithConfig(definition) {
   return definition && definition[symbolResourceWithConfig];
 }
+__name(isResourceWithConfig, "isResourceWithConfig");
 function isEvent(definition) {
   return definition && definition[symbolEvent];
 }
+__name(isEvent, "isEvent");
 function isHook(definition) {
   return definition && definition[symbolHook];
 }
+__name(isHook, "isHook");
 function isTaskMiddleware(definition) {
   return definition && definition[symbolTaskMiddleware];
 }
+__name(isTaskMiddleware, "isTaskMiddleware");
 function isResourceMiddleware(definition) {
   return definition && definition[symbolResourceMiddleware];
 }
+__name(isResourceMiddleware, "isResourceMiddleware");
 function isTag(definition) {
   return definition && definition[symbolTag];
 }
+__name(isTag, "isTag");
 function isOptional(definition) {
   return definition && definition[symbolOptionalDependency];
 }
+__name(isOptional, "isOptional");
 
 // src/platform/index.ts
 function detectEnvironment() {
@@ -648,14 +695,8 @@ function detectEnvironment() {
   }
   return "universal";
 }
-async function loadModule(path) {
-  try {
-    return await import(path);
-  } catch (e) {
-    return __require(path);
-  }
-}
-var PlatformAdapter = class {
+__name(detectEnvironment, "detectEnvironment");
+var _PlatformAdapter = class _PlatformAdapter {
   constructor(env) {
     this.isInitialized = false;
     this.nodeALSClass = null;
@@ -666,7 +707,7 @@ var PlatformAdapter = class {
   }
   async init() {
     if (this.env === "node") {
-      this.nodeALSClass = (await loadModule("node:async_hooks")).AsyncLocalStorage;
+      this.nodeALSClass = (await import('async_hooks')).AsyncLocalStorage;
     }
   }
   onUncaughtException(handler) {
@@ -677,14 +718,14 @@ var PlatformAdapter = class {
       }
       case "browser": {
         const target = globalThis.window ?? globalThis;
-        const h = (e) => handler(e?.error ?? e);
+        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 = (e) => handler(e?.error ?? e);
+          const h = /* @__PURE__ */ __name((e) => handler(e?.error ?? e), "h");
           tgt.addEventListener("error", h);
           return () => tgt.removeEventListener("error", h);
         }
@@ -696,20 +737,20 @@ var PlatformAdapter = class {
   onUnhandledRejection(handler) {
     switch (this.env) {
       case "node": {
-        const h = (reason) => handler(reason);
+        const h = /* @__PURE__ */ __name((reason) => handler(reason), "h");
         process.on("unhandledRejection", h);
         return () => process.off("unhandledRejection", h);
       }
       case "browser": {
-        const target = globalThis.window ?? globalThis;
-        const wrap = (e) => handler(e.reason);
+        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 = (e) => handler(e.reason ?? e);
+          const wrap = /* @__PURE__ */ __name((e) => handler(e.reason ?? e), "wrap");
           tgt.addEventListener("unhandledrejection", wrap);
           return () => tgt.removeEventListener("unhandledrejection", wrap);
         }
@@ -729,7 +770,7 @@ var PlatformAdapter = class {
         };
       }
       case "browser": {
-        const win = window ?? globalThis.window ?? globalThis;
+        const win = window;
         win.addEventListener?.("beforeunload", handler);
         return () => {
           win.removeEventListener?.("beforeunload", handler);
@@ -743,10 +784,10 @@ var PlatformAdapter = class {
           cleanup.push(
             () => tgt.removeEventListener?.("beforeunload", handler)
           );
-          const vis = () => {
+          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)
@@ -801,7 +842,7 @@ var PlatformAdapter = class {
     switch (this.env) {
       case "node": {
         let instance;
-        const get = () => {
+        const get = /* @__PURE__ */ __name(() => {
           if (!instance) {
             if (!this.nodeALSClass) {
               throw new PlatformUnsupportedFunction(
@@ -811,25 +852,27 @@ var PlatformAdapter = class {
             instance = new this.nodeALSClass();
           }
           return instance;
-        };
+        }, "get");
         return {
-          getStore: () => get().getStore(),
-          run: (store2, callback) => get().run(store2, callback)
+          getStore: /* @__PURE__ */ __name(() => get().getStore(), "getStore"),
+          run: /* @__PURE__ */ __name((store2, callback) => get().run(store2, callback), "run")
         };
       }
       case "browser":
       default:
         return {
-          getStore: () => {
+          getStore: /* @__PURE__ */ __name(() => {
             throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
-          },
-          run: () => {
+          }, "getStore"),
+          run: /* @__PURE__ */ __name(() => {
             throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
-          }
+          }, "run")
         };
     }
   }
 };
+__name(_PlatformAdapter, "PlatformAdapter");
+var PlatformAdapter = _PlatformAdapter;
 var platformInstance = null;
 function getPlatform() {
   if (!platformInstance) {
@@ -838,6 +881,7 @@ function getPlatform() {
   }
   return platformInstance;
 }
+__name(getPlatform, "getPlatform");
 
 // src/globals/middleware/requireContext.middleware.ts
 var requireContextTaskMiddleware = defineTaskMiddleware({
@@ -859,6 +903,7 @@ var storage = platform.createAsyncLocalStorage();
 function getCurrentStore() {
   return storage.getStore();
 }
+__name(getCurrentStore, "getCurrentStore");
 function createContext(name = "runner.context") {
   if (!platform.hasAsyncLocalStorage()) {
     throw new PlatformUnsupportedFunction(
@@ -866,7 +911,7 @@ function createContext(name = "runner.context") {
     );
   }
   const ctxId = Symbol(name);
-  const use = () => {
+  const use = /* @__PURE__ */ __name(() => {
     const store2 = getCurrentStore();
     if (!store2 || !store2.has(ctxId)) {
       throw new ContextError(
@@ -874,13 +919,13 @@ function createContext(name = "runner.context") {
       );
     }
     return store2.get(ctxId);
-  };
-  const provide = (value, fn) => {
+  }, "use");
+  const provide = /* @__PURE__ */ __name((value, fn) => {
     const currentStore = getCurrentStore();
     const map = currentStore ? new Map(currentStore) : /* @__PURE__ */ new Map();
     map.set(ctxId, value);
     return storage.run(map, fn);
-  };
+  }, "provide");
   const api = {
     id: ctxId,
     use,
@@ -891,6 +936,7 @@ function createContext(name = "runner.context") {
   };
   return api;
 }
+__name(createContext, "createContext");
 
 // src/globals/resources/debug/debug.tag.ts
 var debugTag = defineTag({
@@ -949,13 +995,14 @@ var globalEvents = {
 var globalEventsArray = [globalEvents.ready];
 
 // src/models/Queue.ts
-var Queue = class {
+var _Queue = class _Queue {
   constructor() {
     this.tail = Promise.resolve();
     this.disposed = false;
     this.abortController = new AbortController();
     // true while inside a queued task → helps detect "queue in queue"
     this.executionContext = getPlatform().createAsyncLocalStorage();
+    this.hasAsyncLocalStorage = getPlatform().hasAsyncLocalStorage();
   }
   /**
    * Schedule an asynchronous task.
@@ -965,7 +1012,7 @@ var Queue = class {
     if (this.disposed) {
       return Promise.reject(new Error("Queue has been disposed"));
     }
-    if (this.executionContext.getStore()) {
+    if (this.hasAsyncLocalStorage && this.executionContext.getStore()) {
       return Promise.reject(
         new Error(
           "Dead\u2011lock detected: a queued task attempted to queue another task"
@@ -974,7 +1021,7 @@ var Queue = class {
     }
     const { signal } = this.abortController;
     const result = this.tail.then(
-      () => this.executionContext.run(true, () => task(signal))
+      () => this.hasAsyncLocalStorage ? this.executionContext.run(true, () => task(signal)) : task(signal)
     );
     this.tail = result.catch(() => {
     });
@@ -995,28 +1042,30 @@ var Queue = class {
     });
   }
 };
+__name(_Queue, "Queue");
+var Queue = _Queue;
 
 // src/globals/resources/queue.resource.ts
 var queueResource = defineResource({
   id: "globals.resources.queue",
-  context: () => ({
+  context: /* @__PURE__ */ __name(() => ({
     map: /* @__PURE__ */ new Map()
-  }),
-  init: async (_, deps, context) => {
+  }), "context"),
+  init: /* @__PURE__ */ __name(async (_, deps, context) => {
     const map = context.map;
     return {
       map,
-      run: (id2, task) => {
+      run: /* @__PURE__ */ __name((id2, task) => {
         if (!map.has(id2)) {
           map.set(id2, new Queue());
         }
         return map.get(id2).run(task);
-      }
+      }, "run")
     };
-  },
-  dispose: async (value, _, deps, context) => {
+  }, "init"),
+  dispose: /* @__PURE__ */ __name(async (value, _, deps, context) => {
     context.map.forEach((queue) => queue.dispose());
-  },
+  }, "dispose"),
   meta: {
     title: "Queue Map",
     description: "A global map that can be used to store and retrieve queues. You can run exclusive tasks based on using an id. queue.run(id, task) will run the task in the queue with the given id. If the queue does not exist, it will be created."
@@ -1193,7 +1242,7 @@ var globalMiddlewares = {
 };
 
 // src/models/TaskRunner.ts
-var TaskRunner = class {
+var _TaskRunner = class _TaskRunner {
   constructor(store2, eventManager, logger) {
     this.store = store2;
     this.eventManager = eventManager;
@@ -1238,10 +1287,12 @@ var TaskRunner = class {
     return this.middlewareManager.composeTaskRunner(task);
   }
 };
+__name(_TaskRunner, "TaskRunner");
+var TaskRunner = _TaskRunner;
 
 // src/models/MiddlewareManager.ts
 var _isLocked;
-var MiddlewareManager = class {
+var _MiddlewareManager = class _MiddlewareManager {
   constructor(store2, eventManager, logger) {
     this.store = store2;
     this.eventManager = eventManager;
@@ -1330,7 +1381,7 @@ var MiddlewareManager = class {
     for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
       const interceptor = reversedInterceptors[i];
       const nextFunction = wrapped;
-      wrapped = async (input) => {
+      wrapped = /* @__PURE__ */ __name(async (input) => {
         const executionInput = {
           task: {
             definition: null,
@@ -1339,11 +1390,11 @@ var MiddlewareManager = class {
           },
           next: nextFunction
         };
-        const wrappedNext = (i2) => {
+        const wrappedNext = /* @__PURE__ */ __name((i2) => {
           return nextFunction(i2.task.input);
-        };
+        }, "wrappedNext");
         return interceptor(wrappedNext, executionInput);
-      };
+      }, "wrapped");
     }
     return wrapped;
   }
@@ -1359,7 +1410,7 @@ var MiddlewareManager = class {
     for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
       const interceptor = reversedInterceptors[i];
       const nextFunction = wrapped;
-      wrapped = async (config) => {
+      wrapped = /* @__PURE__ */ __name(async (config) => {
         const executionInput = {
           resource: {
             definition: null,
@@ -1368,11 +1419,11 @@ var MiddlewareManager = class {
           },
           next: nextFunction
         };
-        const wrappedNext = (input) => {
+        const wrappedNext = /* @__PURE__ */ __name((input) => {
           return nextFunction(input.resource.config);
-        };
+        }, "wrappedNext");
         return interceptor(wrappedNext, executionInput);
-      };
+      }, "wrapped");
     }
     return wrapped;
   }
@@ -1382,7 +1433,7 @@ var MiddlewareManager = class {
    */
   composeTaskRunner(task) {
     const storeTask = this.store.tasks.get(task.id);
-    let next = async (input) => {
+    let next = /* @__PURE__ */ __name(async (input) => {
       let rawInput = input;
       if (task.inputSchema) {
         try {
@@ -1405,36 +1456,36 @@ var MiddlewareManager = class {
         }
       }
       return rawResult;
-    };
+    }, "next");
     if (storeTask.interceptors && storeTask.interceptors.length > 0) {
       for (let i = storeTask.interceptors.length - 1; i >= 0; i--) {
         const interceptor = storeTask.interceptors[i];
         const nextFunction = next;
-        next = async (input) => interceptor(nextFunction, input);
+        next = /* @__PURE__ */ __name(async (input) => interceptor(nextFunction, input), "next");
       }
     }
     if (this.taskMiddlewareInterceptors.length > 0) {
       const reversedInterceptors = [
         ...this.taskMiddlewareInterceptors
       ].reverse();
-      const createExecutionInput = (input, nextFunc) => ({
+      const createExecutionInput = /* @__PURE__ */ __name((input, nextFunc) => ({
         task: {
           definition: task,
           input
         },
         next: nextFunc
-      });
+      }), "createExecutionInput");
       let currentNext = next;
       for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
         const interceptor = reversedInterceptors[i];
         const nextFunction = currentNext;
-        currentNext = async (input) => {
+        currentNext = /* @__PURE__ */ __name(async (input) => {
           const executionInput = createExecutionInput(input, nextFunction);
-          const wrappedNext = (i2) => {
+          const wrappedNext = /* @__PURE__ */ __name((i2) => {
             return nextFunction(i2.task.input);
-          };
+          }, "wrappedNext");
           return interceptor(wrappedNext, executionInput);
-        };
+        }, "currentNext");
       }
       next = currentNext;
     }
@@ -1446,7 +1497,7 @@ var MiddlewareManager = class {
       const middleware = createdMiddlewares[i];
       const storeMiddleware = this.store.taskMiddlewares.get(middleware.id);
       const nextFunction = next;
-      const baseMiddlewareRunner = async (input) => {
+      const baseMiddlewareRunner = /* @__PURE__ */ __name(async (input) => {
         return storeMiddleware.middleware.run(
           {
             task: {
@@ -1458,7 +1509,7 @@ var MiddlewareManager = class {
           storeMiddleware.computedDependencies,
           middleware.config
         );
-      };
+      }, "baseMiddlewareRunner");
       const middlewareInterceptors = this.perMiddlewareInterceptors.get(middleware.id) || [];
       const wrappedMiddleware = this.wrapMiddlewareWithInterceptors(
         middleware,
@@ -1473,7 +1524,7 @@ var MiddlewareManager = class {
    * Run a resource init wrapped with its applicable middlewares.
    */
   async runResourceInit(resource, config, dependencies, context) {
-    let next = async (cfg) => {
+    let next = /* @__PURE__ */ __name(async (cfg) => {
       if (!resource.init) return void 0;
       const rawValue = await resource.init.call(
         null,
@@ -1493,7 +1544,7 @@ var MiddlewareManager = class {
         }
       }
       return rawValue;
-    };
+    }, "next");
     const createdMiddlewares = this.getApplicableResourceMiddlewares(resource);
     for (let i = createdMiddlewares.length - 1; i >= 0; i--) {
       const middleware = createdMiddlewares[i];
@@ -1501,7 +1552,7 @@ var MiddlewareManager = class {
         middleware.id
       );
       const nextFunction = next;
-      const baseMiddlewareRunner = async (cfg) => {
+      const baseMiddlewareRunner = /* @__PURE__ */ __name(async (cfg) => {
         try {
           const result = await storeMiddleware.middleware.run(
             {
@@ -1526,7 +1577,7 @@ var MiddlewareManager = class {
           }
           throw error;
         }
-      };
+      }, "baseMiddlewareRunner");
       const middlewareInterceptors = this.perResourceMiddlewareInterceptors.get(middleware.id) || [];
       const wrappedMiddleware = this.wrapResourceMiddlewareWithInterceptors(
         middleware,
@@ -1539,24 +1590,24 @@ var MiddlewareManager = class {
       const reversedInterceptors = [
         ...this.resourceMiddlewareInterceptors
       ].reverse();
-      const createExecutionInput = (config2, nextFunc) => ({
+      const createExecutionInput = /* @__PURE__ */ __name((config2, nextFunc) => ({
         resource: {
           definition: resource,
           config: config2
         },
         next: nextFunc
-      });
+      }), "createExecutionInput");
       let currentNext = next;
       for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
         const interceptor = reversedInterceptors[i];
         const nextFunction = currentNext;
-        currentNext = async (cfg) => {
+        currentNext = /* @__PURE__ */ __name(async (cfg) => {
           const executionInput = createExecutionInput(cfg, nextFunction);
-          const wrappedNext = (input) => {
+          const wrappedNext = /* @__PURE__ */ __name((input) => {
             return nextFunction(input.resource.config);
-          };
+          }, "wrappedNext");
           return interceptor(wrappedNext, executionInput);
-        };
+        }, "currentNext");
       }
       next = currentNext;
     }
@@ -1603,9 +1654,11 @@ var MiddlewareManager = class {
   }
 };
 _isLocked = new WeakMap();
+__name(_MiddlewareManager, "MiddlewareManager");
+var MiddlewareManager = _MiddlewareManager;
 
 // src/models/ResourceInitializer.ts
-var ResourceInitializer = class {
+var _ResourceInitializer = class _ResourceInitializer {
   constructor(store2, eventManager, logger) {
     this.store = store2;
     this.eventManager = eventManager;
@@ -1646,13 +1699,15 @@ var ResourceInitializer = class {
     );
   }
 };
+__name(_ResourceInitializer, "ResourceInitializer");
+var ResourceInitializer = _ResourceInitializer;
 
 // src/models/utils/safeStringify.ts
 function safeStringify(value, space, options) {
   const seen = /* @__PURE__ */ new WeakSet();
   const holderDepth = /* @__PURE__ */ new WeakMap();
   const maxDepth = typeof options?.maxDepth === "number" ? options.maxDepth : Infinity;
-  const replacer = function(_key, val) {
+  const replacer = /* @__PURE__ */ __name(function(_key, val) {
     if (typeof val === "function") {
       return "function()";
     }
@@ -1671,7 +1726,7 @@ function safeStringify(value, space, options) {
       holderDepth.set(val, currentDepth);
     }
     return val;
-  };
+  }, "replacer");
   try {
     return JSON.stringify(value, replacer, space);
   } catch {
@@ -1682,12 +1737,14 @@ function safeStringify(value, space, options) {
     }
   }
 }
+__name(safeStringify, "safeStringify");
 
 // src/models/LogPrinter.ts
 var ansiRegex = /[›][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
 function stripAnsi(str) {
   return str.replace(ansiRegex, "");
 }
+__name(stripAnsi, "stripAnsi");
 var COLORS = {
   trace: "\x1B[90m",
   debug: "\x1B[36m",
@@ -1847,11 +1904,12 @@ var _LogPrinter = class _LogPrinter {
   }
   static resetWriters() {
     _LogPrinter.writers = {
-      log: (msg) => console.log(msg),
-      error: (msg) => console.error?.(msg)
+      log: /* @__PURE__ */ __name((msg) => console.log(msg), "log"),
+      error: /* @__PURE__ */ __name((msg) => console.error?.(msg), "error")
     };
   }
 };
+__name(_LogPrinter, "LogPrinter");
 _LogPrinter.NO_COLORS = {
   trace: "",
   debug: "",
@@ -1868,9 +1926,9 @@ _LogPrinter.NO_COLORS = {
 };
 _LogPrinter.writers = {
   // eslint-disable-next-line no-console
-  log: (msg) => console.log(msg),
+  log: /* @__PURE__ */ __name((msg) => console.log(msg), "log"),
   // eslint-disable-next-line no-console
-  error: (msg) => console.error?.(msg)
+  error: /* @__PURE__ */ __name((msg) => console.error?.(msg), "error")
 };
 var LogPrinter = _LogPrinter;
 
@@ -2047,6 +2105,7 @@ var _Logger = class _Logger {
     }
   }
 };
+__name(_Logger, "Logger");
 _Logger.Severity = {
   trace: 0,
   debug: 1,
@@ -2058,7 +2117,7 @@ _Logger.Severity = {
 var Logger = _Logger;
 
 // src/models/DependencyProcessor.ts
-var DependencyProcessor = class {
+var _DependencyProcessor = class _DependencyProcessor {
   constructor(store2, eventManager, taskRunner, logger) {
     this.store = store2;
     this.eventManager = eventManager;
@@ -2171,18 +2230,18 @@ var DependencyProcessor = class {
   }
   makeTaskWithIntercept(original) {
     const taskId = original.id;
-    const fn = (input) => {
+    const fn = /* @__PURE__ */ __name((input) => {
       const storeTask = this.store.tasks.get(taskId);
       const effective = storeTask.task;
       return this.taskRunner.run(effective, input);
-    };
+    }, "fn");
     return Object.assign(fn, {
-      intercept: (middleware) => {
+      intercept: /* @__PURE__ */ __name((middleware) => {
         this.store.checkLock();
         const storeTask = this.store.tasks.get(taskId);
         if (!storeTask.interceptors) storeTask.interceptors = [];
         storeTask.interceptors.push(middleware);
-      }
+      }, "intercept")
     });
   }
   async initializeRoot() {
@@ -2205,7 +2264,7 @@ var DependencyProcessor = class {
       const hook = hookStoreElement.hook;
       if (hook.on) {
         const eventDefinition = hook.on;
-        const handler = async (receivedEvent) => {
+        const handler = /* @__PURE__ */ __name(async (receivedEvent) => {
           if (receivedEvent.source === hook.id) {
             return;
           }
@@ -2214,7 +2273,7 @@ var DependencyProcessor = class {
             receivedEvent,
             hookStoreElement.computedDependencies
           );
-        };
+        }, "handler");
         const order = hook.order ?? 0;
         if (eventDefinition === "*") {
           this.eventManager.addGlobalListener(handler, { order });
@@ -2334,11 +2393,13 @@ var DependencyProcessor = class {
     return storeResource.value;
   }
 };
+__name(_DependencyProcessor, "DependencyProcessor");
+var DependencyProcessor = _DependencyProcessor;
 
 // src/models/EventManager.ts
 var HandlerOptionsDefaults = { order: 0 };
 var _isLocked2;
-var EventManager = class {
+var _EventManager = class _EventManager {
   constructor(options) {
     // Core storage for event listeners
     this.listeners = /* @__PURE__ */ new Map();
@@ -2395,16 +2456,16 @@ var EventManager = class {
       }
     }
     const frame = { id: eventDefinition.id, source };
-    const processEmission = async () => {
+    const processEmission = /* @__PURE__ */ __name(async () => {
       const pseudoForExclude = {
         id: eventDefinition.id,
         data,
         timestamp: /* @__PURE__ */ new Date(),
         source,
         meta: eventDefinition.meta || {},
-        stopPropagation: () => {
-        },
-        isPropagationStopped: () => false,
+        stopPropagation: /* @__PURE__ */ __name(() => {
+        }, "stopPropagation"),
+        isPropagationStopped: /* @__PURE__ */ __name(() => false, "isPropagationStopped"),
         tags: eventDefinition.tags
       };
       const excludeFromGlobal = this.isExcludedFromGlobal(pseudoForExclude);
@@ -2416,13 +2477,13 @@ var EventManager = class {
         timestamp: /* @__PURE__ */ new Date(),
         source,
         meta: eventDefinition.meta || {},
-        stopPropagation: () => {
+        stopPropagation: /* @__PURE__ */ __name(() => {
           propagationStopped = true;
-        },
-        isPropagationStopped: () => propagationStopped,
+        }, "stopPropagation"),
+        isPropagationStopped: /* @__PURE__ */ __name(() => propagationStopped, "isPropagationStopped"),
         tags: eventDefinition.tags
       };
-      const baseEmit = async (eventToEmit) => {
+      const baseEmit = /* @__PURE__ */ __name(async (eventToEmit) => {
         if (allListeners.length === 0) {
           return;
         }
@@ -2438,15 +2499,15 @@ var EventManager = class {
             await listener.handler(eventToEmit);
           }
         }
-      };
+      }, "baseEmit");
       let emitWithInterceptors = baseEmit;
       const reversedInterceptors = [...this.emissionInterceptors].reverse();
       for (const interceptor of reversedInterceptors) {
         const nextFunction = emitWithInterceptors;
-        emitWithInterceptors = async (eventToEmit) => interceptor(nextFunction, eventToEmit);
+        emitWithInterceptors = /* @__PURE__ */ __name(async (eventToEmit) => interceptor(nextFunction, eventToEmit), "emitWithInterceptors");
       }
       await emitWithInterceptors(event);
-    };
+    }, "processEmission");
     if (this.runtimeCycleDetection && this.emissionStack && this.currentHookIdContext) {
       const currentStack = this.emissionStack.getStore();
       if (currentStack) {
@@ -2540,9 +2601,9 @@ var EventManager = class {
       timestamp: /* @__PURE__ */ new Date(),
       source: "",
       meta: eventDefinition.meta || {},
-      stopPropagation: () => {
-      },
-      isPropagationStopped: () => false,
+      stopPropagation: /* @__PURE__ */ __name(() => {
+      }, "stopPropagation"),
+      isPropagationStopped: /* @__PURE__ */ __name(() => false, "isPropagationStopped"),
       tags: eventDefinition.tags
     };
     if (this.isExcludedFromGlobal(pseudoEmission)) {
@@ -2582,7 +2643,7 @@ var EventManager = class {
    * @returns Promise resolving to the hook execution result
    */
   async executeHookWithInterceptors(hook, event, computedDependencies) {
-    const baseExecute = async (hookToExecute, eventForHook) => {
+    const baseExecute = /* @__PURE__ */ __name(async (hookToExecute, eventForHook) => {
       try {
         const result = await hookToExecute.run(
           eventForHook,
@@ -2592,12 +2653,12 @@ var EventManager = class {
       } catch (err) {
         throw err;
       }
-    };
+    }, "baseExecute");
     let executeWithInterceptors = baseExecute;
     const reversedInterceptors = [...this.hookInterceptors].reverse();
     for (const interceptor of reversedInterceptors) {
       const nextFunction = executeWithInterceptors;
-      executeWithInterceptors = async (hookToExecute, eventForHook) => interceptor(nextFunction, hookToExecute, eventForHook);
+      executeWithInterceptors = /* @__PURE__ */ __name(async (hookToExecute, eventForHook) => interceptor(nextFunction, hookToExecute, eventForHook), "executeWithInterceptors");
     }
     if (this.runtimeCycleDetection) {
       return await this.currentHookIdContext?.run(
@@ -2716,6 +2777,8 @@ var EventManager = class {
   }
 };
 _isLocked2 = new WeakMap();
+__name(_EventManager, "EventManager");
+var EventManager = _EventManager;
 
 // src/models/utils/findCircularDependencies.ts
 function findCircularDependencies(nodes) {
@@ -2750,6 +2813,7 @@ function findCircularDependencies(nodes) {
     stack.delete(node.id);
     path.pop();
   }
+  __name(dfs, "dfs");
   for (const node of nodes) {
     if (!visited.has(node.id)) {
       dfs(node);
@@ -2758,9 +2822,10 @@ function findCircularDependencies(nodes) {
   result.cycles = Array.from(new Set(result.cycles));
   return result;
 }
+__name(findCircularDependencies, "findCircularDependencies");
 
 // src/models/StoreValidator.ts
-var StoreValidator = class {
+var _StoreValidator = class _StoreValidator {
   constructor(registry) {
     this.registry = registry;
   }
@@ -2839,9 +2904,11 @@ var StoreValidator = class {
     }
   }
 };
+__name(_StoreValidator, "StoreValidator");
+var StoreValidator = _StoreValidator;
 
 // src/models/StoreRegistry.ts
-var StoreRegistry = class {
+var _StoreRegistry = class _StoreRegistry {
   constructor(store2) {
     this.store = store2;
     this.tasks = /* @__PURE__ */ new Map();
@@ -3192,9 +3259,11 @@ var StoreRegistry = class {
     return currentItem;
   }
 };
+__name(_StoreRegistry, "StoreRegistry");
+var StoreRegistry = _StoreRegistry;
 
 // src/models/OverrideManager.ts
-var OverrideManager = class {
+var _OverrideManager = class _OverrideManager {
   constructor(registry) {
     this.registry = registry;
     this.overrides = /* @__PURE__ */ new Map();
@@ -3257,10 +3326,12 @@ var OverrideManager = class {
     }
   }
 };
+__name(_OverrideManager, "OverrideManager");
+var OverrideManager = _OverrideManager;
 
 // src/models/Store.ts
 var _isLocked3, _isInitialized;
-var Store = class {
+var _Store = class _Store {
   constructor(eventManager, logger, onUnhandledError) {
     this.eventManager = eventManager;
     this.logger = logger;
@@ -3439,6 +3510,8 @@ var Store = class {
 };
 _isLocked3 = new WeakMap();
 _isInitialized = new WeakMap();
+__name(_Store, "Store");
+var Store = _Store;
 
 // src/globals/resources/debug/types.ts
 var allFalse = Object.freeze({
@@ -3489,7 +3562,8 @@ function formatConfig(config) {
   }
   return { ...allFalse, ...config };
 }
-var getConfig = (config, taggable) => {
+__name(formatConfig, "formatConfig");
+var getConfig = /* @__PURE__ */ __name((config, taggable) => {
   if (!taggable) {
     return formatConfig(config);
   }
@@ -3499,7 +3573,7 @@ var getConfig = (config, taggable) => {
     return { ...formatConfig(config), ...debugTagConfigFormatted };
   }
   return formatConfig(config);
-};
+}, "getConfig");
 
 // src/globals/resources/debug/debugConfig.resource.ts
 var debugConfig = defineResource({
@@ -3509,21 +3583,21 @@ var debugConfig = defineResource({
     description: "Debug config. This is used to debug the system."
   },
   tags: [globalTags.system],
-  init: async (config) => {
+  init: /* @__PURE__ */ __name(async (config) => {
     const myConfig = { ...getConfig(config) };
     Object.freeze(myConfig);
     return myConfig;
-  }
+  }, "init")
 });
 
 // src/globals/resources/debug/utils.ts
-var hasSystemTag = (definition) => {
+var hasSystemTag = /* @__PURE__ */ __name((definition) => {
   const maybeTags = definition.tags;
   if (!Array.isArray(maybeTags)) {
     return false;
   }
   return globalTags.system.exists(definition);
-};
+}, "hasSystemTag");
 
 // src/globals/resources/debug/globalEvent.hook.ts
 var globalEventListener = defineHook({
@@ -3533,7 +3607,7 @@ var globalEventListener = defineHook({
     logger: globalResources.logger,
     debugConfig
   },
-  run: async (event, { logger, debugConfig: debugConfig2 }) => {
+  run: /* @__PURE__ */ __name(async (event, { logger, debugConfig: debugConfig2 }) => {
     if (hasSystemTag(event)) {
       return;
     }
@@ -3545,7 +3619,7 @@ var globalEventListener = defineHook({
         data: debugConfig2.logEventEmissionInput ? { data: event.data } : void 0
       });
     }
-  },
+  }, "run"),
   meta: {
     title: "Non-system Event Logger",
     description: "Logs all non-system events."
@@ -3556,13 +3630,13 @@ var globalEventListener = defineHook({
 // src/globals/resources/debug/executionTracker.middleware.ts
 var tasksTrackerMiddleware = defineTaskMiddleware({
   id: "globals.debug.middleware.task.executionTracker",
-  everywhere: (task) => !globalTags.system.exists(task),
+  everywhere: /* @__PURE__ */ __name((task) => !globalTags.system.exists(task), "everywhere"),
   dependencies: {
     logger: globalResources.logger,
     debugConfig,
     store: globalResources.store
   },
-  run: async ({ task, next }, { logger, debugConfig: debugConfig2, store: store2 }) => {
+  run: /* @__PURE__ */ __name(async ({ task, next }, { logger, debugConfig: debugConfig2, store: store2 }) => {
     const start = Date.now();
     logger = logger.with({
       source: tasksTrackerMiddleware.id
@@ -3581,7 +3655,7 @@ var tasksTrackerMiddleware = defineTaskMiddleware({
       data: shouldShowResult ? { result } : void 0
     });
     return result;
-  },
+  }, "run"),
   meta: {
     title: "Execution Tracker",
     description: "Tracks the execution of tasks and resources."
@@ -3595,8 +3669,8 @@ var resourcesTrackerMiddleware = defineResourceMiddleware({
     debugConfig,
     store: globalResources.store
   },
-  everywhere: (resource) => !globalTags.system.exists(resource),
-  run: async ({ resource, next }, { logger, debugConfig: debugConfig2, store: store2 }) => {
+  everywhere: /* @__PURE__ */ __name((resource) => !globalTags.system.exists(resource), "everywhere"),
+  run: /* @__PURE__ */ __name(async ({ resource, next }, { logger, debugConfig: debugConfig2, store: store2 }) => {
     const start = Date.now();
     logger = logger.with({
       source: resourcesTrackerMiddleware.id
@@ -3618,7 +3692,7 @@ var resourcesTrackerMiddleware = defineResourceMiddleware({
       data: shouldShowResult ? { result } : void 0
     });
     return result;
-  },
+  }, "run"),
   meta: {
     title: "Execution Tracker",
     description: "Tracks the execution of tasks and resources."
@@ -3640,7 +3714,7 @@ var middlewareInterceptorResource = defineResource({
     debugConfig,
     middlewareManager: globalResources.middlewareManager
   },
-  init: async (event, deps) => {
+  init: /* @__PURE__ */ __name(async (event, deps) => {
     const { logger, debugConfig: debugConfig2, middlewareManager } = deps;
     middlewareManager.intercept(
       "task",
@@ -3698,7 +3772,7 @@ var middlewareInterceptorResource = defineResource({
         return result;
       }
     );
-  }
+  }, "init")
 });
 
 // src/globals/resources/debug/hook.hook.ts
@@ -3714,7 +3788,7 @@ var hookInterceptorResource = defineResource({
     debugConfig,
     eventManager: globalResources.eventManager
   },
-  init: async (event, deps) => {
+  init: /* @__PURE__ */ __name(async (event, deps) => {
     deps.eventManager.interceptHook(async (next, hook, event2) => {
       const { logger, debugConfig: debugConfig2 } = deps;
       if (hasSystemTag(hook)) {
@@ -3737,13 +3811,13 @@ var hookInterceptorResource = defineResource({
         });
       }
     });
-  }
+  }, "init")
 });
 
 // src/globals/resources/debug/debug.resource.ts
 var debugResource = defineResource({
   id: "globals.resources.debug",
-  register: (config) => {
+  register: /* @__PURE__ */ __name((config) => {
     return [
       debugConfig.with(config),
       globalEventListener,
@@ -3752,7 +3826,7 @@ var debugResource = defineResource({
       tasksTrackerMiddleware,
       resourcesTrackerMiddleware
     ];
-  },
+  }, "register"),
   meta: {
     title: "Debug",
     description: "Debug resource. This is used to debug the system."
@@ -3767,25 +3841,26 @@ var processSafetyNetsInstalled = false;
 function installGlobalProcessSafetyNetsOnce() {
   if (processSafetyNetsInstalled) return;
   processSafetyNetsInstalled = true;
-  const onUncaughtException = async (err) => {
+  const onUncaughtException = /* @__PURE__ */ __name(async (err) => {
     for (const handler of activeErrorHandlers) {
       try {
         await handler(err, "uncaughtException");
       } catch (_) {
       }
     }
-  };
-  const onUnhandledRejection = async (reason) => {
+  }, "onUncaughtException");
+  const onUnhandledRejection = /* @__PURE__ */ __name(async (reason) => {
     for (const handler of activeErrorHandlers) {
       try {
         await handler(reason, "unhandledRejection");
       } catch (_) {
       }
     }
-  };
+  }, "onUnhandledRejection");
   platform2.onUncaughtException(onUncaughtException);
   platform2.onUnhandledRejection(onUnhandledRejection);
 }
+__name(installGlobalProcessSafetyNetsOnce, "installGlobalProcessSafetyNetsOnce");
 function registerProcessLevelSafetyNets(handler) {
   installGlobalProcessSafetyNetsOnce();
   activeErrorHandlers.add(handler);
@@ -3793,12 +3868,13 @@ function registerProcessLevelSafetyNets(handler) {
     activeErrorHandlers.delete(handler);
   };
 }
+__name(registerProcessLevelSafetyNets, "registerProcessLevelSafetyNets");
 var activeDisposers = /* @__PURE__ */ new Set();
 var shutdownHooksInstalled = false;
 function installGlobalShutdownHooksOnce() {
   if (shutdownHooksInstalled) return;
   shutdownHooksInstalled = true;
-  const handler = async () => {
+  const handler = /* @__PURE__ */ __name(async () => {
     try {
       const disposers = Array.from(activeDisposers);
       for (const d of disposers) {
@@ -3817,9 +3893,10 @@ function installGlobalShutdownHooksOnce() {
         }
       }
     }
-  };
+  }, "handler");
   platform2.onShutdownSignal(handler);
 }
+__name(installGlobalShutdownHooksOnce, "installGlobalShutdownHooksOnce");
 function registerShutdownHook(disposeOnce) {
   installGlobalShutdownHooksOnce();
   activeDisposers.add(disposeOnce);
@@ -3827,6 +3904,7 @@ function registerShutdownHook(disposeOnce) {
     activeDisposers.delete(disposeOnce);
   };
 }
+__name(registerShutdownHook, "registerShutdownHook");
 
 // src/models/UnhandledError.ts
 function createDefaultUnhandledError(logger) {
@@ -3841,6 +3919,7 @@ function createDefaultUnhandledError(logger) {
     });
   };
 }
+__name(createDefaultUnhandledError, "createDefaultUnhandledError");
 function bindProcessErrorHandler(handler) {
   return async (error, source) => {
     try {
@@ -3849,15 +3928,17 @@ function bindProcessErrorHandler(handler) {
     }
   };
 }
+__name(bindProcessErrorHandler, "bindProcessErrorHandler");
 async function safeReportUnhandledError(handler, info) {
   try {
     await handler(info);
   } catch {
   }
 }
+__name(safeReportUnhandledError, "safeReportUnhandledError");
 
 // src/models/RunResult.ts
-var RunResult = class {
+var _RunResult = class _RunResult {
   constructor(value, logger, store2, eventManager, taskRunner, disposeFn) {
     this.value = value;
     this.logger = logger;
@@ -3871,7 +3952,7 @@ var RunResult = class {
      * @param args - The arguments to pass to the task.
      * @returns The result of the task.
      */
-    this.runTask = (task, ...args) => {
+    this.runTask = /* @__PURE__ */ __name((task, ...args) => {
       if (typeof task === "string") {
         const taskId = task;
         if (!this.store.tasks.has(taskId)) {
@@ -3880,13 +3961,13 @@ var RunResult = class {
         task = this.store.tasks.get(taskId).task;
       }
       return this.taskRunner.run(task, ...args);
-    };
+    }, "runTask");
     /**
      * Emit an event within the context of the run result.
      * @param event - The event to emit.
      * @param payload - The payload to emit.
      */
-    this.emitEvent = (event, payload) => {
+    this.emitEvent = /* @__PURE__ */ __name((event, payload) => {
       if (typeof event === "string") {
         const eventId = event;
         if (!this.store.events.has(eventId)) {
@@ -3895,29 +3976,31 @@ var RunResult = class {
         event = this.store.events.get(eventId).event;
       }
       return this.eventManager.emit(event, payload, "outside");
-    };
+    }, "emitEvent");
     /**
      * Get the value of a resource from the run result.
      * @param resource - The resource to get the value of.
      * @returns The value of the resource.
      */
-    this.getResourceValue = (resource) => {
+    this.getResourceValue = /* @__PURE__ */ __name((resource) => {
       const resourceId = typeof resource === "string" ? resource : resource.id;
       if (!this.store.resources.has(resourceId)) {
         throw new ResourceNotFoundError(resourceId);
       }
       return this.store.resources.get(resourceId).value;
-    };
-    this.dispose = () => {
+    }, "getResourceValue");
+    this.dispose = /* @__PURE__ */ __name(() => {
       return this.disposeFn();
-    };
+    }, "dispose");
   }
 };
+__name(_RunResult, "RunResult");
+var RunResult = _RunResult;
 
 // src/run.ts
 var platform3 = getPlatform();
 async function run(resourceOrResourceWithConfig, options) {
-  await getPlatform().init();
+  await platform3.init();
   const {
     debug = void 0,
     logs = {},
@@ -3960,7 +4043,7 @@ async function run(resourceOrResourceWithConfig, options) {
     logger
   );
   let unhookShutdown;
-  const disposeAll = async () => {
+  const disposeAll = /* @__PURE__ */ __name(async () => {
     try {
       if (unhookProcessSafetyNets) {
         unhookProcessSafetyNets();
@@ -3973,7 +4056,7 @@ async function run(resourceOrResourceWithConfig, options) {
     } finally {
       await store2.dispose();
     }
-  };
+  }, "disposeAll");
   try {
     if (debug) {
       store2.storeGenericItem(debugResource.with(debug));
@@ -4029,6 +4112,7 @@ async function run(resourceOrResourceWithConfig, options) {
     throw err;
   }
 }
+__name(run, "run");
 function extractResourceAndConfig(resourceOrResourceWithConfig) {
   let resource;
   let config;
@@ -4041,6 +4125,7 @@ function extractResourceAndConfig(resourceOrResourceWithConfig) {
   }
   return { resource, config };
 }
+__name(extractResourceAndConfig, "extractResourceAndConfig");
 
 // src/testing.ts
 var testResourceCounter = 0;
@@ -4060,12 +4145,13 @@ function createTestResource(root, options) {
     }
   });
 }
+__name(createTestResource, "createTestResource");
 function buildTestFacade(deps) {
   return {
     // Run a task within the fully initialized ecosystem
-    runTask: (task, ...args) => deps.taskRunner.run(task, ...args),
+    runTask: /* @__PURE__ */ __name((task, ...args) => deps.taskRunner.run(task, ...args), "runTask"),
     // Access a resource value by id (string or symbol)
-    getResource: (id2) => deps.store.resources.get(id2)?.value,
+    getResource: /* @__PURE__ */ __name((id2) => deps.store.resources.get(id2)?.value, "getResource"),
     // Expose internals when needed in tests (not recommended for app usage)
     taskRunner: deps.taskRunner,
     store: deps.store,
@@ -4073,9 +4159,10 @@ function buildTestFacade(deps) {
     eventManager: deps.eventManager
   };
 }
+__name(buildTestFacade, "buildTestFacade");
 
 // src/models/Semaphore.ts
-var Semaphore = class {
+var _Semaphore = class _Semaphore {
   constructor(maxPermits) {
     this.waitingQueue = [];
     this.disposed = false;
@@ -4110,10 +4197,10 @@ var Semaphore = class {
         }, options.timeout);
       }
       if (options?.signal) {
-        const abortHandler = () => {
+        const abortHandler = /* @__PURE__ */ __name(() => {
           this.removeFromQueue(operation);
           reject(new Error("Operation was aborted"));
-        };
+        }, "abortHandler");
         options.signal.addEventListener("abort", abortHandler, { once: true });
         const originalResolve = operation.resolve;
         const originalReject = operation.reject;
@@ -4219,6 +4306,8 @@ var Semaphore = class {
     };
   }
 };
+__name(_Semaphore, "Semaphore");
+var Semaphore = _Semaphore;
 
 // src/index.ts
 var globals = {