@fluojs/event-bus 1.0.0-beta.1

package/dist/service.js

@@ -0,0 +1,500 @@
+let _initClass;
+function _applyDecs(e, t, n, r, o, i) { var a, c, u, s, f, l, p, d = Symbol.metadata || Symbol.for("Symbol.metadata"), m = Object.defineProperty, h = Object.create, y = [h(null), h(null)], v = t.length; function g(t, n, r) { return function (o, i) { n && (i = o, o = e); for (var a = 0; a < t.length; a++) i = t[a].apply(o, r ? [i] : []); return r ? i : o; }; } function b(e, t, n, r) { if ("function" != typeof e && (r || void 0 !== e)) throw new TypeError(t + " must " + (n || "be") + " a function" + (r ? "" : " or undefined")); return e; } function applyDec(e, t, n, r, o, i, u, s, f, l, p) { function d(e) { if (!p(e)) throw new TypeError("Attempted to access private element on non-instance"); } var h = [].concat(t[0]), v = t[3], w = !u, D = 1 === o, S = 3 === o, j = 4 === o, E = 2 === o; function I(t, n, r) { return function (o, i) { return n && (i = o, o = e), r && r(o), P[t].call(o, i); }; } if (!w) { var P = {}, k = [], F = S ? "get" : j || D ? "set" : "value"; if (f ? (l || D ? P = { get: _setFunctionName(function () { return v(this); }, r, "get"), set: function (e) { t[4](this, e); } } : P[F] = v, l || _setFunctionName(P[F], r, E ? "" : F)) : l || (P = Object.getOwnPropertyDescriptor(e, r)), !l && !f) { if ((c = y[+s][r]) && 7 !== (c ^ o)) throw Error("Decorating two elements with the same name (" + P[F].name + ") is not supported yet"); y[+s][r] = o < 3 ? 1 : o; } } for (var N = e, O = h.length - 1; O >= 0; O -= n ? 2 : 1) { var T = b(h[O], "A decorator", "be", !0), z = n ? h[O - 1] : void 0, A = {}, H = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: r, metadata: a, addInitializer: function (e, t) { if (e.v) throw new TypeError("attempted to call addInitializer after decoration was finished"); b(t, "An initializer", "be", !0), i.push(t); }.bind(null, A) }; if (w) c = T.call(z, N, H), A.v = 1, b(c, "class decorators", "return") && (N = c);else if (H.static = s, H.private = f, c = H.access = { has: f ? p.bind() : function (e) { return r in e; } }, j || (c.get = f ? E ? function (e) { return d(e), P.value; } : I("get", 0, d) : function (e) { return e[r]; }), E || S || (c.set = f ? I("set", 0, d) : function (e, t) { e[r] = t; }), N = T.call(z, D ? { get: P.get, set: P.set } : P[F], H), A.v = 1, D) { if ("object" == typeof N && N) (c = b(N.get, "accessor.get")) && (P.get = c), (c = b(N.set, "accessor.set")) && (P.set = c), (c = b(N.init, "accessor.init")) && k.unshift(c);else if (void 0 !== N) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined"); } else b(N, (l ? "field" : "method") + " decorators", "return") && (l ? k.unshift(N) : P[F] = N); } return o < 2 && u.push(g(k, s, 1), g(i, s, 0)), l || w || (f ? D ? u.splice(-1, 0, I("get", s), I("set", s)) : u.push(E ? P[F] : b.call.bind(P[F])) : m(e, r, P)), N; } function w(e) { return m(e, d, { configurable: !0, enumerable: !0, value: a }); } return void 0 !== i && (a = i[d]), a = h(null == a ? null : a), f = [], l = function (e) { e && f.push(g(e)); }, p = function (t, r) { for (var i = 0; i < n.length; i++) { var a = n[i], c = a[1], l = 7 & c; if ((8 & c) == t && !l == r) { var p = a[2], d = !!a[3], m = 16 & c; applyDec(t ? e : e.prototype, a, m, d ? "#" + p : _toPropertyKey(p), l, l < 2 ? [] : t ? s = s || [] : u = u || [], f, !!t, d, r, t && d ? function (t) { return _checkInRHS(t) === e; } : o); } } }, p(8, 0), p(0, 0), p(8, 1), p(0, 1), l(u), l(s), c = f, v || w(e), { e: c, get c() { var n = []; return v && [w(e = applyDec(e, [t], r, e.name, 5, n)), g(n, 1)]; } }; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; }
+function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; }
+import { Inject } from '@fluojs/core';
+import { cloneWithFallback, getClassDiMetadata } from '@fluojs/core/internal';
+import { APPLICATION_LOGGER, COMPILED_MODULES, RUNTIME_CONTAINER } from '@fluojs/runtime/internal';
+import { getEventHandlerMetadataEntries } from './metadata.js';
+import { createEventBusPlatformStatusSnapshot } from './status.js';
+import { EVENT_BUS_OPTIONS } from './tokens.js';
+function createIsolatedEvent(eventType, source) {
+  const clonedPayload = cloneWithFallback(source);
+  if (typeof clonedPayload !== 'object' || clonedPayload === null) {
+    return clonedPayload;
+  }
+  return Object.assign(Object.create(eventType.prototype), clonedPayload);
+}
+class EventPublishTimeoutError extends Error {
+  constructor(timeoutMs) {
+    super(`Event publish timed out after ${String(timeoutMs)}ms.`);
+    this.timeoutMs = timeoutMs;
+  }
+}
+class EventPublishAbortError extends Error {
+  constructor() {
+    super('Event publish was aborted.');
+  }
+}
+function scopeFromProvider(provider) {
+  if (typeof provider === 'function') {
+    return getClassDiMetadata(provider)?.scope ?? 'singleton';
+  }
+  if ('useClass' in provider) {
+    return provider.scope ?? getClassDiMetadata(provider.useClass)?.scope ?? 'singleton';
+  }
+  return 'scope' in provider ? provider.scope ?? 'singleton' : 'singleton';
+}
+function methodKeyToName(methodKey) {
+  return typeof methodKey === 'symbol' ? methodKey.toString() : methodKey;
+}
+function isClassProvider(provider) {
+  return typeof provider === 'object' && provider !== null && 'useClass' in provider;
+}
+
+/**
+ * Lifecycle-managed in-process event bus with optional external transport fan-out.
+ *
+ * The service discovers `@OnEvent()` handlers, clones payloads before dispatch,
+ * and can publish the same events to an external transport such as Redis Pub/Sub.
+ */
+let _EventBusLifecycleSer;
+class EventBusLifecycleService {
+  static {
+    [_EventBusLifecycleSer, _initClass] = _applyDecs(this, [Inject(RUNTIME_CONTAINER, COMPILED_MODULES, APPLICATION_LOGGER, EVENT_BUS_OPTIONS)], []).c;
+  }
+  descriptors = [];
+  discoveryPromise;
+  discovered = false;
+  lifecycleState = 'created';
+  handlerInstances = new Map();
+  subscribedChannels = new Set();
+  transportCloseFailures = 0;
+  transportPublishFailures = 0;
+  transportSubscribeFailures = 0;
+  transport;
+  constructor(runtimeContainer, compiledModules, logger, moduleOptions) {
+    this.runtimeContainer = runtimeContainer;
+    this.compiledModules = compiledModules;
+    this.logger = logger;
+    this.moduleOptions = moduleOptions;
+    this.transport = moduleOptions.transport;
+  }
+  async onApplicationBootstrap() {
+    this.lifecycleState = 'discovering';
+    try {
+      await this.ensureDiscovered();
+      await this.subscribeTransportChannels();
+      this.lifecycleState = 'ready';
+    } catch (error) {
+      this.lifecycleState = 'failed';
+      throw error;
+    }
+  }
+  async onApplicationShutdown() {
+    this.lifecycleState = 'stopping';
+    if (this.transport) {
+      try {
+        await this.transport.close();
+      } catch (error) {
+        this.transportCloseFailures += 1;
+        this.lifecycleState = 'failed';
+        this.logger.error('EventBusTransport failed to close.', error, 'EventBusLifecycleService');
+      }
+    }
+    if (this.lifecycleState !== 'failed') {
+      this.lifecycleState = 'stopped';
+    }
+  }
+
+  /**
+   * Creates a platform status snapshot for health checks and diagnostics.
+   *
+   * @returns A structured snapshot describing discovery state, transport wiring, and failure counters.
+   */
+  createPlatformStatusSnapshot() {
+    return createEventBusPlatformStatusSnapshot({
+      handlersDiscovered: this.descriptors.length,
+      lifecycleState: this.lifecycleState,
+      subscribedChannels: this.subscribedChannels.size,
+      transportCloseFailures: this.transportCloseFailures,
+      transportConfigured: this.transport !== undefined,
+      transportPublishFailures: this.transportPublishFailures,
+      transportSubscribeFailures: this.transportSubscribeFailures,
+      waitForHandlersDefault: this.moduleOptions.publish?.waitForHandlers ?? true
+    });
+  }
+
+  /**
+   * Publishes one event to matching local handlers and, when configured, to the external transport.
+   *
+   * @param event Event instance to publish.
+   * @param options Optional timeout, abort signal, and wait-for-handler controls.
+   * @returns A promise that resolves once the configured local/transport publication completes.
+   */
+  async publish(event, options) {
+    await this.ensureDiscovered();
+    const matchingDescriptors = this.matchEventDescriptors(event);
+    const publishOptions = this.resolvePublishOptions(options);
+    const transportPayload = createIsolatedEvent(event.constructor, event);
+    const transportPublish = this.publishToTransport(transportPayload, matchingDescriptors);
+    if (!publishOptions.waitForHandlers) {
+      const backgroundTasks = this.createBackgroundInvocationTasks(matchingDescriptors, event, publishOptions.signal);
+      this.runInvocationTasksInBackground([...backgroundTasks, transportPublish]);
+      return;
+    }
+    if (matchingDescriptors.length === 0) {
+      await transportPublish;
+      return;
+    }
+    const invocationTasks = this.createInvocationTasks(matchingDescriptors, event, publishOptions);
+    await Promise.allSettled([...invocationTasks, transportPublish]);
+  }
+  matchEventDescriptors(event) {
+    return this.descriptors.filter(descriptor => event instanceof descriptor.eventType);
+  }
+  createInvocationTasks(descriptors, event, publishOptions) {
+    return descriptors.map(descriptor => {
+      const isolatedEvent = createIsolatedEvent(descriptor.eventType, event);
+      return this.invokeHandlerWithBounds(descriptor, isolatedEvent, publishOptions);
+    });
+  }
+  createBackgroundInvocationTasks(descriptors, event, signal) {
+    return descriptors.map(descriptor => {
+      const isolatedEvent = createIsolatedEvent(descriptor.eventType, event);
+      return this.invokeHandlerInBackground(descriptor, isolatedEvent, signal);
+    });
+  }
+  runInvocationTasksInBackground(invocationTasks) {
+    for (const task of invocationTasks) {
+      void task;
+    }
+  }
+  async invokeHandlerInBackground(descriptor, event, signal) {
+    if (signal?.aborted) {
+      this.logPublishCancelledBeforeDispatch(descriptor);
+      return;
+    }
+    await this.invokeHandler(descriptor, event);
+  }
+  async ensureDiscovered() {
+    if (this.discovered) {
+      return;
+    }
+    if (this.discoveryPromise) {
+      await this.discoveryPromise;
+      return;
+    }
+    if (this.compiledModules.length === 0) {
+      this.logger.warn('EventBus.publish() was called before onApplicationBootstrap completed. Handlers may not yet be registered.', 'EventBusLifecycleService');
+    }
+    this.discoveryPromise = this.discoverHandlers();
+    await this.discoveryPromise;
+  }
+  resolvePublishOptions(options) {
+    const defaults = this.moduleOptions.publish;
+    const timeoutMs = this.normalizeTimeoutMs(options?.timeoutMs ?? defaults?.timeoutMs);
+    const waitForHandlers = options?.waitForHandlers ?? defaults?.waitForHandlers ?? true;
+    return {
+      signal: options?.signal,
+      timeoutMs,
+      waitForHandlers
+    };
+  }
+  normalizeTimeoutMs(timeoutMs) {
+    if (typeof timeoutMs !== 'number' || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      return undefined;
+    }
+    return Math.floor(timeoutMs);
+  }
+  async discoverHandlers() {
+    try {
+      this.descriptors = this.discoverHandlerDescriptors();
+      this.handlerInstances.clear();
+      await this.preloadHandlerInstances(this.descriptors);
+      this.discovered = true;
+    } finally {
+      this.discoveryPromise = undefined;
+    }
+  }
+  channelFromEventType(eventType) {
+    if (typeof eventType.eventKey === 'string') {
+      const eventKey = eventType.eventKey.trim();
+      if (eventKey.length > 0) {
+        return eventKey;
+      }
+    }
+    return eventType.name;
+  }
+  channelsForTransportPublish(event, descriptors) {
+    const channels = new Set();
+    for (const descriptor of descriptors) {
+      channels.add(this.channelFromEventType(descriptor.eventType));
+    }
+    if (channels.size === 0) {
+      channels.add(this.channelFromEventType(event.constructor));
+    }
+    return Array.from(channels);
+  }
+  async publishToTransport(event, descriptors) {
+    if (!this.transport) {
+      return;
+    }
+    const channels = this.channelsForTransportPublish(event, descriptors);
+    const publishTasks = channels.map(async channel => {
+      const payload = createIsolatedEvent(event.constructor, event);
+      try {
+        await this.transport.publish(channel, payload);
+      } catch (error) {
+        this.transportPublishFailures += 1;
+        this.logger.error(`EventBusTransport failed to publish to channel "${channel}".`, error, 'EventBusLifecycleService');
+      }
+    });
+    await Promise.allSettled(publishTasks);
+  }
+  async subscribeTransportChannels() {
+    if (!this.transport) {
+      return;
+    }
+    const descriptorsByChannel = new Map();
+    for (const descriptor of this.descriptors) {
+      const channel = this.channelFromEventType(descriptor.eventType);
+      const channelDescriptors = descriptorsByChannel.get(channel) ?? [];
+      channelDescriptors.push(descriptor);
+      descriptorsByChannel.set(channel, channelDescriptors);
+    }
+    for (const [channel, channelDescriptors] of descriptorsByChannel) {
+      await this.subscribeTransportChannel(channel, channelDescriptors);
+    }
+  }
+  async subscribeTransportChannel(channel, channelDescriptors) {
+    try {
+      await this.transport.subscribe(channel, async payload => {
+        if (channelDescriptors.length === 0) {
+          return;
+        }
+        const invocationTasks = channelDescriptors.map(descriptor => this.invokeHandlerWithBounds(descriptor, createIsolatedEvent(descriptor.eventType, payload), {
+          signal: undefined,
+          timeoutMs: this.normalizeTimeoutMs(this.moduleOptions.publish?.timeoutMs),
+          waitForHandlers: this.moduleOptions.publish?.waitForHandlers ?? true
+        }));
+        await Promise.allSettled(invocationTasks);
+      });
+      this.subscribedChannels.add(channel);
+    } catch (error) {
+      this.transportSubscribeFailures += 1;
+      this.logger.error(`EventBusTransport failed to subscribe to channel "${channel}".`, error, 'EventBusLifecycleService');
+      throw error;
+    }
+  }
+  async preloadHandlerInstances(descriptors) {
+    for (const descriptor of descriptors) {
+      if (this.handlerInstances.has(descriptor.token)) {
+        continue;
+      }
+      await this.resolveHandlerInstance(descriptor);
+    }
+  }
+  async invokeHandlerWithBounds(descriptor, event, publishOptions) {
+    if (publishOptions.signal?.aborted) {
+      this.logPublishCancelledBeforeDispatch(descriptor);
+      return;
+    }
+    const invocation = this.invokeHandler(descriptor, event);
+    try {
+      await this.awaitInvocationBounds(invocation, publishOptions);
+    } catch (error) {
+      this.logBoundedInvocationError(descriptor, error);
+    }
+  }
+  logPublishCancelledBeforeDispatch(descriptor) {
+    this.logger.warn(`Event publish was cancelled before dispatching handler ${descriptor.targetName}.${descriptor.methodName}.`, 'EventBusLifecycleService');
+  }
+  logBoundedInvocationError(descriptor, error) {
+    if (error instanceof EventPublishTimeoutError) {
+      this.logger.warn(`Event handler ${descriptor.targetName}.${descriptor.methodName} exceeded publish timeout of ${String(error.timeoutMs)}ms.`, 'EventBusLifecycleService');
+      return;
+    }
+    if (error instanceof EventPublishAbortError) {
+      this.logger.warn(`Event publish was cancelled while waiting for handler ${descriptor.targetName}.${descriptor.methodName}.`, 'EventBusLifecycleService');
+      return;
+    }
+    this.logger.error(`Event handler ${descriptor.targetName}.${descriptor.methodName} failed while applying publish bounds.`, error, 'EventBusLifecycleService');
+  }
+  async awaitInvocationBounds(invocation, publishOptions) {
+    const timeoutMs = publishOptions.timeoutMs;
+    const signal = publishOptions.signal;
+    if (timeoutMs === undefined && !signal) {
+      await invocation;
+      return;
+    }
+    const bounds = this.createInvocationBounds(timeoutMs, signal);
+    try {
+      await Promise.race([invocation, ...bounds.map(bound => bound.promise)]);
+    } finally {
+      for (const bound of bounds) {
+        bound.cleanup();
+      }
+    }
+  }
+  createInvocationBounds(timeoutMs, signal) {
+    const bounds = [];
+    if (timeoutMs !== undefined) {
+      bounds.push(this.createTimeoutBound(timeoutMs));
+    }
+    if (signal) {
+      if (signal.aborted) {
+        throw new EventPublishAbortError();
+      }
+      bounds.push(this.createAbortBound(signal));
+    }
+    return bounds;
+  }
+  createTimeoutBound(timeoutMs) {
+    let timeoutId;
+    return {
+      cleanup() {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+      },
+      promise: new Promise((_resolve, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(new EventPublishTimeoutError(timeoutMs));
+        }, timeoutMs);
+      })
+    };
+  }
+  createAbortBound(signal) {
+    let abortListener;
+    return {
+      cleanup() {
+        if (abortListener) {
+          signal.removeEventListener('abort', abortListener);
+        }
+      },
+      promise: new Promise((_resolve, reject) => {
+        abortListener = () => {
+          reject(new EventPublishAbortError());
+        };
+        signal.addEventListener('abort', abortListener, {
+          once: true
+        });
+      })
+    };
+  }
+  discoverHandlerDescriptors() {
+    const seen = new WeakMap();
+    const descriptors = [];
+    for (const candidate of this.discoveryCandidates()) {
+      const entries = getEventHandlerMetadataEntries(candidate.targetType.prototype);
+      if (this.shouldSkipNonSingletonCandidate(candidate, entries.length)) {
+        continue;
+      }
+      for (const entry of entries) {
+        const eventType = entry.metadata.eventType;
+        if (this.isDuplicateHandlerRegistration(seen, candidate.targetType, entry.propertyKey, eventType)) {
+          continue;
+        }
+        descriptors.push(this.createHandlerDescriptor(candidate, entry.propertyKey, eventType));
+      }
+    }
+    return descriptors;
+  }
+  shouldSkipNonSingletonCandidate(candidate, entryCount) {
+    if (candidate.scope === 'singleton') {
+      return false;
+    }
+    if (entryCount > 0) {
+      this.logger.warn(`${candidate.targetType.name} in module ${candidate.moduleName} declares @OnEvent() methods but is registered with ${candidate.scope} scope. Event handlers are registered only for singleton providers.`, 'EventBusLifecycleService');
+    }
+    return true;
+  }
+  isDuplicateHandlerRegistration(seen, targetType, methodKey, eventType) {
+    let methodsByKey = seen.get(targetType);
+    if (!methodsByKey) {
+      methodsByKey = new Map();
+      seen.set(targetType, methodsByKey);
+    }
+    let seenEventTypes = methodsByKey.get(methodKey);
+    if (!seenEventTypes) {
+      seenEventTypes = new Set();
+      methodsByKey.set(methodKey, seenEventTypes);
+    }
+    if (seenEventTypes.has(eventType)) {
+      return true;
+    }
+    seenEventTypes.add(eventType);
+    return false;
+  }
+  createHandlerDescriptor(candidate, methodKey, eventType) {
+    return {
+      eventType,
+      methodKey,
+      methodName: methodKeyToName(methodKey),
+      moduleName: candidate.moduleName,
+      targetName: candidate.targetType.name,
+      token: candidate.token
+    };
+  }
+  discoveryCandidates() {
+    const candidates = [];
+    for (const compiledModule of this.compiledModules) {
+      for (const provider of compiledModule.definition.providers ?? []) {
+        if (typeof provider === 'function') {
+          candidates.push({
+            moduleName: compiledModule.type.name,
+            scope: scopeFromProvider(provider),
+            targetType: provider,
+            token: provider
+          });
+          continue;
+        }
+        if (isClassProvider(provider)) {
+          candidates.push({
+            moduleName: compiledModule.type.name,
+            scope: scopeFromProvider(provider),
+            targetType: provider.useClass,
+            token: provider.provide
+          });
+        }
+      }
+      for (const controller of compiledModule.definition.controllers ?? []) {
+        candidates.push({
+          moduleName: compiledModule.type.name,
+          scope: scopeFromProvider(controller),
+          targetType: controller,
+          token: controller
+        });
+      }
+    }
+    return candidates;
+  }
+  async invokeHandler(descriptor, event) {
+    const instance = await this.resolveHandlerInstance(descriptor);
+    if (instance === undefined) {
+      return;
+    }
+    const value = instance[descriptor.methodKey];
+    if (typeof value !== 'function') {
+      this.logger.warn(`Event handler ${descriptor.targetName}.${descriptor.methodName} is not callable and was skipped.`, 'EventBusLifecycleService');
+      return;
+    }
+    try {
+      await Promise.resolve(value.call(instance, event));
+    } catch (error) {
+      this.logger.error(`Event handler ${descriptor.targetName}.${descriptor.methodName} failed.`, error, 'EventBusLifecycleService');
+    }
+  }
+  async resolveHandlerInstance(descriptor) {
+    const cached = this.handlerInstances.get(descriptor.token);
+    if (cached) {
+      return await cached;
+    }
+    const resolving = this.runtimeContainer.resolve(descriptor.token);
+    this.handlerInstances.set(descriptor.token, resolving);
+    try {
+      return await resolving;
+    } catch (error) {
+      this.handlerInstances.delete(descriptor.token);
+      this.logger.error(`Failed to resolve event handler target ${descriptor.targetName} from module ${descriptor.moduleName}.`, error, 'EventBusLifecycleService');
+      return undefined;
+    }
+  }
+  static {
+    _initClass();
+  }
+}
+export { _EventBusLifecycleSer as EventBusLifecycleService };

