@autometa/events 0.3.2 → 1.0.0-rc.0

package/dist/index.js

@@ -1,328 +1,412 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  ArgsEventSchema: () => ArgsEventSchema,
-  EndAfterOptsSchema: () => EndAfterOptsSchema,
-  EndBeforeOptsSchema: () => EndBeforeOptsSchema,
-  EndFeatureOptsSchema: () => EndFeatureOptsSchema,
-  EndRuleOptsSchema: () => EndRuleOptsSchema,
-  EndScenarioOptsSchema: () => EndScenarioOptsSchema,
-  EndScenarioOutlineOptsSchema: () => EndScenarioOutlineOptsSchema,
-  EndSetupOptsSchema: () => EndSetupOptsSchema,
-  EndStepOptsSchema: () => EndStepOptsSchema,
-  EndTeardownOptsSchema: () => EndTeardownOptsSchema,
-  ErrorEventSchema: () => ErrorEventSchema,
-  EventOptionsSchema: () => EventOptionsSchema,
-  EventSubscriberSchema: () => EventSubscriberSchema,
-  ProviderSubscriber: () => ProviderSubscriber,
-  StartAfterOptsSchema: () => StartAfterOptsSchema,
-  StartBeforeOptsSchema: () => StartBeforeOptsSchema,
-  StartFeatureOptsSchema: () => StartFeatureOptsSchema,
-  StartScenarioOptsSchema: () => StartScenarioOptsSchema,
-  StartScenarioOutlineOptsSchema: () => StartScenarioOutlineOptsSchema,
-  StartSetupOptsSchema: () => StartSetupOptsSchema,
-  StartStepOptsSchema: () => StartStepOptsSchema,
-  StartTeardownOptsSchema: () => StartTeardownOptsSchema,
-  Status: () => Status,
-  StatusSchema: () => StatusSchema,
-  TestEmitter: () => TestEmitter,
-  TestEventEmitter: () => TestEventEmitter,
-  UUIDStringSchema: () => UUIDStringSchema
-});
-module.exports = __toCommonJS(src_exports);
+import { createToken, createContainer, Scope } from '@autometa/injection';
 
