@chromahq/core 0.1.15 → 0.1.16

package/dist/boot-Dl66KPJQ.js

@@ -0,0 +1,1629 @@
+'use strict';
+
+var container$1 = require('@inversifyjs/container');
+
+const container = new container$1.Container({
+  defaultScope: "Singleton"
+});
+container.id = Math.random().toString(36).substring(2, 15);
+
+var JobState = /* @__PURE__ */ ((JobState2) => {
+  JobState2["SCHEDULED"] = "scheduled";
+  JobState2["RUNNING"] = "running";
+  JobState2["PAUSED"] = "paused";
+  JobState2["STOPPED"] = "stopped";
+  JobState2["COMPLETED"] = "completed";
+  JobState2["FAILED"] = "failed";
+  return JobState2;
+})(JobState || {});
+
+class MiddlewareRegistryClass {
+  constructor() {
+    this.global = [];
+    this.perHandler = /* @__PURE__ */ new Map();
+  }
+  registerGlobal(fn) {
+    this.global.push(fn);
+  }
+  registerForKey(key, fn) {
+    const arr = this.perHandler.get(key) ?? [];
+    arr.push(fn);
+    this.perHandler.set(key, arr);
+  }
+  pipeline(key) {
+    return [...this.global, ...this.perHandler.get(key) ?? []];
+  }
+}
+const MiddlewareRegistry = new MiddlewareRegistryClass();
+
+const DEFAULT_PORT_NAME = "chroma-bridge";
+
+class DefaultErrorHandler {
+  handle(error, context) {
+    return {
+      id: context.request.id,
+      error: error?.message ?? "UNKNOWN_ERROR",
+      timestamp: Date.now()
+    };
+  }
+}
+const _BridgeRuntimeManager = class _BridgeRuntimeManager {
+  constructor(options) {
+    this.keepAliveTimer = null;
+    this.isInitialized = false;
+    this.container = options.container;
+    this.portName = options.portName ?? DEFAULT_PORT_NAME;
+    this.enableLogging = options.enableLogging ?? true;
+    this.errorHandler = options.errorHandler ?? new DefaultErrorHandler();
+    this.logger = new BridgeLogger(this.enableLogging);
+    this.keepAlive = options.keepAlive ?? false;
+  }
+  /**
+   * Initialize the bridge runtime and start listening for connections
+   */
+  initialize() {
+    if (this.isInitialized) {
+      this.logger.warn("Bridge runtime already initialized");
+      return;
+    }
+    this.setupPortListener();
+    if (this.keepAlive) {
+      this.startKeepAlive();
+    }
+    this.isInitialized = true;
+  }
+  /**
+   * Setup Chrome runtime port listener
+   */
+  setupPortListener() {
+    chrome.runtime.onConnect.addListener((port) => {
+      try {
+        if (!this.isValidPort(port)) {
+          return;
+        }
+        this.logger.info(`\u{1F4E1} Port connected: ${port.name}`);
+        this.setupMessageHandler(port);
+        if (chrome.runtime.lastError) {
+          this.logger.warn(`Runtime error during port setup: ${chrome.runtime.lastError.message}`);
+          chrome.runtime.lastError;
+        }
+      } catch (error) {
+        this.logger.error("Error setting up port listener:", error);
+        if (chrome.runtime.lastError) {
+          this.logger.warn(`Additional runtime error: ${chrome.runtime.lastError.message}`);
+          chrome.runtime.lastError;
+        }
+      }
+    });
+  }
+  /**
+   * Validate incoming port connection
+   */
+  isValidPort(port) {
+    if (port.name !== this.portName) {
+      this.logger.warn(`Ignoring port "${port.name}", expected "${this.portName}"`);
+      return false;
+    }
+    const senderId = port.sender?.id;
+    if (senderId !== chrome.runtime.id) {
+      this.logger.warn(
+        `Ignoring port from different extension (senderId: ${senderId}, expected: ${chrome.runtime.id})`
+      );
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Setup message handler for connected port
+   */
+  setupMessageHandler(port) {
+    port.onMessage.addListener(async (request) => {
+      const context = this.createPipelineContext(request);
+      try {
+        this.logger.debug("\u{1F4E8} Received message:", {
+          key: request.key,
+          id: request.id,
+          hasPayload: !!request.payload
+        });
+        const response = await this.processMessage(context);
+        this.sendResponse(port, response);
+      } catch (error) {
+        const errorResponse = await this.handleError(error, context);
+        this.sendResponse(port, errorResponse);
+      }
+    });
+    port.onDisconnect.addListener(() => {
+      if (chrome.runtime.lastError) {
+        this.logger.warn(`\u{1F4F4} Port disconnected with error: ${chrome.runtime.lastError.message}`);
+        chrome.runtime.lastError;
+      } else {
+        this.logger.info(`\u{1F4F4} Port disconnected: ${port.name}`);
+      }
+    });
+  }
+  /**
+   * Create pipeline context for request processing
+   */
+  createPipelineContext(request) {
+    return {
+      request,
+      startTime: Date.now(),
+      metadata: { ...request.metadata }
+    };
+  }
+  /**
+   * Process message through middleware pipeline and handler
+   */
+  async processMessage(context) {
+    const { request } = context;
+    const handler = this.resolveHandler(request.key);
+    const middlewares = MiddlewareRegistry.pipeline(request.key);
+    const data = await this.runPipeline(
+      middlewares,
+      context,
+      () => handler.handle(request.payload)
+    );
+    return {
+      id: request.id,
+      data,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Resolve message handler from dependency injection container
+   */
+  resolveHandler(key) {
+    try {
+      const handler = this.container.get(key);
+      if (!handler || typeof handler.handle !== "function") {
+        throw new Error(`Handler "${key}" does not implement MessageHandler interface`);
+      }
+      return handler;
+    } catch (error) {
+      throw new Error(`Failed to resolve handler "${key}": ${error.message}`);
+    }
+  }
+  /**
+   * Execute middleware pipeline with proper error handling
+   */
+  async runPipeline(middlewares, context, finalHandler) {
+    let currentIndex = -1;
+    const executeNext = async () => {
+      currentIndex++;
+      if (currentIndex === middlewares.length) {
+        return finalHandler();
+      }
+      if (currentIndex > middlewares.length) {
+        throw new Error("next() called multiple times");
+      }
+      const middleware = middlewares[currentIndex];
+      return middleware(context, executeNext);
+    };
+    return executeNext();
+  }
+  /**
+   * Handle errors during message processing
+   */
+  async handleError(error, context) {
+    const duration = Date.now() - context.startTime;
+    this.logger.error(`\u{1F4A5} Message processing failed after ${duration}ms:`, {
+      key: context.request.key,
+      id: context.request.id,
+      error: error.message
+    });
+    return this.errorHandler.handle(error, context);
+  }
+  /**
+   * Send response back through the port
+   */
+  sendResponse(port, response) {
+    try {
+      if (!port) {
+        this.logger.warn(`Cannot send response: port is null (ID: ${response.id})`);
+        return;
+      }
+      port.postMessage(response);
+      if (chrome.runtime.lastError) {
+        this.logger.warn(
+          `Chrome runtime error during postMessage: ${chrome.runtime.lastError.message} (ID: ${response.id})`
+        );
+        chrome.runtime.lastError;
+        return;
+      }
+      this.logger.debug("\u{1F4E4} Response sent:", {
+        id: response.id,
+        hasData: !!response.data,
+        hasError: !!response.error,
+        data: response.data
+      });
+    } catch (error) {
+      this.logger.error("Failed to send response:", error);
+      if (chrome.runtime.lastError) {
+        this.logger.warn(`Additional Chrome runtime error: ${chrome.runtime.lastError.message}`);
+        chrome.runtime.lastError;
+      }
+    }
+  }
+  /**
+   * Get runtime statistics
+   */
+  getStats() {
+    return {
+      portName: this.portName,
+      initialized: this.isInitialized
+    };
+  }
+  /**
+   * Start keep-alive timer to keep service worker alive
+   */
+  startKeepAlive() {
+    if (this.keepAliveTimer) return;
+    this.logger.info("Starting keep-alive timer to keep service worker alive");
+    this.keepAliveTimer = setInterval(() => {
+      chrome.runtime.getPlatformInfo(() => {
+      });
+    }, _BridgeRuntimeManager.KEEP_ALIVE_INTERVAL_MS);
+  }
+  /**
+   * Stop keep-alive timer
+   */
+  stopKeepAlive() {
+    if (this.keepAliveTimer) {
+      clearInterval(this.keepAliveTimer);
+      this.keepAliveTimer = null;
+      this.logger.info("Stopped keep-alive timer");
+    }
+  }
+};
+_BridgeRuntimeManager.KEEP_ALIVE_INTERVAL_MS = 25e3;
+let BridgeRuntimeManager = _BridgeRuntimeManager;
+class BridgeLogger {
+  constructor(enabled = true) {
+    this.enabled = enabled;
+  }
+  info(message, context) {
+    if (!this.enabled) return;
+    console.log(`[Bridge] ${message}`);
+    if (context) console.log("  Context:", context);
+  }
+  success(message) {
+    if (!this.enabled) return;
+    console.log(`[Bridge] ${message}`);
+  }
+  warn(message) {
+    if (!this.enabled) return;
+    console.warn(`[Bridge] ${message}`);
+  }
+  error(message, error) {
+    if (!this.enabled) return;
+    console.error(`[Bridge] ${message}`);
+    if (error) console.error("  Error:", error);
+  }
+  debug(message, context) {
+    if (!this.enabled) return;
+    console.debug(`[Bridge] ${message}`);
+    if (context) console.debug("  Context:", context);
+  }
+}
+function bootstrap$1(options) {
+  const runtime = new BridgeRuntimeManager(options);
+  runtime.initialize();
+}
+
+class AlarmAdapter {
+  constructor() {
+    this.callbacks = /* @__PURE__ */ new Map();
+  }
+  onTrigger(callback) {
+    this.triggerCallback = callback;
+  }
+  schedule(id, when) {
+    const delay = Math.max(0, when - Date.now());
+    const timeoutId = setTimeout(() => {
+      this.callbacks.delete(id);
+      this.triggerCallback?.(id);
+    }, delay);
+    this.callbacks.set(id, () => clearTimeout(timeoutId));
+    return timeoutId;
+  }
+  cancel(id) {
+    const callback = this.callbacks.get(id);
+    if (callback) {
+      callback();
+      this.callbacks.delete(id);
+    }
+  }
+}
+
+class TimeoutAdapter {
+  constructor() {
+    this.callbacks = /* @__PURE__ */ new Map();
+  }
+  onTrigger(callback) {
+    this.triggerCallback = callback;
+  }
+  schedule(id, when) {
+    const delay = Math.max(0, when - Date.now());
+    const timeoutId = setTimeout(() => {
+      this.callbacks.delete(id);
+      this.triggerCallback?.(id);
+    }, delay);
+    this.callbacks.set(id, () => clearTimeout(timeoutId));
+    return timeoutId;
+  }
+  cancel(id) {
+    const callback = this.callbacks.get(id);
+    if (callback) {
+      callback();
+      this.callbacks.delete(id);
+    }
+  }
+}
+
+const _JobRegistry = class _JobRegistry {
+  constructor() {
+    this.jobs = /* @__PURE__ */ new Map();
+  }
+  register(id, job, options) {
+    const context = this.createJobContext(id, options);
+    this.jobs.set(id, {
+      job,
+      context,
+      options
+    });
+  }
+  resolve(id) {
+    const entry = this.jobs.get(id);
+    return entry?.job;
+  }
+  meta(id) {
+    const entry = this.jobs.get(id);
+    return entry?.options;
+  }
+  getContext(id) {
+    const entry = this.jobs.get(id);
+    return entry?.context;
+  }
+  updateState(id, state) {
+    const entry = this.jobs.get(id);
+    if (entry) {
+      entry.context.state = state;
+      entry.context.updatedAt = /* @__PURE__ */ new Date();
+      switch (state) {
+        case JobState.RUNNING:
+          entry.context.startedAt = /* @__PURE__ */ new Date();
+          break;
+        case JobState.PAUSED:
+          entry.context.pausedAt = /* @__PURE__ */ new Date();
+          break;
+        case JobState.STOPPED:
+          entry.context.stoppedAt = /* @__PURE__ */ new Date();
+          break;
+        case JobState.COMPLETED:
+          entry.context.completedAt = /* @__PURE__ */ new Date();
+          break;
+      }
+    }
+  }
+  setTimeoutId(id, timeoutId) {
+    const entry = this.jobs.get(id);
+    if (entry) {
+      entry.timeoutId = timeoutId;
+    }
+  }
+  setIntervalId(id, intervalId) {
+    const entry = this.jobs.get(id);
+    if (entry) {
+      entry.intervalId = intervalId;
+    }
+  }
+  clearTimers(id) {
+    const entry = this.jobs.get(id);
+    if (entry) {
+      if (entry.timeoutId) {
+        clearTimeout(entry.timeoutId);
+        entry.timeoutId = void 0;
+      }
+      if (entry.intervalId) {
+        clearInterval(entry.intervalId);
+        entry.intervalId = void 0;
+      }
+    }
+  }
+  pause(id) {
+    const entry = this.jobs.get(id);
+    console.log(`Pausing job ${id}`);
+    if (entry && entry.context.state === JobState.RUNNING) {
+      console.log(`paused job ${id}`);
+      this.updateState(id, JobState.PAUSED);
+      this.clearTimers(id);
+      entry.job.pause?.();
+    }
+  }
+  resume(id) {
+    const entry = this.jobs.get(id);
+    console.log(`Resuming job ${id}`);
+    if (entry && entry.context.state === JobState.PAUSED) {
+      console.log(`Resuming job ${id}`);
+      this.updateState(id, JobState.SCHEDULED);
+      entry.job.resume?.();
+    }
+  }
+  stop(id) {
+    const entry = this.jobs.get(id);
+    if (entry && entry.context.state !== JobState.STOPPED) {
+      console.log(`Stopping job ${id}`);
+      this.updateState(id, JobState.STOPPED);
+      this.clearTimers(id);
+      entry.job.stop?.();
+    }
+  }
+  createJobContext(id, options) {
+    const now = /* @__PURE__ */ new Date();
+    return {
+      id,
+      options,
+      state: JobState.SCHEDULED,
+      createdAt: now,
+      updatedAt: now,
+      retryCount: 0,
+      pause: () => this.pause(id),
+      resume: () => this.resume(id),
+      stop: () => this.stop(id),
+      complete: () => this.updateState(id, JobState.COMPLETED),
+      fail: (error) => {
+        this.updateState(id, JobState.FAILED);
+        const entry = this.jobs.get(id);
+        if (entry) entry.context.error = error;
+      },
+      retry: () => {
+        const entry = this.jobs.get(id);
+        if (entry) {
+          entry.context.retryCount = (entry.context.retryCount || 0) + 1;
+          this.updateState(id, JobState.SCHEDULED);
+        }
+      },
+      isRunning: () => this.getContext(id)?.state === JobState.RUNNING,
+      isPaused: () => this.getContext(id)?.state === JobState.PAUSED,
+      isStopped: () => this.getContext(id)?.state === JobState.STOPPED,
+      isCompleted: () => this.getContext(id)?.state === JobState.COMPLETED,
+      isFailed: () => this.getContext(id)?.state === JobState.FAILED,
+      isRetrying: () => (this.getContext(id)?.retryCount || 0) > 0,
+      isScheduled: () => this.getContext(id)?.state === JobState.SCHEDULED,
+      isDelayed: () => !!options.delay,
+      isRecurring: () => !!options.cron,
+      isCron: () => !!options.cron,
+      isTimeout: () => !!options.delay && !options.cron,
+      isAlarm: () => !!options.cron || !!options.delay && options.delay > 6e4
+    };
+  }
+};
+_JobRegistry.instance = new _JobRegistry();
+let JobRegistry = _JobRegistry;
+
+/* Extracts second, minute, hour, date, month and the weekday from a date. */
+function extractDateElements(date) {
+    return {
+        second: date.getSeconds(),
+        minute: date.getMinutes(),
+        hour: date.getHours(),
+        day: date.getDate(),
+        month: date.getMonth(),
+        weekday: date.getDay(),
+        year: date.getFullYear(),
+    };
+}
+/* Gets the amount of days in the given month (indexed by 0) of the given year. */
+function getDaysInMonth(year, month) {
+    return new Date(year, month + 1, 0).getDate();
+}
+/* Gets the amount of days from weekday1 to weekday2. */
+function getDaysBetweenWeekdays(weekday1, weekday2) {
+    if (weekday1 <= weekday2) {
+        return weekday2 - weekday1;
+    }
+    return 6 - weekday1 + weekday2 + 1;
+}
+
+class Cron {
+    constructor({ seconds, minutes, hours, days, months, weekdays, }) {
+        // Validate that there are values provided.
+        if (!seconds || seconds.size === 0)
+            throw new Error('There must be at least one allowed second.');
+        if (!minutes || minutes.size === 0)
+            throw new Error('There must be at least one allowed minute.');
+        if (!hours || hours.size === 0)
+            throw new Error('There must be at least one allowed hour.');
+        if (!months || months.size === 0)
+            throw new Error('There must be at least one allowed month.');
+        if ((!weekdays || weekdays.size === 0) && (!days || days.size === 0))
+            throw new Error('There must be at least one allowed day or weekday.');
+        // Convert set to array and sort in ascending order.
+        this.seconds = Array.from(seconds).sort((a, b) => a - b);
+        this.minutes = Array.from(minutes).sort((a, b) => a - b);
+        this.hours = Array.from(hours).sort((a, b) => a - b);
+        this.days = Array.from(days).sort((a, b) => a - b);
+        this.months = Array.from(months).sort((a, b) => a - b);
+        this.weekdays = Array.from(weekdays).sort((a, b) => a - b);
+        // Validate that all values are integers within the constraint.
+        const validateData = (name, data, constraint) => {
+            if (data.some((x) => typeof x !== 'number' ||
+                x % 1 !== 0 ||
+                x < constraint.min ||
+                x > constraint.max)) {
+                throw new Error(`${name} must only consist of integers which are within the range of ${constraint.min} and ${constraint.max}`);
+            }
+        };
+        validateData('seconds', this.seconds, { min: 0, max: 59 });
+        validateData('minutes', this.minutes, { min: 0, max: 59 });
+        validateData('hours', this.hours, { min: 0, max: 23 });
+        validateData('days', this.days, { min: 1, max: 31 });
+        validateData('months', this.months, { min: 0, max: 11 });
+        validateData('weekdays', this.weekdays, { min: 0, max: 6 });
+        // For each element, store a reversed copy in the reversed attribute for finding prev dates.
+        this.reversed = {
+            seconds: this.seconds.map((x) => x).reverse(),
+            minutes: this.minutes.map((x) => x).reverse(),
+            hours: this.hours.map((x) => x).reverse(),
+            days: this.days.map((x) => x).reverse(),
+            months: this.months.map((x) => x).reverse(),
+            weekdays: this.weekdays.map((x) => x).reverse(),
+        };
+    }
+    /**
+     * Find the next or previous hour, starting from the given start hour that matches the hour constraint.
+     * startHour itself might also be allowed.
+     */
+    findAllowedHour(dir, startHour) {
+        return dir === 'next'
+            ? this.hours.find((x) => x >= startHour)
+            : this.reversed.hours.find((x) => x <= startHour);
+    }
+    /**
+     * Find the next or previous minute, starting from the given start minute that matches the minute constraint.
+     * startMinute itself might also be allowed.
+     */
+    findAllowedMinute(dir, startMinute) {
+        return dir === 'next'
+            ? this.minutes.find((x) => x >= startMinute)
+            : this.reversed.minutes.find((x) => x <= startMinute);
+    }
+    /**
+     * Find the next or previous second, starting from the given start second that matches the second constraint.
+     * startSecond itself IS NOT allowed.
+     */
+    findAllowedSecond(dir, startSecond) {
+        return dir === 'next'
+            ? this.seconds.find((x) => x > startSecond)
+            : this.reversed.seconds.find((x) => x < startSecond);
+    }
+    /**
+     * Find the next or previous time, starting from the given start time that matches the hour, minute
+     * and second constraints. startTime itself might also be allowed.
+     */
+    findAllowedTime(dir, startTime) {
+        // Try to find an allowed hour.
+        let hour = this.findAllowedHour(dir, startTime.hour);
+        if (hour !== undefined) {
+            if (hour === startTime.hour) {
+                // We found an hour that is the start hour. Try to find an allowed minute.
+                let minute = this.findAllowedMinute(dir, startTime.minute);
+                if (minute !== undefined) {
+                    if (minute === startTime.minute) {
+                        // We found a minute that is the start minute. Try to find an allowed second.
+                        const second = this.findAllowedSecond(dir, startTime.second);
+                        if (second !== undefined) {
+                            // We found a second within the start hour and minute.
+                            return { hour, minute, second };
+                        }
+                        // We did not find a valid second within the start minute. Try to find another minute.
+                        minute = this.findAllowedMinute(dir, dir === 'next' ? startTime.minute + 1 : startTime.minute - 1);
+                        if (minute !== undefined) {
+                            // We found a minute which is not the start minute. Return that minute together with the hour and the first / last allowed second.
+                            return {
+                                hour,
+                                minute,
+                                second: dir === 'next' ? this.seconds[0] : this.reversed.seconds[0],
+                            };
+                        }
+                    }
+                    else {
+                        // We found a minute which is not the start minute. Return that minute together with the hour and the first / last allowed second.
+                        return {
+                            hour,
+                            minute,
+                            second: dir === 'next' ? this.seconds[0] : this.reversed.seconds[0],
+                        };
+                    }
+                }
+                // We did not find an allowed minute / second combination inside the start hour. Try to find the next / previous allowed hour.
+                hour = this.findAllowedHour(dir, dir === 'next' ? startTime.hour + 1 : startTime.hour - 1);
+                if (hour !== undefined) {
+                    // We found an allowed hour which is not the start hour. Return that hour together with the first / last allowed minutes / seconds.
+                    return {
+                        hour,
+                        minute: dir === 'next' ? this.minutes[0] : this.reversed.minutes[0],
+                        second: dir === 'next' ? this.seconds[0] : this.reversed.seconds[0],
+                    };
+                }
+            }
+            else {
+                // We found an allowed hour which is not the start hour. Return that hour together with the first / last allowed minutes / seconds.
+                return {
+                    hour,
+                    minute: dir === 'next' ? this.minutes[0] : this.reversed.minutes[0],
+                    second: dir === 'next' ? this.seconds[0] : this.reversed.seconds[0],
+                };
+            }
+        }
+        // No allowed time found.
+        return undefined;
+    }
+    /**
+     * Find the next or previous day in the given month, starting from the given startDay
+     * that matches either the day or the weekday constraint. startDay itself might also be allowed.
+     */
+    findAllowedDayInMonth(dir, year, month, startDay) {
+        var _a, _b;
+        if (startDay < 1)
+            throw new Error('startDay must not be smaller than 1.');
+        // If only days are restricted: allow day based on day constraint only.
+        // If only weekdays are restricted: allow day based on weekday constraint only.
+        // If both are restricted: allow day based on both day and weekday constraint. pick day that is closer to startDay.
+        // If none are restricted: return the day closest to startDay (respecting dir) that is allowed (or startDay itself).
+        const daysInMonth = getDaysInMonth(year, month);
+        const daysRestricted = this.days.length !== 31;
+        const weekdaysRestricted = this.weekdays.length !== 7;
+        if (!daysRestricted && !weekdaysRestricted) {
+            if (startDay > daysInMonth) {
+                return dir === 'next' ? undefined : daysInMonth;
+            }
+            return startDay;
+        }
+        // Try to find a day based on the days constraint.
+        let allowedDayByDays;
+        if (daysRestricted) {
+            allowedDayByDays =
+                dir === 'next'
+                    ? this.days.find((x) => x >= startDay)
+                    : this.reversed.days.find((x) => x <= startDay);
+            // Make sure the day does not exceed the amount of days in month.
+            if (allowedDayByDays !== undefined && allowedDayByDays > daysInMonth) {
+                allowedDayByDays = undefined;
+            }
+        }
+        // Try to find a day based on the weekday constraint.
+        let allowedDayByWeekdays;
+        if (weekdaysRestricted) {
+            const startWeekday = new Date(year, month, startDay).getDay();
+            const nearestAllowedWeekday = dir === 'next'
+                ? (_a = this.weekdays.find((x) => x >= startWeekday)) !== null && _a !== void 0 ? _a : this.weekdays[0]
+                : (_b = this.reversed.weekdays.find((x) => x <= startWeekday)) !== null && _b !== void 0 ? _b : this.reversed.weekdays[0];
+            if (nearestAllowedWeekday !== undefined) {
+                const daysBetweenWeekdays = dir === 'next'
+                    ? getDaysBetweenWeekdays(startWeekday, nearestAllowedWeekday)
+                    : getDaysBetweenWeekdays(nearestAllowedWeekday, startWeekday);
+                allowedDayByWeekdays =
+                    dir === 'next'
+                        ? startDay + daysBetweenWeekdays
+                        : startDay - daysBetweenWeekdays;
+                // Make sure the day does not exceed the month boundaries.
+                if (allowedDayByWeekdays > daysInMonth || allowedDayByWeekdays < 1) {
+                    allowedDayByWeekdays = undefined;
+                }
+            }
+        }
+        if (allowedDayByDays !== undefined && allowedDayByWeekdays !== undefined) {
+            // If a day is found both via the days and the weekdays constraint, pick the day
+            // that is closer to start date.
+            return dir === 'next'
+                ? Math.min(allowedDayByDays, allowedDayByWeekdays)
+                : Math.max(allowedDayByDays, allowedDayByWeekdays);
+        }
+        if (allowedDayByDays !== undefined) {
+            return allowedDayByDays;
+        }
+        if (allowedDayByWeekdays !== undefined) {
+            return allowedDayByWeekdays;
+        }
+        return undefined;
+    }
+    /** Gets the next date starting from the given start date or now. */
+    getNextDate(startDate = new Date()) {
+        const startDateElements = extractDateElements(startDate);
+        let minYear = startDateElements.year;
+        let startIndexMonth = this.months.findIndex((x) => x >= startDateElements.month);
+        if (startIndexMonth === -1) {
+            startIndexMonth = 0;
+            minYear++;
+        }
+        // We try every month within the next 5 years to make sure that we tried to
+        // find a matching date insidde a whole leap year.
+        const maxIterations = this.months.length * 5;
+        for (let i = 0; i < maxIterations; i++) {
+            // Get the next year and month.
+            const year = minYear + Math.floor((startIndexMonth + i) / this.months.length);
+            const month = this.months[(startIndexMonth + i) % this.months.length];
+            const isStartMonth = year === startDateElements.year && month === startDateElements.month;
+            // Find the next day.
+            let day = this.findAllowedDayInMonth('next', year, month, isStartMonth ? startDateElements.day : 1);
+            let isStartDay = isStartMonth && day === startDateElements.day;
+            // If we found a day and it is the start day, try to find a valid time beginning from the start date time.
+            if (day !== undefined && isStartDay) {
+                const nextTime = this.findAllowedTime('next', startDateElements);
+                if (nextTime !== undefined) {
+                    return new Date(year, month, day, nextTime.hour, nextTime.minute, nextTime.second);
+                }
+                // If no valid time has been found for the start date, try the next day.
+                day = this.findAllowedDayInMonth('next', year, month, day + 1);
+                isStartDay = false;
+            }
+            // If we found a next day and it is not the start day, just use the next day with the first allowed values
+            // for hours, minutes and seconds.
+            if (day !== undefined && !isStartDay) {
+                return new Date(year, month, day, this.hours[0], this.minutes[0], this.seconds[0]);
+            }
+            // No allowed day has been found for this month. Continue to search in next month.
+        }
+        throw new Error('No valid next date was found.');
+    }
+    /** Gets the specified amount of future dates starting from the given start date or now. */
+    getNextDates(amount, startDate) {
+        const dates = [];
+        let nextDate;
+        for (let i = 0; i < amount; i++) {
+            nextDate = this.getNextDate(nextDate !== null && nextDate !== void 0 ? nextDate : startDate);
+            dates.push(nextDate);
+        }
+        return dates;
+    }
+    /**
+     * Get an ES6 compatible iterator which iterates over the next dates starting from startDate or now.
+     * The iterator runs until the optional endDate is reached or forever.
+     */
+    *getNextDatesIterator(startDate, endDate) {
+        let nextDate;
+        while (true) {
+            nextDate = this.getNextDate(nextDate !== null && nextDate !== void 0 ? nextDate : startDate);
+            if (endDate && endDate.getTime() < nextDate.getTime()) {
+                return;
+            }
+            yield nextDate;
+        }
+    }
+    /** Gets the previous date starting from the given start date or now. */
+    getPrevDate(startDate = new Date()) {
+        const startDateElements = extractDateElements(startDate);
+        let maxYear = startDateElements.year;
+        let startIndexMonth = this.reversed.months.findIndex((x) => x <= startDateElements.month);
+        if (startIndexMonth === -1) {
+            startIndexMonth = 0;
+            maxYear--;
+        }
+        // We try every month within the past 5 years to make sure that we tried to
+        // find a matching date inside a whole leap year.
+        const maxIterations = this.reversed.months.length * 5;
+        for (let i = 0; i < maxIterations; i++) {
+            // Get the next year and month.
+            const year = maxYear -
+                Math.floor((startIndexMonth + i) / this.reversed.months.length);
+            const month = this.reversed.months[(startIndexMonth + i) % this.reversed.months.length];
+            const isStartMonth = year === startDateElements.year && month === startDateElements.month;
+            // Find the previous day.
+            let day = this.findAllowedDayInMonth('prev', year, month, isStartMonth
+                ? startDateElements.day
+                : // Start searching from the last day of the month.
+                    getDaysInMonth(year, month));
+            let isStartDay = isStartMonth && day === startDateElements.day;
+            // If we found a day and it is the start day, try to find a valid time beginning from the start date time.
+            if (day !== undefined && isStartDay) {
+                const prevTime = this.findAllowedTime('prev', startDateElements);
+                if (prevTime !== undefined) {
+                    return new Date(year, month, day, prevTime.hour, prevTime.minute, prevTime.second);
+                }
+                // If no valid time has been found for the start date, try the previous day.
+                if (day > 1) {
+                    day = this.findAllowedDayInMonth('prev', year, month, day - 1);
+                    isStartDay = false;
+                }
+            }
+            // If we found a previous day and it is not the start day, just use the previous day with the first allowed values
+            // for hours, minutes and seconds (which will be the latest time due to using the reversed array).
+            if (day !== undefined && !isStartDay) {
+                return new Date(year, month, day, this.reversed.hours[0], this.reversed.minutes[0], this.reversed.seconds[0]);
+            }
+            // No allowed day has been found for this month. Continue to search in previous month.
+        }
+        throw new Error('No valid previous date was found.');
+    }
+    /** Gets the specified amount of previous dates starting from the given start date or now. */
+    getPrevDates(amount, startDate) {
+        const dates = [];
+        let prevDate;
+        for (let i = 0; i < amount; i++) {
+            prevDate = this.getPrevDate(prevDate !== null && prevDate !== void 0 ? prevDate : startDate);
+            dates.push(prevDate);
+        }
+        return dates;
+    }
+    /**
+     * Get an ES6 compatible iterator which iterates over the previous dates starting from startDate or now.
+     * The iterator runs until the optional endDate is reached or forever.
+     */
+    *getPrevDatesIterator(startDate, endDate) {
+        let prevDate;
+        while (true) {
+            prevDate = this.getPrevDate(prevDate !== null && prevDate !== void 0 ? prevDate : startDate);
+            if (endDate && endDate.getTime() > prevDate.getTime()) {
+                return;
+            }
+            yield prevDate;
+        }
+    }
+    /** Returns true when there is a cron date at the given date. */
+    matchDate(date) {
+        const { second, minute, hour, day, month, weekday } = extractDateElements(date);
+        if (this.seconds.indexOf(second) === -1 ||
+            this.minutes.indexOf(minute) === -1 ||
+            this.hours.indexOf(hour) === -1 ||
+            this.months.indexOf(month) === -1) {
+            return false;
+        }
+        if (this.days.length !== 31 && this.weekdays.length !== 7) {
+            return (this.days.indexOf(day) !== -1 || this.weekdays.indexOf(weekday) !== -1);
+        }
+        return (this.days.indexOf(day) !== -1 && this.weekdays.indexOf(weekday) !== -1);
+    }
+}
+
+const secondConstraint = {
+    min: 0,
+    max: 59,
+};
+const minuteConstraint = {
+    min: 0,
+    max: 59,
+};
+const hourConstraint = {
+    min: 0,
+    max: 23,
+};
+const dayConstraint = {
+    min: 1,
+    max: 31,
+};
+const monthConstraint = {
+    min: 1,
+    max: 12,
+    aliases: {
+        jan: '1',
+        feb: '2',
+        mar: '3',
+        apr: '4',
+        may: '5',
+        jun: '6',
+        jul: '7',
+        aug: '8',
+        sep: '9',
+        oct: '10',
+        nov: '11',
+        dec: '12',
+    },
+};
+const weekdayConstraint = {
+    min: 0,
+    max: 7,
+    aliases: {
+        mon: '1',
+        tue: '2',
+        wed: '3',
+        thu: '4',
+        fri: '5',
+        sat: '6',
+        sun: '7',
+    },
+};
+const timeNicknames = {
+    '@yearly': '0 0 1 1 *',
+    '@annually': '0 0 1 1 *',
+    '@monthly': '0 0 1 * *',
+    '@weekly': '0 0 * * 0',
+    '@daily': '0 0 * * *',
+    '@hourly': '0 * * * *',
+    '@minutely': '* * * * *',
+};
+function parseElement(element, constraint) {
+    const result = new Set();
+    // If returned set of numbers is empty, the scheduler class interpretes the emtpy set of numbers as all valid values of the constraint
+    if (element === '*') {
+        for (let i = constraint.min; i <= constraint.max; i = i + 1) {
+            result.add(i);
+        }
+        return result;
+    }
+    // If the element is a list, parse each element in the list.
+    const listElements = element.split(',');
+    if (listElements.length > 1) {
+        for (const listElement of listElements) {
+            const parsedListElement = parseElement(listElement, constraint);
+            for (const x of parsedListElement) {
+                result.add(x);
+            }
+        }
+        return result;
+    }
+    // Helper function to parse a single element, which includes checking for alias, valid number and constraint min and max.
+    const parseSingleElement = (singleElement) => {
+        var _a, _b;
+        // biome-ignore lint/style/noParameterAssign: adding another variable with a new name is more confusing
+        singleElement =
+            (_b = (_a = constraint.aliases) === null || _a === void 0 ? void 0 : _a[singleElement.toLowerCase()]) !== null && _b !== void 0 ? _b : singleElement;
+        const parsedElement = Number.parseInt(singleElement, 10);
+        if (Number.isNaN(parsedElement)) {
+            throw new Error(`Failed to parse ${element}: ${singleElement} is NaN.`);
+        }
+        if (parsedElement < constraint.min || parsedElement > constraint.max) {
+            throw new Error(`Failed to parse ${element}: ${singleElement} is outside of constraint range of ${constraint.min} - ${constraint.max}.`);
+        }
+        return parsedElement;
+    };
+    // Detect if the element is a range.
+    // Possible range formats: 'start-end', 'start-end/step', '*', '*/step'.
+    // Where start and end can be numbers or aliases.
+    // Capture groups: 1: start-end, 2: start, 3: end, 4: /step, 5: step.
+    const rangeSegments = /^(([0-9a-zA-Z]+)-([0-9a-zA-Z]+)|\*)(\/([0-9]+))?$/.exec(element);
+    // If not, it must be a single element.
+    if (rangeSegments === null) {
+        result.add(parseSingleElement(element));
+        return result;
+    }
+    // If it is a range, get start and end of the range.
+    let parsedStart = rangeSegments[1] === '*'
+        ? constraint.min
+        : parseSingleElement(rangeSegments[2]);
+    const parsedEnd = rangeSegments[1] === '*'
+        ? constraint.max
+        : parseSingleElement(rangeSegments[3]);
+    // need to catch Sunday, which gets parsed here as 7, but is also legitimate at the start of a range as 0, to avoid the out of order error
+    if (constraint === weekdayConstraint &&
+        parsedStart === 7 &&
+        // this check ensures that sun-sun is not incorrectly parsed as [0,1,2,3,4,5,6]
+        parsedEnd !== 7) {
+        parsedStart = 0;
+    }
+    if (parsedStart > parsedEnd) {
+        throw new Error(`Failed to parse ${element}: Invalid range (start: ${parsedStart}, end: ${parsedEnd}).`);
+    }
+    // Check whether there is a custom step defined for the range, defaulting to 1.
+    const step = rangeSegments[5];
+    let parsedStep = 1;
+    if (step !== undefined) {
+        parsedStep = Number.parseInt(step, 10);
+        if (Number.isNaN(parsedStep)) {
+            throw new Error(`Failed to parse step: ${step} is NaN.`);
+        }
+        if (parsedStep < 1) {
+            throw new Error(`Failed to parse step: Expected ${step} to be greater than 0.`);
+        }
+    }
+    // Go from start to end of the range by the given steps.
+    for (let i = parsedStart; i <= parsedEnd; i = i + parsedStep) {
+        result.add(i);
+    }
+    return result;
+}
+/** Parses a cron expression into a Cron instance. */
+function parseCronExpression(cronExpression) {
+    var _a;
+    if (typeof cronExpression !== 'string') {
+        throw new TypeError('Invalid cron expression: must be of type string.');
+    }
+    // Convert time nicknames.
+    // biome-ignore lint/style/noParameterAssign: adding another variable with a new name is more confusing
+    cronExpression = (_a = timeNicknames[cronExpression.toLowerCase()]) !== null && _a !== void 0 ? _a : cronExpression;
+    // Split the cron expression into its elements, removing empty elements (extra whitespaces).
+    const elements = cronExpression.split(' ').filter((elem) => elem.length > 0);
+    if (elements.length < 5 || elements.length > 6) {
+        throw new Error('Invalid cron expression: expected 5 or 6 elements.');
+    }
+    const rawSeconds = elements.length === 6 ? elements[0] : '0';
+    const rawMinutes = elements.length === 6 ? elements[1] : elements[0];
+    const rawHours = elements.length === 6 ? elements[2] : elements[1];
+    const rawDays = elements.length === 6 ? elements[3] : elements[2];
+    const rawMonths = elements.length === 6 ? elements[4] : elements[3];
+    const rawWeekdays = elements.length === 6 ? elements[5] : elements[4];
+    return new Cron({
+        seconds: parseElement(rawSeconds, secondConstraint),
+        minutes: parseElement(rawMinutes, minuteConstraint),
+        hours: parseElement(rawHours, hourConstraint),
+        days: parseElement(rawDays, dayConstraint),
+        // months in cron are indexed by 1, but Cron expects indexes by 0, so we need to reduce all set values by one.
+        months: new Set(Array.from(parseElement(rawMonths, monthConstraint)).map((x) => x - 1)),
+        weekdays: new Set(Array.from(parseElement(rawWeekdays, weekdayConstraint)).map((x) => x % 7)),
+    });
+}
+
+function getNextCronDate(expr) {
+  try {
+    const interval = parseCronExpression(expr);
+    return interval.getNextDate();
+  } catch (error) {
+    console.error("Invalid cron expression:", expr, error);
+    throw new Error("Invalid cron expression");
+  }
+}
+
+class Scheduler {
+  constructor() {
+    this.registry = JobRegistry.instance;
+    this.alarm = new AlarmAdapter();
+    this.timeout = new TimeoutAdapter();
+    console.log("Scheduler initialized");
+    this.alarm.onTrigger(this.execute.bind(this));
+    this.timeout.onTrigger(this.execute.bind(this));
+  }
+  schedule(id, options) {
+    const context = this.registry.getContext(id);
+    if (!context || context.isStopped()) {
+      console.log(`Job ${id} is stopped, skipping schedule`);
+      return;
+    }
+    console.log(`Scheduling job ${id} with options:`, options);
+    const when = this.getScheduleTime(options);
+    const adapter = when - Date.now() < 6e4 ? this.timeout : this.alarm;
+    const timerId = adapter.schedule(id, when);
+    if (adapter === this.timeout) {
+      this.registry.setTimeoutId(id, timerId);
+    }
+  }
+  pause(id) {
+    console.log(`Pausing job ${id}`);
+    this.registry.pause(id);
+  }
+  resume(id) {
+    console.log(`Resuming job ${id}`);
+    this.registry.resume(id);
+    const options = this.registry.meta(id);
+    if (options) {
+      this.schedule(id, options);
+    }
+  }
+  stop(id) {
+    console.log(`Stopping job ${id}`);
+    this.registry.stop(id);
+  }
+  async execute(id) {
+    const job = this.registry.resolve(id);
+    const context = this.registry.getContext(id);
+    if (!job || !context) {
+      console.log(`Job ${id} not found or no context`);
+      return;
+    }
+    if (context.isPaused() || context.isStopped()) {
+      console.log(`Job ${id} is paused or stopped, skipping execution`);
+      return;
+    }
+    try {
+      this.registry.updateState(id, JobState.RUNNING);
+      console.log(`Executing job ${id}`);
+      const jobInstance = container.get(id);
+      console.log(jobInstance);
+      await jobInstance.handle.bind(jobInstance).call(jobInstance, context);
+      if (!context.isStopped() && !context.isPaused()) {
+        this.registry.updateState(id, JobState.COMPLETED);
+        const options = this.registry.meta(id);
+        if (options?.cron) {
+          this.registry.updateState(id, JobState.SCHEDULED);
+          this.schedule(id, options);
+        }
+      }
+    } catch (error) {
+      console.error(`Job ${id} execution failed:`, error);
+      context.fail(error);
+    }
+  }
+  getScheduleTime(options) {
+    if (options.delay) return Date.now() + options.delay;
+    if (options.cron) {
+      const date = getNextCronDate(options.cron);
+      if (!date) {
+        throw new Error("Invalid cron expression");
+      }
+      return date.getTime();
+    }
+    return Date.now();
+  }
+  // Public API for job control
+  getJobState(id) {
+    return this.registry.getContext(id)?.state;
+  }
+  listJobs() {
+    const jobs = [];
+    return jobs;
+  }
+}
+
+class ApplicationBootstrap {
+  constructor() {
+    this.serviceDependencies = /* @__PURE__ */ new Map();
+    this.serviceRegistry = /* @__PURE__ */ new Map();
+    this.logger = new BootstrapLogger();
+    this.storeDefinitions = [];
+  }
+  /**
+   * Add a store definition to be initialized
+   */
+  withStore(storeDefinition) {
+    if (storeDefinition && storeDefinition.def && storeDefinition.store) {
+      this.storeDefinitions.push(storeDefinition);
+    }
+    return this;
+  }
+  /**
+   * Add multiple store definitions to be initialized
+   */
+  withStores(storeDefinitions) {
+    storeDefinitions.forEach((store) => this.withStore(store));
+    return this;
+  }
+  /**
+   * Create and initialize a new Chroma application instance
+   */
+  async create({
+    keepPortAlive = false,
+    portName,
+    enableLogs = true
+  }) {
+    try {
+      this.logger = new BootstrapLogger(enableLogs);
+      this.logger.info("\u{1F680} Starting Chroma application bootstrap...");
+      await this.discoverAndInitializeStores();
+      await this.discoverServices();
+      this.analyzeDependencies();
+      await this.registerMessages();
+      await this.registerJobs();
+      await this.bootMessages();
+      await this.bootServices();
+      this.logger.success("\u{1F389} Chroma application initialization complete!");
+      bootstrap$1({ container, keepAlive: keepPortAlive, portName });
+    } catch (error) {
+      this.logger.error("\u{1F4A5} Application bootstrap failed:", error);
+      throw error;
+    }
+  }
+  /**
+   * Boot all registered services by calling their onBoot method if present
+   */
+  async bootServices() {
+    this.logger.info("\u{1F680} Booting services...");
+    console.log("services", this.serviceRegistry.entries());
+    for (const [serviceName, ServiceClass] of this.serviceRegistry.entries()) {
+      try {
+        const instance = container.get(ServiceClass);
+        if (typeof instance.onBoot === "function") {
+          await instance.onBoot();
+          this.logger.success(`Booted service: ${serviceName}`);
+        }
+      } catch (error) {
+        this.logger.error(`Failed to boot service ${serviceName}:`, error);
+      }
+    }
+  }
+  /**
+   * Discover all services in the application directory
+   */
+  async discoverServices() {
+    this.logger.info("\u{1F50D} Discovering services...");
+    const serviceModules = undefined(
+      "/src/app/services/**/*.service.{ts,js}",
+      { eager: true }
+    );
+    const serviceClasses = [];
+    for (const module of Object.values(serviceModules)) {
+      const ServiceClass = module?.default;
+      if (ServiceClass) {
+        serviceClasses.push(ServiceClass);
+        this.serviceRegistry.set(ServiceClass.name, ServiceClass);
+      }
+    }
+    const circularDepsResult = this.detectCircularDependencies(serviceClasses);
+    if (circularDepsResult.hasCircularDependencies) {
+      this.logger.error("\u{1F4A5} Circular dependencies detected!");
+      circularDepsResult.cycles.forEach((cycle, index) => {
+        this.logger.error(`Cycle ${index + 1}: ${cycle.cycle.join(" \u2192 ")} \u2192 ${cycle.cycle[0]}`);
+      });
+      throw new Error(`Circular dependencies found. Cannot initialize services.`);
+    }
+    for (const ServiceClass of serviceClasses) {
+      container.bind(ServiceClass).toSelf().inSingletonScope();
+      this.logger.debug(`\u{1F4E6} Discovered service: ${ServiceClass.name}`);
+    }
+    this.logger.success(
+      `\u2705 Registered ${serviceClasses.length} services without circular dependencies`
+    );
+  }
+  /**
+   * Detect circular dependencies in service classes using reflection
+   * Enhanced: logs all detected dependencies for debugging
+   */
+  detectCircularDependencies(serviceClasses) {
+    const dependencyGraph = /* @__PURE__ */ new Map();
+    for (const ServiceClass of serviceClasses) {
+      const dependencies = this.extractDependencies(ServiceClass);
+      this.logger.debug(`[DependencyDetection] ${ServiceClass.name} dependencies:`, {
+        dependencies: dependencies.map(
+          (dep) => typeof dep === "function" ? dep.name : typeof dep === "string" ? dep : dep?.toString()
+        )
+      });
+      const dependencyNames = dependencies.map(
+        (dep) => typeof dep === "function" ? dep.name : typeof dep === "string" ? dep : dep?.toString()
+      );
+      dependencyGraph.set(ServiceClass.name, {
+        service: ServiceClass.name,
+        dependencies: dependencyNames,
+        constructor: ServiceClass
+      });
+    }
+    const cycles = [];
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const currentPath = [];
+    for (const serviceName of dependencyGraph.keys()) {
+      if (!visited.has(serviceName)) {
+        this.detectCycles(
+          serviceName,
+          dependencyGraph,
+          visited,
+          recursionStack,
+          currentPath,
+          cycles
+        );
+      }
+    }
+    return {
+      hasCircularDependencies: cycles.length > 0,
+      cycles,
+      dependencyGraph
+    };
+  }
+  /**
+   * Extract dependencies from constructor using reflect-metadata
+   * Fallback: parse constructor parameter names if metadata is missing
+   */
+  extractDependencies(ServiceClass) {
+    try {
+      const paramTypes = Reflect.getMetadata("design:paramtypes", ServiceClass) || [];
+      const injectMetadata = Reflect.getMetadata("inversify:tagged", ServiceClass) || /* @__PURE__ */ new Map();
+      const dependencies = [];
+      for (let i = 0; i < paramTypes.length; i++) {
+        const paramType = paramTypes[i];
+        const paramMetadata = injectMetadata.get(i);
+        if (paramMetadata && paramMetadata.length > 0) {
+          const injectTag = paramMetadata.find((tag) => tag.key === "inject");
+          if (injectTag) {
+            dependencies.push(injectTag.value);
+          } else {
+            dependencies.push(paramType);
+          }
+        } else {
+          dependencies.push(paramType);
+        }
+      }
+      if (dependencies.length === 0) {
+        const paramNames = this.getConstructorParamNames(ServiceClass);
+        this.logger.debug(
+          `[DependencyDetection:FALLBACK] ${ServiceClass.name} constructor param names:`,
+          { paramNames }
+        );
+        return paramNames;
+      }
+      return dependencies.filter((dep) => dep && dep !== Object);
+    } catch (error) {
+      this.logger.debug(`Could not extract dependencies for ${ServiceClass.name}: ${error}`);
+      return [];
+    }
+  }
+  /**
+   * Fallback: Parse constructor parameter names from function source
+   */
+  getConstructorParamNames(ServiceClass) {
+    const constructor = ServiceClass.prototype.constructor;
+    const src = constructor.toString();
+    const match = src.match(/constructor\s*\(([^)]*)\)/);
+    if (!match) return [];
+    const params = match[1].split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+    return params;
+  }
+  /**
+   * Perform DFS to detect cycles in dependency graph
+   */
+  detectCycles(serviceName, graph, visited, recursionStack, currentPath, cycles) {
+    visited.add(serviceName);
+    recursionStack.add(serviceName);
+    currentPath.push(serviceName);
+    const node = graph.get(serviceName);
+    if (!node) {
+      recursionStack.delete(serviceName);
+      currentPath.pop();
+      return;
+    }
+    for (const dependency of node.dependencies) {
+      if (!graph.has(dependency)) {
+        continue;
+      }
+      if (!visited.has(dependency)) {
+        this.detectCycles(dependency, graph, visited, recursionStack, currentPath, cycles);
+      } else if (recursionStack.has(dependency)) {
+        const cycleStartIndex = currentPath.indexOf(dependency);
+        const cycle = currentPath.slice(cycleStartIndex);
+        cycles.push({
+          cycle: [...cycle],
+          services: [...currentPath]
+        });
+      }
+    }
+    recursionStack.delete(serviceName);
+    currentPath.pop();
+  }
+  /**
+   * Debug method to visualize the dependency graph
+   */
+  analyzeDependencies() {
+    const serviceClasses = Array.from(this.serviceRegistry.values());
+    const result = this.detectCircularDependencies(serviceClasses);
+    this.logger.info("\u{1F4CA} Dependency Analysis Report:");
+    this.logger.info(`Total Services: ${result.dependencyGraph.size}`);
+    if (result.hasCircularDependencies) {
+      this.logger.error(`\u{1F504} Circular Dependencies Found: ${result.cycles.length}`);
+      result.cycles.forEach((cycle, index) => {
+        this.logger.error(`  Cycle ${index + 1}: ${cycle.cycle.join(" \u2192 ")} \u2192 ${cycle.cycle[0]}`);
+      });
+    } else {
+      this.logger.success("\u2705 No circular dependencies detected");
+    }
+    this.logger.info("\u{1F333} Service Dependency Tree:");
+    for (const [serviceName, node] of result.dependencyGraph) {
+      if (node.dependencies.length > 0) {
+        this.logger.info(`  ${serviceName} depends on:`);
+        node.dependencies.forEach((dep) => {
+          this.logger.info(`    - ${dep}`);
+        });
+      } else {
+        this.logger.info(`  ${serviceName} (no dependencies)`);
+      }
+    }
+  }
+  /**
+   * Initialize stores from provided definitions
+   */
+  async discoverAndInitializeStores() {
+    try {
+      if (this.storeDefinitions.length === 0) {
+        this.logger.debug("\u{1F4ED} No store definitions provided");
+        return;
+      }
+      this.logger.info(`Initializing ${this.storeDefinitions.length} store(s)...`);
+      let isFirstStore = true;
+      for (const store of this.storeDefinitions) {
+        const diKey = `CentralStore:${store.def.name}`;
+        const storeInstance = store.store;
+        const classes = store.classes;
+        container.bind(diKey).toConstantValue(storeInstance);
+        if (isFirstStore) {
+          container.bind(Symbol.for("Store")).toConstantValue(storeInstance);
+          isFirstStore = false;
+        }
+        this.registerMessageClass(classes.GetStoreStateMessage, `store:${store.def.name}:getState`);
+        this.registerMessageClass(classes.SetStoreStateMessage, `store:${store.def.name}:setState`);
+        this.registerMessageClass(
+          classes.SubscribeToStoreMessage,
+          `store:${store.def.name}:subscribe`
+        );
+        this.logger.debug(`\u2705 Initialized store: ${store.def.name}`);
+      }
+      this.logger.success(`\u2705 Initialized ${this.storeDefinitions.length} store(s)`);
+    } catch (error) {
+      this.logger.error("\u274C Failed to initialize stores:", error);
+    }
+  }
+  /**
+   * Register message handlers
+   */
+  async registerMessages() {
+    this.logger.info("\u{1F4E8} Registering messages...");
+    const messageModules = undefined(
+      "/src/app/messages/**/*.message.{ts,js}",
+      { eager: true }
+    );
+    const messageClasses = [];
+    for (const module of Object.values(messageModules)) {
+      const MessageClass = module?.default;
+      if (MessageClass) messageClasses.push(MessageClass);
+    }
+    if (messageClasses.length > 0) {
+      const circularDepsResult = this.detectCircularDependencies(messageClasses);
+      if (circularDepsResult.hasCircularDependencies) {
+        this.logger.error("\u{1F4A5} Circular dependencies detected in messages!");
+        circularDepsResult.cycles.forEach((cycle, index) => {
+          this.logger.error(
+            `Message Cycle ${index + 1}: ${cycle.cycle.join(" \u2192 ")} \u2192 ${cycle.cycle[0]}`
+          );
+        });
+        throw new Error(`Circular dependencies found in messages. Cannot register messages.`);
+      }
+    }
+    for (const module of Object.values(messageModules)) {
+      const MessageClass = module?.default;
+      if (!MessageClass) continue;
+      try {
+        for (const [name, ServiceClass] of this.serviceRegistry) {
+          if (!ServiceClass) {
+            this.logger.warn(`\u26A0\uFE0F Service not found in registry: ${name}`);
+          }
+          if (!container.isBound(ServiceClass)) {
+            this.logger.warn(`\u26A0\uFE0F Service not bound in container: ${name}`);
+          }
+        }
+        const messageMetadata = Reflect.getMetadata("name", MessageClass);
+        const messageName = messageMetadata || MessageClass.name;
+        container.bind(messageName).to(MessageClass).inSingletonScope();
+        this.logger.success(`\u2705 Registered message: ${messageName}`);
+      } catch (error) {
+        this.logger.error(`\u274C Failed to register message ${MessageClass.name}:`, error);
+      }
+    }
+  }
+  async registerMessageClass(MessageClass, name) {
+    container.bind(name).to(MessageClass).inSingletonScope();
+    this.logger.success(`\u2705 Registered message: ${name}`);
+  }
+  /**
+   * Boot all registered messages
+   */
+  async bootMessages() {
+    this.logger.info("\u{1F680} Booting messages...");
+    const messageModules = undefined(
+      "/src/app/messages/**/*.message.{ts,js}",
+      { eager: true }
+    );
+    for (const module of Object.values(messageModules)) {
+      const MessageClass = module?.default;
+      if (!MessageClass || typeof MessageClass.prototype.boot !== "function") continue;
+      try {
+        const messageMetadata = Reflect.getMetadata("name", MessageClass);
+        const messageName = messageMetadata || MessageClass.name;
+        const messageInstance = container.get(messageName);
+        await messageInstance.boot();
+        this.logger.success(`\u2705 Booted message: ${messageName}`);
+      } catch (error) {
+        this.logger.error(`\u274C Failed to boot message ${MessageClass.name}:`, error);
+      }
+    }
+  }
+  /**
+   * Register jobs for scheduled execution
+   */
+  async registerJobs() {
+    this.logger.info("\u{1F552} Registering jobs...");
+    const jobModules = undefined(
+      "/src/app/jobs/**/*.job.{ts,js}",
+      { eager: true }
+    );
+    if (!container.isBound(Scheduler)) {
+      container.bind(Scheduler).toSelf().inSingletonScope();
+    }
+    console.log("container isBound(Scheduler)", container.isBound(Scheduler));
+    for (const [name, ServiceClass] of this.serviceRegistry) {
+      if (!ServiceClass) {
+        this.logger.warn(`\u26A0\uFE0F Service not found in registry: ${name}`);
+      }
+      if (!container.isBound(ServiceClass)) {
+        this.logger.warn(`\u26A0\uFE0F Service not bound in container: ${name}`);
+      } else {
+        container.get(ServiceClass);
+        console.log("got service", name);
+      }
+    }
+    this.scheduler = container.get(Scheduler);
+    for (const module of Object.values(jobModules)) {
+      const JobClass = module?.default;
+      if (!JobClass) continue;
+      try {
+        const jobMetadata = Reflect.getMetadata("name", JobClass);
+        const jobName = jobMetadata || JobClass.name;
+        container.bind(JobClass).toSelf().inSingletonScope();
+        const id = `${jobName.toLowerCase()}:${JobClass.name.toLowerCase()} ${Math.random().toString(36).substring(2, 15)}`;
+        container.bind(id).to(JobClass).inSingletonScope();
+        const options = Reflect.getMetadata("job:options", JobClass) || {};
+        const instance = container.get(JobClass);
+        JobRegistry.instance.register(id, instance, options);
+        this.scheduler.schedule(id, options);
+        this.logger.success(`\u2705 Registered job: ${jobName}`);
+      } catch (error) {
+        this.logger.error(`\u274C Failed to register job ${JobClass.name}:`, error);
+      }
+    }
+  }
+}
+class BootstrapLogger {
+  constructor(enableLogs = true) {
+    this.enableLogs = enableLogs;
+  }
+  info(message, context) {
+    if (!this.enableLogs) return;
+    console.log(message);
+    if (context) console.log("  ", context);
+  }
+  success(message) {
+    if (!this.enableLogs) return;
+    console.log(message);
+  }
+  warn(message) {
+    if (!this.enableLogs) return;
+    console.warn(message);
+  }
+  error(message, error) {
+    if (!this.enableLogs) return;
+    console.error(message);
+    if (error) console.error("  ", error);
+  }
+  debug(message, context) {
+    if (!this.enableLogs) return;
+    console.debug(message);
+    if (context) console.debug("  ", context);
+  }
+  divider() {
+    if (!this.enableLogs) return;
+    console.log("=".repeat(50));
+  }
+}
+async function create({
+  keepPortAlive = false,
+  portName,
+  enableLogs = true
+} = {}) {
+  const bootstrap2 = new ApplicationBootstrap();
+  await bootstrap2.create({
+    keepPortAlive,
+    portName,
+    enableLogs
+  });
+}
+function bootstrap() {
+  return new BootstrapBuilder();
+}
+class BootstrapBuilder {
+  constructor() {
+    this.app = new ApplicationBootstrap();
+  }
+  /**
+   * Add a store definition to be initialized
+   */
+  withStore(storeDefinition) {
+    this.app.withStore(storeDefinition);
+    return this;
+  }
+  /**
+   * Add multiple store definitions to be initialized
+   */
+  withStores(storeDefinitions) {
+    this.app.withStores(storeDefinitions);
+    return this;
+  }
+  /**
+   * Create and start the application
+   */
+  async create({
+    keepPortAlive = false,
+    portName,
+    enableLogs = true
+  } = {}) {
+    await this.app.create({ keepPortAlive, portName, enableLogs });
+  }
+}
+
+exports.JobState = JobState;
+exports.bootstrap = bootstrap;
+exports.container = container;
+exports.create = create;
+//# sourceMappingURL=boot-Dl66KPJQ.js.map