nvent 0.4.0

package/dist/runtime/server/events/adapters/memoryAdapter.js

@@ -0,0 +1,171 @@
+const GLOBAL_KEY = "__nuxt_queue_memory_adapter__";
+function getStore() {
+  if (!globalThis[GLOBAL_KEY]) {
+    globalThis[GLOBAL_KEY] = {
+      events: /* @__PURE__ */ new Map(),
+      listeners: /* @__PURE__ */ new Map(),
+      indices: /* @__PURE__ */ new Map()
+    };
+  }
+  return globalThis[GLOBAL_KEY];
+}
+export function createMemoryAdapter() {
+  const { events, listeners, indices } = getStore();
+  return {
+    async append(stream, e) {
+      const id = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+      const rec = { ...e, id, ts: (/* @__PURE__ */ new Date()).toISOString() };
+      const list = events.get(stream) || [];
+      list.push(rec);
+      events.set(stream, list);
+      const set = listeners.get(stream);
+      if (set) set.forEach((cb) => cb(rec));
+      return rec;
+    },
+    async read(stream, opts) {
+      const list = events.get(stream) || [];
+      const dir = opts?.direction || "forward";
+      if (dir === "backward") {
+        let end = list.length;
+        if (opts?.fromId) {
+          const idx2 = list.findIndex((e) => e.id === opts.fromId);
+          end = idx2 >= 0 ? idx2 : list.length;
+        }
+        const count = opts?.limit && opts.limit > 0 ? opts.limit : end;
+        const start = Math.max(0, end - count);
+        const slice = list.slice(start, end);
+        return slice.reverse();
+      }
+      if (!opts?.fromId) {
+        if (opts?.limit && opts.limit > 0) return list.slice(0, opts.limit);
+        return list;
+      }
+      const idx = list.findIndex((e) => e.id === opts.fromId);
+      const out = idx >= 0 ? list.slice(idx + 1) : list;
+      if (opts?.limit && opts.limit > 0) return out.slice(0, opts.limit);
+      return out;
+    },
+    async subscribe(stream, onEvent) {
+      let set = listeners.get(stream);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        listeners.set(stream, set);
+      }
+      set.add(onEvent);
+      return {
+        unsubscribe() {
+          set.delete(onEvent);
+        }
+      };
+    },
+    async indexAdd(key, id, score, metadata) {
+      const data = indices.get(key) || [];
+      const existing = data.findIndex((entry) => entry.id === id);
+      if (existing >= 0) {
+        data[existing].score = score;
+        if (metadata) {
+          data[existing].metadata = metadata;
+        }
+      } else {
+        data.push({ id, score, metadata });
+      }
+      indices.set(key, data);
+    },
+    async indexRead(key, opts) {
+      const data = indices.get(key) || [];
+      const sorted = [...data].sort((a, b) => b.score - a.score);
+      const offset = opts?.offset || 0;
+      const limit = opts?.limit || 50;
+      return sorted.slice(offset, offset + limit);
+    },
+    async indexGet(key, id) {
+      const data = indices.get(key) || [];
+      const entry = data.find((item) => item.id === id);
+      if (!entry) return null;
+      return {
+        id: entry.id,
+        score: entry.score,
+        metadata: entry.metadata
+      };
+    },
+    async indexUpdate(key, id, metadata) {
+      const data = indices.get(key) || [];
+      const entryIndex = data.findIndex((item) => item.id === id);
+      if (entryIndex === -1) {
+        data.push({ id, score: Date.now(), metadata: { ...metadata, version: 1 } });
+        indices.set(key, data);
+        return true;
+      }
+      const entry = data[entryIndex];
+      const currentVersion = entry.metadata?.version || 0;
+      const expectedVersion = metadata.version !== void 0 ? metadata.version - 1 : currentVersion;
+      if (currentVersion !== expectedVersion) {
+        return false;
+      }
+      entry.metadata = {
+        ...entry.metadata,
+        ...metadata,
+        version: currentVersion + 1
+      };
+      indices.set(key, data);
+      return true;
+    },
+    async indexUpdateWithRetry(key, id, metadata, maxRetries = 3) {
+      for (let attempt = 0; attempt < maxRetries; attempt++) {
+        const success = await this.indexUpdate(key, id, metadata);
+        if (success) return;
+        await new Promise((resolve) => setTimeout(resolve, 10 * Math.pow(2, attempt)));
+      }
+      throw new Error(`Failed to update index after ${maxRetries} retries`);
+    },
+    async indexIncrement(key, id, field, increment = 1) {
+      const data = indices.get(key) || [];
+      const entryIndex = data.findIndex((item) => item.id === id);
+      if (entryIndex === -1) {
+        const newEntry = {
+          id,
+          score: Date.now(),
+          metadata: { [field]: increment, version: 1 }
+        };
+        data.push(newEntry);
+        indices.set(key, data);
+        return increment;
+      }
+      const entry = data[entryIndex];
+      if (!entry.metadata) {
+        entry.metadata = { version: 0 };
+      }
+      const currentValue = entry.metadata[field] || 0;
+      const newValue = currentValue + increment;
+      entry.metadata[field] = newValue;
+      entry.metadata.version = (entry.metadata.version || 0) + 1;
+      indices.set(key, data);
+      return newValue;
+    },
+    async deleteStream(subject) {
+      events.delete(subject);
+      listeners.delete(subject);
+    },
+    async deleteByPattern(pattern) {
+      const regexPattern = pattern.replace(/\*/g, ".*").replace(/\?/g, ".");
+      const regex = new RegExp(`^${regexPattern}$`);
+      let count = 0;
+      for (const key of events.keys()) {
+        if (regex.test(key)) {
+          events.delete(key);
+          listeners.delete(key);
+          count++;
+        }
+      }
+      return count;
+    },
+    async deleteIndex(key) {
+      indices.delete(key);
+    },
+    async close() {
+      listeners.clear();
+      events.clear();
+      indices.clear();
+    }
+  };
+}

