@bluelibs/runner 4.8.6 → 4.9.0

package/dist/edge/index.cjs

@@ -172,78 +172,87 @@ var cacheMiddleware = defineTaskMiddleware({
   }
 });
 
-// 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/platform/adapters/node-als.ts
+async function loadAsyncLocalStorageClass() {
+  const mod = __require("async_hooks");
+  return mod.AsyncLocalStorage;
 }
-__name(getCallerFile, "getCallerFile");
+__name(loadAsyncLocalStorageClass, "loadAsyncLocalStorageClass");
 
-// 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
-      };
-    }
-  };
-}
-__name(defineTask, "defineTask");
-defineTask.phantom = (taskConfig) => {
-  const taskDef = defineTask({
-    ...taskConfig,
-    run: /* @__PURE__ */ __name(async (input) => {
-      return void 0;
-    }, "run")
-  });
-  taskDef[symbolPhantomTask] = true;
-  return taskDef;
+// src/platform/adapters/node.ts
+var NodePlatformAdapter = class {
+  constructor() {
+    this.id = "node";
+    this.setTimeout = globalThis.setTimeout;
+    this.clearTimeout = globalThis.clearTimeout;
+  }
+  static {
+    __name(this, "NodePlatformAdapter");
+  }
+  async init() {
+    this.alsClass = await loadAsyncLocalStorageClass();
+  }
+  onUncaughtException(handler) {
+    process.on("uncaughtException", handler);
+    return () => process.off("uncaughtException", handler);
+  }
+  onUnhandledRejection(handler) {
+    const h = /* @__PURE__ */ __name((reason) => handler(reason), "h");
+    process.on("unhandledRejection", h);
+    return () => process.off("unhandledRejection", h);
+  }
+  onShutdownSignal(handler) {
+    process.on("SIGINT", handler);
+    process.on("SIGTERM", handler);
+    return () => {
+      process.off("SIGINT", handler);
+      process.off("SIGTERM", handler);
+    };
+  }
+  exit(code) {
+    process.exit(code);
+  }
+  getEnv(key) {
+    return process.env[key];
+  }
+  hasAsyncLocalStorage() {
+    return true;
+  }
+  createAsyncLocalStorage() {
+    let instance;
+    const ensure = /* @__PURE__ */ __name(() => {
+      if (!this.alsClass) {
+        let als;
+        const forceNoop = typeof process !== "undefined" && !!process.env?.RUNNER_FORCE_NOOP_ALS;
+        if (!forceNoop) {
+          try {
+            const mod = __require("async_hooks");
+            als = mod?.AsyncLocalStorage;
+          } catch (_) {
+            als = void 0;
+          }
+        }
+        this.alsClass = als ? als : class NoopAsyncLocalStorage {
+          static {
+            __name(this, "NoopAsyncLocalStorage");
+          }
+          getStore() {
+            return void 0;
+          }
+          run(_store, callback) {
+            return callback();
+          }
+        };
+      }
+      return instance ??= new this.alsClass();
+    }, "ensure");
+    return {
+      getStore: /* @__PURE__ */ __name(() => ensure().getStore(), "getStore"),
+      run: /* @__PURE__ */ __name((store2, callback) => ensure().run(store2, callback), "run")
+    };
+  }
 };
 
-// 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 || []
-  };
-}
-__name(defineHook, "defineHook");
-
 // src/errors.ts
 var errors_exports = {};
 __export(errors_exports, {
@@ -370,86 +379,93 @@ function errorBuilder(id2) {
 __name(errorBuilder, "errorBuilder");
 var error = errorBuilder;
 
-// src/platform/adapters/node-als.ts
-async function loadAsyncLocalStorageClass() {
-  const mod = __require("async_hooks");
-  return mod.AsyncLocalStorage;
-}
-__name(loadAsyncLocalStorageClass, "loadAsyncLocalStorageClass");
-
-// src/platform/adapters/node.ts
-var NodePlatformAdapter = class {
-  constructor() {
-    this.id = "node";
-    this.setTimeout = globalThis.setTimeout;
-    this.clearTimeout = globalThis.clearTimeout;
-  }
-  static {
-    __name(this, "NodePlatformAdapter");
-  }
-  async init() {
-    this.alsClass = await loadAsyncLocalStorageClass();
-  }
-  onUncaughtException(handler) {
-    process.on("uncaughtException", handler);
-    return () => process.off("uncaughtException", handler);
-  }
-  onUnhandledRejection(handler) {
-    const h = /* @__PURE__ */ __name((reason) => handler(reason), "h");
-    process.on("unhandledRejection", h);
-    return () => process.off("unhandledRejection", h);
-  }
-  onShutdownSignal(handler) {
-    process.on("SIGINT", handler);
-    process.on("SIGTERM", handler);
-    return () => {
-      process.off("SIGINT", handler);
-      process.off("SIGTERM", handler);
-    };
-  }
-  exit(code) {
-    process.exit(code);
-  }
-  getEnv(key) {
-    return process.env[key];
-  }
-  hasAsyncLocalStorage() {
-    return true;
-  }
-  createAsyncLocalStorage() {
-    let instance;
-    const ensure = /* @__PURE__ */ __name(() => {
-      if (!this.alsClass) {
-        let als;
-        const forceNoop = typeof process !== "undefined" && !!process.env?.RUNNER_FORCE_NOOP_ALS;
-        if (!forceNoop) {
-          try {
-            const mod = __require("async_hooks");
-            als = mod?.AsyncLocalStorage;
-          } catch (_) {
-            als = void 0;
-          }
-        }
-        this.alsClass = als ? als : class NoopAsyncLocalStorage {
-          static {
-            __name(this, "NoopAsyncLocalStorage");
-          }
-          getStore() {
-            return void 0;
-          }
-          run(_store, callback) {
-            return callback();
-          }
-        };
-      }
-      return instance ??= new this.alsClass();
-    }, "ensure");
-    return {
-      getStore: /* @__PURE__ */ __name(() => ensure().getStore(), "getStore"),
-      run: /* @__PURE__ */ __name((store2, callback) => ensure().run(store2, callback), "run")
-    };
+// src/errors.ts
+var duplicateRegistrationError = error("runner.errors.duplicateRegistration").format(
+  ({ type, id: id2 }) => `${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.`
+).build();
+var dependencyNotFoundError = error("runner.errors.dependencyNotFound").format(
+  ({ key }) => `Dependency ${key.toString()} not found. Did you forget to register it through a resource?`
+).build();
+var unknownItemTypeError = error(
+  "runner.errors.unknownItemType"
+).format(
+  ({ item }) => `Unknown item type: ${String(
+    item
+  )}. Please ensure you are not using different versions of '@bluelibs/runner'`
+).build();
+var contextError = error(
+  "runner.errors.context"
+).format(({ details }) => details ?? "Context error").build();
+var circularDependenciesError = error("runner.errors.circularDependencies").format(({ 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";
   }
-};
+  return `Circular dependencies detected:
+${cycleDetails}${guidance}`;
+}).build();
+var eventNotFoundError = error(
+  "runner.errors.eventNotFound"
+).format(
+  ({ id: id2 }) => `Event "${id2.toString()}" not found. Did you forget to register it?`
+).build();
+var resourceNotFoundError = error(
+  "runner.errors.resourceNotFound"
+).format(
+  ({ id: id2 }) => `Resource "${id2.toString()}" not found. Did you forget to register it or are you using the correct id?`
+).build();
+var middlewareNotRegisteredError = error("runner.errors.middlewareNotRegistered").format(
+  ({ type, source, middlewareId }) => `Middleware inside ${type} "${source}" depends on "${middlewareId}" but it's not registered. Did you forget to register it?`
+).build();
+var tagNotFoundError = error(
+  "runner.errors.tagNotFound"
+).format(
+  ({ id: id2 }) => `Tag "${id2}" not registered. Did you forget to register it inside a resource?`
+).build();
+var lockedError = error(
+  "runner.errors.locked"
+).format(
+  ({ what }) => `Cannot modify the ${what.toString()} when it is locked.`
+).build();
+var storeAlreadyInitializedError = error(
+  "runner.errors.storeAlreadyInitialized"
+).format(() => "Store already initialized. Cannot reinitialize.").build();
+var validationError = error("runner.errors.validation").format(({ subject, id: id2, originalError }) => {
+  const errorMessage = originalError instanceof Error ? originalError.message : String(originalError);
+  return `${subject} validation failed for ${id2.toString()}: ${errorMessage}`;
+}).build();
+var eventCycleError = error("runner.errors.eventCycle").format(({ path }) => {
+  const chain = path.map((p) => `${p.id}\u2190${p.source}`).join("  ->  ");
+  return `Event emission cycle detected:
+  ${chain}
+
+Break the cycle by changing hook logic (avoid mutual emits) or gate with conditions/tags.`;
+}).build();
+var eventEmissionCycleError = error("runner.errors.eventEmissionCycle").format(({ cycles }) => {
+  const list = cycles.map((c) => `  \u2022 ${c}`).join("\n");
+  return `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.`;
+}).build();
+var platformUnsupportedFunctionError = error("runner.errors.platformUnsupportedFunction").format(
+  ({ functionName }) => `Platform function not supported in this environment: ${functionName}. Detected platform: ${detectEnvironment()}.`
+).build();
+var cancellationError = error(
+  "runner.errors.cancellation"
+).format(({ reason }) => reason || "Operation cancelled").build();
+var tunnelOwnershipConflictError = error("runner.errors.tunnelOwnershipConflict").format(
+  ({ taskId, currentOwnerId, attemptedOwnerId }) => `Task "${taskId}" is already tunneled by resource "${currentOwnerId}". Resource "${attemptedOwnerId}" cannot tunnel it again. Ensure each task is owned by a single tunnel client.`
+).build();
+function isCancellationError(err) {
+  return cancellationError.is(err);
+}
+__name(isCancellationError, "isCancellationError");
 
 // src/platform/adapters/browser.ts
 var BrowserPlatformAdapter = class {
@@ -758,6 +774,12 @@ function setPlatform(adapter) {
   adapter.id;
 }
 __name(setPlatform, "setPlatform");
+function isNode() {
+  {
+    return false;
+  }
+}
+__name(isNode, "isNode");
 var PlatformAdapter = class {
   constructor(env) {
     this.setTimeout = globalThis.setTimeout;
@@ -811,93 +833,79 @@ var PlatformAdapter = class {
   }
 };
 
-// src/errors.ts
-var duplicateRegistrationError = error("runner.errors.duplicateRegistration").format(
-  ({ type, id: id2 }) => `${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.`
-).build();
-var dependencyNotFoundError = error("runner.errors.dependencyNotFound").format(
-  ({ key }) => `Dependency ${key.toString()} not found. Did you forget to register it through a resource?`
-).build();
-var unknownItemTypeError = error(
-  "runner.errors.unknownItemType"
-).format(
-  ({ item }) => `Unknown item type: ${String(
-    item
-  )}. Please ensure you are not using different versions of '@bluelibs/runner'`
-).build();
-var contextError = error(
-  "runner.errors.context"
-).format(({ details }) => details ?? "Context error").build();
-var circularDependenciesError = error("runner.errors.circularDependencies").format(({ 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";
+// src/tools/getCallerFile.ts
+function getCallerFile() {
+  const originalPrepare = Error.prepareStackTrace;
+  try {
+    if (isNode()) {
+      const err = new Error();
+      Error.prepareStackTrace = (_err, stack2) => stack2;
+      const stack = err.stack;
+      stack.shift();
+      stack.shift();
+      const candidate = stack.shift();
+      const file = candidate?.getFileName?.();
+      return file;
+    }
+    return "unknown";
+  } finally {
+    Error.prepareStackTrace = originalPrepare;
   }
-  return `Circular dependencies detected:
-${cycleDetails}${guidance}`;
-}).build();
-var eventNotFoundError = error(
-  "runner.errors.eventNotFound"
-).format(
-  ({ id: id2 }) => `Event "${id2.toString()}" not found. Did you forget to register it?`
-).build();
-var resourceNotFoundError = error(
-  "runner.errors.resourceNotFound"
-).format(
-  ({ id: id2 }) => `Resource "${id2.toString()}" not found. Did you forget to register it or are you using the correct id?`
-).build();
-var middlewareNotRegisteredError = error("runner.errors.middlewareNotRegistered").format(
-  ({ type, source, middlewareId }) => `Middleware inside ${type} "${source}" depends on "${middlewareId}" but it's not registered. Did you forget to register it?`
-).build();
-var tagNotFoundError = error(
-  "runner.errors.tagNotFound"
-).format(
-  ({ id: id2 }) => `Tag "${id2}" not registered. Did you forget to register it inside a resource?`
-).build();
-var lockedError = error(
-  "runner.errors.locked"
-).format(
-  ({ what }) => `Cannot modify the ${what.toString()} when it is locked.`
-).build();
-var storeAlreadyInitializedError = error(
-  "runner.errors.storeAlreadyInitialized"
-).format(() => "Store already initialized. Cannot reinitialize.").build();
-var validationError = error("runner.errors.validation").format(({ subject, id: id2, originalError }) => {
-  const errorMessage = originalError instanceof Error ? originalError.message : String(originalError);
-  return `${subject} validation failed for ${id2.toString()}: ${errorMessage}`;
-}).build();
-var eventCycleError = error("runner.errors.eventCycle").format(({ path }) => {
-  const chain = path.map((p) => `${p.id}\u2190${p.source}`).join("  ->  ");
-  return `Event emission cycle detected:
-  ${chain}
-
-Break the cycle by changing hook logic (avoid mutual emits) or gate with conditions/tags.`;
-}).build();
-var eventEmissionCycleError = error("runner.errors.eventEmissionCycle").format(({ cycles }) => {
-  const list = cycles.map((c) => `  \u2022 ${c}`).join("\n");
-  return `Event emission cycles detected between hooks and events:
-${list}
+}
+__name(getCallerFile, "getCallerFile");
 
-This was detected at compile time (dry-run). Break the cycle by avoiding mutual emits between hooks or scoping hooks using tags.`;
-}).build();
-var platformUnsupportedFunctionError = error("runner.errors.platformUnsupportedFunction").format(
-  ({ functionName }) => `Platform function not supported in this environment: ${functionName}. Detected platform: ${detectEnvironment()}.`
-).build();
-var cancellationError = error(
-  "runner.errors.cancellation"
-).format(({ reason }) => reason || "Operation cancelled").build();
-var tunnelOwnershipConflictError = error("runner.errors.tunnelOwnershipConflict").format(
-  ({ taskId, currentOwnerId, attemptedOwnerId }) => `Task "${taskId}" is already tunneled by resource "${currentOwnerId}". Resource "${attemptedOwnerId}" cannot tunnel it again. Ensure each task is owned by a single tunnel client.`
-).build();
-function isCancellationError(err) {
-  return cancellationError.is(err);
+// 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
+      };
+    }
+  };
+}
+__name(defineTask, "defineTask");
+defineTask.phantom = (taskConfig) => {
+  const taskDef = defineTask({
+    ...taskConfig,
+    run: /* @__PURE__ */ __name(async (input) => {
+      return void 0;
+    }, "run")
+  });
+  taskDef[symbolPhantomTask] = true;
+  return taskDef;
+};
+
+// 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 || []
+  };
 }
-__name(isCancellationError, "isCancellationError");
+__name(defineHook, "defineHook");
 
 // src/definers/defineResource.ts
 function defineResource(constConfig) {
@@ -958,6 +966,7 @@ function defineEvent(config) {
     [symbolEvent]: true,
     // This is a workaround
     tags: eventConfig.tags || [],
+    parallel: eventConfig.parallel,
     optional() {
       return {
         inner: this,
@@ -3488,30 +3497,279 @@ var DependencyProcessor = class {
   }
 };
 
-// src/models/EventManager.ts
+// src/models/event/types.ts
 var HandlerOptionsDefaults = { order: 0 };
-var EventManager = class {
-  constructor(options) {
-    // Core storage for event listeners
+
+// src/models/event/ListenerRegistry.ts
+var ListenerRegistry = class {
+  constructor(isExcludedFromGlobal) {
     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._globalListenersCacheValid = true;
+    this.isExcludedFromGlobal = isExcludedFromGlobal ?? ((event2) => globalTags.excludeFromGlobalHooks.exists(event2));
+  }
+  static {
+    __name(this, "ListenerRegistry");
+  }
+  get globalListenersCacheValid() {
+    return this._globalListenersCacheValid;
+  }
+  addListener(eventId, newListener) {
+    const listeners = this.listeners.get(eventId);
+    if (listeners) {
+      this.insertListener(listeners, newListener);
+    } else {
+      this.listeners.set(eventId, [newListener]);
+    }
+    this.invalidateCache(eventId);
+  }
+  addGlobalListener(newListener) {
+    this.insertListener(this.globalListeners, newListener);
+    this.invalidateCache();
+  }
+  getListenersForEmit(eventDefinition) {
+    const excludeGlobal = this.isExcludedFromGlobal(eventDefinition);
+    if (excludeGlobal) {
+      return this.listeners.get(eventDefinition.id) || [];
+    }
+    return this.getCachedMergedListeners(eventDefinition.id);
+  }
+  hasListeners(eventDefinition) {
+    const eventListeners = this.listeners.get(eventDefinition.id) || [];
+    if (eventListeners.length > 0) {
+      return true;
+    }
+    if (this.globalListeners.length === 0) {
+      return false;
+    }
+    return !this.isExcludedFromGlobal(eventDefinition);
+  }
+  /**
+   * Cached merge between event-specific and global listeners.
+   * Exposed for backward compatibility with existing tests.
+   */
+  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;
+  }
+  invalidateCache(eventId) {
+    if (eventId) {
+      this.cachedMergedListeners.delete(eventId);
+    } else {
+      this._globalListenersCacheValid = false;
+    }
+  }
+  mergeSortedListeners(a, b) {
+    const result = [];
+    let i = 0;
+    let 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;
+  }
+  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);
+  }
+};
+function createListener(newListener) {
+  return {
+    handler: newListener.handler,
+    order: newListener.order ?? HandlerOptionsDefaults.order,
+    filter: newListener.filter,
+    id: newListener.id,
+    isGlobal: newListener.isGlobal ?? false
+  };
+}
+__name(createListener, "createListener");
+
+// src/models/event/InterceptorPipeline.ts
+function composeInterceptors(interceptors, base) {
+  return interceptors.slice().reverse().reduce(
+    (next, interceptor) => (...args) => interceptor(next, ...args),
+    base
+  );
+}
+__name(composeInterceptors, "composeInterceptors");
+
+// src/models/event/EmissionExecutor.ts
+async function executeSequentially({
+  listeners,
+  event: event2,
+  isPropagationStopped
+}) {
+  for (const listener of listeners) {
+    if (isPropagationStopped()) {
+      break;
+    }
+    if (shouldExecuteListener(listener, event2)) {
+      await listener.handler(event2);
+    }
+  }
+}
+__name(executeSequentially, "executeSequentially");
+async function executeInParallel({
+  listeners,
+  event: event2
+}) {
+  if (listeners.length === 0 || event2.isPropagationStopped()) {
+    return;
+  }
+  let currentOrder = listeners[0].order;
+  let currentBatch = [];
+  const executeBatch = /* @__PURE__ */ __name(async (batch) => {
+    const results = await Promise.allSettled(
+      batch.map(async (listener) => {
+        if (shouldExecuteListener(listener, event2)) {
+          await listener.handler(event2);
+        }
+      })
+    );
+    const errors = results.map((result, index) => ({ result, listener: batch[index] })).filter(
+      (r2) => r2.result.status === "rejected"
+    ).map(({ result, listener }) => {
+      const reason = result.reason;
+      const errObj = reason && typeof reason === "object" ? reason : new Error(String(reason));
+      if (errObj.listenerId === void 0) {
+        errObj.listenerId = listener.id;
+      }
+      if (errObj.listenerOrder === void 0) {
+        errObj.listenerOrder = listener.order;
+      }
+      return errObj;
+    });
+    if (errors.length > 0) {
+      if (errors.length === 1) {
+        throw errors[0];
+      }
+      const aggregateError = new Error(
+        `${errors.length} listeners failed in parallel batch`
+      );
+      aggregateError.errors = errors;
+      aggregateError.name = "AggregateError";
+      throw aggregateError;
+    }
+  }, "executeBatch");
+  for (const listener of listeners) {
+    if (listener.order !== currentOrder) {
+      await executeBatch(currentBatch);
+      currentBatch = [];
+      currentOrder = listener.order;
+      if (event2.isPropagationStopped()) {
+        break;
+      }
+    }
+    currentBatch.push(listener);
+  }
+  if (currentBatch.length > 0 && !event2.isPropagationStopped()) {
+    await executeBatch(currentBatch);
+  }
+}
+__name(executeInParallel, "executeInParallel");
+function shouldExecuteListener(listener, event2) {
+  if (listener.id && listener.id === event2.source) {
+    return false;
+  }
+  return !listener.filter || listener.filter(event2);
+}
+__name(shouldExecuteListener, "shouldExecuteListener");
+
+// src/models/event/CycleContext.ts
+var CycleContext = class {
+  static {
+    __name(this, "CycleContext");
+  }
+  constructor(runtimeCycleDetection) {
+    const platform3 = getPlatform();
+    if (platform3.hasAsyncLocalStorage() && runtimeCycleDetection) {
+      this.emissionStack = platform3.createAsyncLocalStorage();
+      this.currentHookIdContext = platform3.createAsyncLocalStorage();
+      this.isEnabled = true;
+    } else {
+      this.emissionStack = null;
+      this.currentHookIdContext = null;
+      this.isEnabled = false;
+    }
+  }
+  runEmission(frame, source, processEmission) {
+    if (!this.isEnabled || !this.emissionStack || !this.currentHookIdContext) {
+      return processEmission();
+    }
+    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) {
+          eventCycleError.throw({
+            path: [...currentStack.slice(cycleStart), frame]
+          });
+        }
+      }
+    }
+    const nextStack = currentStack ? [...currentStack, frame] : [frame];
+    return this.emissionStack.run(nextStack, processEmission);
+  }
+  runHook(hookId, execute) {
+    if (!this.isEnabled || !this.currentHookIdContext) {
+      return execute();
+    }
+    return this.currentHookIdContext.run(hookId, execute);
+  }
+};
+
+// src/models/EventManager.ts
+var EventManager = class {
+  constructor(options) {
+    // Interceptors storage (tests access these directly)
     this.emissionInterceptors = [];
     this.hookInterceptors = [];
     // Locking mechanism to prevent modifications after initialization
     this.#isLocked = 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;
-    }
+    this.registry = new ListenerRegistry();
+    this.cycleContext = new CycleContext(this.runtimeCycleDetection);
+    this.listeners = this.registry.listeners;
+    this.globalListeners = this.registry.globalListeners;
+    this.cachedMergedListeners = this.registry.cachedMergedListeners;
   }
   static {
     __name(this, "EventManager");
@@ -3552,8 +3810,7 @@ var EventManager = class {
     }
     const frame = { id: eventDefinition.id, source };
     const processEmission = /* @__PURE__ */ __name(async () => {
-      const excludeFromGlobal = globalTags.excludeFromGlobalHooks.exists(eventDefinition);
-      const allListeners = excludeFromGlobal ? this.listeners.get(eventDefinition.id) || [] : this.getCachedMergedListeners(eventDefinition.id);
+      const allListeners = this.registry.getListenersForEmit(eventDefinition);
       let propagationStopped = false;
       const event2 = {
         id: eventDefinition.id,
@@ -3571,49 +3828,23 @@ var EventManager = class {
         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);
-          }
+        if (eventDefinition.parallel) {
+          await executeInParallel({ listeners: allListeners, event: eventToEmit });
+        } else {
+          await executeSequentially({
+            listeners: allListeners,
+            event: eventToEmit,
+            isPropagationStopped: /* @__PURE__ */ __name(() => propagationStopped, "isPropagationStopped")
+          });
         }
       }, "baseEmit");
-      let emitWithInterceptors = baseEmit;
-      const reversedInterceptors = [...this.emissionInterceptors].reverse();
-      for (const interceptor of reversedInterceptors) {
-        const nextFunction = emitWithInterceptors;
-        emitWithInterceptors = /* @__PURE__ */ __name(async (eventToEmit) => interceptor(nextFunction, eventToEmit), "emitWithInterceptors");
-      }
+      const emitWithInterceptors = composeInterceptors(
+        this.emissionInterceptors,
+        baseEmit
+      );
       await emitWithInterceptors(event2);
     }, "processEmission");
-    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) {
-            eventCycleError.throw({
-              path: [...currentStack.slice(cycleStart), frame]
-            });
-          }
-        }
-      }
-      const nextStack = currentStack ? [...currentStack, frame] : [frame];
-      await this.emissionStack.run(nextStack, processEmission);
-    } else {
-      await processEmission();
-    }
+    await this.cycleContext.runEmission(frame, source, processEmission);
   }
   /**
    * Registers an event listener for specific event(s).
@@ -3625,24 +3856,18 @@ var EventManager = class {
    */
   addListener(event2, handler, options = HandlerOptionsDefaults) {
     this.checkLock();
-    const newListener = {
+    const newListener = createListener({
       handler,
-      order: options.order || 0,
+      order: options.order,
       filter: options.filter,
       id: options.id,
       isGlobal: false
-    };
+    });
     if (Array.isArray(event2)) {
       event2.forEach((id2) => this.addListener(id2, handler, options));
     } else {
       const eventId = event2.id;
-      const listeners = this.listeners.get(eventId);
-      if (listeners) {
-        this.insertListener(listeners, newListener);
-      } else {
-        this.listeners.set(eventId, [newListener]);
-      }
-      this.invalidateCache(eventId);
+      this.registry.addListener(eventId, newListener);
     }
   }
   /**
@@ -3654,15 +3879,14 @@ var EventManager = class {
    */
   addGlobalListener(handler, options = HandlerOptionsDefaults) {
     this.checkLock();
-    const newListener = {
+    const newListener = createListener({
       handler,
-      order: options.order || 0,
+      order: options.order,
       filter: options.filter,
       id: options.id,
       isGlobal: true
-    };
-    this.insertListener(this.globalListeners, newListener);
-    this.invalidateCache();
+    });
+    this.registry.addGlobalListener(newListener);
   }
   /**
    * Checks if there are any listeners registered for the given event
@@ -3671,15 +3895,7 @@ var EventManager = class {
    * @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 isExcludedFromGlobal = globalTags.excludeFromGlobalHooks.exists(eventDefinition);
-    return !isExcludedFromGlobal;
+    return this.registry.hasListeners(eventDefinition);
   }
   /**
    * Adds an interceptor for all event emissions
@@ -3724,20 +3940,14 @@ var EventManager = class {
         throw err;
       }
     }, "baseExecute");
-    let executeWithInterceptors = baseExecute;
-    const reversedInterceptors = [...this.hookInterceptors].reverse();
-    for (const interceptor of reversedInterceptors) {
-      const nextFunction = executeWithInterceptors;
-      executeWithInterceptors = /* @__PURE__ */ __name(async (hookToExecute, eventForHook) => interceptor(nextFunction, hookToExecute, eventForHook), "executeWithInterceptors");
-    }
-    if (this.runtimeCycleDetection) {
-      return await this.currentHookIdContext?.run(
-        hook2.id,
-        async () => await executeWithInterceptors(hook2, event2)
-      );
-    } else {
-      return await executeWithInterceptors(hook2, event2);
-    }
+    const executeWithInterceptors = composeInterceptors(
+      this.hookInterceptors,
+      baseExecute
+    );
+    return this.cycleContext.isEnabled ? await this.cycleContext.runHook(
+      hook2.id,
+      () => executeWithInterceptors(hook2, event2)
+    ) : await executeWithInterceptors(hook2, event2);
   }
   // ==================== PRIVATE METHODS ====================
   /**
@@ -3748,102 +3958,12 @@ var EventManager = class {
       lockedError.throw({ what: "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(event2) {
-    return globalTags.excludeFromGlobalHooks.exists(event2);
-  }
   /**
    * 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
+   * Kept for backward compatibility (tests spy on this).
    */
   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;
-    }
+    return this.registry.getCachedMergedListeners(eventId);
   }
 };
 
@@ -5789,6 +5909,10 @@ function makeEventBuilder(state) {
       const next = clone5(state, { meta: m });
       return makeEventBuilder(next);
     },
+    parallel(enabled = true) {
+      const next = clone5(state, { parallel: enabled });
+      return makeEventBuilder(next);
+    },
     build() {
       const event2 = defineEvent({
         ...state
@@ -5807,7 +5931,8 @@ function eventBuilder(id2) {
     filePath,
     meta: {},
     payloadSchema: void 0,
-    tags: []
+    tags: [],
+    parallel: void 0
   });
   return makeEventBuilder(initial);
 }