package/dist/status.d.ts

@@ -0,0 +1,20 @@
+import type { PlatformHealthReport, PlatformReadinessReport, PlatformSnapshot } from '@fluojs/runtime';
+export type EventBusLifecycleState = 'created' | 'discovering' | 'ready' | 'stopping' | 'stopped' | 'failed';
+export interface EventBusStatusAdapterInput {
+    handlersDiscovered: number;
+    lifecycleState: EventBusLifecycleState;
+    subscribedChannels: number;
+    transportCloseFailures: number;
+    transportConfigured: boolean;
+    transportPublishFailures: number;
+    transportSubscribeFailures: number;
+    waitForHandlersDefault: boolean;
+}
+export interface EventBusPlatformStatusSnapshot {
+    readiness: PlatformReadinessReport;
+    health: PlatformHealthReport;
+    ownership: PlatformSnapshot['ownership'];
+    details: Record<string, unknown>;
+}
+export declare function createEventBusPlatformStatusSnapshot(input: EventBusStatusAdapterInput): EventBusPlatformStatusSnapshot;
+//# sourceMappingURL=status.d.ts.map

package/dist/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../src/status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEvG,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,aAAa,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE7G,MAAM,WAAW,0BAA0B;IACzC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,sBAAsB,CAAC;IACvC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,wBAAwB,EAAE,MAAM,CAAC;IACjC,0BAA0B,EAAE,MAAM,CAAC;IACnC,sBAAsB,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,8BAA8B;IAC7C,SAAS,EAAE,uBAAuB,CAAC;IACnC,MAAM,EAAE,oBAAoB,CAAC;IAC7B,SAAS,EAAE,gBAAgB,CAAC,WAAW,CAAC,CAAC;IACzC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAwFD,wBAAgB,oCAAoC,CAAC,KAAK,EAAE,0BAA0B,GAAG,8BAA8B,CAqBtH"}