package/dist/runtime/server/events/adapters/redis/redisAdapter.d.ts

@@ -0,0 +1,2 @@
+import type { EventStoreAdapter } from '../../types.js';
+export declare function createRedisAdapter(): EventStoreAdapter;

package/dist/runtime/server/events/adapters/redis/redisAdapter.js

@@ -0,0 +1,348 @@
+import { useRuntimeConfig, useServerLogger } from "#imports";
+import IORedis from "ioredis";
+import { RedisPubSubGateway } from "./redisPubSubGateway.js";
+const logger = useServerLogger("redis-adapter");
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+export function createRedisAdapter() {
+  const rc = useRuntimeConfig();
+  const conn = rc?.queue?.eventStore?.redis || {};
+  const rsOpts = rc?.queue?.eventStore?.options?.redisStreams || {};
+  const redis = new IORedis({
+    host: conn.host,
+    port: conn.port,
+    username: conn.username,
+    password: conn.password,
+    lazyConnect: true,
+    enableReadyCheck: false
+    // Disable ready check to avoid INFO command conflicts
+  });
+  const subscriber = new IORedis({
+    host: conn.host,
+    port: conn.port,
+    username: conn.username,
+    password: conn.password,
+    lazyConnect: true,
+    enableReadyCheck: false
+  });
+  const gateway = new RedisPubSubGateway(subscriber);
+  function buildFields(e) {
+    const dataStr = e.data !== void 0 ? JSON.stringify(e.data) : "";
+    const fields = [
+      "type",
+      String(e.type || ""),
+      "runId",
+      String(e.runId || ""),
+      "flowName",
+      String(e.flowName || ""),
+      "data",
+      dataStr,
+      "ts",
+      e.ts || nowIso()
+    ];
+    if (e.stepName) {
+      fields.push("stepName", String(e.stepName));
+    }
+    if (e.stepId) {
+      fields.push("stepId", String(e.stepId));
+    }
+    if (e.attempt !== void 0) {
+      fields.push("attempt", String(e.attempt));
+    }
+    return fields;
+  }
+  function parseFieldsToRecord(id, arr) {
+    const obj = {};
+    for (let i = 0; i < arr.length; i += 2) {
+      const k = String(arr[i]);
+      const v = String(arr[i + 1] ?? "");
+      obj[k] = v;
+    }
+    let data;
+    try {
+      data = obj.data ? JSON.parse(obj.data) : void 0;
+    } catch {
+      data = void 0;
+    }
+    const rec = {
+      id,
+      ts: obj.ts || nowIso(),
+      type: obj.type || "event",
+      runId: obj.runId || "",
+      flowName: obj.flowName || "",
+      data
+    };
+    if (obj.stepName) rec.stepName = obj.stepName;
+    if (obj.stepId) rec.stepId = obj.stepId;
+    if (obj.attempt) rec.attempt = Number.parseInt(obj.attempt, 10);
+    return rec;
+  }
+  return {
+    async append(subject, e) {
+      if (!redis.status || redis.status === "end") await redis.connect();
+      const ts = nowIso();
+      const payloadFields = buildFields({ ...e, ts });
+      const stream = subject;
+      let id;
+      if (rsOpts?.trim?.maxLen && rsOpts.trim.maxLen > 0) {
+        const approx = rsOpts?.trim?.approx !== false;
+        const args = approx ? ["MAXLEN", "~", String(rsOpts.trim.maxLen)] : ["MAXLEN", String(rsOpts.trim.maxLen)];
+        id = await redis.xadd(stream, ...args, "*", ...payloadFields);
+      } else {
+        id = await redis.xadd(stream, "*", ...payloadFields);
+      }
+      const channel = `nq:events:${subject}`;
+      await redis.publish(channel, id);
+      if (process.env.NQ_DEBUG_EVENTS === "1") {
+        logger.info("[redis-streams] appended and published", { stream, id, channel, type: e.type });
+      }
+      const rec = { ...e, id, ts, subject };
+      return rec;
+    },
+    async read(subject, opts) {
+      if (!redis.status || redis.status === "end") await redis.connect();
+      const from = opts?.fromId ? opts.fromId : "0-0";
+      const count = opts?.limit || 100;
+      const dir = opts?.direction || "forward";
+      const stream = subject;
+      let resp = [];
+      if (dir === "backward") {
+        resp = await redis.xrevrange(stream, from === "0-0" ? "+" : `(${from}`, "-", "COUNT", count);
+      } else {
+        resp = await redis.xrange(stream, from === "0-0" ? "-" : `(${from}`, "+", "COUNT", count);
+      }
+      const out = [];
+      for (const [id, arr] of resp) {
+        try {
+          const rec = parseFieldsToRecord(id, arr);
+          out.push(rec);
+        } catch {
+        }
+      }
+      return out;
+    },
+    async subscribe(subject, onEvent) {
+      const stream = subject;
+      const channel = `nq:events:${subject}`;
+      if (!redis.status || redis.status === "end") await redis.connect();
+      let running = true;
+      if (process.env.NQ_DEBUG_EVENTS === "1") {
+        logger.info("[redis-streams] subscribing", { stream, channel });
+      }
+      const messageHandler = async (messageId) => {
+        if (!running) return;
+        try {
+          const entries = await redis.xrange(stream, messageId, messageId, "COUNT", 1);
+          if (entries && entries.length > 0) {
+            const [id, arr] = entries[0];
+            const rec = parseFieldsToRecord(id, arr);
+            if (process.env.NQ_DEBUG_EVENTS === "1") {
+              logger.info("[redis-streams] received event", { stream, id, type: rec.type });
+            }
+            onEvent(rec);
+          }
+        } catch (err) {
+          if (process.env.NQ_DEBUG_EVENTS === "1") {
+            logger.error("[redis-streams] message handling error:", err);
+          }
+        }
+      };
+      const unsubscribe = await gateway.subscribe(channel, messageHandler);
+      return {
+        unsubscribe() {
+          running = false;
+          unsubscribe();
+        }
+      };
+    },
+    async indexAdd(key, id, score, metadata) {
+      if (!redis.status || redis.status === "end") await redis.connect();
+      await redis.zadd(key, score, id);
+      if (metadata) {
+        const metaKey = `${key}:meta:${id}`;
+        const toStore = { version: "0" };
+        for (const [k, v] of Object.entries(metadata)) {
+          toStore[k] = Array.isArray(v) ? JSON.stringify(v) : String(v);
+        }
+        await redis.hset(metaKey, toStore);
+      }
+    },
+    async indexRead(key, opts) {
+      if (!redis.status || redis.status === "end") await redis.connect();
+      const offset = opts?.offset || 0;
+      const limit = opts?.limit || 50;
+      const end = offset + limit - 1;
+      const results = await redis.zrevrange(key, offset, end, "WITHSCORES");
+      const entries = [];
+      for (let i = 0; i < results.length; i += 2) {
+        const id = results[i];
+        const score = Number.parseInt(results[i + 1]);
+        const metaKey = `${key}:meta:${id}`;
+        const metadata = await redis.hgetall(metaKey);
+        let parsedMetadata = void 0;
+        if (Object.keys(metadata).length > 0) {
+          parsedMetadata = { ...metadata };
+          if (parsedMetadata.emittedEvents) {
+            parsedMetadata.emittedEvents = JSON.parse(parsedMetadata.emittedEvents);
+          }
+          if (parsedMetadata.version !== void 0) {
+            parsedMetadata.version = Number.parseInt(parsedMetadata.version, 10);
+          }
+          if (parsedMetadata.startedAt !== void 0) {
+            parsedMetadata.startedAt = Number.parseInt(parsedMetadata.startedAt, 10);
+          }
+          if (parsedMetadata.completedAt !== void 0) {
+            parsedMetadata.completedAt = Number.parseInt(parsedMetadata.completedAt, 10);
+          }
+          if (parsedMetadata.stepCount !== void 0) {
+            parsedMetadata.stepCount = Number.parseInt(parsedMetadata.stepCount, 10);
+          }
+          if (parsedMetadata.completedSteps !== void 0) {
+            parsedMetadata.completedSteps = Number.parseInt(parsedMetadata.completedSteps, 10);
+          }
+        }
+        entries.push({
+          id,
+          score,
+          metadata: parsedMetadata
+        });
+      }
+      return entries;
+    },
+    async indexGet(key, id) {
+      if (!redis.status || redis.status === "end") await redis.connect();
+      const score = await redis.zscore(key, id);
+      if (!score) return null;
+      const metaKey = `${key}:meta:${id}`;
+      const metadata = await redis.hgetall(metaKey);
+      if (Object.keys(metadata).length === 0) {
+        return { id, score: Number.parseFloat(score) };
+      }
+      const parsed = { ...metadata };
+      if (parsed.emittedEvents) {
+        parsed.emittedEvents = JSON.parse(parsed.emittedEvents);
+      }
+      if (parsed.version !== void 0) {
+        parsed.version = Number.parseInt(parsed.version, 10);
+      }
+      if (parsed.startedAt !== void 0) {
+        parsed.startedAt = Number.parseInt(parsed.startedAt, 10);
+      }
+      if (parsed.completedAt !== void 0) {
+        parsed.completedAt = Number.parseInt(parsed.completedAt, 10);
+      }
+      if (parsed.stepCount !== void 0) {
+        parsed.stepCount = Number.parseInt(parsed.stepCount, 10);
+      }
+      if (parsed.completedSteps !== void 0) {
+        parsed.completedSteps = Number.parseInt(parsed.completedSteps, 10);
+      }
+      return {
+        id,
+        score: Number.parseFloat(score),
+        metadata: parsed
+      };
+    },
+    async indexUpdate(key, id, metadata) {
+      if (!redis.status || redis.status === "end") await redis.connect();
+      const metaKey = `${key}:meta:${id}`;
+      const current = await redis.hget(metaKey, "version");
+      const currentVersion = current ? Number.parseInt(current, 10) : 0;
+      const script = `
+        local current = redis.call('HGET', KEYS[1], 'version')
+        if current == ARGV[1] then
+          for i = 2, #ARGV, 2 do
+            redis.call('HSET', KEYS[1], ARGV[i], ARGV[i + 1])
+          end
+          redis.call('HSET', KEYS[1], 'version', tonumber(ARGV[1]) + 1)
+          return 1
+        else
+          return 0
+        end
+      `;
+      const args = [currentVersion.toString()];
+      for (const [k, v] of Object.entries(metadata)) {
+        if (v === void 0) continue;
+        args.push(k);
+        if (Array.isArray(v)) {
+          args.push(JSON.stringify(v.filter((item) => item != null)));
+        } else {
+          args.push(String(v));
+        }
+      }
+      const result = await redis.eval(script, 1, metaKey, ...args);
+      return result === 1;
+    },
+    async indexUpdateWithRetry(key, id, metadata, maxRetries = 3) {
+      for (let attempt = 0; attempt < maxRetries; attempt++) {
+        const success = await this.indexUpdate(key, id, metadata);
+        if (success) return;
+        await new Promise((resolve) => setTimeout(resolve, 10 * Math.pow(2, attempt)));
+      }
+      throw new Error(`Failed to update index after ${maxRetries} retries`);
+    },
+    async indexIncrement(key, id, field, increment = 1) {
+      if (!redis.status || redis.status === "end") await redis.connect();
+      const metaKey = `${key}:meta:${id}`;
+      const newValue = await redis.hincrby(metaKey, field, increment);
+      await redis.hincrby(metaKey, "version", 1);
+      return newValue;
+    },
+    async setMetadataTTL(flowName, runId, ttlSeconds) {
+      if (!redis.status || redis.status === "end") await redis.connect();
+      const metaKey = `nq:flow:idx:${flowName}:meta:${runId}`;
+      await redis.expire(metaKey, ttlSeconds);
+    },
+    async cleanupCompletedFlows(key, retentionSeconds) {
+      if (!redis.status || redis.status === "end") await redis.connect();
+      const now = Date.now();
+      const cutoffTime = now - retentionSeconds * 1e3;
+      const oldEntries = await redis.zrangebyscore(key, "-inf", cutoffTime);
+      let removedCount = 0;
+      for (const runId of oldEntries) {
+        const metaKey = `${key}:meta:${runId}`;
+        const metadata = await redis.hgetall(metaKey);
+        if (metadata && (metadata.status === "completed" || metadata.status === "failed")) {
+          await redis.zrem(key, runId);
+          await redis.del(metaKey);
+          removedCount++;
+        }
+      }
+      return removedCount;
+    },
+    async deleteStream(subject) {
+      if (!redis.status || redis.status === "end") await redis.connect();
+      await redis.del(subject);
+    },
+    async deleteByPattern(pattern) {
+      if (!redis.status || redis.status === "end") await redis.connect();
+      let cursor = "0";
+      const keysToDelete = [];
+      do {
+        const result = await redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
+        cursor = result[0];
+        const keys = result[1];
+        if (keys.length > 0) {
+          keysToDelete.push(...keys);
+        }
+      } while (cursor !== "0");
+      if (keysToDelete.length > 0) {
+        await redis.del(...keysToDelete);
+      }
+      return keysToDelete.length;
+    },
+    async deleteIndex(key) {
+      if (!redis.status || redis.status === "end") await redis.connect();
+      await redis.del(key);
+    },
+    async close() {
+      try {
+        await gateway.cleanup();
+        await redis.quit();
+        await subscriber.quit();
+      } catch {
+      }
+    }
+  };
+}

