@bluelibs/runner 4.5.0-alpha → 4.5.0-alpha.2

package/dist/index.cjs

@@ -0,0 +1,4265 @@
+'use strict';
+
+var lruCache = require('lru-cache');
+
+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 __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 = {};
+__export(defs_exports, {
+  isOneOf: () => isOneOf,
+  onAnyOf: () => onAnyOf,
+  symbolDispose: () => symbolDispose,
+  symbolEvent: () => symbolEvent,
+  symbolFilePath: () => symbolFilePath,
+  symbolHook: () => symbolHook,
+  symbolIndexResource: () => symbolIndexResource,
+  symbolMiddleware: () => symbolMiddleware,
+  symbolMiddlewareConfigured: () => symbolMiddlewareConfigured,
+  symbolOptionalDependency: () => symbolOptionalDependency,
+  symbolResource: () => symbolResource,
+  symbolResourceMiddleware: () => symbolResourceMiddleware,
+  symbolResourceWithConfig: () => symbolResourceWithConfig,
+  symbolStore: () => symbolStore,
+  symbolTag: () => symbolTag,
+  symbolTagConfigured: () => symbolTagConfigured,
+  symbolTask: () => symbolTask,
+  symbolTaskMiddleware: () => symbolTaskMiddleware
+});
+
+// src/types/symbols.ts
+var symbolTask = Symbol("runner.task");
+var symbolResource = Symbol("runner.resource");
+var symbolResourceWithConfig = Symbol(
+  "runner.resourceWithConfig"
+);
+var symbolEvent = Symbol("runner.event");
+var symbolMiddleware = Symbol("runner.middleware");
+var symbolTaskMiddleware = Symbol(
+  "runner.taskMiddleware"
+);
+var symbolResourceMiddleware = Symbol(
+  "runner.resourceMiddleware"
+);
+var symbolMiddlewareConfigured = Symbol(
+  "runner.middlewareConfigured"
+);
+var symbolHook = Symbol("runner.hook");
+var symbolTag = Symbol("runner.tag");
+var symbolTagConfigured = Symbol(
+  "runner.tagConfigured"
+);
+var symbolOptionalDependency = Symbol(
+  "runner.optionalDependency"
+);
+var symbolFilePath = Symbol("runner.filePath");
+var symbolDispose = Symbol("runner.dispose");
+var symbolStore = Symbol("runner.store");
+var symbolIndexResource = Symbol(
+  "runner.indexResource"
+);
+
+// src/types/event.ts
+function onAnyOf(...defs) {
+  return defs;
+}
+function isOneOf(emission, defs) {
+  return defs.some((d) => d.id === emission.id);
+}
+var cacheFactoryTask = defineTask({
+  id: "globals.tasks.cacheFactory",
+  run: async (options) => {
+    return new lruCache.LRUCache(options);
+  }
+});
+var cacheResource = defineResource({
+  id: "globals.resources.cache",
+  register: [cacheFactoryTask],
+  dependencies: {
+    cacheFactoryTask
+  },
+  init: async (config, { cacheFactoryTask: cacheFactoryTask2 }) => {
+    return {
+      map: /* @__PURE__ */ new Map(),
+      cacheFactoryTask: cacheFactoryTask2,
+      defaultOptions: {
+        ttl: 10 * 1e3,
+        max: 100,
+        // Maximum number of items in cache
+        ttlAutopurge: true,
+        // Automatically purge expired items
+        ...config.defaultOptions
+      }
+    };
+  },
+  dispose: async (cache) => {
+    for (const cacheInstance of cache.map.values()) {
+      await cacheInstance.clear();
+    }
+  }
+});
+var defaultKeyBuilder = (taskId, input) => `${taskId}-${JSON.stringify(input)}`;
+var cacheMiddleware = defineTaskMiddleware({
+  id: "globals.middleware.cache",
+  dependencies: { cache: cacheResource },
+  async run({ task, next }, deps, config) {
+    const { cache } = deps;
+    config = {
+      keyBuilder: defaultKeyBuilder,
+      ttl: 10 * 1e3,
+      max: 100,
+      // Maximum number of items in cache
+      ttlAutopurge: true,
+      // Automatically purge expired items
+      ...config
+    };
+    const taskId = task.definition.id;
+    let cacheHolderForTask = cache.map.get(taskId);
+    if (!cacheHolderForTask) {
+      const { keyBuilder, ...lruOptions } = config;
+      const cacheOptions = {
+        ...cache.defaultOptions,
+        ...lruOptions
+      };
+      cacheHolderForTask = await cache.cacheFactoryTask(cacheOptions);
+      cache.map.set(taskId, cacheHolderForTask);
+    }
+    const key = config.keyBuilder(taskId, task.input);
+    const cachedValue = await cacheHolderForTask.get(key);
+    if (cachedValue) {
+      return cachedValue;
+    }
+    const result = await next(task.input);
+    await cacheHolderForTask.set(key, result);
+    return result;
+  }
+});
+
+// src/tools/getCallerFile.ts
+function getCallerFile() {
+  const originalFunc = Error.prepareStackTrace;
+  try {
+    const err = new Error();
+    let callerfile;
+    let currentfile;
+    Error.prepareStackTrace = (err2, stack2) => stack2;
+    const stack = err.stack;
+    stack.shift();
+    currentfile = stack.shift()?.getFileName?.();
+    callerfile = stack.shift()?.getFileName?.();
+    return callerfile;
+  } finally {
+    Error.prepareStackTrace = originalFunc;
+  }
+}
+
+// src/definers/defineTask.ts
+function defineTask(taskConfig) {
+  const filePath = getCallerFile();
+  const id2 = taskConfig.id;
+  return {
+    [symbolTask]: true,
+    [symbolFilePath]: filePath,
+    id: id2,
+    dependencies: taskConfig.dependencies || {},
+    middleware: taskConfig.middleware || [],
+    run: taskConfig.run,
+    inputSchema: taskConfig.inputSchema,
+    resultSchema: taskConfig.resultSchema,
+    meta: taskConfig.meta || {},
+    tags: taskConfig.tags || [],
+    // autorun,
+    optional() {
+      return {
+        inner: this,
+        [symbolOptionalDependency]: true
+      };
+    }
+  };
+}
+
+// src/definers/defineHook.ts
+function defineHook(hookDef) {
+  const filePath = getCallerFile();
+  return {
+    [symbolHook]: true,
+    [symbolFilePath]: filePath,
+    id: hookDef.id,
+    dependencies: hookDef.dependencies || {},
+    on: hookDef.on,
+    order: hookDef.order,
+    run: hookDef.run,
+    meta: hookDef.meta || {},
+    tags: hookDef.tags || []
+  };
+}
+
+// src/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  CircularDependenciesError: () => CircularDependenciesError,
+  ContextError: () => ContextError,
+  DependencyNotFoundError: () => DependencyNotFoundError,
+  DuplicateRegistrationError: () => DuplicateRegistrationError,
+  EventCycleError: () => EventCycleError,
+  EventEmissionCycleError: () => EventEmissionCycleError,
+  EventNotFoundError: () => EventNotFoundError,
+  LockedError: () => LockedError,
+  MiddlewareNotRegisteredError: () => MiddlewareNotRegisteredError,
+  PlatformUnsupportedFunction: () => PlatformUnsupportedFunction,
+  ResourceNotFoundError: () => ResourceNotFoundError,
+  RuntimeError: () => RuntimeError,
+  StoreAlreadyInitializedError: () => StoreAlreadyInitializedError,
+  TagNotFoundError: () => TagNotFoundError,
+  UnknownItemTypeError: () => UnknownItemTypeError,
+  ValidationError: () => ValidationError
+});
+var RuntimeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RuntimeError";
+  }
+};
+var DuplicateRegistrationError = class 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.`
+    );
+    this.name = "DuplicateRegistrationError";
+  }
+};
+var DependencyNotFoundError = class extends RuntimeError {
+  constructor(key) {
+    super(
+      `Dependency ${key.toString()} not found. Did you forget to register it through a resource?`
+    );
+    this.name = "DependencyNotFoundError";
+  }
+};
+var UnknownItemTypeError = class extends RuntimeError {
+  constructor(item) {
+    super(
+      `Unknown item type: ${item}. Please ensure you are not using different versions of '@bluelibs/runner'`
+    );
+    this.name = "UnknownItemTypeError";
+  }
+};
+var ContextError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ContextError";
+  }
+};
+var CircularDependenciesError = class extends RuntimeError {
+  constructor(cycles) {
+    const cycleDetails = cycles.map((cycle) => `  \u2022 ${cycle}`).join("\n");
+    const hasMiddleware = cycles.some((cycle) => cycle.includes("middleware"));
+    let guidance = "\n\nTo resolve circular dependencies:";
+    guidance += "\n  \u2022 Consider refactoring to reduce coupling between components";
+    guidance += "\n  \u2022 Extract shared dependencies into separate resources";
+    if (hasMiddleware) {
+      guidance += "\n  \u2022 For middleware: you can filter out tasks/resources using everywhere(fn)";
+      guidance += "\n  \u2022 Consider using events for communication instead of direct dependencies";
+    }
+    super(`Circular dependencies detected:
+${cycleDetails}${guidance}`);
+    this.name = "CircularDependenciesError";
+  }
+};
+var EventNotFoundError = class extends RuntimeError {
+  constructor(id2) {
+    super(`Event "${id2.toString()}" not found. Did you forget to register it?`);
+    this.name = "EventNotFoundError";
+  }
+};
+var ResourceNotFoundError = class extends RuntimeError {
+  constructor(id2) {
+    super(
+      `Resource "${id2.toString()}" not found. Did you forget to register it or are you using the correct id?`
+    );
+    this.name = "ResourceNotFoundError";
+  }
+};
+var MiddlewareNotRegisteredError = class 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?`
+    );
+    this.name = `MiddlewareNotRegisteredError: ${type} ${source} ${middlewareId}`;
+  }
+};
+var TagNotFoundError = class extends RuntimeError {
+  constructor(id2) {
+    super(
+      `Tag "${id2}" not registered. Did you forget to register it inside a resource?`
+    );
+    this.name = "TagNotRegisteredError";
+  }
+};
+var LockedError = class extends RuntimeError {
+  constructor(what) {
+    super(`Cannot modify the ${what.toString()} when it is locked.`);
+    this.name = "LockedError";
+  }
+};
+var StoreAlreadyInitializedError = class extends RuntimeError {
+  constructor() {
+    super("Store already initialized. Cannot reinitialize.");
+    this.name = "StoreAlreadyInitializedError";
+  }
+};
+var ValidationError = class 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 {
+  constructor(path) {
+    const chain = path.map((p) => `${p.id}\u2190${p.source}`).join("  ->  ");
+    super(
+      `Event emission cycle detected:
+  ${chain}
+
+Break the cycle by changing hook logic (avoid mutual emits) or gate with conditions/tags.`
+    );
+    this.name = "EventCycleError";
+  }
+};
+var EventEmissionCycleError = class extends RuntimeError {
+  constructor(cycles) {
+    const list = cycles.map((c) => `  \u2022 ${c}`).join("\n");
+    super(
+      `Event emission cycles detected between hooks and events:
+${list}
+
+This was detected at compile time (dry-run). Break the cycle by avoiding mutual emits between hooks or scoping hooks using tags.`
+    );
+    this.name = "EventEmissionCycleError";
+  }
+};
+var PlatformUnsupportedFunction = class extends RuntimeError {
+  constructor(functionName) {
+    super(
+      `Platform function not supported in this environment: ${functionName}`
+    );
+    this.name = "PlatformUnsupportedFunction";
+  }
+};
+
+// src/definers/defineResource.ts
+function defineResource(constConfig) {
+  const filePath = constConfig[symbolFilePath] || getCallerFile();
+  const isIndexResource = constConfig[symbolIndexResource] || false;
+  const id2 = constConfig.id;
+  return {
+    [symbolResource]: true,
+    [symbolFilePath]: filePath,
+    [symbolIndexResource]: isIndexResource,
+    id: id2,
+    dependencies: constConfig.dependencies,
+    dispose: constConfig.dispose,
+    register: constConfig.register || [],
+    overrides: constConfig.overrides || [],
+    init: constConfig.init,
+    context: constConfig.context,
+    configSchema: constConfig.configSchema,
+    resultSchema: constConfig.resultSchema,
+    tags: constConfig.tags || [],
+    with: function(config) {
+      if (constConfig.configSchema) {
+        try {
+          config = constConfig.configSchema.parse(config);
+        } catch (error) {
+          throw new ValidationError(
+            "Resource config",
+            id2,
+            error instanceof Error ? error : new Error(String(error))
+          );
+        }
+      }
+      return {
+        [symbolResourceWithConfig]: true,
+        id: this.id,
+        resource: this,
+        config
+      };
+    },
+    meta: constConfig.meta || {},
+    middleware: constConfig.middleware || [],
+    optional() {
+      return {
+        inner: this,
+        [symbolOptionalDependency]: true
+      };
+    }
+  };
+}
+
+// src/definers/defineEvent.ts
+function defineEvent(config) {
+  const callerFilePath = getCallerFile();
+  const eventConfig = config;
+  return {
+    ...eventConfig,
+    id: eventConfig.id,
+    [symbolFilePath]: callerFilePath,
+    [symbolEvent]: true,
+    // This is a workaround
+    tags: eventConfig.tags || [],
+    optional() {
+      return {
+        inner: this,
+        [symbolOptionalDependency]: true
+      };
+    }
+  };
+}
+
+// src/definers/defineTaskMiddleware.ts
+function defineTaskMiddleware(middlewareDef) {
+  const filePath = getCallerFile();
+  const base = {
+    [symbolFilePath]: filePath,
+    [symbolTaskMiddleware]: true,
+    config: {},
+    configSchema: middlewareDef.configSchema,
+    ...middlewareDef,
+    dependencies: middlewareDef.dependencies || {}
+  };
+  const wrap = (obj) => {
+    return {
+      ...obj,
+      with: (config) => {
+        if (obj.configSchema) {
+          try {
+            config = obj.configSchema.parse(config);
+          } catch (error) {
+            throw new ValidationError(
+              "Middleware config",
+              obj.id,
+              error instanceof Error ? error : new Error(String(error))
+            );
+          }
+        }
+        return wrap({
+          ...obj,
+          [symbolMiddlewareConfigured]: true,
+          config: {
+            ...obj.config,
+            ...config
+          }
+        });
+      }
+    };
+  };
+  return wrap(base);
+}
+
+// src/definers/defineResourceMiddleware.ts
+function defineResourceMiddleware(middlewareDef) {
+  const filePath = getCallerFile();
+  const base = {
+    [symbolFilePath]: filePath,
+    [symbolResourceMiddleware]: true,
+    config: {},
+    configSchema: middlewareDef.configSchema,
+    ...middlewareDef,
+    dependencies: middlewareDef.dependencies || {}
+  };
+  const wrap = (obj) => {
+    return {
+      ...obj,
+      with: (config) => {
+        if (obj.configSchema) {
+          try {
+            config = obj.configSchema.parse(config);
+          } catch (error) {
+            throw new ValidationError(
+              "Middleware config",
+              obj.id,
+              error
+            );
+          }
+        }
+        return wrap({
+          ...obj,
+          [symbolMiddlewareConfigured]: true,
+          config: {
+            ...obj.config,
+            ...config
+          }
+        });
+      }
+    };
+  };
+  return wrap(base);
+}
+
+// src/definers/defineOverride.ts
+function defineOverride(base, patch) {
+  const { id: _ignored, ...rest } = patch;
+  return {
+    ...base,
+    ...rest,
+    id: base.id
+  };
+}
+
+// src/definers/defineTag.ts
+function defineTag(definition) {
+  const id2 = definition.id;
+  const filePath = getCallerFile();
+  const foundation = {
+    id: id2,
+    meta: definition.meta,
+    config: definition.config,
+    configSchema: definition.configSchema
+  };
+  return {
+    ...foundation,
+    [symbolTag]: true,
+    [symbolFilePath]: filePath,
+    /**
+     * Specify custom config for this tag which extends the default one if exists
+     * @param tagConfig
+     * @returns
+     */
+    with(tagConfig) {
+      if (definition.configSchema) {
+        try {
+          tagConfig = definition.configSchema.parse(tagConfig);
+        } catch (error) {
+          throw new ValidationError("Tag config", this.id, error);
+        }
+      }
+      let config;
+      if (typeof tagConfig === "object") {
+        if (typeof foundation.config === "object") {
+          config = {
+            ...foundation.config,
+            ...tagConfig
+          };
+        } else {
+          config = tagConfig;
+        }
+      } else {
+        config = tagConfig;
+      }
+      return {
+        ...foundation,
+        [symbolTagConfigured]: true,
+        config
+      };
+    },
+    /**
+     * Checks if the tag exists in a taggable or a list of tags.
+     * @param target
+     * @returns
+     */
+    exists(target) {
+      let currentTags = [];
+      if (Array.isArray(target)) {
+        currentTags = target;
+      } else {
+        currentTags = target.tags;
+      }
+      for (const candidate of currentTags) {
+        if (candidate.id === id2) {
+          return true;
+        }
+      }
+      return false;
+    },
+    /**
+     * Function which serves 2 purposes, verifying if the task exists, and retrieving its config
+     * @param target
+     * @returns
+     */
+    extract(target) {
+      let currentTags = [];
+      if (Array.isArray(target)) {
+        currentTags = target;
+      } else {
+        currentTags = target.tags || [];
+      }
+      for (const candidate of currentTags) {
+        if (candidate.id === id2) {
+          return candidate.config;
+        }
+      }
+      return;
+    }
+  };
+}
+
+// src/definers/tools.ts
+function isTask(definition) {
+  return definition && definition[symbolTask];
+}
+function isResource(definition) {
+  return definition && definition[symbolResource];
+}
+function isResourceWithConfig(definition) {
+  return definition && definition[symbolResourceWithConfig];
+}
+function isEvent(definition) {
+  return definition && definition[symbolEvent];
+}
+function isHook(definition) {
+  return definition && definition[symbolHook];
+}
+function isTaskMiddleware(definition) {
+  return definition && definition[symbolTaskMiddleware];
+}
+function isResourceMiddleware(definition) {
+  return definition && definition[symbolResourceMiddleware];
+}
+function isTag(definition) {
+  return definition && definition[symbolTag];
+}
+function isOptional(definition) {
+  return definition && definition[symbolOptionalDependency];
+}
+
+// src/platform/index.ts
+function detectEnvironment() {
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    return "browser";
+  }
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    return "node";
+  }
+  return "universal";
+}
+async function loadModule(path) {
+  try {
+    return await import(path);
+  } catch (e) {
+    return __require(path);
+  }
+}
+var PlatformAdapter = class {
+  constructor(env) {
+    this.isInitialized = false;
+    this.nodeALSClass = null;
+    // timers
+    this.setTimeout = globalThis.setTimeout;
+    this.clearTimeout = globalThis.clearTimeout;
+    this.env = env ?? detectEnvironment();
+  }
+  async init() {
+    if (this.env === "node") {
+      this.nodeALSClass = (await loadModule("node:async_hooks")).AsyncLocalStorage;
+    }
+  }
+  onUncaughtException(handler) {
+    switch (this.env) {
+      case "node": {
+        process.on("uncaughtException", handler);
+        return () => process.off("uncaughtException", handler);
+      }
+      case "browser": {
+        const target = globalThis.window ?? globalThis;
+        const h = (e) => handler(e?.error ?? e);
+        target.addEventListener?.("error", h);
+        return () => target.removeEventListener?.("error", h);
+      }
+      default: {
+        const tgt = globalThis;
+        if (tgt.addEventListener) {
+          const h = (e) => handler(e?.error ?? e);
+          tgt.addEventListener("error", h);
+          return () => tgt.removeEventListener("error", h);
+        }
+        return () => {
+        };
+      }
+    }
+  }
+  onUnhandledRejection(handler) {
+    switch (this.env) {
+      case "node": {
+        const h = (reason) => handler(reason);
+        process.on("unhandledRejection", h);
+        return () => process.off("unhandledRejection", h);
+      }
+      case "browser": {
+        const target = globalThis.window ?? globalThis;
+        const wrap = (e) => handler(e.reason);
+        target.addEventListener?.("unhandledrejection", wrap);
+        return () => target.removeEventListener?.("unhandledrejection", wrap);
+      }
+      default: {
+        const tgt = globalThis;
+        if (tgt.addEventListener) {
+          const wrap = (e) => handler(e.reason ?? e);
+          tgt.addEventListener("unhandledrejection", wrap);
+          return () => tgt.removeEventListener("unhandledrejection", wrap);
+        }
+        return () => {
+        };
+      }
+    }
+  }
+  onShutdownSignal(handler) {
+    switch (this.env) {
+      case "node": {
+        process.on("SIGINT", handler);
+        process.on("SIGTERM", handler);
+        return () => {
+          process.off("SIGINT", handler);
+          process.off("SIGTERM", handler);
+        };
+      }
+      case "browser": {
+        const win = window ?? globalThis.window ?? globalThis;
+        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 = () => {
+            const doc = globalThis.document;
+            if (doc && doc.visibilityState === "hidden") handler();
+          };
+          tgt.addEventListener("visibilitychange", vis);
+          cleanup.push(
+            () => tgt.removeEventListener?.("visibilitychange", vis)
+          );
+        }
+        if (typeof process !== "undefined" && process.on) {
+          process.on("SIGINT", handler);
+          process.on("SIGTERM", handler);
+          cleanup.push(() => {
+            process.off?.("SIGINT", handler);
+            process.off?.("SIGTERM", handler);
+          });
+        }
+        return () => cleanup.forEach((fn) => fn());
+      }
+    }
+  }
+  exit(code) {
+    switch (this.env) {
+      case "node":
+        process.exit(code);
+        return;
+      default:
+        throw new PlatformUnsupportedFunction("exit");
+    }
+  }
+  getEnv(key) {
+    switch (this.env) {
+      case "node":
+        return process.env[key];
+      default: {
+        const g = globalThis;
+        if (g.__ENV__ && typeof g.__ENV__ === "object") return g.__ENV__[key];
+        if (typeof process !== "undefined" && process.env)
+          return process.env[key];
+        if (g.env && typeof g.env === "object") return g.env[key];
+        return void 0;
+      }
+    }
+  }
+  hasAsyncLocalStorage() {
+    switch (this.env) {
+      case "node":
+        return true;
+      // We'll try native, else polyfill
+      case "browser":
+      default:
+        return false;
+    }
+  }
+  createAsyncLocalStorage() {
+    switch (this.env) {
+      case "node": {
+        let instance;
+        const get = () => {
+          if (!instance) {
+            if (!this.nodeALSClass) {
+              throw new PlatformUnsupportedFunction(
+                "createAsyncLocalStorage: Platform not initialized"
+              );
+            }
+            instance = new this.nodeALSClass();
+          }
+          return instance;
+        };
+        return {
+          getStore: () => get().getStore(),
+          run: (store2, callback) => get().run(store2, callback)
+        };
+      }
+      case "browser":
+      default:
+        return {
+          getStore: () => {
+            throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
+          },
+          run: () => {
+            throw new PlatformUnsupportedFunction("createAsyncLocalStorage");
+          }
+        };
+    }
+  }
+};
+var platformInstance = null;
+function getPlatform() {
+  if (!platformInstance) {
+    const env = detectEnvironment();
+    platformInstance = new PlatformAdapter(env);
+  }
+  return platformInstance;
+}
+
+// src/globals/middleware/requireContext.middleware.ts
+var requireContextTaskMiddleware = defineTaskMiddleware({
+  id: "globals.middleware.requireContext",
+  async run({ task, next }, deps, config) {
+    if (!config.context) {
+      throw new Error(
+        "Context not available. Did you forget to pass 'context' to the middleware?"
+      );
+    }
+    config.context.use();
+    return next(task?.input);
+  }
+});
+
+// src/context.ts
+var platform = getPlatform();
+var storage = platform.createAsyncLocalStorage();
+function getCurrentStore() {
+  return storage.getStore();
+}
+function createContext(name = "runner.context") {
+  if (!platform.hasAsyncLocalStorage()) {
+    throw new PlatformUnsupportedFunction(
+      `createAsyncLocalStorage: Cannot create context ${name}: no async storage available in this environment`
+    );
+  }
+  const ctxId = Symbol(name);
+  const use = () => {
+    const store2 = getCurrentStore();
+    if (!store2 || !store2.has(ctxId)) {
+      throw new ContextError(
+        `Context not available for symbol ${ctxId.toString()}`
+      );
+    }
+    return store2.get(ctxId);
+  };
+  const provide = (value, fn) => {
+    const currentStore = getCurrentStore();
+    const map = currentStore ? new Map(currentStore) : /* @__PURE__ */ new Map();
+    map.set(ctxId, value);
+    return storage.run(map, fn);
+  };
+  const api = {
+    id: ctxId,
+    use,
+    provide,
+    require() {
+      return requireContextTaskMiddleware.with({ context: api });
+    }
+  };
+  return api;
+}
+
+// src/globals/resources/debug/debug.tag.ts
+var debugTag = defineTag({
+  id: "globals.tags.debug",
+  meta: {
+    title: "Debug",
+    description: "Debug-specific tags. Used for filtering out noise when you're focusing on your application."
+  }
+});
+
+// src/globals/globalTags.ts
+var globalTags = {
+  system: defineTag({
+    id: "globals.tags.system",
+    meta: {
+      title: "System",
+      description: "System-wide tags. Used for filtering out noise when you're focusing on your application."
+    }
+  }),
+  excludeFromGlobalHooks: defineTag({
+    id: "globals.tags.excludeFromGlobalHooks",
+    meta: {
+      title: "Exclude Event From Global Hooks",
+      description: "Marks events that should not be dispatched to global hooks (on: '*')."
+    }
+  }),
+  debug: debugTag
+};
+
+// src/globals/globalEvents.ts
+var systemTag = globalTags.system;
+var globalEvents = {
+  // Minimal core events retained if any (custom events can still be defined by users)
+  /**
+   * Emitted when the system is fully initialized and ready for work.
+   */
+  ready: defineEvent({
+    id: "globals.events.ready",
+    meta: {
+      title: "System Ready",
+      description: "Emitted when the system has completed boot and is ready for listeners to start work.This runs right before returning value for run()."
+    }
+  }),
+  /**
+   * Central error boundary event for any thrown error across the runner.
+   */
+  unhandledError: defineEvent({
+    id: "globals.events.unhandledError",
+    meta: {
+      title: "Unhandled Error",
+      description: "Central error boundary event for any thrown error across the runner."
+    },
+    tags: [systemTag, globalTags.excludeFromGlobalHooks]
+  })
+};
+var globalEventsArray = [globalEvents.ready];
+
+// src/models/Queue.ts
+var Queue = class {
+  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();
+  }
+  /**
+   * Schedule an asynchronous task.
+   * @param task – receives an AbortSignal so it can cancel early if desired.
+   */
+  run(task) {
+    if (this.disposed) {
+      return Promise.reject(new Error("Queue has been disposed"));
+    }
+    if (this.executionContext.getStore()) {
+      return Promise.reject(
+        new Error(
+          "Dead\u2011lock detected: a queued task attempted to queue another task"
+        )
+      );
+    }
+    const { signal } = this.abortController;
+    const result = this.tail.then(
+      () => this.executionContext.run(true, () => task(signal))
+    );
+    this.tail = result.catch(() => {
+    });
+    return result;
+  }
+  /**
+   * Disposes the queue.
+   * @param options.cancel – if true, broadcasts AbortSignal to running task.
+   *                         default: false (waits for tasks to finish).
+   */
+  async dispose(options = {}) {
+    if (this.disposed) return;
+    this.disposed = true;
+    if (options.cancel) {
+      this.abortController.abort();
+    }
+    await this.tail.catch(() => {
+    });
+  }
+};
+
+// src/globals/resources/queue.resource.ts
+var queueResource = defineResource({
+  id: "globals.resources.queue",
+  context: () => ({
+    map: /* @__PURE__ */ new Map()
+  }),
+  init: async (_, deps, context) => {
+    const map = context.map;
+    return {
+      map,
+      run: (id2, task) => {
+        if (!map.has(id2)) {
+          map.set(id2, new Queue());
+        }
+        return map.get(id2).run(task);
+      }
+    };
+  },
+  dispose: async (value, _, deps, context) => {
+    context.map.forEach((queue) => queue.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."
+  }
+});
+
+// src/globals/globalResources.ts
+var systemTag2 = globalTags.system;
+var store = defineResource({
+  id: "globals.resources.store",
+  meta: {
+    title: "Store",
+    description: "A global store that can be used to store and retrieve tasks, resources, events and middleware"
+  },
+  tags: [systemTag2]
+});
+var globalResources = {
+  store,
+  middlewareManager: defineResource({
+    id: "globals.resources.middlewareManager",
+    meta: {
+      title: "Middleware Manager",
+      description: "Manages all middleware and middleware interceptors."
+    },
+    tags: [systemTag2]
+  }),
+  eventManager: defineResource({
+    id: "globals.resources.eventManager",
+    meta: {
+      title: "Event Manager",
+      description: "Manages all events and event listeners. This is meant to be used internally for most use-cases."
+    },
+    tags: [systemTag2]
+  }),
+  taskRunner: defineResource({
+    id: "globals.resources.taskRunner",
+    meta: {
+      title: "Task Runner",
+      description: "Manages the execution of tasks and task dependencies. This is meant to be used internally for most use-cases."
+    },
+    tags: [systemTag2]
+  }),
+  logger: defineResource({
+    id: "globals.resources.logger",
+    meta: {
+      // We skip system tag for logger because it's part of the utility toolkit.
+      title: "Logger",
+      description: "Logs all events and errors. This is meant to be used internally for most use-cases. Emits a globals.log event for each log."
+    },
+    tags: [systemTag2]
+  }),
+  cache: cacheResource,
+  queue: queueResource
+};
+
+// src/globals/middleware/retry.middleware.ts
+var retryTaskMiddleware = defineTaskMiddleware({
+  id: "globals.middleware.retry.task",
+  async run({ task, next }, deps, config) {
+    const input = task?.input;
+    let attempts = 0;
+    const maxRetries = config.retries ?? 3;
+    const shouldStop = config.stopRetryIf ?? (() => false);
+    while (true) {
+      try {
+        return await next(input);
+      } catch (error) {
+        const err = error;
+        if (shouldStop(err) || attempts >= maxRetries) {
+          throw error;
+        }
+        const delay = config.delayStrategy ? config.delayStrategy(attempts, err) : 100 * Math.pow(2, attempts);
+        if (delay > 0) {
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        attempts++;
+      }
+    }
+  }
+});
+var retryResourceMiddleware = defineResourceMiddleware({
+  id: "globals.middleware.retry.resource",
+  async run({ resource, next }, deps, config) {
+    const input = resource?.config;
+    let attempts = 0;
+    const maxRetries = config.retries ?? 3;
+    const shouldStop = config.stopRetryIf ?? (() => false);
+    while (true) {
+      try {
+        return await next(input);
+      } catch (error) {
+        const err = error;
+        if (shouldStop(err) || attempts >= maxRetries) {
+          throw error;
+        }
+        const delay = config.delayStrategy ? config.delayStrategy(attempts, err) : 100 * Math.pow(2, attempts);
+        if (delay > 0) {
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        attempts++;
+      }
+    }
+  }
+});
+
+// src/globals/middleware/timeout.middleware.ts
+var timeoutTaskMiddleware = defineTaskMiddleware({
+  id: "globals.middleware.timeout.task",
+  async run({ task, next }, _deps, config) {
+    const input = task?.input;
+    const ttl = Math.max(0, config.ttl);
+    const message = `Operation timed out after ${ttl}ms`;
+    if (ttl === 0) {
+      const error = new Error(message);
+      error.name = "TimeoutError";
+      throw error;
+    }
+    const controller = new AbortController();
+    const timeoutPromise = new Promise((_, reject) => {
+      const timeoutId = setTimeout(() => {
+        controller.abort();
+        const error = new Error(message);
+        error.name = "TimeoutError";
+        reject(error);
+      }, ttl);
+      controller.signal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+      });
+    });
+    return Promise.race([next(input), timeoutPromise]);
+  }
+});
+var timeoutResourceMiddleware = defineResourceMiddleware({
+  id: "globals.middleware.timeout.resource",
+  async run({ resource, next }, _deps, config) {
+    const input = resource?.config;
+    const ttl = Math.max(0, config.ttl);
+    const message = `Operation timed out after ${ttl}ms`;
+    if (ttl === 0) {
+      const error = new Error(message);
+      error.name = "TimeoutError";
+      throw error;
+    }
+    const controller = new AbortController();
+    const timeoutPromise = new Promise((_, reject) => {
+      const timeoutId = setTimeout(() => {
+        controller.abort();
+        const error = new Error(message);
+        error.name = "TimeoutError";
+        reject(error);
+      }, ttl);
+      controller.signal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+      });
+    });
+    return Promise.race([next(input), timeoutPromise]);
+  }
+});
+
+// src/globals/globalMiddleware.ts
+var globalMiddlewares = {
+  requireContext: requireContextTaskMiddleware,
+  task: {
+    requireContext: requireContextTaskMiddleware,
+    cache: cacheMiddleware,
+    // common with resources
+    retry: retryTaskMiddleware,
+    timeout: timeoutTaskMiddleware
+  },
+  resource: {
+    retry: retryResourceMiddleware,
+    timeout: timeoutResourceMiddleware
+  }
+};
+
+// src/models/TaskRunner.ts
+var TaskRunner = class {
+  constructor(store2, eventManager, logger) {
+    this.store = store2;
+    this.eventManager = eventManager;
+    this.logger = logger;
+    this.runnerStore = /* @__PURE__ */ new Map();
+    this.middlewareManager = this.store.getMiddlewareManager();
+  }
+  /**
+   * 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
+   * @param task the task to be run
+   * @param input the input to be passed to the task
+   */
+  async run(task, input) {
+    let runner = this.runnerStore.get(task.id);
+    if (!runner) {
+      runner = this.createRunnerWithMiddleware(task);
+      this.runnerStore.set(task.id, runner);
+    }
+    try {
+      return await runner(input);
+    } catch (error) {
+      try {
+        await this.store.onUnhandledError({
+          error,
+          kind: "task",
+          source: task.id
+        });
+      } catch (_) {
+      }
+      throw error;
+    }
+  }
+  /**
+   * Creates the function with the chain of middleware.
+   * @param task
+   * @param input
+   * @param taskDependencies
+   * @returns
+   */
+  createRunnerWithMiddleware(task) {
+    return this.middlewareManager.composeTaskRunner(task);
+  }
+};
+
+// src/models/MiddlewareManager.ts
+var _isLocked;
+var MiddlewareManager = class {
+  constructor(store2, eventManager, logger) {
+    this.store = store2;
+    this.eventManager = eventManager;
+    this.logger = logger;
+    // Interceptor storage
+    this.taskMiddlewareInterceptors = [];
+    this.resourceMiddlewareInterceptors = [];
+    // Per-middleware interceptor storage
+    this.perMiddlewareInterceptors = /* @__PURE__ */ new Map();
+    this.perResourceMiddlewareInterceptors = /* @__PURE__ */ new Map();
+    // Locking mechanism to prevent modifications after initialization
+    __privateAdd(this, _isLocked, false);
+  }
+  /**
+   * Gets the current lock status of the MiddlewareManager
+   */
+  get isLocked() {
+    return __privateGet(this, _isLocked);
+  }
+  /**
+   * Locks the MiddlewareManager, preventing any further modifications to interceptors
+   */
+  lock() {
+    __privateSet(this, _isLocked, true);
+  }
+  /**
+   * Throws an error if the MiddlewareManager is locked
+   */
+  checkLock() {
+    if (__privateGet(this, _isLocked)) {
+      throw new LockedError("MiddlewareManager");
+    }
+  }
+  /**
+   * Adds an interceptor for task or resource middleware execution
+   * Interceptors are executed in the order they are added, with the ability to
+   * modify, log, or prevent middleware execution
+   *
+   * @param kind - The type of middleware to intercept ("task" or "resource")
+   * @param interceptor - The interceptor function to add
+   */
+  intercept(kind, interceptor) {
+    this.checkLock();
+    if (kind === "task") {
+      this.taskMiddlewareInterceptors.push(
+        interceptor
+      );
+    } else {
+      this.resourceMiddlewareInterceptors.push(
+        interceptor
+      );
+    }
+  }
+  /**
+   * Adds an interceptor for a specific middleware instance with better type safety
+   * This method automatically determines the type and provides type-safe access
+   *
+   * @param middleware - The middleware instance to intercept
+   * @param interceptor - The interceptor function with proper typing
+   */
+  interceptMiddleware(middleware, interceptor) {
+    this.checkLock();
+    if (isTaskMiddleware(middleware)) {
+      if (!this.perMiddlewareInterceptors.has(middleware.id)) {
+        this.perMiddlewareInterceptors.set(middleware.id, []);
+      }
+      this.perMiddlewareInterceptors.get(middleware.id).push(interceptor);
+    } else if (isResourceMiddleware(middleware)) {
+      if (!this.perResourceMiddlewareInterceptors.has(middleware.id)) {
+        this.perResourceMiddlewareInterceptors.set(middleware.id, []);
+      }
+      this.perResourceMiddlewareInterceptors.get(middleware.id).push(interceptor);
+    } else {
+      throw new Error("Unknown middleware type");
+    }
+  }
+  /**
+   * Wrap a middleware with its specific interceptors in onion style
+   */
+  wrapMiddlewareWithInterceptors(middleware, middlewareRunner, interceptors) {
+    if (!interceptors.length) {
+      return middlewareRunner;
+    }
+    const reversedInterceptors = [...interceptors].reverse();
+    let wrapped = middlewareRunner;
+    for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
+      const interceptor = reversedInterceptors[i];
+      const nextFunction = wrapped;
+      wrapped = async (input) => {
+        const executionInput = {
+          task: {
+            definition: null,
+            // Will be filled by middleware.run
+            input
+          },
+          next: nextFunction
+        };
+        const wrappedNext = (i2) => {
+          return nextFunction(i2.task.input);
+        };
+        return interceptor(wrappedNext, executionInput);
+      };
+    }
+    return wrapped;
+  }
+  /**
+   * Wrap a resource middleware with its specific interceptors in onion style
+   */
+  wrapResourceMiddlewareWithInterceptors(middleware, middlewareRunner, interceptors) {
+    if (!interceptors.length) {
+      return middlewareRunner;
+    }
+    const reversedInterceptors = [...interceptors].reverse();
+    let wrapped = middlewareRunner;
+    for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
+      const interceptor = reversedInterceptors[i];
+      const nextFunction = wrapped;
+      wrapped = async (config) => {
+        const executionInput = {
+          resource: {
+            definition: null,
+            // Will be filled by middleware.run
+            config
+          },
+          next: nextFunction
+        };
+        const wrappedNext = (input) => {
+          return nextFunction(input.resource.config);
+        };
+        return interceptor(wrappedNext, executionInput);
+      };
+    }
+    return wrapped;
+  }
+  /**
+   * Compose a runner for a task with its local interceptors and applicable middlewares.
+   * Returns a function that accepts the task input and resolves to the task output.
+   */
+  composeTaskRunner(task) {
+    const storeTask = this.store.tasks.get(task.id);
+    let next = async (input) => {
+      let rawInput = input;
+      if (task.inputSchema) {
+        try {
+          rawInput = task.inputSchema.parse(rawInput);
+        } catch (error) {
+          throw new ValidationError(
+            "Task input",
+            task.id,
+            error instanceof Error ? error : new Error(String(error))
+          );
+        }
+      }
+      const deps = storeTask.computedDependencies;
+      const rawResult = await task.run.call(null, rawInput, deps);
+      if (task.resultSchema) {
+        try {
+          return task.resultSchema.parse(rawResult);
+        } catch (error) {
+          throw new ValidationError("Task result", task.id, error);
+        }
+      }
+      return rawResult;
+    };
+    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);
+      }
+    }
+    if (this.taskMiddlewareInterceptors.length > 0) {
+      const reversedInterceptors = [
+        ...this.taskMiddlewareInterceptors
+      ].reverse();
+      const createExecutionInput = (input, nextFunc) => ({
+        task: {
+          definition: task,
+          input
+        },
+        next: nextFunc
+      });
+      let currentNext = next;
+      for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
+        const interceptor = reversedInterceptors[i];
+        const nextFunction = currentNext;
+        currentNext = async (input) => {
+          const executionInput = createExecutionInput(input, nextFunction);
+          const wrappedNext = (i2) => {
+            return nextFunction(i2.task.input);
+          };
+          return interceptor(wrappedNext, executionInput);
+        };
+      }
+      next = currentNext;
+    }
+    const createdMiddlewares = this.getApplicableTaskMiddlewares(task);
+    if (createdMiddlewares.length === 0) {
+      return next;
+    }
+    for (let i = createdMiddlewares.length - 1; i >= 0; i--) {
+      const middleware = createdMiddlewares[i];
+      const storeMiddleware = this.store.taskMiddlewares.get(middleware.id);
+      const nextFunction = next;
+      const baseMiddlewareRunner = async (input) => {
+        return storeMiddleware.middleware.run(
+          {
+            task: {
+              definition: task,
+              input
+            },
+            next: nextFunction
+          },
+          storeMiddleware.computedDependencies,
+          middleware.config
+        );
+      };
+      const middlewareInterceptors = this.perMiddlewareInterceptors.get(middleware.id) || [];
+      const wrappedMiddleware = this.wrapMiddlewareWithInterceptors(
+        middleware,
+        baseMiddlewareRunner,
+        middlewareInterceptors
+      );
+      next = wrappedMiddleware;
+    }
+    return next;
+  }
+  /**
+   * Run a resource init wrapped with its applicable middlewares.
+   */
+  async runResourceInit(resource, config, dependencies, context) {
+    let next = async (cfg) => {
+      if (!resource.init) return void 0;
+      const rawValue = await resource.init.call(
+        null,
+        cfg,
+        dependencies,
+        context
+      );
+      if (resource.resultSchema) {
+        try {
+          return resource.resultSchema.parse(rawValue);
+        } catch (error) {
+          throw new ValidationError(
+            "Resource result",
+            resource.id,
+            error
+          );
+        }
+      }
+      return rawValue;
+    };
+    const createdMiddlewares = this.getApplicableResourceMiddlewares(resource);
+    for (let i = createdMiddlewares.length - 1; i >= 0; i--) {
+      const middleware = createdMiddlewares[i];
+      const storeMiddleware = this.store.resourceMiddlewares.get(
+        middleware.id
+      );
+      const nextFunction = next;
+      const baseMiddlewareRunner = async (cfg) => {
+        try {
+          const result = await storeMiddleware.middleware.run(
+            {
+              resource: {
+                definition: resource,
+                config: cfg
+              },
+              next: nextFunction
+            },
+            storeMiddleware.computedDependencies,
+            middleware.config
+          );
+          return result;
+        } catch (error) {
+          try {
+            await this.store.onUnhandledError({
+              error,
+              kind: "resourceInit",
+              source: resource.id
+            });
+          } catch (_) {
+          }
+          throw error;
+        }
+      };
+      const middlewareInterceptors = this.perResourceMiddlewareInterceptors.get(middleware.id) || [];
+      const wrappedMiddleware = this.wrapResourceMiddlewareWithInterceptors(
+        middleware,
+        baseMiddlewareRunner,
+        middlewareInterceptors
+      );
+      next = wrappedMiddleware;
+    }
+    if (this.resourceMiddlewareInterceptors.length > 0) {
+      const reversedInterceptors = [
+        ...this.resourceMiddlewareInterceptors
+      ].reverse();
+      const createExecutionInput = (config2, nextFunc) => ({
+        resource: {
+          definition: resource,
+          config: config2
+        },
+        next: nextFunc
+      });
+      let currentNext = next;
+      for (let i = reversedInterceptors.length - 1; i >= 0; i--) {
+        const interceptor = reversedInterceptors[i];
+        const nextFunction = currentNext;
+        currentNext = async (cfg) => {
+          const executionInput = createExecutionInput(cfg, nextFunction);
+          const wrappedNext = (input) => {
+            return nextFunction(input.resource.config);
+          };
+          return interceptor(wrappedNext, executionInput);
+        };
+      }
+      next = currentNext;
+    }
+    return next(config);
+  }
+  getApplicableTaskMiddlewares(task) {
+    const existingMiddlewares = task.middleware;
+    const existingMiddlewareIds = existingMiddlewares.map((x) => x.id);
+    const globalMiddlewares2 = this.getEverywhereMiddlewareForTasks(task).filter(
+      (x) => !existingMiddlewareIds.includes(x.id)
+    );
+    return [...globalMiddlewares2, ...existingMiddlewares];
+  }
+  getApplicableResourceMiddlewares(resource) {
+    const existingMiddlewares = resource.middleware;
+    const existingMiddlewareIds = existingMiddlewares.map((x) => x.id);
+    const globalMiddlewares2 = this.getEverywhereMiddlewareForResources(
+      resource
+    ).filter((x) => !existingMiddlewareIds.includes(x.id));
+    return [...globalMiddlewares2, ...existingMiddlewares];
+  }
+  /**
+   * @param task
+   * @returns
+   */
+  getEverywhereMiddlewareForTasks(task) {
+    return Array.from(this.store.taskMiddlewares.values()).filter((x) => Boolean(x.middleware.everywhere)).filter((x) => {
+      if (typeof x.middleware.everywhere === "function") {
+        return x.middleware.everywhere(task);
+      }
+      return true;
+    }).map((x) => x.middleware);
+  }
+  /**
+   * Returns all global middleware for resource, which do not depend on the target resource.
+   */
+  getEverywhereMiddlewareForResources(target) {
+    return Array.from(this.store.resourceMiddlewares.values()).filter((x) => Boolean(x.middleware.everywhere)).filter((x) => {
+      if (typeof x.middleware.everywhere === "function") {
+        return x.middleware.everywhere(target);
+      }
+      return true;
+    }).map((x) => x.middleware);
+  }
+};
+_isLocked = new WeakMap();
+
+// src/models/ResourceInitializer.ts
+var ResourceInitializer = class {
+  constructor(store2, eventManager, logger) {
+    this.store = store2;
+    this.eventManager = eventManager;
+    this.logger = logger;
+    this.middlewareManager = new MiddlewareManager(
+      this.store,
+      this.eventManager,
+      this.logger
+    );
+  }
+  /**
+   * 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
+   */
+  async initializeResource(resource, config, dependencies) {
+    const context = resource.context?.();
+    let value;
+    if (!resource.init) {
+      resource.init = (async () => void 0);
+    }
+    if (resource.init) {
+      value = await this.initWithMiddleware(
+        resource,
+        config,
+        dependencies,
+        context
+      );
+    }
+    return { value, context };
+  }
+  // Lifecycle emissions removed
+  async initWithMiddleware(resource, config, dependencies, context) {
+    return this.middlewareManager.runResourceInit(
+      resource,
+      config,
+      dependencies,
+      context
+    );
+  }
+};
+
+// 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) {
+    if (typeof val === "function") {
+      return "function()";
+    }
+    if (typeof val === "bigint") {
+      return val.toString();
+    }
+    const holderObject = Object(this);
+    const parentDepth = holderDepth.get(holderObject) || 0;
+    const currentDepth = parentDepth + 1;
+    if (typeof val === "object" && val !== null) {
+      if (seen.has(val)) return "[Circular]";
+      if (currentDepth > maxDepth) {
+        return Array.isArray(val) ? "[Array]" : "[Object]";
+      }
+      seen.add(val);
+      holderDepth.set(val, currentDepth);
+    }
+    return val;
+  };
+  try {
+    return JSON.stringify(value, replacer, space);
+  } catch {
+    try {
+      return String(value);
+    } catch {
+      return "[Unserializable]";
+    }
+  }
+}
+
+// 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, "");
+}
+var COLORS = {
+  trace: "\x1B[90m",
+  debug: "\x1B[36m",
+  info: "\x1B[32m",
+  warn: "\x1B[33m",
+  error: "\x1B[31m",
+  critical: "\x1B[35m",
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+var ICONS = {
+  trace: "\u25CB",
+  debug: "\u25C6",
+  info: "\u25CF",
+  warn: "\u25B2",
+  error: "\u2715",
+  critical: "\u2588"
+};
+var _LogPrinter = class _LogPrinter {
+  constructor(options) {
+    this.strategy = options.strategy;
+    if (options.strategy === "plain") {
+      this.colors = _LogPrinter.NO_COLORS;
+    } else {
+      const base = options.useColors || options.colorTheme ? COLORS : _LogPrinter.NO_COLORS;
+      this.colors = { ...base, ...options.colorTheme || {} };
+    }
+  }
+  print(log) {
+    if (this.strategy === "json") {
+      _LogPrinter.writers.log(safeStringify(this.normalizeForJson(log)));
+      return;
+    }
+    if (this.strategy === "json_pretty") {
+      _LogPrinter.writers.log(safeStringify(this.normalizeForJson(log), 2));
+      return;
+    }
+    const { level, source, message, timestamp, error, data, context } = log;
+    const timePart = this.formatTime(timestamp);
+    const levelPart = this.formatLevel(level);
+    const sourcePart = this.formatSource(source);
+    const headerLine = [timePart, levelPart, sourcePart].filter(Boolean).join(" ");
+    const messageString = this.formatMessage(message);
+    const messageLines = messageString.split("\n");
+    const output = [headerLine];
+    const timePartLength = stripAnsi(timePart).length;
+    const levelPartLength = stripAnsi(levelPart).length;
+    const indentation = " ".repeat(timePartLength + 1 + levelPartLength + 1);
+    if (message) {
+      output.push(...messageLines.map((line) => `${indentation}${line}`));
+    }
+    const errorLines = this.formatError(error);
+    const dataLines = this.formatData(data);
+    const contextLines = this.formatContext(context);
+    const detailsExist = errorLines.length > 0 || dataLines.length > 0 || contextLines.length > 0;
+    if (detailsExist) {
+      output.push("");
+    }
+    output.push(...errorLines, ...dataLines, ...contextLines);
+    if (detailsExist) {
+      output.push("");
+    }
+    const writer = this.pickWriter(level);
+    output.forEach((line) => writer(line));
+    writer("");
+  }
+  pickWriter(level) {
+    const toError = level === "warn" || level === "error" || level === "critical";
+    if (toError && typeof _LogPrinter.writers.error === "function") {
+      return (msg) => _LogPrinter.writers.error(msg);
+    }
+    return (msg) => _LogPrinter.writers.log(msg);
+  }
+  formatTime(timestamp) {
+    const time = timestamp.toISOString().slice(11, 19);
+    const ms = timestamp.getMilliseconds().toString().padStart(3, "0");
+    return `${this.colors.gray}${time}.${ms}${this.colors.reset}`;
+  }
+  formatLevel(level) {
+    const color = this.colors[level] || this.colors.info;
+    const icon = ICONS[level] || "\u25CF";
+    const label = level.toUpperCase().padEnd(7);
+    return `${color}${icon} ${this.colors.bold}${label}${this.colors.reset}`;
+  }
+  formatSource(source) {
+    if (!source) return "";
+    return `${this.colors.cyan}${source}${this.colors.reset}`;
+  }
+  formatMessage(message) {
+    if (typeof message === "object" && message !== null) {
+      return safeStringify(message, 2);
+    }
+    return String(message);
+  }
+  formatError(error, indentation = "  ") {
+    if (!error) return [];
+    const lines = [];
+    lines.push(
+      `${indentation}${this.colors.gray}\u2570\u2500${this.colors.reset} ${this.colors.error}Error: ${error.name}: ${error.message}${this.colors.reset}`
+    );
+    if (error.stack) {
+      const frames = error.stack.split("\n").slice(1);
+      frames.forEach((frame) => {
+        const cleaned = frame.trim().replace(/^at /, "");
+        lines.push(
+          `${indentation}   ${this.colors.gray}\u21B3${this.colors.reset} ${this.colors.dim}${cleaned}${this.colors.reset}`
+        );
+      });
+    }
+    return lines;
+  }
+  formatData(data, indentation = "  ") {
+    if (!data || Object.keys(data).length === 0) return [];
+    const lines = [];
+    const formatted = safeStringify(data, 2, { maxDepth: 3 }).split("\n");
+    lines.push(
+      `${indentation}${this.colors.gray}\u2570\u2500${this.colors.reset} ${this.colors.cyan}Data:${this.colors.reset}`
+    );
+    formatted.forEach((line) => {
+      lines.push(`${indentation}${this.colors.dim}${line}${this.colors.reset}`);
+    });
+    return lines;
+  }
+  formatContext(context, indentation = "  ") {
+    if (!context) return [];
+    const filtered = { ...context };
+    delete filtered.source;
+    if (Object.keys(filtered).length === 0) return [];
+    const lines = [];
+    const formatted = safeStringify(filtered, 2, { maxDepth: 3 }).split("\n");
+    lines.push(
+      `${indentation}${this.colors.gray}\u2570\u2500${this.colors.reset} ${this.colors.blue}Context:${this.colors.reset}`
+    );
+    formatted.forEach((line) => {
+      lines.push(`${indentation}${this.colors.dim}${line}${this.colors.reset}`);
+    });
+    return lines;
+  }
+  normalizeForJson(log) {
+    const normalized = { ...log };
+    if (typeof log.message === "object") {
+      const text = safeStringify(log.message);
+      try {
+        normalized.message = JSON.parse(text);
+      } catch {
+        normalized.message = text;
+      }
+    }
+    return normalized;
+  }
+  static setWriters(writers) {
+    _LogPrinter.writers = { ..._LogPrinter.writers, ...writers };
+  }
+  static resetWriters() {
+    _LogPrinter.writers = {
+      log: (msg) => console.log(msg),
+      error: (msg) => console.error?.(msg)
+    };
+  }
+};
+_LogPrinter.NO_COLORS = {
+  trace: "",
+  debug: "",
+  info: "",
+  warn: "",
+  error: "",
+  critical: "",
+  reset: "",
+  bold: "",
+  dim: "",
+  blue: "",
+  cyan: "",
+  gray: ""
+};
+_LogPrinter.writers = {
+  // eslint-disable-next-line no-console
+  log: (msg) => console.log(msg),
+  // eslint-disable-next-line no-console
+  error: (msg) => console.error?.(msg)
+};
+var LogPrinter = _LogPrinter;
+
+// src/models/Logger.ts
+var _Logger = class _Logger {
+  constructor(options, boundContext = {}, source, printer) {
+    this.printThreshold = "info";
+    this.printStrategy = "pretty";
+    this.bufferLogs = false;
+    this.buffer = [];
+    this.boundContext = {};
+    this.isLocked = false;
+    this.useColors = true;
+    // Observable why not?
+    this.localListeners = [];
+    this.boundContext = { ...boundContext };
+    this.printThreshold = options.printThreshold;
+    this.printStrategy = options.printStrategy;
+    this.bufferLogs = options.bufferLogs;
+    this.useColors = typeof options.useColors === "boolean" ? options.useColors : this.detectColorSupport();
+    this.source = source;
+    this.printer = printer ? printer : new LogPrinter({
+      strategy: this.printStrategy,
+      useColors: this.useColors
+    });
+  }
+  detectColorSupport() {
+    const noColor = typeof process !== "undefined" && !!process.env.NO_COLOR;
+    if (noColor) return false;
+    const isTty = typeof process !== "undefined" && !!process.stdout && !!process.stdout.isTTY;
+    return isTty;
+  }
+  /**
+   * Creates a new logger instance with additional bound context
+   */
+  with({
+    source,
+    additionalContext: context
+  }) {
+    const child = new _Logger(
+      {
+        printThreshold: this.printThreshold,
+        printStrategy: this.printStrategy,
+        bufferLogs: this.bufferLogs,
+        useColors: this.useColors
+      },
+      { ...this.boundContext, ...context },
+      source,
+      this.printer
+    );
+    child.rootLogger = this.rootLogger ?? this;
+    return child;
+  }
+  /**
+   * Core logging method with structured LogInfo
+   */
+  async log(level, message, logInfo = {}) {
+    const { source, error, data, ...context } = logInfo;
+    const log = {
+      level,
+      message,
+      source: source || this.source,
+      timestamp: /* @__PURE__ */ new Date(),
+      error: error ? this.extractErrorInfo(error) : void 0,
+      data: data || void 0,
+      context: { ...this.boundContext, ...context }
+    };
+    const root = this.rootLogger ?? this;
+    if (root.bufferLogs) {
+      root.buffer.push(log);
+      return;
+    }
+    await root.triggerLogListeners(log);
+    if (root.canPrint(level)) {
+      root.printer.print(log);
+    }
+  }
+  extractErrorInfo(error) {
+    if (error instanceof Error) {
+      return {
+        name: error.name,
+        message: error.message,
+        stack: error.stack
+      };
+    }
+    return {
+      name: "UnknownError",
+      message: String(error)
+    };
+  }
+  async info(message, logInfo) {
+    await this.log("info", message, logInfo);
+  }
+  async error(message, logInfo) {
+    await this.log("error", message, logInfo);
+  }
+  async warn(message, logInfo) {
+    await this.log("warn", message, logInfo);
+  }
+  async debug(message, logInfo) {
+    await this.log("debug", message, logInfo);
+  }
+  async trace(message, logInfo) {
+    await this.log("trace", message, logInfo);
+  }
+  async critical(message, logInfo) {
+    await this.log("critical", message, logInfo);
+  }
+  /**
+   * Direct print for tests and advanced scenarios. Delegates to LogPrinter.
+   */
+  print(log) {
+    this.printer.print(log);
+  }
+  /**
+   * @param listener - A listener that will be triggered for every log.
+   */
+  onLog(listener) {
+    if (this.rootLogger && this.rootLogger !== this) {
+      this.rootLogger.onLog(listener);
+    } else {
+      this.localListeners.push(listener);
+    }
+  }
+  /**
+   * Marks the logger as ready.
+   * This is used to trigger the local listeners and print the buffered logs (if they exists)
+   * @returns A promise that resolves when the logger is ready.
+   */
+  async lock() {
+    const root = this.rootLogger ?? this;
+    if (root.isLocked) {
+      return;
+    }
+    if (root.bufferLogs) {
+      for (const log of root.buffer) {
+        await root.triggerLogListeners(log);
+      }
+      for (const log of root.buffer) {
+        if (root.canPrint(log.level)) {
+          root.printer.print(log);
+        }
+      }
+    }
+    root.bufferLogs = false;
+    root.buffer = [];
+    root.isLocked = true;
+  }
+  canPrint(level) {
+    if (this.printThreshold === null) {
+      return false;
+    }
+    return this.printThreshold && _Logger.Severity[level] >= _Logger.Severity[this.printThreshold];
+  }
+  async triggerLogListeners(log) {
+    if (this.rootLogger && this.rootLogger !== this) {
+      await this.rootLogger.triggerLogListeners(log);
+    }
+    for (const listener of this.localListeners) {
+      try {
+        await listener(log);
+      } catch (error) {
+        this.print({
+          level: "error",
+          message: "Error in log listener",
+          timestamp: /* @__PURE__ */ new Date(),
+          error: {
+            name: "ListenerError",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        });
+        continue;
+      }
+    }
+  }
+};
+_Logger.Severity = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+  critical: 5
+};
+var Logger = _Logger;
+
+// src/models/DependencyProcessor.ts
+var DependencyProcessor = class {
+  constructor(store2, eventManager, taskRunner, logger) {
+    this.store = store2;
+    this.eventManager = eventManager;
+    this.taskRunner = taskRunner;
+    this.logger = logger.with({ source: "dependencyProcessor" });
+    this.resourceInitializer = new ResourceInitializer(
+      store2,
+      eventManager,
+      logger
+    );
+  }
+  /**
+   * This function is going to go through all the resources, tasks and middleware to compute their required dependencies.
+   */
+  async computeAllDependencies() {
+    for (const middleware of this.store.resourceMiddlewares.values()) {
+      const computedDependencies = await this.extractDependencies(
+        middleware.middleware.dependencies,
+        middleware.middleware.id
+      );
+      middleware.computedDependencies = computedDependencies;
+      middleware.isInitialized = true;
+    }
+    for (const middleware of this.store.taskMiddlewares.values()) {
+      const computedDependencies = await this.extractDependencies(
+        middleware.middleware.dependencies,
+        middleware.middleware.id
+      );
+      middleware.computedDependencies = computedDependencies;
+      middleware.isInitialized = true;
+    }
+    for (const resource of this.store.resources.values()) {
+      await this.processResourceDependencies(resource);
+    }
+    for (const task of this.store.tasks.values()) {
+      await this.computeTaskDependencies(task);
+    }
+    for (const hookStoreElement of this.store.hooks.values()) {
+      const hook = hookStoreElement.hook;
+      const deps = hook.dependencies;
+      hookStoreElement.computedDependencies = await this.extractDependencies(
+        deps,
+        hook.id
+      );
+    }
+    await this.initializeUninitializedResources();
+  }
+  async computeTaskDependencies(task) {
+    const deps = task.task.dependencies;
+    task.computedDependencies = await this.extractDependencies(
+      deps,
+      task.task.id
+    );
+    task.isInitialized = true;
+  }
+  // Most likely these are resources that no-one has dependencies towards
+  // We need to ensure they work too!
+  async initializeUninitializedResources() {
+    for (const resource of this.store.resources.values()) {
+      if (resource.isInitialized === false && // The root is the last one to be initialized and is done in a separate process.
+      resource.resource.id !== this.store.root.resource.id) {
+        await this.processResourceDependencies(resource);
+        const { value, context } = await this.resourceInitializer.initializeResource(
+          resource.resource,
+          resource.config,
+          resource.computedDependencies
+        );
+        resource.context = context;
+        resource.value = value;
+        resource.isInitialized = true;
+      }
+    }
+  }
+  /**
+   * Processes dependencies and hooks
+   * @param resource
+   */
+  async processResourceDependencies(resource) {
+    const deps = resource.resource.dependencies || {};
+    const extracted = await this.extractDependencies(
+      deps,
+      resource.resource.id
+    );
+    resource.computedDependencies = this.wrapResourceDependencies(
+      deps,
+      extracted
+    );
+  }
+  wrapResourceDependencies(deps, extracted) {
+    const wrapped = {};
+    for (const key of Object.keys(deps)) {
+      const original = deps[key];
+      const value = extracted[key];
+      if (isOptional(original)) {
+        const inner = original.inner;
+        if (isTask(inner)) {
+          wrapped[key] = value ? this.makeTaskWithIntercept(inner) : void 0;
+        } else {
+          wrapped[key] = value;
+        }
+        continue;
+      }
+      if (isTask(original)) {
+        wrapped[key] = this.makeTaskWithIntercept(original);
+      } else {
+        wrapped[key] = value;
+      }
+    }
+    return wrapped;
+  }
+  makeTaskWithIntercept(original) {
+    const taskId = original.id;
+    const fn = (input) => {
+      const storeTask = this.store.tasks.get(taskId);
+      const effective = storeTask.task;
+      return this.taskRunner.run(effective, input);
+    };
+    return Object.assign(fn, {
+      intercept: (middleware) => {
+        this.store.checkLock();
+        const storeTask = this.store.tasks.get(taskId);
+        if (!storeTask.interceptors) storeTask.interceptors = [];
+        storeTask.interceptors.push(middleware);
+      }
+    });
+  }
+  async initializeRoot() {
+    const rootResource = this.store.root;
+    const { value, context } = await this.resourceInitializer.initializeResource(
+      rootResource.resource,
+      rootResource.config,
+      // They are already computed
+      rootResource.computedDependencies
+    );
+    rootResource.context = context;
+    rootResource.value = value;
+    rootResource.isInitialized = true;
+  }
+  /**
+   * Processes all hooks, should run before emission of any event.
+   */
+  attachListeners() {
+    for (const hookStoreElement of this.store.hooks.values()) {
+      const hook = hookStoreElement.hook;
+      if (hook.on) {
+        const eventDefinition = hook.on;
+        const handler = async (receivedEvent) => {
+          if (receivedEvent.source === hook.id) {
+            return;
+          }
+          return this.eventManager.executeHookWithInterceptors(
+            hook,
+            receivedEvent,
+            hookStoreElement.computedDependencies
+          );
+        };
+        const order = hook.order ?? 0;
+        if (eventDefinition === "*") {
+          this.eventManager.addGlobalListener(handler, { order });
+        } else if (Array.isArray(eventDefinition)) {
+          for (const ed of eventDefinition) {
+            if (this.store.events.get(ed.id) === void 0) {
+              throw new EventNotFoundError(ed.id);
+            }
+          }
+          this.eventManager.addListener(eventDefinition, handler, {
+            order
+          });
+        } else {
+          if (this.store.events.get(eventDefinition.id) === void 0) {
+            throw new EventNotFoundError(eventDefinition.id);
+          }
+          this.eventManager.addListener(eventDefinition, handler, {
+            order
+          });
+        }
+      }
+    }
+  }
+  async extractDependencies(map, source) {
+    const object = {};
+    for (const key in map) {
+      try {
+        object[key] = await this.extractDependency(map[key], source);
+        if (object[key] instanceof Logger) {
+          object[key] = object[key].with({ source });
+        }
+      } catch (e) {
+        const errorMessage = String(e);
+        this.logger.error(
+          `Failed to extract dependency from source: ${source} -> ${key} with error: ${errorMessage}`
+        );
+        throw e;
+      }
+    }
+    this.logger.trace(`Finished computing dependencies for source: ${source}`);
+    return object;
+  }
+  async extractDependency(object, source) {
+    this.logger.trace(`Extracting dependency -> ${source} -> ${object?.id}`);
+    if (isOptional(object)) {
+      const inner = object.inner;
+      if (isResource(inner)) {
+        const exists = this.store.resources.get(inner.id) !== void 0;
+        return exists ? this.extractResourceDependency(inner) : void 0;
+      } else if (isTask(inner)) {
+        const exists = this.store.tasks.get(inner.id) !== void 0;
+        return exists ? this.extractTaskDependency(inner) : void 0;
+      } else if (isEvent(inner)) {
+        const exists = this.store.events.get(inner.id) !== void 0;
+        return exists ? this.extractEventDependency(inner, source) : void 0;
+      }
+      throw new UnknownItemTypeError(inner);
+    }
+    if (isResource(object)) {
+      return this.extractResourceDependency(object);
+    } else if (isTask(object)) {
+      return this.extractTaskDependency(object);
+    } else if (isEvent(object)) {
+      return this.extractEventDependency(object, source);
+    } else {
+      throw new UnknownItemTypeError(object);
+    }
+  }
+  /**
+   * Converts the event into a running functions with real inputs
+   * @param object
+   * @returns
+   */
+  extractEventDependency(object, source) {
+    return async (input) => {
+      return this.eventManager.emit(object, input, source);
+    };
+  }
+  async extractTaskDependency(object) {
+    const storeTask = this.store.tasks.get(object.id);
+    if (storeTask === void 0) {
+      throw new DependencyNotFoundError(`Task ${object.id}`);
+    }
+    if (!storeTask.isInitialized) {
+      const dependencies = object.dependencies;
+      storeTask.computedDependencies = await this.extractDependencies(
+        dependencies,
+        storeTask.task.id
+      );
+      storeTask.isInitialized = true;
+    }
+    return (input) => {
+      return this.taskRunner.run(storeTask.task, input);
+    };
+  }
+  async extractResourceDependency(object) {
+    const storeResource = this.store.resources.get(object.id);
+    if (storeResource === void 0) {
+      throw new DependencyNotFoundError(`Resource ${object.id}`);
+    }
+    const { resource, config } = storeResource;
+    if (!storeResource.isInitialized) {
+      if (resource.init) {
+        const depMap = resource.dependencies || {};
+        const raw = await this.extractDependencies(depMap, resource.id);
+        const wrapped = this.wrapResourceDependencies(depMap, raw);
+        const { value, context } = await this.resourceInitializer.initializeResource(
+          resource,
+          config,
+          wrapped
+        );
+        storeResource.context = context;
+        storeResource.value = value;
+      }
+      storeResource.isInitialized = true;
+    }
+    return storeResource.value;
+  }
+};
+
+// src/models/EventManager.ts
+var HandlerOptionsDefaults = { order: 0 };
+var _isLocked2;
+var EventManager = class {
+  constructor(options) {
+    // Core storage for event listeners
+    this.listeners = /* @__PURE__ */ new Map();
+    this.globalListeners = [];
+    // Caching system for merged listeners to improve performance
+    this.cachedMergedListeners = /* @__PURE__ */ new Map();
+    this.globalListenersCacheValid = true;
+    // Interceptors storage
+    this.emissionInterceptors = [];
+    this.hookInterceptors = [];
+    // Locking mechanism to prevent modifications after initialization
+    __privateAdd(this, _isLocked2, false);
+    this.runtimeCycleDetection = options?.runtimeCycleDetection ?? true;
+    if (getPlatform().hasAsyncLocalStorage() && this.runtimeCycleDetection) {
+      this.emissionStack = getPlatform().createAsyncLocalStorage();
+      this.currentHookIdContext = getPlatform().createAsyncLocalStorage();
+    } else {
+      this.runtimeCycleDetection = false;
+      this.emissionStack = null;
+      this.currentHookIdContext = null;
+    }
+  }
+  // ==================== PUBLIC API ====================
+  /**
+   * Gets the current lock status of the EventManager
+   */
+  get isLocked() {
+    return __privateGet(this, _isLocked2);
+  }
+  /**
+   * Locks the EventManager, preventing any further modifications to listeners
+   */
+  lock() {
+    __privateSet(this, _isLocked2, true);
+  }
+  /**
+   * Emits an event to all registered listeners for that event type.
+   * Listeners are processed in order of priority and can stop event propagation.
+   *
+   * @param eventDefinition - The event definition to emit
+   * @param data - The event payload data
+   * @param source - The source identifier of the event emitter
+   */
+  async emit(eventDefinition, data, source) {
+    if (eventDefinition.payloadSchema) {
+      try {
+        data = eventDefinition.payloadSchema.parse(data);
+      } catch (error) {
+        throw new ValidationError(
+          "Event payload",
+          eventDefinition.id,
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+    }
+    const frame = { id: eventDefinition.id, source };
+    const processEmission = async () => {
+      const pseudoForExclude = {
+        id: eventDefinition.id,
+        data,
+        timestamp: /* @__PURE__ */ new Date(),
+        source,
+        meta: eventDefinition.meta || {},
+        stopPropagation: () => {
+        },
+        isPropagationStopped: () => false,
+        tags: eventDefinition.tags
+      };
+      const excludeFromGlobal = this.isExcludedFromGlobal(pseudoForExclude);
+      const allListeners = excludeFromGlobal ? this.listeners.get(eventDefinition.id) || [] : this.getCachedMergedListeners(eventDefinition.id);
+      let propagationStopped = false;
+      const event = {
+        id: eventDefinition.id,
+        data,
+        timestamp: /* @__PURE__ */ new Date(),
+        source,
+        meta: eventDefinition.meta || {},
+        stopPropagation: () => {
+          propagationStopped = true;
+        },
+        isPropagationStopped: () => propagationStopped,
+        tags: eventDefinition.tags
+      };
+      const baseEmit = async (eventToEmit) => {
+        if (allListeners.length === 0) {
+          return;
+        }
+        this.isExcludedFromGlobal(eventToEmit);
+        for (const listener of allListeners) {
+          if (propagationStopped) {
+            break;
+          }
+          if (listener.id && listener.id === eventToEmit.source) {
+            continue;
+          }
+          if (!listener.filter || listener.filter(eventToEmit)) {
+            await listener.handler(eventToEmit);
+          }
+        }
+      };
+      let emitWithInterceptors = baseEmit;
+      const reversedInterceptors = [...this.emissionInterceptors].reverse();
+      for (const interceptor of reversedInterceptors) {
+        const nextFunction = emitWithInterceptors;
+        emitWithInterceptors = async (eventToEmit) => interceptor(nextFunction, eventToEmit);
+      }
+      await emitWithInterceptors(event);
+    };
+    if (this.runtimeCycleDetection && this.emissionStack && this.currentHookIdContext) {
+      const currentStack = this.emissionStack.getStore();
+      if (currentStack) {
+        const cycleStart = currentStack.findIndex(
+          (f) => f.id === frame.id
+        );
+        if (cycleStart !== -1) {
+          const top = currentStack[currentStack.length - 1];
+          const currentHookId = this.currentHookIdContext.getStore();
+          const safeReEmitBySameHook = top.id === frame.id && currentHookId && currentHookId === source;
+          if (!safeReEmitBySameHook) {
+            throw new EventCycleError([
+              ...currentStack.slice(cycleStart),
+              frame
+            ]);
+          }
+        }
+      }
+      const nextStack = currentStack ? [...currentStack, frame] : [frame];
+      await this.emissionStack.run(nextStack, processEmission);
+    } else {
+      await processEmission();
+    }
+  }
+  /**
+   * Registers an event listener for specific event(s).
+   * Listeners are ordered by priority and executed in ascending order.
+   *
+   * @param event - The event definition(s) to listen for
+   * @param handler - The callback function to handle the event
+   * @param options - Configuration options for the listener
+   */
+  addListener(event, handler, options = HandlerOptionsDefaults) {
+    this.checkLock();
+    const newListener = {
+      handler,
+      order: options.order || 0,
+      filter: options.filter,
+      id: options.id,
+      isGlobal: false
+    };
+    if (Array.isArray(event)) {
+      event.forEach((id2) => this.addListener(id2, handler, options));
+    } else {
+      const eventId = event.id;
+      const listeners = this.listeners.get(eventId);
+      if (listeners) {
+        this.insertListener(listeners, newListener);
+      } else {
+        this.listeners.set(eventId, [newListener]);
+      }
+      this.invalidateCache(eventId);
+    }
+  }
+  /**
+   * Registers a global event listener that handles all events.
+   * Global listeners are mixed with specific listeners and ordered by priority.
+   *
+   * @param handler - The callback function to handle events
+   * @param options - Configuration options for the listener
+   */
+  addGlobalListener(handler, options = HandlerOptionsDefaults) {
+    this.checkLock();
+    const newListener = {
+      handler,
+      order: options.order || 0,
+      filter: options.filter,
+      id: options.id,
+      isGlobal: true
+    };
+    this.insertListener(this.globalListeners, newListener);
+    this.invalidateCache();
+  }
+  /**
+   * Checks if there are any listeners registered for the given event
+   *
+   * @param eventDefinition - The event definition to check
+   * @returns true if listeners exist, false otherwise
+   */
+  hasListeners(eventDefinition) {
+    const eventListeners = this.listeners.get(eventDefinition.id) || [];
+    if (eventListeners.length > 0) {
+      return true;
+    }
+    if (this.globalListeners.length === 0) {
+      return false;
+    }
+    const pseudoEmission = {
+      id: eventDefinition.id,
+      data: void 0,
+      timestamp: /* @__PURE__ */ new Date(),
+      source: "",
+      meta: eventDefinition.meta || {},
+      stopPropagation: () => {
+      },
+      isPropagationStopped: () => false,
+      tags: eventDefinition.tags
+    };
+    if (this.isExcludedFromGlobal(pseudoEmission)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Adds an interceptor for all event emissions
+   * Interceptors are executed in the order they are added, with the ability to
+   * modify, log, or prevent event emissions
+   *
+   * @param interceptor - The interceptor function to add
+   */
+  intercept(interceptor) {
+    this.checkLock();
+    this.emissionInterceptors.push(interceptor);
+  }
+  /**
+   * Adds an interceptor for hook execution
+   * Interceptors are executed in the order they are added, with the ability to
+   * modify, log, or prevent hook execution
+   *
+   * @param interceptor - The interceptor function to add
+   */
+  interceptHook(interceptor) {
+    this.checkLock();
+    this.hookInterceptors.push(interceptor);
+  }
+  /**
+   * Executes a hook with all registered hook interceptors applied
+   * This method should be used by TaskRunner when executing hooks
+   *
+   * @param hook - The hook to execute
+   * @param event - The event that triggered the hook
+   * @param computedDependencies - The computed dependencies for the hook
+   * @returns Promise resolving to the hook execution result
+   */
+  async executeHookWithInterceptors(hook, event, computedDependencies) {
+    const baseExecute = async (hookToExecute, eventForHook) => {
+      try {
+        const result = await hookToExecute.run(
+          eventForHook,
+          computedDependencies
+        );
+        return result;
+      } catch (err) {
+        throw err;
+      }
+    };
+    let executeWithInterceptors = baseExecute;
+    const reversedInterceptors = [...this.hookInterceptors].reverse();
+    for (const interceptor of reversedInterceptors) {
+      const nextFunction = executeWithInterceptors;
+      executeWithInterceptors = async (hookToExecute, eventForHook) => interceptor(nextFunction, hookToExecute, eventForHook);
+    }
+    if (this.runtimeCycleDetection) {
+      return await this.currentHookIdContext?.run(
+        hook.id,
+        async () => await executeWithInterceptors(hook, event)
+      );
+    } else {
+      return await executeWithInterceptors(hook, event);
+    }
+  }
+  // ==================== PRIVATE METHODS ====================
+  /**
+   * Throws an error if the EventManager is locked
+   */
+  checkLock() {
+    if (__privateGet(this, _isLocked2)) {
+      throw new LockedError("EventManager");
+    }
+  }
+  /**
+   * Merges two sorted arrays of listeners while maintaining order.
+   * Used to combine event-specific listeners with global listeners.
+   *
+   * @param a - First array of listeners
+   * @param b - Second array of listeners
+   * @returns Merged and sorted array of listeners
+   */
+  mergeSortedListeners(a, b) {
+    const result = [];
+    let i = 0, j = 0;
+    while (i < a.length && j < b.length) {
+      if (a[i].order <= b[j].order) {
+        result.push(a[i++]);
+      } else {
+        result.push(b[j++]);
+      }
+    }
+    while (i < a.length) result.push(a[i++]);
+    while (j < b.length) result.push(b[j++]);
+    return result;
+  }
+  /**
+   * Inserts a new listener into a sorted array using binary search.
+   * Maintains order based on listener priority.
+   *
+   * @param listeners - Array to insert into
+   * @param newListener - Listener to insert
+   */
+  insertListener(listeners, newListener) {
+    let low = 0;
+    let high = listeners.length;
+    while (low < high) {
+      const mid = low + high >>> 1;
+      if (listeners[mid].order < newListener.order) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    }
+    listeners.splice(low, 0, newListener);
+  }
+  /**
+   * Returns true if the given emission carries the tag that marks
+   * it as excluded from global ("*") listeners.
+   *
+   * @param event - The event emission to check
+   * @returns true if event should exclude global listeners
+   */
+  isExcludedFromGlobal(event) {
+    return globalTags.excludeFromGlobalHooks.exists(event);
+  }
+  /**
+   * Retrieves cached merged listeners for an event, or creates them if not cached.
+   * Combines event-specific listeners with global listeners and sorts them by priority.
+   *
+   * @param eventId - The event ID to get listeners for
+   * @returns Array of merged listeners sorted by priority
+   */
+  getCachedMergedListeners(eventId) {
+    if (!this.globalListenersCacheValid) {
+      this.cachedMergedListeners.clear();
+      this.globalListenersCacheValid = true;
+    }
+    let cached = this.cachedMergedListeners.get(eventId);
+    if (!cached) {
+      const eventListeners = this.listeners.get(eventId) || [];
+      if (eventListeners.length === 0 && this.globalListeners.length === 0) {
+        cached = [];
+      } else if (eventListeners.length === 0) {
+        cached = this.globalListeners;
+      } else if (this.globalListeners.length === 0) {
+        cached = eventListeners;
+      } else {
+        cached = this.mergeSortedListeners(
+          eventListeners,
+          this.globalListeners
+        );
+      }
+      this.cachedMergedListeners.set(eventId, cached);
+    }
+    return cached;
+  }
+  /**
+   * Invalidates the cached merged listeners.
+   * If eventId is provided, only invalidates cache for that specific event.
+   * Otherwise, invalidates the global cache.
+   *
+   * @param eventId - Optional specific event ID to invalidate
+   */
+  invalidateCache(eventId) {
+    if (eventId) {
+      this.cachedMergedListeners.delete(eventId);
+    } else {
+      this.globalListenersCacheValid = false;
+    }
+  }
+};
+_isLocked2 = new WeakMap();
+
+// src/models/utils/findCircularDependencies.ts
+function findCircularDependencies(nodes) {
+  const result = {
+    cycles: [],
+    missingDependencies: []
+  };
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const path = [];
+  function dfs(node) {
+    if (stack.has(node.id)) {
+      const cycleStartIndex = path.indexOf(node.id);
+      const cycle = path.slice(cycleStartIndex).concat(node.id).join(" -> ");
+      result.cycles.push(cycle);
+      return;
+    }
+    if (visited.has(node.id)) return;
+    visited.add(node.id);
+    stack.add(node.id);
+    path.push(node.id);
+    for (const [depKey, dependentNode] of Object.entries(node.dependencies)) {
+      if (!dependentNode) {
+        result.missingDependencies.push({
+          nodeId: node.id,
+          dependencyId: depKey
+        });
+        continue;
+      }
+      dfs(dependentNode);
+    }
+    stack.delete(node.id);
+    path.pop();
+  }
+  for (const node of nodes) {
+    if (!visited.has(node.id)) {
+      dfs(node);
+    }
+  }
+  result.cycles = Array.from(new Set(result.cycles));
+  return result;
+}
+
+// src/models/StoreValidator.ts
+var StoreValidator = class {
+  constructor(registry) {
+    this.registry = registry;
+  }
+  checkIfIDExists(id2) {
+    if (this.registry.tasks.has(id2)) {
+      throw new DuplicateRegistrationError("Task", id2);
+    }
+    if (this.registry.resources.has(id2)) {
+      throw new DuplicateRegistrationError("Resource", id2);
+    }
+    if (this.registry.events.has(id2)) {
+      throw new DuplicateRegistrationError("Event", id2);
+    }
+    if (this.registry.taskMiddlewares.has(id2)) {
+      throw new DuplicateRegistrationError("Middleware", id2);
+    }
+    if (this.registry.resourceMiddlewares.has(id2)) {
+      throw new DuplicateRegistrationError("Middleware", id2);
+    }
+    if (this.registry.tags.has(id2)) {
+      throw new DuplicateRegistrationError("Tag", id2);
+    }
+    if (this.registry.hooks.has(id2)) {
+      throw new DuplicateRegistrationError("Hook", id2);
+    }
+  }
+  runSanityChecks() {
+    for (const task of this.registry.tasks.values()) {
+      const middlewares = task.task.middleware;
+      middlewares.forEach((middlewareAttachment) => {
+        if (!this.registry.taskMiddlewares.has(middlewareAttachment.id)) {
+          throw new MiddlewareNotRegisteredError(
+            "task",
+            task.task.id,
+            middlewareAttachment.id
+          );
+        }
+      });
+    }
+    for (const resource of this.registry.resources.values()) {
+      const middlewares = resource.resource.middleware;
+      middlewares.forEach((middlewareAttachment) => {
+        if (!this.registry.resourceMiddlewares.has(middlewareAttachment.id)) {
+          throw new MiddlewareNotRegisteredError(
+            "resource",
+            resource.resource.id,
+            middlewareAttachment.id
+          );
+        }
+      });
+    }
+    this.ensureAllTagsUsedAreRegistered();
+  }
+  ensureAllTagsUsedAreRegistered() {
+    const taggables = [
+      ...Array.from(this.registry.tasks.values()).map((x) => x.task),
+      ...Array.from(this.registry.resources.values()).map((x) => x.resource),
+      ...Array.from(this.registry.events.values()).map((x) => x.event),
+      ...Array.from(this.registry.taskMiddlewares.values()).map(
+        (x) => x.middleware
+      ),
+      ...Array.from(this.registry.resourceMiddlewares.values()).map(
+        (x) => x.middleware
+      ),
+      ...Array.from(this.registry.hooks.values()).map((x) => x.hook)
+    ];
+    for (const taggable of taggables) {
+      const tags = taggable.tags;
+      if (tags) {
+        for (const tag of tags) {
+          if (!this.registry.tags.has(tag.id)) {
+            throw new TagNotFoundError(tag.id);
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/models/StoreRegistry.ts
+var StoreRegistry = class {
+  constructor(store2) {
+    this.store = store2;
+    this.tasks = /* @__PURE__ */ new Map();
+    this.resources = /* @__PURE__ */ new Map();
+    this.events = /* @__PURE__ */ new Map();
+    this.taskMiddlewares = /* @__PURE__ */ new Map();
+    this.resourceMiddlewares = /* @__PURE__ */ new Map();
+    this.hooks = /* @__PURE__ */ new Map();
+    this.tags = /* @__PURE__ */ new Map();
+    this.validator = new StoreValidator(this);
+  }
+  getValidator() {
+    return this.validator;
+  }
+  storeGenericItem(item) {
+    if (isTask(item)) {
+      this.storeTask(item);
+    } else if (isHook && isHook(item)) {
+      this.storeHook(item);
+    } else if (isResource(item)) {
+      this.storeResource(item);
+    } else if (isEvent(item)) {
+      this.storeEvent(item);
+    } else if (isTaskMiddleware(item)) {
+      this.storeTaskMiddleware(item);
+    } else if (isResourceMiddleware(item)) {
+      this.storeResourceMiddleware(item);
+    } else if (isResourceWithConfig(item)) {
+      this.storeResourceWithConfig(item);
+    } else if (isTag(item)) {
+      this.storeTag(item);
+    } else {
+      throw new UnknownItemTypeError(item);
+    }
+  }
+  storeTag(item) {
+    this.validator.checkIfIDExists(item.id);
+    this.tags.set(item.id, item);
+  }
+  storeHook(item, overrideMode = "normal") {
+    overrideMode === "normal" && this.validator.checkIfIDExists(item.id);
+    const hook = this.getFreshValue(item, this.hooks, "hook", overrideMode);
+    this.hooks.set(hook.id, {
+      hook,
+      computedDependencies: {}
+    });
+  }
+  storeTaskMiddleware(item, storingMode = "normal") {
+    storingMode === "normal" && this.validator.checkIfIDExists(item.id);
+    const middleware = this.getFreshValue(
+      item,
+      this.taskMiddlewares,
+      "middleware",
+      storingMode
+    );
+    this.taskMiddlewares.set(item.id, {
+      middleware,
+      computedDependencies: {},
+      isInitialized: false
+    });
+  }
+  storeResourceMiddleware(item, overrideMode = "normal") {
+    overrideMode === "normal" && this.validator.checkIfIDExists(item.id);
+    const middleware = this.getFreshValue(
+      item,
+      this.resourceMiddlewares,
+      "middleware",
+      overrideMode
+    );
+    this.resourceMiddlewares.set(item.id, {
+      middleware,
+      computedDependencies: {},
+      isInitialized: false
+    });
+  }
+  storeEvent(item) {
+    this.validator.checkIfIDExists(item.id);
+    this.events.set(item.id, { event: item });
+  }
+  storeResourceWithConfig(item, storingMode = "normal") {
+    storingMode === "normal" && this.validator.checkIfIDExists(item.resource.id);
+    const prepared = this.getFreshValue(
+      item.resource,
+      this.resources,
+      "resource",
+      storingMode,
+      item.config
+    );
+    this.resources.set(prepared.id, {
+      resource: prepared,
+      config: item.config,
+      value: void 0,
+      isInitialized: false,
+      context: {}
+    });
+    this.computeRegistrationDeeply(prepared, item.config);
+    return prepared;
+  }
+  computeRegistrationDeeply(element, config) {
+    const items = typeof element.register === "function" ? element.register(config) : element.register;
+    element.register = items;
+    for (const item of items) {
+      this.storeGenericItem(item);
+    }
+  }
+  storeResource(item, overrideMode = "normal") {
+    overrideMode === "normal" && this.validator.checkIfIDExists(item.id);
+    const prepared = this.getFreshValue(
+      item,
+      this.resources,
+      "resource",
+      overrideMode
+    );
+    this.resources.set(prepared.id, {
+      resource: prepared,
+      config: {},
+      value: void 0,
+      isInitialized: false,
+      context: prepared.context?.() || {}
+    });
+    this.computeRegistrationDeeply(prepared, {});
+    return prepared;
+  }
+  storeTask(item, storingMode = "normal") {
+    storingMode === "normal" && this.validator.checkIfIDExists(item.id);
+    const task = this.getFreshValue(item, this.tasks, "task", storingMode);
+    this.tasks.set(task.id, {
+      task,
+      computedDependencies: {},
+      isInitialized: false
+    });
+  }
+  // Feels like a dependencyProcessor task?
+  getDependentNodes() {
+    const depenedants = [];
+    const nodeMap = /* @__PURE__ */ new Map();
+    this.setupBlankNodes(nodeMap, depenedants);
+    for (const task of this.tasks.values()) {
+      const node = nodeMap.get(task.task.id);
+      if (task.task.dependencies) {
+        for (const [depKey, depItem] of Object.entries(
+          task.task.dependencies
+        )) {
+          const candidate = isOptional(depItem) ? depItem.inner : depItem;
+          const depNode = nodeMap.get(candidate.id);
+          if (depNode) {
+            node.dependencies[depKey] = depNode;
+          }
+        }
+      }
+      const t = task.task;
+      for (const middleware of t.middleware) {
+        const middlewareNode = nodeMap.get(middleware.id);
+        if (middlewareNode) {
+          node.dependencies[middleware.id] = middlewareNode;
+        }
+      }
+    }
+    for (const storeTaskMiddleware of this.taskMiddlewares.values()) {
+      const node = nodeMap.get(storeTaskMiddleware.middleware.id);
+      const { middleware } = storeTaskMiddleware;
+      if (middleware.dependencies) {
+        for (const [depKey, depItem] of Object.entries(
+          middleware.dependencies
+        )) {
+          const candidate = isOptional(depItem) ? depItem.inner : depItem;
+          const depNode = nodeMap.get(candidate.id);
+          if (depNode) {
+            node.dependencies[depKey] = depNode;
+          }
+        }
+      }
+      if (middleware.everywhere) {
+        const filter = typeof middleware.everywhere === "function" ? middleware.everywhere : () => true;
+        for (const task of this.tasks.values()) {
+          if (filter(task.task)) {
+            const taskNode = nodeMap.get(task.task.id);
+            taskNode.dependencies[`__middleware.${middleware.id}`] = node;
+          }
+        }
+      }
+    }
+    for (const storeResourceMiddleware of this.resourceMiddlewares.values()) {
+      const node = nodeMap.get(storeResourceMiddleware.middleware.id);
+      const { middleware } = storeResourceMiddleware;
+      if (middleware.dependencies) {
+        for (const [depKey, depItem] of Object.entries(
+          middleware.dependencies
+        )) {
+          const candidate = isOptional(depItem) ? depItem.inner : depItem;
+          const depNode = nodeMap.get(candidate.id);
+          if (depNode) {
+            node.dependencies[depKey] = depNode;
+          }
+        }
+      }
+      if (middleware.everywhere) {
+        const filter = typeof middleware.everywhere === "function" ? middleware.everywhere : () => true;
+        for (const resource of this.resources.values()) {
+          if (filter(resource.resource)) {
+            const resourceNode = nodeMap.get(resource.resource.id);
+            resourceNode.dependencies[`__middleware.${middleware.id}`] = node;
+          }
+        }
+      }
+    }
+    for (const resource of this.resources.values()) {
+      const node = nodeMap.get(resource.resource.id);
+      if (resource.resource.dependencies) {
+        for (const [depKey, depItem] of Object.entries(
+          resource.resource.dependencies
+        )) {
+          const candidate = isOptional(depItem) ? depItem.inner : depItem;
+          const depNode = nodeMap.get(candidate.id);
+          if (depNode) {
+            node.dependencies[depKey] = depNode;
+          }
+        }
+      }
+      for (const middleware of resource.resource.middleware) {
+        const middlewareNode = nodeMap.get(middleware.id);
+        if (middlewareNode) {
+          node.dependencies[middleware.id] = middlewareNode;
+        }
+      }
+    }
+    for (const hook of this.hooks.values()) {
+      const node = nodeMap.get(hook.hook.id);
+      if (hook.hook.dependencies) {
+        for (const [depKey, depItem] of Object.entries(
+          hook.hook.dependencies
+        )) {
+          const candidate = isOptional(depItem) ? depItem.inner : depItem;
+          const depNode = nodeMap.get(candidate.id);
+          if (depNode) {
+            node.dependencies[depKey] = depNode;
+          }
+        }
+      }
+    }
+    return depenedants;
+  }
+  /**
+   * Builds a directed graph of event emissions based on hooks listening to events
+   * and their dependencies on events (emission capability). Ignores wildcard hooks by default.
+   */
+  buildEventEmissionGraph() {
+    const nodes = /* @__PURE__ */ new Map();
+    for (const e of this.events.values()) {
+      nodes.set(e.event.id, { id: e.event.id, dependencies: {} });
+    }
+    for (const h of this.hooks.values()) {
+      const listened = [];
+      const on = h.hook.on;
+      if (on === "*") continue;
+      if (Array.isArray(on)) listened.push(...on.map((e) => e.id));
+      else listened.push(on.id);
+      const depEvents = [];
+      const deps = h.hook.dependencies;
+      if (deps) {
+        for (const value of Object.values(deps)) {
+          const candidate = isOptional(value) ? value.inner : value;
+          if (candidate && isEvent(candidate)) {
+            depEvents.push(candidate.id);
+          }
+        }
+      }
+      for (const srcId of listened) {
+        const srcNode = nodes.get(srcId);
+        if (!srcNode) continue;
+        for (const dstId of depEvents) {
+          if (srcId === dstId) continue;
+          const dstNode = nodes.get(dstId);
+          if (dstNode) {
+            srcNode.dependencies[dstId] = dstNode;
+          }
+        }
+      }
+    }
+    return Array.from(nodes.values());
+  }
+  setupBlankNodes(nodeMap, depenedants) {
+    for (const task of this.tasks.values()) {
+      const node = {
+        id: task.task.id,
+        dependencies: {}
+      };
+      nodeMap.set(task.task.id, node);
+      depenedants.push(node);
+    }
+    for (const middleware of this.taskMiddlewares.values()) {
+      const node = {
+        id: middleware.middleware.id,
+        dependencies: {}
+      };
+      nodeMap.set(middleware.middleware.id, node);
+      depenedants.push(node);
+    }
+    for (const middleware of this.resourceMiddlewares.values()) {
+      const node = {
+        id: middleware.middleware.id,
+        dependencies: {}
+      };
+      nodeMap.set(middleware.middleware.id, node);
+      depenedants.push(node);
+    }
+    for (const resource of this.resources.values()) {
+      const node = {
+        id: resource.resource.id,
+        dependencies: {}
+      };
+      nodeMap.set(resource.resource.id, node);
+      depenedants.push(node);
+    }
+    for (const hook of this.hooks.values()) {
+      const node = {
+        id: hook.hook.id,
+        dependencies: {}
+      };
+      nodeMap.set(hook.hook.id, node);
+      depenedants.push(node);
+    }
+  }
+  getTasksWithTag(tag) {
+    const tagId = typeof tag === "string" ? tag : tag.id;
+    return Array.from(this.tasks.values()).filter((x) => {
+      return x.task.tags.some((t) => t.id === tagId);
+    }).map((x) => x.task);
+  }
+  getResourcesWithTag(tag) {
+    const tagId = typeof tag === "string" ? tag : tag.id;
+    return Array.from(this.resources.values()).filter((x) => {
+      return x.resource.tags.some((t) => t.id === tagId);
+    }).map((x) => x.resource);
+  }
+  /**
+   * Used to fetch the value cloned, and if we're dealing with an override, we need to extend the previous value.
+   */
+  getFreshValue(item, collection, key, overrideMode, config) {
+    let currentItem;
+    if (overrideMode === "override") {
+      const existing = collection.get(item.id)[key];
+      currentItem = { ...existing, ...item };
+    } else {
+      currentItem = { ...item };
+    }
+    currentItem.dependencies = typeof currentItem.dependencies === "function" ? currentItem.dependencies(config || currentItem.config) : currentItem.dependencies;
+    return currentItem;
+  }
+};
+
+// src/models/OverrideManager.ts
+var OverrideManager = class {
+  constructor(registry) {
+    this.registry = registry;
+    this.overrides = /* @__PURE__ */ new Map();
+    this.overrideRequests = /* @__PURE__ */ new Set();
+  }
+  storeOverridesDeeply(element) {
+    element.overrides.forEach((override) => {
+      if (!override) {
+        return;
+      }
+      if (isResource(override)) {
+        this.storeOverridesDeeply(override);
+      }
+      let id2;
+      if (isResourceWithConfig(override)) {
+        this.storeOverridesDeeply(override.resource);
+        id2 = override.resource.id;
+      } else {
+        id2 = override.id;
+      }
+      this.overrideRequests.add({ source: element.id, override });
+      this.overrides.set(id2, override);
+    });
+  }
+  processOverrides() {
+    for (const override of this.overrides.values()) {
+      let hasAnyItem = false;
+      if (isTask(override)) {
+        hasAnyItem = this.registry.tasks.has(override.id);
+      } else if (isResource(override)) {
+        hasAnyItem = this.registry.resources.has(override.id);
+      } else if (isTaskMiddleware(override)) {
+        hasAnyItem = this.registry.taskMiddlewares.has(override.id);
+      } else if (isResourceMiddleware(override)) {
+        hasAnyItem = this.registry.resourceMiddlewares.has(override.id);
+      } else if (isResourceWithConfig(override)) {
+        hasAnyItem = this.registry.resources.has(override.resource.id);
+      } else if (isHook(override)) {
+        hasAnyItem = this.registry.hooks.has(override.id);
+      }
+      if (!hasAnyItem) {
+        const id2 = isResourceWithConfig(override) ? override.resource.id : override.id;
+        throw new DependencyNotFoundError(id2);
+      }
+    }
+    for (const override of this.overrides.values()) {
+      if (isTask(override)) {
+        this.registry.storeTask(override, "override");
+      } else if (isResource(override)) {
+        this.registry.storeResource(override, "override");
+      } else if (isTaskMiddleware(override)) {
+        this.registry.storeTaskMiddleware(override, "override");
+      } else if (isResourceMiddleware(override)) {
+        this.registry.storeResourceMiddleware(override, "override");
+      } else if (isResourceWithConfig(override)) {
+        this.registry.storeResourceWithConfig(override, "override");
+      } else if (isHook(override)) {
+        this.registry.storeHook(override, "override");
+      }
+    }
+  }
+};
+
+// src/models/Store.ts
+var _isLocked3, _isInitialized;
+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);
+  }
+  // Delegate properties to registry
+  get tasks() {
+    return this.registry.tasks;
+  }
+  get hooks() {
+    return this.registry.hooks;
+  }
+  get resources() {
+    return this.registry.resources;
+  }
+  get events() {
+    return this.registry.events;
+  }
+  get taskMiddlewares() {
+    return this.registry.taskMiddlewares;
+  }
+  get resourceMiddlewares() {
+    return this.registry.resourceMiddlewares;
+  }
+  get tags() {
+    return this.registry.tags;
+  }
+  get overrides() {
+    return this.overrideManager.overrides;
+  }
+  get overrideRequests() {
+    return this.overrideManager.overrideRequests;
+  }
+  // Expose the shared MiddlewareManager instance so other components (like TaskRunner)
+  // can compose runners using the same interceptor configuration.
+  getMiddlewareManager() {
+    return this.middlewareManager;
+  }
+  get isLocked() {
+    return __privateGet(this, _isLocked3);
+  }
+  lock() {
+    __privateSet(this, _isLocked3, true);
+  }
+  checkLock() {
+    if (__privateGet(this, _isLocked3)) {
+      throw new Error("Cannot modify the Store when it is locked.");
+    }
+  }
+  registerGlobalComponents() {
+    const builtInResourcesMap = /* @__PURE__ */ new Map();
+    builtInResourcesMap.set(globalResources.store, this);
+    builtInResourcesMap.set(globalResources.eventManager, this.eventManager);
+    builtInResourcesMap.set(globalResources.logger, this.logger);
+    builtInResourcesMap.set(globalResources.taskRunner, this.taskRunner);
+    builtInResourcesMap.set(
+      globalResources.middlewareManager,
+      this.middlewareManager
+    );
+    this.registry.storeGenericItem(globalResources.queue);
+    for (const [resource, value] of builtInResourcesMap.entries()) {
+      this.registry.storeGenericItem(resource);
+      const entry = this.resources.get(resource.id);
+      if (entry) {
+        entry.value = value;
+        entry.isInitialized = true;
+      }
+    }
+    Object.values(globalTags).forEach((tag) => {
+      this.registry.storeTag(tag);
+    });
+    globalEventsArray.forEach((event) => {
+      this.registry.storeEvent(event);
+    });
+    const builtInTaskMiddlewares = [
+      requireContextTaskMiddleware,
+      retryTaskMiddleware,
+      timeoutTaskMiddleware
+    ];
+    builtInTaskMiddlewares.forEach((middleware) => {
+      this.registry.taskMiddlewares.set(middleware.id, {
+        middleware,
+        computedDependencies: {},
+        isInitialized: false
+      });
+    });
+    const builtInResourceMiddlewares = [
+      retryResourceMiddleware,
+      timeoutResourceMiddleware
+    ];
+    builtInResourceMiddlewares.forEach((middleware) => {
+      this.registry.resourceMiddlewares.set(middleware.id, {
+        middleware,
+        computedDependencies: {},
+        isInitialized: false
+      });
+    });
+  }
+  setTaskRunner(taskRunner) {
+    this.taskRunner = taskRunner;
+  }
+  setupRootResource(root, config) {
+    root.dependencies = typeof root.dependencies === "function" ? root.dependencies(config) : root.dependencies;
+    this.root = {
+      resource: root,
+      computedDependencies: {},
+      config,
+      value: void 0,
+      isInitialized: false,
+      context: {}
+    };
+    this.registry.computeRegistrationDeeply(root, config);
+    this.registry.resources.set(root.id, this.root);
+  }
+  validateDependencyGraph() {
+    const dependentNodes = this.registry.getDependentNodes();
+    const circularDependencies = findCircularDependencies(dependentNodes);
+    if (circularDependencies.cycles.length > 0) {
+      throw new CircularDependenciesError(circularDependencies.cycles);
+    }
+  }
+  validateEventEmissionGraph() {
+    const eventNodes = this.registry.buildEventEmissionGraph();
+    const circular = findCircularDependencies(eventNodes);
+    if (circular.cycles.length > 0) {
+      throw new EventEmissionCycleError(circular.cycles);
+    }
+  }
+  initializeStore(root, config) {
+    if (__privateGet(this, _isInitialized)) {
+      throw new StoreAlreadyInitializedError();
+    }
+    this.registerGlobalComponents();
+    this.setupRootResource(root, config);
+    this.validator.runSanityChecks();
+    for (const resource of this.resources.values()) {
+      this.overrideManager.storeOverridesDeeply(resource.resource);
+    }
+    __privateSet(this, _isInitialized, true);
+  }
+  async dispose() {
+    for (const resource of this.resources.values()) {
+      if (resource.isInitialized && resource.resource.dispose) {
+        await resource.resource.dispose(
+          resource.value,
+          resource.config,
+          resource.computedDependencies,
+          resource.context
+        );
+      }
+    }
+  }
+  processOverrides() {
+    this.overrideManager.processOverrides();
+  }
+  storeGenericItem(item) {
+    return this.registry.storeGenericItem(item);
+  }
+  /**
+   * Returns all tasks with the given tag.
+   * @param tag - The tag to filter by.
+   * @returns The tasks with the given tag.
+   */
+  getTasksWithTag(tag) {
+    return this.registry.getTasksWithTag(tag);
+  }
+  getResourcesWithTag(tag) {
+    return this.registry.getResourcesWithTag(tag);
+  }
+};
+_isLocked3 = new WeakMap();
+_isInitialized = new WeakMap();
+
+// src/globals/resources/debug/types.ts
+var allFalse = Object.freeze({
+  logResourceBeforeRun: false,
+  logResourceAfterRun: false,
+  logMiddlewareBeforeRun: false,
+  logMiddlewareAfterRun: false,
+  logTaskBeforeRun: false,
+  logTaskAfterRun: false,
+  logTaskInput: false,
+  logTaskOutput: false,
+  logResourceConfig: false,
+  logResourceValue: false,
+  logHookTriggered: false,
+  logHookCompleted: false,
+  logEventEmissionOnRun: false,
+  logEventEmissionInput: false
+});
+var levelNormal = Object.freeze({
+  ...allFalse,
+  logTaskAfterRun: true,
+  logTaskBeforeRun: true,
+  logResourceBeforeRun: true,
+  logResourceAfterRun: true,
+  logMiddlewareBeforeRun: true,
+  logMiddlewareAfterRun: true,
+  logHookTriggered: true,
+  logHookCompleted: true,
+  logEventEmissionOnRun: true
+});
+Object.freeze(levelNormal);
+var levelVerbose = Object.freeze({
+  ...levelNormal,
+  logTaskInput: true,
+  logTaskOutput: true,
+  logResourceConfig: true,
+  logResourceValue: true,
+  logHookTriggered: true,
+  logHookCompleted: true
+});
+Object.freeze(levelVerbose);
+function formatConfig(config) {
+  if (config === "normal") {
+    return { ...levelNormal };
+  }
+  if (config === "verbose") {
+    return { ...levelVerbose };
+  }
+  return { ...allFalse, ...config };
+}
+var getConfig = (config, taggable) => {
+  if (!taggable) {
+    return formatConfig(config);
+  }
+  const debugTagConfig = debugTag.extract(taggable);
+  if (debugTagConfig) {
+    const debugTagConfigFormatted = formatConfig(debugTagConfig);
+    return { ...formatConfig(config), ...debugTagConfigFormatted };
+  }
+  return formatConfig(config);
+};
+
+// src/globals/resources/debug/debugConfig.resource.ts
+var debugConfig = defineResource({
+  id: "globals.debug.resources.config",
+  meta: {
+    title: "Debug Config",
+    description: "Debug config. This is used to debug the system."
+  },
+  tags: [globalTags.system],
+  init: async (config) => {
+    const myConfig = { ...getConfig(config) };
+    Object.freeze(myConfig);
+    return myConfig;
+  }
+});
+
+// src/globals/resources/debug/utils.ts
+var hasSystemTag = (definition) => {
+  const maybeTags = definition.tags;
+  if (!Array.isArray(maybeTags)) {
+    return false;
+  }
+  return globalTags.system.exists(definition);
+};
+
+// src/globals/resources/debug/globalEvent.hook.ts
+var globalEventListener = defineHook({
+  id: "globals.debug.hooks.onAnyEvent",
+  on: "*",
+  dependencies: {
+    logger: globalResources.logger,
+    debugConfig
+  },
+  run: async (event, { logger, debugConfig: debugConfig2 }) => {
+    if (hasSystemTag(event)) {
+      return;
+    }
+    debugConfig2 = getConfig(debugConfig2, event);
+    if (debugConfig2.logEventEmissionOnRun) {
+      const message = `Event ${String(event.id)} emitted`;
+      await logger.info(message, {
+        source: "globals.debug.hooks.onAnyEvent",
+        data: debugConfig2.logEventEmissionInput ? { data: event.data } : void 0
+      });
+    }
+  },
+  meta: {
+    title: "Non-system Event Logger",
+    description: "Logs all non-system events."
+  },
+  tags: [globalTags.system]
+});
+
+// src/globals/resources/debug/executionTracker.middleware.ts
+var tasksTrackerMiddleware = defineTaskMiddleware({
+  id: "globals.debug.middleware.task.executionTracker",
+  everywhere: (task) => !globalTags.system.exists(task),
+  dependencies: {
+    logger: globalResources.logger,
+    debugConfig,
+    store: globalResources.store
+  },
+  run: async ({ task, next }, { logger, debugConfig: debugConfig2, store: store2 }) => {
+    const start = Date.now();
+    logger = logger.with({
+      source: tasksTrackerMiddleware.id
+    });
+    debugConfig2 = getConfig(debugConfig2, task?.definition);
+    const taskStartMessage = `Task ${task.definition.id} is running...`;
+    const shouldShowData = debugConfig2.logTaskInput && task.input;
+    await logger.info(taskStartMessage, {
+      data: shouldShowData ? { input: task.input } : void 0
+    });
+    const result = await next(task.input);
+    const duration = Date.now() - start;
+    const taskCompleteMessage = `Task ${task.definition.id} completed in ${duration}ms`;
+    const shouldShowResult = debugConfig2.logTaskOutput && result;
+    await logger.info(taskCompleteMessage, {
+      data: shouldShowResult ? { result } : void 0
+    });
+    return result;
+  },
+  meta: {
+    title: "Execution Tracker",
+    description: "Tracks the execution of tasks and resources."
+  },
+  tags: [globalTags.system]
+});
+var resourcesTrackerMiddleware = defineResourceMiddleware({
+  id: "globals.debug.middleware.resource.executionTracker",
+  dependencies: {
+    logger: globalResources.logger,
+    debugConfig,
+    store: globalResources.store
+  },
+  everywhere: (resource) => !globalTags.system.exists(resource),
+  run: async ({ resource, next }, { logger, debugConfig: debugConfig2, store: store2 }) => {
+    const start = Date.now();
+    logger = logger.with({
+      source: resourcesTrackerMiddleware.id
+    });
+    debugConfig2 = getConfig(debugConfig2, resource?.definition);
+    const resourceStartMessage = `Resource ${resource.definition.id} is initializing...`;
+    const isConfigEmpty = Object.keys(resource.config || {}).length === 0;
+    const shouldShowConfig = debugConfig2.logResourceConfig && !isConfigEmpty;
+    await logger.info(resourceStartMessage, {
+      data: shouldShowConfig ? { config: resource.config } : void 0
+    });
+    const result = await next(resource.config);
+    const duration = Date.now() - start;
+    const resourceCompleteMessage = `Resource ${String(
+      resource.definition.id
+    )} initialized in ${duration}ms`;
+    const shouldShowResult = debugConfig2.logResourceValue && result !== void 0;
+    await logger.info(resourceCompleteMessage, {
+      data: shouldShowResult ? { result } : void 0
+    });
+    return result;
+  },
+  meta: {
+    title: "Execution Tracker",
+    description: "Tracks the execution of tasks and resources."
+  },
+  tags: [globalTags.system]
+});
+
+// src/globals/resources/debug/middleware.hook.ts
+var id = "globals.debug.resources.middlewareInterceptor";
+var middlewareInterceptorResource = defineResource({
+  id,
+  meta: {
+    title: "Middleware Interceptor",
+    description: "Intercepts task and resource middleware, skipping system-tagged entities."
+  },
+  tags: [globalTags.system],
+  dependencies: {
+    logger: globalResources.logger,
+    debugConfig,
+    middlewareManager: globalResources.middlewareManager
+  },
+  init: async (event, deps) => {
+    const { logger, debugConfig: debugConfig2, middlewareManager } = deps;
+    middlewareManager.intercept(
+      "task",
+      async (next, input) => {
+        const taskDef = input.task.definition;
+        if (!hasSystemTag(taskDef)) {
+          const cfg = getConfig(debugConfig2, event);
+          if (cfg.logMiddlewareBeforeRun) {
+            const msg = `Middleware triggered for task ${String(taskDef.id)}`;
+            await logger.info(msg, {
+              source: id
+            });
+          }
+        }
+        const result = await next(input);
+        if (!hasSystemTag(taskDef)) {
+          const cfg = getConfig(debugConfig2, event);
+          if (cfg.logMiddlewareAfterRun) {
+            const msg = `Middleware completed for task ${String(taskDef.id)}`;
+            await logger.info(msg, {
+              source: id
+            });
+          }
+        }
+        return result;
+      }
+    );
+    middlewareManager.intercept(
+      "resource",
+      async (next, input) => {
+        const resourceDef = input.resource.definition;
+        if (!hasSystemTag(resourceDef)) {
+          const cfg = getConfig(debugConfig2, event);
+          if (cfg.logMiddlewareBeforeRun) {
+            const msg = `Middleware triggered for resource ${String(
+              resourceDef.id
+            )}`;
+            await logger.info(msg, {
+              source: id
+            });
+          }
+        }
+        const result = await next(input);
+        if (!hasSystemTag(resourceDef)) {
+          const cfg = getConfig(debugConfig2, event);
+          if (cfg.logMiddlewareAfterRun) {
+            const msg = `Middleware completed for resource ${String(
+              resourceDef.id
+            )}`;
+            await logger.info(msg, {
+              source: id
+            });
+          }
+        }
+        return result;
+      }
+    );
+  }
+});
+
+// src/globals/resources/debug/hook.hook.ts
+var hookInterceptorResource = defineResource({
+  id: "globals.debug.resources.hookInterceptor",
+  meta: {
+    title: "Hook Interceptor",
+    description: "Intercepts hooks for debug logging, skipping system-tagged hooks."
+  },
+  tags: [globalTags.system],
+  dependencies: {
+    logger: globalResources.logger,
+    debugConfig,
+    eventManager: globalResources.eventManager
+  },
+  init: async (event, deps) => {
+    deps.eventManager.interceptHook(async (next, hook, event2) => {
+      const { logger, debugConfig: debugConfig2 } = deps;
+      if (hasSystemTag(hook)) {
+        return await next(hook, event2);
+      }
+      const resolved = getConfig(debugConfig2, event2);
+      if (resolved.logHookTriggered) {
+        const hookId = hook.id;
+        let logString = `Hook triggered for ${String(hookId)}`;
+        await logger.info(logString, {
+          source: "globals.debug.resources.hookInterceptor"
+        });
+      }
+      await next(hook, event2);
+      if (resolved.logHookCompleted) {
+        const hookId = hook.id;
+        let logString = `Hook completed for ${String(hookId)}`;
+        await logger.info(logString, {
+          source: "globals.debug.resources.hookInterceptor"
+        });
+      }
+    });
+  }
+});
+
+// src/globals/resources/debug/debug.resource.ts
+var debugResource = defineResource({
+  id: "globals.resources.debug",
+  register: (config) => {
+    return [
+      debugConfig.with(config),
+      globalEventListener,
+      middlewareInterceptorResource,
+      hookInterceptorResource,
+      tasksTrackerMiddleware,
+      resourcesTrackerMiddleware
+    ];
+  },
+  meta: {
+    title: "Debug",
+    description: "Debug resource. This is used to debug the system."
+  },
+  tags: [globalTags.system]
+});
+
+// src/processHooks.ts
+var platform2 = getPlatform();
+var activeErrorHandlers = /* @__PURE__ */ new Set();
+var processSafetyNetsInstalled = false;
+function installGlobalProcessSafetyNetsOnce() {
+  if (processSafetyNetsInstalled) return;
+  processSafetyNetsInstalled = true;
+  const onUncaughtException = async (err) => {
+    for (const handler of activeErrorHandlers) {
+      try {
+        await handler(err, "uncaughtException");
+      } catch (_) {
+      }
+    }
+  };
+  const onUnhandledRejection = async (reason) => {
+    for (const handler of activeErrorHandlers) {
+      try {
+        await handler(reason, "unhandledRejection");
+      } catch (_) {
+      }
+    }
+  };
+  platform2.onUncaughtException(onUncaughtException);
+  platform2.onUnhandledRejection(onUnhandledRejection);
+}
+function registerProcessLevelSafetyNets(handler) {
+  installGlobalProcessSafetyNetsOnce();
+  activeErrorHandlers.add(handler);
+  return () => {
+    activeErrorHandlers.delete(handler);
+  };
+}
+var activeDisposers = /* @__PURE__ */ new Set();
+var shutdownHooksInstalled = false;
+function installGlobalShutdownHooksOnce() {
+  if (shutdownHooksInstalled) return;
+  shutdownHooksInstalled = true;
+  const handler = async () => {
+    try {
+      const disposers = Array.from(activeDisposers);
+      for (const d of disposers) {
+        try {
+          await d();
+        } catch {
+        }
+        activeDisposers.delete(d);
+      }
+    } finally {
+      try {
+        platform2.exit(0);
+      } catch (e) {
+        if (!(e instanceof PlatformUnsupportedFunction)) {
+          throw e;
+        }
+      }
+    }
+  };
+  platform2.onShutdownSignal(handler);
+}
+function registerShutdownHook(disposeOnce) {
+  installGlobalShutdownHooksOnce();
+  activeDisposers.add(disposeOnce);
+  return () => {
+    activeDisposers.delete(disposeOnce);
+  };
+}
+
+// src/models/UnhandledError.ts
+function createDefaultUnhandledError(logger) {
+  return async ({ error, kind, source }) => {
+    const normalizedError = error instanceof Error ? error : new Error(String(error));
+    await logger.error(`${normalizedError.toString()}`, {
+      source,
+      error: normalizedError,
+      data: {
+        kind
+      }
+    });
+  };
+}
+function bindProcessErrorHandler(handler) {
+  return async (error, source) => {
+    try {
+      await handler({ error, kind: "process", source });
+    } catch {
+    }
+  };
+}
+async function safeReportUnhandledError(handler, info) {
+  try {
+    await handler(info);
+  } catch {
+  }
+}
+
+// src/models/RunResult.ts
+var RunResult = class {
+  constructor(value, logger, store2, eventManager, taskRunner, disposeFn) {
+    this.value = value;
+    this.logger = logger;
+    this.store = store2;
+    this.eventManager = eventManager;
+    this.taskRunner = taskRunner;
+    this.disposeFn = disposeFn;
+    /**
+     * Run a task within the context of the run result.
+     * @param task - The task to run.
+     * @param args - The arguments to pass to the task.
+     * @returns The result of the task.
+     */
+    this.runTask = (task, ...args) => {
+      if (typeof task === "string") {
+        const taskId = task;
+        if (!this.store.tasks.has(taskId)) {
+          throw new RuntimeError(`Task "${taskId}" not found.`);
+        }
+        task = this.store.tasks.get(taskId).task;
+      }
+      return this.taskRunner.run(task, ...args);
+    };
+    /**
+     * 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) => {
+      if (typeof event === "string") {
+        const eventId = event;
+        if (!this.store.events.has(eventId)) {
+          throw new RuntimeError(`Event "${eventId}" not found.`);
+        }
+        event = this.store.events.get(eventId).event;
+      }
+      return this.eventManager.emit(event, payload, "outside");
+    };
+    /**
+     * 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) => {
+      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 = () => {
+      return this.disposeFn();
+    };
+  }
+};
+
+// src/run.ts
+var platform3 = getPlatform();
+async function run(resourceOrResourceWithConfig, options) {
+  await getPlatform().init();
+  const {
+    debug = void 0,
+    logs = {},
+    errorBoundary = true,
+    shutdownHooks = true,
+    dryRun = false,
+    onUnhandledError: onUnhandledErrorOpt,
+    runtimeCycleDetection = true
+  } = options || {};
+  const {
+    printThreshold = platform3.getEnv("NODE_ENV") === "test" ? null : "info",
+    printStrategy = "pretty",
+    bufferLogs = false
+  } = logs;
+  const eventManager = new EventManager({
+    runtimeCycleDetection
+  });
+  let { resource, config } = extractResourceAndConfig(
+    resourceOrResourceWithConfig
+  );
+  const logger = new Logger({
+    printThreshold,
+    printStrategy,
+    bufferLogs
+  });
+  const onUnhandledError = onUnhandledErrorOpt || createDefaultUnhandledError(logger);
+  const store2 = new Store(eventManager, logger, onUnhandledError);
+  const taskRunner = new TaskRunner(store2, eventManager, logger);
+  store2.setTaskRunner(taskRunner);
+  let unhookProcessSafetyNets;
+  if (errorBoundary) {
+    unhookProcessSafetyNets = registerProcessLevelSafetyNets(
+      bindProcessErrorHandler(onUnhandledError)
+    );
+  }
+  const processor = new DependencyProcessor(
+    store2,
+    eventManager,
+    taskRunner,
+    logger
+  );
+  let unhookShutdown;
+  const disposeAll = async () => {
+    try {
+      if (unhookProcessSafetyNets) {
+        unhookProcessSafetyNets();
+        unhookProcessSafetyNets = void 0;
+      }
+      if (unhookShutdown) {
+        unhookShutdown();
+        unhookShutdown = void 0;
+      }
+    } finally {
+      await store2.dispose();
+    }
+  };
+  try {
+    if (debug) {
+      store2.storeGenericItem(debugResource.with(debug));
+    }
+    store2.initializeStore(resource, config);
+    await store2.processOverrides();
+    store2.validateDependencyGraph();
+    store2.validateEventEmissionGraph();
+    const boundedLogger = logger.with({ source: "run" });
+    if (dryRun) {
+      await boundedLogger.debug("Dry run mode. Skipping initialization...");
+      return new RunResult(
+        store2.root.value,
+        logger,
+        store2,
+        eventManager,
+        taskRunner,
+        disposeAll
+      );
+    }
+    await boundedLogger.debug("Events stored. Attaching listeners...");
+    await processor.attachListeners();
+    await boundedLogger.debug("Listeners attached. Computing dependencies...");
+    await processor.computeAllDependencies();
+    await boundedLogger.debug(
+      "Dependencies computed. Proceeding with initialization..."
+    );
+    await processor.initializeRoot();
+    store2.lock();
+    eventManager.lock();
+    await logger.lock();
+    await eventManager.emit(
+      globalEvents.ready,
+      {
+        root: store2.root.resource
+      },
+      "system"
+    );
+    await boundedLogger.info("Runner online. Awaiting tasks and events.");
+    if (shutdownHooks) {
+      unhookShutdown = registerShutdownHook(() => store2.dispose());
+    }
+    return new RunResult(
+      store2.root.value,
+      logger,
+      store2,
+      eventManager,
+      taskRunner,
+      disposeAll
+    );
+  } catch (err) {
+    await disposeAll();
+    throw err;
+  }
+}
+function extractResourceAndConfig(resourceOrResourceWithConfig) {
+  let resource;
+  let config;
+  if (isResourceWithConfig(resourceOrResourceWithConfig)) {
+    resource = resourceOrResourceWithConfig.resource;
+    config = resourceOrResourceWithConfig.config;
+  } else {
+    resource = resourceOrResourceWithConfig;
+    config = void 0;
+  }
+  return { resource, config };
+}
+
+// src/testing.ts
+var testResourceCounter = 0;
+function createTestResource(root, options) {
+  return defineResource({
+    id: `testing.${root.id}.${++testResourceCounter}`,
+    register: [root],
+    overrides: options?.overrides || [],
+    dependencies: {
+      taskRunner: globalResources.taskRunner,
+      store: globalResources.store,
+      logger: globalResources.logger,
+      eventManager: globalResources.eventManager
+    },
+    async init(_, deps) {
+      return buildTestFacade(deps);
+    }
+  });
+}
+function buildTestFacade(deps) {
+  return {
+    // Run a task within the fully initialized ecosystem
+    runTask: (task, ...args) => deps.taskRunner.run(task, ...args),
+    // Access a resource value by id (string or symbol)
+    getResource: (id2) => deps.store.resources.get(id2)?.value,
+    // Expose internals when needed in tests (not recommended for app usage)
+    taskRunner: deps.taskRunner,
+    store: deps.store,
+    logger: deps.logger,
+    eventManager: deps.eventManager
+  };
+}
+
+// src/models/Semaphore.ts
+var Semaphore = class {
+  constructor(maxPermits) {
+    this.waitingQueue = [];
+    this.disposed = false;
+    if (maxPermits <= 0) {
+      throw new Error("maxPermits must be greater than 0");
+    }
+    this.permits = maxPermits;
+    this.maxPermits = maxPermits;
+  }
+  /**
+   * Acquire a permit. If no permits are available, waits until one becomes available.
+   */
+  async acquire(options) {
+    if (this.disposed) {
+      throw new Error("Semaphore has been disposed");
+    }
+    if (options?.signal?.aborted) {
+      throw new Error("Operation was aborted");
+    }
+    if (this.permits > 0) {
+      this.permits--;
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const operation = { resolve, reject };
+      if (options?.timeout && options.timeout > 0) {
+        operation.timeout = setTimeout(() => {
+          this.removeFromQueue(operation);
+          reject(
+            new Error(`Semaphore acquire timeout after ${options.timeout}ms`)
+          );
+        }, options.timeout);
+      }
+      if (options?.signal) {
+        const abortHandler = () => {
+          this.removeFromQueue(operation);
+          reject(new Error("Operation was aborted"));
+        };
+        options.signal.addEventListener("abort", abortHandler, { once: true });
+        const originalResolve = operation.resolve;
+        const originalReject = operation.reject;
+        operation.resolve = () => {
+          options.signal.removeEventListener("abort", abortHandler);
+          originalResolve();
+        };
+        operation.reject = (error) => {
+          options.signal.removeEventListener("abort", abortHandler);
+          originalReject(error);
+        };
+      }
+      this.waitingQueue.push(operation);
+    });
+  }
+  /**
+   * Release a permit, allowing waiting operations to proceed.
+   */
+  release() {
+    if (this.disposed) {
+      return;
+    }
+    if (this.waitingQueue.length > 0) {
+      const nextOperation = this.waitingQueue.shift();
+      if (nextOperation.timeout) {
+        clearTimeout(nextOperation.timeout);
+      }
+      nextOperation.resolve();
+    } else {
+      this.permits = Math.min(this.permits + 1, this.maxPermits);
+    }
+  }
+  removeFromQueue(operation) {
+    const index = this.waitingQueue.indexOf(operation);
+    if (index !== -1) {
+      this.waitingQueue.splice(index, 1);
+      if (operation.timeout) {
+        clearTimeout(operation.timeout);
+      }
+    }
+  }
+  /**
+   * Execute a function with a permit, automatically releasing it afterwards.
+   */
+  async withPermit(fn, options) {
+    await this.acquire(options);
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+  /**
+   * Dispose the semaphore, rejecting all waiting operations and preventing new ones.
+   */
+  dispose() {
+    if (this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    while (this.waitingQueue.length > 0) {
+      const operation = this.waitingQueue.shift();
+      if (operation.timeout) {
+        clearTimeout(operation.timeout);
+      }
+      operation.reject(new Error("Semaphore has been disposed"));
+    }
+  }
+  /**
+   * Get current number of available permits (for debugging)
+   */
+  getAvailablePermits() {
+    return this.permits;
+  }
+  /**
+   * Get current number of waiting operations (for debugging)
+   */
+  getWaitingCount() {
+    return this.waitingQueue.length;
+  }
+  /**
+   * Get maximum number of permits
+   */
+  getMaxPermits() {
+    return this.maxPermits;
+  }
+  /**
+   * Check if the semaphore has been disposed
+   */
+  isDisposed() {
+    return this.disposed;
+  }
+  /**
+   * Get metrics about the current state of the semaphore
+   */
+  getMetrics() {
+    return {
+      availablePermits: this.permits,
+      waitingCount: this.waitingQueue.length,
+      maxPermits: this.maxPermits,
+      utilization: (this.maxPermits - this.permits) / this.maxPermits,
+      disposed: this.disposed
+    };
+  }
+};
+
+// src/index.ts
+var globals = {
+  events: globalEvents,
+  resources: globalResources,
+  middleware: globalMiddlewares,
+  tags: globalTags
+};
+
+exports.DependencyProcessor = DependencyProcessor;
+exports.Errors = errors_exports;
+exports.EventManager = EventManager;
+exports.Logger = Logger;
+exports.MiddlewareManager = MiddlewareManager;
+exports.Queue = Queue;
+exports.ResourceInitializer = ResourceInitializer;
+exports.RunResult = RunResult;
+exports.Semaphore = Semaphore;
+exports.Store = Store;
+exports.TaskRunner = TaskRunner;
+exports.allFalse = allFalse;
+exports.bindProcessErrorHandler = bindProcessErrorHandler;
+exports.createContext = createContext;
+exports.createDefaultUnhandledError = createDefaultUnhandledError;
+exports.createTestResource = createTestResource;
+exports.definitions = defs_exports;
+exports.event = defineEvent;
+exports.getConfig = getConfig;
+exports.globals = globals;
+exports.hook = defineHook;
+exports.levelNormal = levelNormal;
+exports.levelVerbose = levelVerbose;
+exports.override = defineOverride;
+exports.resource = defineResource;
+exports.resourceMiddleware = defineResourceMiddleware;
+exports.run = run;
+exports.safeReportUnhandledError = safeReportUnhandledError;
+exports.tag = defineTag;
+exports.task = defineTask;
+exports.taskMiddleware = defineTaskMiddleware;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map