-// src/event-options.ts
-var import_zod = require("zod");
-var uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/gm;
-var UUIDStringSchema = (0, import_zod.string)().regex(uuidRegex).optional();
-var StatusSchema = import_zod.z.union([
-  (0, import_zod.literal)("FAILED"),
-  (0, import_zod.literal)("BROKEN"),
-  (0, import_zod.literal)("PASSED"),
-  (0, import_zod.literal)("SKIPPED")
-]);
-var EventOptionsSchema = (0, import_zod.object)({
-  title: (0, import_zod.string)().optional(),
-  keyword: (0, import_zod.string)().optional(),
-  tags: (0, import_zod.string)().array().optional(),
-  modifier: (0, import_zod.literal)("skip").or((0, import_zod.literal)("only")).optional(),
-  status: StatusSchema.optional()
-});
-var ErrorEventSchema = EventOptionsSchema.extend({
-  error: import_zod.z.instanceof(Error).optional()
-});
-var ArgsEventSchema = EventOptionsSchema.extend({
-  args: import_zod.z.array(import_zod.z.unknown()).optional()
-});
-var StartFeatureOptsSchema = EventOptionsSchema.extend({
-  path: (0, import_zod.string)().optional()
-});
-var EndFeatureOptsSchema = ErrorEventSchema;
-var EndRuleOptsSchema = ErrorEventSchema;
-var StartScenarioOutlineOptsSchema = EventOptionsSchema;
-var EndScenarioOutlineOptsSchema = ErrorEventSchema;
-var StartScenarioOptsSchema = EventOptionsSchema;
-var EndScenarioOptsSchema = ErrorEventSchema;
-var StartStepOptsSchema = EventOptionsSchema.extend({
-  args: import_zod.z.array(import_zod.z.unknown()).optional(),
-  expression: import_zod.z.string().optional()
-});
-var EndStepOptsSchema = EventOptionsSchema.extend({
-  args: import_zod.z.array(import_zod.z.unknown()).optional(),
-  expression: import_zod.z.string()
-}).and(ErrorEventSchema);
-var StartBeforeOptsSchema = ArgsEventSchema;
-var EndBeforeOptsSchema = ErrorEventSchema;
-var StartAfterOptsSchema = ArgsEventSchema;
-var EndAfterOptsSchema = ErrorEventSchema;
-var StartSetupOptsSchema = ArgsEventSchema;
-var EndSetupOptsSchema = ErrorEventSchema;
-var StartTeardownOptsSchema = ArgsEventSchema;
-var EndTeardownOptsSchema = ErrorEventSchema;
-
-// src/event-subscriber.ts
-var import_zod2 = require("zod");
-var EventSubscriberSchema = (0, import_zod2.object)({
-  onFeature: (0, import_zod2.function)()
-});
-var ProviderSubscriber = class {
-  constructor() {
-    this.addFixtureInstance = (instance) => {
-      this.fixtures.instances?.push(instance);
+// src/dispatcher.ts
+var EventDispatcherToken = createToken(
+  "@autometa/events/dispatcher"
+);
+var EventDispatcher = class _EventDispatcher {
+  constructor(container = createContainer()) {
+    this.container = container;
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.sequence = 0;
+  }
+  static create(options = {}) {
+    const container = options.container ?? createContainer();
+    if (!container.isRegistered(EventDispatcherToken)) {
+      container.registerValue(
+        EventDispatcherToken,
+        new _EventDispatcher(container),
+        { scope: Scope.SINGLETON }
+      );
+    }
+    return container.resolve(EventDispatcherToken);
+  }
+  /**
+   * Subscribe to events of a particular type.
+   */
+  subscribe(type, subscriber) {
+    const set = this.subscribers.get(type) ?? /* @__PURE__ */ new Set();
+    set.add(subscriber);
+    this.subscribers.set(type, set);
+    return () => {
+      set.delete(subscriber);
+      if (set.size === 0) {
+        this.subscribers.delete(type);
+      }
+    };
+  }
+  /**
+   * Publish an event to all registered subscribers. Subscribers are awaited in
+   * series to preserve ordering guarantees; callers can fork when concurrency is
+   * desired.
+   */
+  async dispatch(event) {
+    const envelope = {
+      sequence: ++this.sequence,
+      event
     };
+    const listeners = this.subscribers.get(event.type);
+    if (!listeners || listeners.size === 0) {
+      return;
+    }
+    for (const listener of listeners) {
+      await listener(envelope);
+    }
+  }
+  clear() {
+    this.subscribers.clear();
+    this.sequence = 0;
   }
 };
 
-// src/test-emitter.ts
-var import_events = __toESM(require("events"), 1);
-var TestEmitter = class extends import_events.default {
-  constructor(name) {
-    super();
-    this.name = name;
-    this.promises = [];
-    this.emitStart = (...args) => {
-      this.emit(`onStart${this.name}`, ...args);
+// src/emitter.ts
+var defaultIdFactory = () => {
+  const crypto = globalThis.crypto;
+  if (crypto && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+};
+var EventEmitter = class {
+  constructor(dispatcher, options = {}) {
+    this.dispatcher = dispatcher;
+    this.createId = options.createId ?? defaultIdFactory;
+    this.now = options.now ?? Date.now;
+  }
+  async featureStarted(options) {
+    const event = {
+      type: "feature.started",
+      feature: options.feature,
+      ...this.base(options)
     };
-    this.onStart = (action) => {
-      if (action) {
-        this.on(`onStart${this.name}`, this.collectPromises(this.name, action));
-      }
+    await this.dispatcher.dispatch(event);
+  }
+  async featureCompleted(options) {
+    const event = {
+      type: "feature.completed",
+      feature: options.feature,
+      ...this.base(options)
     };
-    this.onEnd = (action) => {
-      if (action) {
-        this.on(`onEnd${this.name}`, this.collectPromises(this.name, action));
-      }
+    await this.dispatcher.dispatch(event);
+  }
+  async ruleStarted(options) {
+    const event = {
+      type: "rule.started",
+      feature: options.feature,
+      rule: options.rule,
+      ...this.base(options)
     };
-    this.emitEnd = (...args) => {
-      this.emit(`onEnd${this.name}`, ...args);
+    await this.dispatcher.dispatch(event);
+  }
+  async ruleCompleted(options) {
+    const event = {
+      type: "rule.completed",
+      feature: options.feature,
+      rule: options.rule,
+      ...this.base(options)
     };
-    this.load = (onStart, onEnd) => {
-      this.onStart(onStart);
-      this.onEnd(onEnd);
+    await this.dispatcher.dispatch(event);
+  }
+  async scenarioStarted(options) {
+    const event = {
+      type: "scenario.started",
+      feature: options.feature,
+      scenario: options.scenario,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
     };
-    this.collectPromises = (name, action) => {
-      return (...args) => {
-        try {
-          const result = action(...args);
-          if (result instanceof Promise) {
-            this.promises.push(result);
-          }
-        } catch (e) {
-          console.error(
-            `Event Subscriber ${name} threw an error ${e.message}`
-          );
-        }
-      };
+    await this.dispatcher.dispatch(event);
+  }
+  async scenarioCompleted(options) {
+    const event = {
+      type: "scenario.completed",
+      feature: options.feature,
+      scenario: options.scenario,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
     };
-    this.waitForPromises = async () => {
-      const settled = await Promise.allSettled(this.promises);
-      return settled.filter((it) => it.status === "rejected").length;
+    await this.dispatcher.dispatch(event);
+  }
+  async scenarioOutlineStarted(options) {
+    const event = {
+      type: "scenarioOutline.started",
+      feature: options.feature,
+      scenarioOutline: options.scenarioOutline,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
     };
+    await this.dispatcher.dispatch(event);
   }
-};
-
-// src/test-event-emitter.ts
-var TestEventEmitter = class {
-  constructor() {
-    this.scenarioOutline = new TestEmitter("ScenarioOutline");
-    this.feature = new TestEmitter("Feature");
-    this.rule = new TestEmitter("Rule");
-    this.scenario = new TestEmitter("Scenario");
-    this.scenarioWrapper = new TestEmitter("Scenario Wrapper");
-    this.setup = new TestEmitter("Setup");
-    this.beforeFeature = new TestEmitter(
-      "BeforeFeature"
-    );
-    this.afterFeature = new TestEmitter("AfterFeature");
-    this.beforeRule = new TestEmitter("BeforeRule");
-    this.afterRule = new TestEmitter("AfterRule");
-    this.beforeScenarioOutline = new TestEmitter(
-      "BeforeScenarioOutline"
-    );
-    this.afterScenarioOutline = new TestEmitter(
-      "AfterScenarioOutline"
-    );
-    this.beforeExamples = new TestEmitter(
-      "BeforeExamples"
-    );
-    this.afterExamples = new TestEmitter(
-      "AfterExamples"
-    );
-    this.teardown = new TestEmitter("Teardown");
-    this.before = new TestEmitter("Before");
-    this.after = new TestEmitter("After");
-    this.step = new TestEmitter("Step");
-    this.beforeStep = new TestEmitter("BeforeStep");
-    this.afterStep = new TestEmitter("AfterStep");
-    this.settleAsyncEvents = async () => {
-      return await Promise.allSettled([
-        this.scenarioOutline.waitForPromises(),
-        this.feature.waitForPromises(),
-        this.rule.waitForPromises(),
-        this.scenario.waitForPromises(),
-        this.scenarioWrapper.waitForPromises(),
-        this.setup.waitForPromises(),
-        this.teardown.waitForPromises(),
-        this.before.waitForPromises(),
-        this.after.waitForPromises(),
-        this.step.waitForPromises()
-      ]);
+  async scenarioOutlineCompleted(options) {
+    const event = {
+      type: "scenarioOutline.completed",
+      feature: options.feature,
+      scenarioOutline: options.scenarioOutline,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
     };
-    this.load = ({
-      onFeatureStart,
-      onFeatureEnd,
-      onScenarioOutlineStart,
-      onScenarioOutlineEnd,
-      onScenarioStart,
-      onScenarioEnd,
-      onRuleStart,
-      onRuleEnd,
-      onBeforeStart,
-      onBeforeEnd,
-      onSetupStart,
-      onSetupEnd,
-      onStepStart,
-      onStepEnd,
-      onAfterStart,
-      onAfterEnd,
-      onTeardownStart,
-      onTeardownEnd,
-      onPreScenarioStart,
-      onPostScenarioEnd,
-      onBeforeFeatureStart,
-      onBeforeFeatureEnd,
-      onAfterFeatureStart,
-      onAfterFeatureEnd,
-      onBeforeRuleStart,
-      onBeforeRuleEnd,
-      onAfterRuleStart,
-      onAfterRuleEnd,
-      onBeforeScenarioOutlineStart,
-      onBeforeScenarioOutlineEnd,
-      onAfterScenarioOutlineStart,
-      onAfterScenarioOutlineEnd,
-      onBeforeExamplesStart,
-      onBeforeExamplesEnd,
-      onAfterExamplesStart,
-      onBeforeStepStart,
-      onBeforeStepEnd,
-      onAfterStepStart,
-      onAfterStepEnd
-    }) => {
-      this.feature.load(onFeatureStart, onFeatureEnd);
-      this.rule.load(onRuleStart, onRuleEnd);
-      this.scenarioOutline.load(onScenarioOutlineStart, onScenarioOutlineEnd);
-      this.scenario.load(onScenarioStart, onScenarioEnd);
-      this.step.load(onStepStart, onStepEnd);
-      this.before.load(onBeforeStart, onBeforeEnd);
-      this.after.load(onAfterStart, onAfterEnd);
-      this.setup.load(onSetupStart, onSetupEnd);
-      this.teardown.load(onTeardownStart, onTeardownEnd);
-      this.scenarioWrapper.load(onPreScenarioStart, onPostScenarioEnd);
-      this.beforeFeature.load(onBeforeFeatureStart, onBeforeFeatureEnd);
-      this.afterFeature.load(onAfterFeatureStart, onAfterFeatureEnd);
-      this.beforeRule.load(onBeforeRuleStart, onBeforeRuleEnd);
-      this.afterRule.load(onAfterRuleStart, onAfterRuleEnd);
-      this.beforeScenarioOutline.load(
-        onBeforeScenarioOutlineStart,
-        onBeforeScenarioOutlineEnd
-      );
-      this.afterScenarioOutline.load(
-        onAfterScenarioOutlineStart,
-        onAfterScenarioOutlineEnd
-      );
-      this.beforeExamples.load(onBeforeExamplesStart, onBeforeExamplesEnd);
-      this.afterExamples.load(onAfterExamplesStart, onBeforeStepStart);
-      this.beforeStep.load(onBeforeStepStart, onBeforeStepEnd);
-      this.afterStep.load(onAfterStepStart, onAfterStepEnd);
+    await this.dispatcher.dispatch(event);
+  }
+  async exampleStarted(options) {
+    const event = {
+      type: "example.started",
+      feature: options.feature,
+      scenarioOutline: options.scenarioOutline,
+      example: options.example,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async exampleCompleted(options) {
+    const event = {
+      type: "example.completed",
+      feature: options.feature,
+      scenarioOutline: options.scenarioOutline,
+      example: options.example,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async backgroundStarted(options) {
+    const event = {
+      type: "background.started",
+      feature: options.feature,
+      background: options.background,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async backgroundCompleted(options) {
+    const event = {
+      type: "background.completed",
+      feature: options.feature,
+      background: options.background,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async stepStarted(options) {
+    const event = {
+      type: "step.started",
+      feature: options.feature,
+      scenario: options.scenario,
+      step: options.step,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async stepCompleted(options) {
+    const event = {
+      type: "step.completed",
+      feature: options.feature,
+      scenario: options.scenario,
+      step: options.step,
+      pickle: options.pickle,
+      ...options.rule ? { rule: options.rule } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async hookStarted(options) {
+    const event = {
+      type: "hook.started",
+      hook: options.hook,
+      ...options.hook.feature ? { feature: options.hook.feature } : {},
+      ...options.hook.rule ? { rule: options.hook.rule } : {},
+      ...options.hook.scenario ? { scenario: options.hook.scenario } : {},
+      ...options.hook.scenarioOutline ? { scenarioOutline: options.hook.scenarioOutline } : {},
+      ...options.hook.example ? { example: options.hook.example } : {},
+      ...options.hook.background ? { background: options.hook.background } : {},
+      ...options.hook.step ? { step: options.hook.step } : {},
+      ...options.hook.pickle ? { pickle: options.hook.pickle } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async hookCompleted(options) {
+    const event = {
+      type: "hook.completed",
+      hook: options.hook,
+      ...options.hook.feature ? { feature: options.hook.feature } : {},
+      ...options.hook.rule ? { rule: options.hook.rule } : {},
+      ...options.hook.scenario ? { scenario: options.hook.scenario } : {},
+      ...options.hook.scenarioOutline ? { scenarioOutline: options.hook.scenarioOutline } : {},
+      ...options.hook.example ? { example: options.hook.example } : {},
+      ...options.hook.background ? { background: options.hook.background } : {},
+      ...options.hook.step ? { step: options.hook.step } : {},
+      ...options.hook.pickle ? { pickle: options.hook.pickle } : {},
+      ...this.base(options)
     };
+    await this.dispatcher.dispatch(event);
   }
+  async statusChanged(options) {
+    const event = {
+      type: "status.changed",
+      status: options.status,
+      ...options.previousStatus ? { previousStatus: options.previousStatus } : {},
+      ...options.feature ? { feature: options.feature } : {},
+      ...options.rule ? { rule: options.rule } : {},
+      ...options.scenario ? { scenario: options.scenario } : {},
+      ...options.scenarioOutline ? { scenarioOutline: options.scenarioOutline } : {},
+      ...options.example ? { example: options.example } : {},
+      ...options.pickle ? { pickle: options.pickle } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  async errorRaised(options) {
+    const event = {
+      type: "error",
+      error: options.error,
+      phase: options.phase,
+      ...options.feature ? { feature: options.feature } : {},
+      ...options.rule ? { rule: options.rule } : {},
+      ...options.scenario ? { scenario: options.scenario } : {},
+      ...options.scenarioOutline ? { scenarioOutline: options.scenarioOutline } : {},
+      ...options.example ? { example: options.example } : {},
+      ...options.background ? { background: options.background } : {},
+      ...options.pickle ? { pickle: options.pickle } : {},
+      ...this.base(options)
+    };
+    await this.dispatcher.dispatch(event);
+  }
+  base(options) {
+    const base = {
+      id: options.id ?? this.createId(),
+      timestamp: options.timestamp ?? this.now()
+    };
+    if (options.metadata !== void 0) {
+      base.metadata = options.metadata;
+    }
+    return base;
+  }
+};
+
+// src/bus.ts
+var BUS_KEY = Symbol.for("@autometa/events/bus");
+function getEventBus() {
+  const store = globalThis;
+  const existing = store[BUS_KEY];
+  if (existing) {
+    return existing;
+  }
+  const dispatcher = EventDispatcher.create();
+  const emitter = new EventEmitter(dispatcher);
+  const bus = { dispatcher, emitter };
+  store[BUS_KEY] = bus;
+  return bus;
+}
+function getEventDispatcher() {
+  return getEventBus().dispatcher;
+}
+function getEventEmitter() {
+  return getEventBus().emitter;
+}
+function resetEventBus() {
+  const store = globalThis;
+  const existing = store[BUS_KEY];
+  if (existing) {
+    existing.dispatcher.clear();
+  }
+  store[BUS_KEY] = void 0;
+}
+
+// src/hooks.ts
+var HookKind = {
+  BEFORE_FEATURE: "beforeFeature",
+  AFTER_FEATURE: "afterFeature",
+  BEFORE_RULE: "beforeRule",
+  AFTER_RULE: "afterRule",
+  BEFORE_SCENARIO: "beforeScenario",
+  AFTER_SCENARIO: "afterScenario",
+  BEFORE_SCENARIO_OUTLINE: "beforeScenarioOutline",
+  AFTER_SCENARIO_OUTLINE: "afterScenarioOutline",
+  BEFORE_EXAMPLE: "beforeExample",
+  AFTER_EXAMPLE: "afterExample",
+  BEFORE_BACKGROUND: "beforeBackground",
+  AFTER_BACKGROUND: "afterBackground",
+  BEFORE_STEP: "beforeStep",
+  AFTER_STEP: "afterStep",
+  SETUP: "setup",
+  TEARDOWN: "teardown",
+  CUSTOM: "custom"
 };
 
-// src/test-status.ts
-var Status = {
-  FAILED: "FAILED",
-  BROKEN: "BROKEN",
-  PASSED: "PASSED",
-  SKIPPED: "SKIPPED"
+// src/listener.ts
+function registerTestListener(listener, options = {}) {
+  const dispatcher = options.dispatcher ?? getEventDispatcher();
+  const unsubscribers = [];
+  const subscribe = (type, handler) => {
+    if (!handler && !listener.onEvent) {
+      return;
+    }
+    unsubscribers.push(
+      dispatcher.subscribe(type, async (envelope) => {
+        if (listener.onEvent) {
+          await listener.onEvent(envelope);
+        }
+        if (handler) {
+          await handler(envelope);
+        }
+      })
+    );
+  };
+  subscribe("feature.started", listener.onFeatureStarted);
+  subscribe("feature.completed", listener.onFeatureCompleted);
+  subscribe("rule.started", listener.onRuleStarted);
+  subscribe("rule.completed", listener.onRuleCompleted);
+  subscribe("scenario.started", listener.onScenarioStarted);
+  subscribe("scenario.completed", listener.onScenarioCompleted);
+  subscribe(
+    "scenarioOutline.started",
+    listener.onScenarioOutlineStarted
+  );
+  subscribe(
+    "scenarioOutline.completed",
+    listener.onScenarioOutlineCompleted
+  );
+  subscribe("example.started", listener.onExampleStarted);
+  subscribe("example.completed", listener.onExampleCompleted);
+  subscribe("background.started", listener.onBackgroundStarted);
+  subscribe("background.completed", listener.onBackgroundCompleted);
+  subscribe("step.started", listener.onStepStarted);
+  subscribe("step.completed", listener.onStepCompleted);
+  subscribe("hook.started", listener.onHookStarted);
+  subscribe("hook.completed", listener.onHookCompleted);
+  subscribe("status.changed", listener.onStatusChanged);
+  subscribe("error", listener.onError);
+  return () => {
+    for (const unsubscribe of unsubscribers) {
+      unsubscribe();
+    }
+  };
+}
+
+// src/status.ts
+var TestStatus = {
+  IDLE: "idle",
+  RUNNING: "running",
+  PASSED: "passed",
+  FAILED: "failed",
+  SKIPPED: "skipped",
+  BROKEN: "broken"
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ArgsEventSchema,
-  EndAfterOptsSchema,
-  EndBeforeOptsSchema,
-  EndFeatureOptsSchema,
-  EndRuleOptsSchema,
-  EndScenarioOptsSchema,
-  EndScenarioOutlineOptsSchema,
-  EndSetupOptsSchema,
-  EndStepOptsSchema,
-  EndTeardownOptsSchema,
-  ErrorEventSchema,
-  EventOptionsSchema,
-  EventSubscriberSchema,
-  ProviderSubscriber,
-  StartAfterOptsSchema,
-  StartBeforeOptsSchema,
-  StartFeatureOptsSchema,
-  StartScenarioOptsSchema,
-  StartScenarioOutlineOptsSchema,
-  StartSetupOptsSchema,
-  StartStepOptsSchema,
-  StartTeardownOptsSchema,
-  Status,
-  StatusSchema,
-  TestEmitter,
-  TestEventEmitter,
-  UUIDStringSchema
-});
+function isTerminalStatus(status) {
+  return status === TestStatus.PASSED || status === TestStatus.FAILED || status === TestStatus.SKIPPED || status === TestStatus.BROKEN;
+}
+
+export { EventDispatcher, EventDispatcherToken, EventEmitter, HookKind, TestStatus, getEventBus, getEventDispatcher, getEventEmitter, isTerminalStatus, registerTestListener, resetEventBus };
+//# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map