package/dist/runtime/server/events/adapters/redis/redisPubSubGateway.d.ts

@@ -0,0 +1,29 @@
+import type IORedis from 'ioredis';
+/**
+ * Gateway pattern for Redis Pub/Sub
+ * Maintains a single 'message' listener and routes to channel-specific handlers
+ */
+export declare class RedisPubSubGateway {
+    private subscriber;
+    private channelSubscribers;
+    private initialized;
+    constructor(subscriber: IORedis);
+    private initialize;
+    /**
+     * Subscribe to a channel with a handler
+     * Returns unsubscribe function
+     */
+    subscribe(channel: string, handler: (messageId: string) => void): Promise<() => void>;
+    /**
+     * Get subscriber count for a channel (for debugging)
+     */
+    getSubscriberCount(channel: string): number;
+    /**
+     * Get total subscriber count across all channels
+     */
+    getTotalSubscriberCount(): number;
+    /**
+     * Cleanup all subscriptions
+     */
+    cleanup(): Promise<void>;
+}

package/dist/runtime/server/events/adapters/redis/redisPubSubGateway.js

@@ -0,0 +1,82 @@
+import { useServerLogger } from "#imports";
+const logger = useServerLogger("redis-adapter");
+export class RedisPubSubGateway {
+  constructor(subscriber) {
+    this.subscriber = subscriber;
+  }
+  channelSubscribers = /* @__PURE__ */ new Map();
+  initialized = false;
+  initialize() {
+    if (this.initialized) return;
+    this.initialized = true;
+    this.subscriber.on("message", (channel, messageId) => {
+      const handlers = this.channelSubscribers.get(channel);
+      if (!handlers || handlers.size === 0) return;
+      for (const handler of handlers) {
+        try {
+          handler(messageId);
+        } catch (err) {
+          if (process.env.NQ_DEBUG_EVENTS === "1") {
+            logger.error("[redis-pubsub-gateway] Handler error:", err);
+          }
+        }
+      }
+    });
+  }
+  /**
+   * Subscribe to a channel with a handler
+   * Returns unsubscribe function
+   */
+  async subscribe(channel, handler) {
+    this.initialize();
+    if (!this.channelSubscribers.has(channel)) {
+      this.channelSubscribers.set(channel, /* @__PURE__ */ new Set());
+      await this.subscriber.subscribe(channel);
+      if (process.env.NQ_DEBUG_EVENTS === "1") {
+        logger.info("[redis-pubsub-gateway] Subscribed to channel:", channel);
+      }
+    }
+    this.channelSubscribers.get(channel).add(handler);
+    return () => {
+      const handlers = this.channelSubscribers.get(channel);
+      if (handlers) {
+        handlers.delete(handler);
+        if (handlers.size === 0) {
+          this.channelSubscribers.delete(channel);
+          this.subscriber.unsubscribe(channel).catch(() => {
+          });
+          if (process.env.NQ_DEBUG_EVENTS === "1") {
+            logger.info("[redis-pubsub-gateway] Unsubscribed from channel:", channel);
+          }
+        }
+      }
+    };
+  }
+  /**
+   * Get subscriber count for a channel (for debugging)
+   */
+  getSubscriberCount(channel) {
+    return this.channelSubscribers.get(channel)?.size ?? 0;
+  }
+  /**
+   * Get total subscriber count across all channels
+   */
+  getTotalSubscriberCount() {
+    let count = 0;
+    for (const handlers of this.channelSubscribers.values()) {
+      count += handlers.size;
+    }
+    return count;
+  }
+  /**
+   * Cleanup all subscriptions
+   */
+  async cleanup() {
+    const channels = Array.from(this.channelSubscribers.keys());
+    this.channelSubscribers.clear();
+    if (channels.length > 0) {
+      await this.subscriber.unsubscribe(...channels).catch(() => {
+      });
+    }
+  }
+}

