nvent 0.4.4 → 0.5.0

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

@@ -1,171 +0,0 @@
-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-utils/events/adapters/redis/redisAdapter.d.ts

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

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

@@ -1,348 +0,0 @@
-import { useRuntimeConfig, useNventLogger } from "#imports";
-import IORedis from "ioredis";
-import { RedisPubSubGateway } from "./redisPubSubGateway.js";
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-export function createRedisAdapter() {
-  const rc = useRuntimeConfig();
-  const logger = useNventLogger("redis-adapter");
-  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-utils/events/adapters/redis/redisPubSubGateway.d.ts

@@ -1,30 +0,0 @@
-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;
-    private logger;
-    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-utils/events/adapters/redis/redisPubSubGateway.js

@@ -1,82 +0,0 @@
-import { useNventLogger } from "#imports";
-export class RedisPubSubGateway {
-  constructor(subscriber) {
-    this.subscriber = subscriber;
-  }
-  channelSubscribers = /* @__PURE__ */ new Map();
-  initialized = false;
-  logger = useNventLogger("redis-pubsub-gateway");
-  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") {
-            this.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") {
-        this.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") {
-            this.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-utils/events/eventStoreFactory.d.ts

@@ -1,19 +0,0 @@
-import { getStreamNames } from './streamNames.js';
-import type { EventStoreAdapter } from './types.js';
-export interface EventStoreInstance {
-    name: string;
-    append: EventStoreAdapter['append'];
-    read: EventStoreAdapter['read'];
-    subscribe: EventStoreAdapter['subscribe'];
-}
-export interface EventStoreFactory {
-    adapter: EventStoreAdapter;
-    names: ReturnType<typeof getStreamNames>;
-    stream(name: string): EventStoreInstance;
-    /** Idempotently start stream store wiring that persists ingress events and projections */
-    start(): void;
-    /** Stop wiring and release listeners */
-    stop(): void;
-}
-export declare function getEventStoreFactory(): EventStoreFactory;
-export declare function setEventStoreFactory(f: EventStoreFactory): void;

package/dist/runtime/server-utils/events/eventStoreFactory.js

@@ -1,44 +0,0 @@
-import { useRuntimeConfig, useNventLogger } from "#imports";
-import { getStreamNames } from "./streamNames.js";
-import { createRedisAdapter } from "./adapters/redis/redisAdapter.js";
-import { createMemoryAdapter } from "./adapters/memoryAdapter.js";
-import { createFileAdapter } from "./adapters/fileAdapter.js";
-import { createWiringRegistry } from "./wiring/registry.js";
-let cachedFactory = null;
-export function getEventStoreFactory() {
-  if (cachedFactory) return cachedFactory;
-  const logger = useNventLogger("event-store-factory");
-  const rc = useRuntimeConfig();
-  const adapter = rc?.queue?.eventStore?.adapter || "memory";
-  let adapterInstance;
-  if (adapter === "memory") adapterInstance = createMemoryAdapter();
-  else if (adapter === "file") adapterInstance = createFileAdapter();
-  else if (adapter === "redis") adapterInstance = createRedisAdapter();
-  else adapterInstance = createMemoryAdapter();
-  logger.debug("Event store initialized", { adapter, adapterType: adapter });
-  const names = getStreamNames();
-  const wiring = createWiringRegistry({ adapter: adapterInstance, names });
-  const factory = {
-    adapter: adapterInstance,
-    names,
-    stream(name) {
-      return {
-        name,
-        append: (s, e) => adapterInstance.append(s, e),
-        read: (s, o) => adapterInstance.read(s, o),
-        subscribe: (s, cb) => adapterInstance.subscribe(s, cb)
-      };
-    },
-    start() {
-      wiring.start();
-    },
-    stop() {
-      wiring.stop();
-    }
-  };
-  cachedFactory = factory;
-  return factory;
-}
-export function setEventStoreFactory(f) {
-  cachedFactory = f;
-}