package/dist/status.js

@@ -0,0 +1,96 @@
+function createReadiness(input) {
+  if (input.lifecycleState === 'ready' && input.transportSubscribeFailures === 0) {
+    return {
+      critical: true,
+      status: 'ready'
+    };
+  }
+  if (input.lifecycleState === 'ready' && input.transportSubscribeFailures > 0) {
+    return {
+      critical: true,
+      reason: 'Event bus transport subscription is partially degraded.',
+      status: 'degraded'
+    };
+  }
+  if (input.lifecycleState === 'discovering') {
+    return {
+      critical: true,
+      reason: 'Event handlers are still being discovered.',
+      status: 'degraded'
+    };
+  }
+  if (input.lifecycleState === 'stopping') {
+    return {
+      critical: true,
+      reason: 'Event bus is shutting down.',
+      status: 'not-ready'
+    };
+  }
+  if (input.lifecycleState === 'stopped') {
+    return {
+      critical: true,
+      reason: 'Event bus is stopped.',
+      status: 'not-ready'
+    };
+  }
+  if (input.lifecycleState === 'failed') {
+    return {
+      critical: true,
+      reason: 'Event bus failed to complete startup or shutdown.',
+      status: 'not-ready'
+    };
+  }
+  return {
+    critical: true,
+    reason: 'Event bus has not completed discovery yet.',
+    status: 'not-ready'
+  };
+}
+function createHealth(input) {
+  if (input.lifecycleState === 'failed' || input.lifecycleState === 'stopped') {
+    return {
+      reason: 'Event bus transport lifecycle is not active.',
+      status: 'unhealthy'
+    };
+  }
+  if (input.lifecycleState === 'discovering' || input.lifecycleState === 'stopping') {
+    return {
+      reason: 'Event bus is transitioning lifecycle state.',
+      status: 'degraded'
+    };
+  }
+  if (input.transportPublishFailures > 0 || input.transportSubscribeFailures > 0 || input.transportCloseFailures > 0) {
+    return {
+      reason: 'Event bus transport reported recoverable runtime failures.',
+      status: 'degraded'
+    };
+  }
+  return {
+    status: 'healthy'
+  };
+}
+function resolveOperationMode(input) {
+  return input.transportConfigured ? 'transport-backed' : 'local-only';
+}
+export function createEventBusPlatformStatusSnapshot(input) {
+  return {
+    details: {
+      dependencies: input.transportConfigured ? ['transport.external'] : [],
+      handlersDiscovered: input.handlersDiscovered,
+      lifecycleState: input.lifecycleState,
+      operationMode: resolveOperationMode(input),
+      subscribedChannels: input.subscribedChannels,
+      transportCloseFailures: input.transportCloseFailures,
+      transportConfigured: input.transportConfigured,
+      transportPublishFailures: input.transportPublishFailures,
+      transportSubscribeFailures: input.transportSubscribeFailures,
+      waitForHandlersDefault: input.waitForHandlersDefault
+    },
+    health: createHealth(input),
+    ownership: {
+      externallyManaged: input.transportConfigured,
+      ownsResources: false
+    },
+    readiness: createReadiness(input)
+  };
+}

package/dist/tokens.d.ts

@@ -0,0 +1,7 @@
+import type { Token } from '@fluojs/core';
+import type { EventBus, EventBusModuleOptions } from './types.js';
+/** Compatibility injection token for the event bus facade. */
+export declare const EVENT_BUS: Token<EventBus>;
+/** Injection token for event-bus module defaults and optional transport wiring. */
+export declare const EVENT_BUS_OPTIONS: Token<EventBusModuleOptions>;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../src/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,KAAK,EAAE,QAAQ,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAElE,8DAA8D;AAC9D,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAgC,CAAC;AACvE,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,qBAAqB,CAAwC,CAAC"}

package/dist/tokens.js

@@ -0,0 +1,4 @@
+/** Compatibility injection token for the event bus facade. */
+export const EVENT_BUS = Symbol.for('fluo.event-bus');
+/** Injection token for event-bus module defaults and optional transport wiring. */
+export const EVENT_BUS_OPTIONS = Symbol.for('fluo.event-bus.options');