package/dist/runtime/server/events/eventBus.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from 'node:events';
+import type { EventRecord } from '../../types.js';
+type Handler = (e: EventRecord) => void;
+declare global {
+    var __nq_bus_emitter: EventEmitter | undefined;
+}
+declare function publish(event: EventRecord): void;
+declare function subscribeRunId(runId: string, handler: Handler): () => void;
+declare function onType(type: string, handler: Handler): () => void;
+export declare const eventBus: {
+    publish: typeof publish;
+    subscribeRunId: typeof subscribeRunId;
+    onType: typeof onType;
+};
+export declare function getEventBus(): {
+    publish: typeof publish;
+    subscribeRunId: typeof subscribeRunId;
+    onType: typeof onType;
+};
+export {};

package/dist/runtime/server/events/eventBus.js

@@ -0,0 +1,35 @@
+import { EventEmitter } from "node:events";
+const emitter = globalThis.__nq_bus_emitter ??= new EventEmitter();
+try {
+  const max = Number(process.env.NQ_BUS_MAX_LISTENERS || 100);
+  if (!Number.isNaN(max) && max > 0) emitter.setMaxListeners(max);
+} catch {
+}
+function eventNameForRunId(runId) {
+  return `runId:${runId}`;
+}
+function eventNameForType(type) {
+  return `type:${type}`;
+}
+function publish(event) {
+  emitter.emit(eventNameForRunId(event.runId), event);
+  emitter.emit(eventNameForType(event.type), event);
+}
+function subscribeRunId(runId, handler) {
+  const name = eventNameForRunId(runId);
+  emitter.on(name, handler);
+  return () => {
+    emitter.off(name, handler);
+  };
+}
+function onType(type, handler) {
+  const name = eventNameForType(type);
+  emitter.on(name, handler);
+  return () => {
+    emitter.off(name, handler);
+  };
+}
+export const eventBus = { publish, subscribeRunId, onType };
+export function getEventBus() {
+  return eventBus;
+}