hyper-scheduler 1.0.0 → 1.0.1

package/dist/index.js

@@ -0,0 +1,995 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const TaskStatus = {
+  IDLE: "idle",
+  RUNNING: "running",
+  STOPPED: "stopped",
+  ERROR: "error"
+};
+const SchedulerEvents = {
+  TASK_REGISTERED: "task_registered",
+  TASK_STARTED: "task_started",
+  TASK_COMPLETED: "task_completed",
+  TASK_FAILED: "task_failed",
+  TASK_STOPPED: "task_stopped",
+  TASK_REMOVED: "task_removed",
+  TASK_UPDATED: "task_updated",
+  SCHEDULER_STARTED: "scheduler_started",
+  SCHEDULER_STOPPED: "scheduler_stopped"
+};
+class TaskRegistry {
+  constructor() {
+    __publicField(this, "tasks");
+    this.tasks = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 注册一个新任务。
+   * @param task 任务对象
+   * @throws Error 如果 ID 已存在
+   */
+  addTask(task) {
+    if (this.tasks.has(task.id)) {
+      throw new Error(`Task with ID "${task.id}" already exists.`);
+    }
+    this.tasks.set(task.id, task);
+  }
+  /**
+   * 根据 ID 获取任务。
+   * @param id 任务 ID
+   * @returns 任务对象或 undefined
+   */
+  getTask(id) {
+    return this.tasks.get(id);
+  }
+  /**
+   * 删除任务。
+   * @param id 任务 ID
+   * @returns 是否删除成功
+   */
+  deleteTask(id) {
+    return this.tasks.delete(id);
+  }
+  /**
+   * 获取所有已注册的任务。
+   * @returns 任务数组
+   */
+  getAllTasks() {
+    return Array.from(this.tasks.values());
+  }
+  /**
+   * 清空所有任务。
+   */
+  clear() {
+    this.tasks.clear();
+  }
+}
+function validateId(id) {
+  if (!id || typeof id !== "string" || id.trim() === "") {
+    throw new Error("Task ID must be a non-empty string.");
+  }
+}
+function parseField(field, min, max) {
+  const values = /* @__PURE__ */ new Set();
+  if (field === "*") {
+    for (let i = min; i <= max; i++) {
+      values.add(i);
+    }
+    return Array.from(values).sort((a, b) => a - b);
+  }
+  const parts = field.split(",");
+  for (const part of parts) {
+    if (part.includes("/")) {
+      const [range, step] = part.split("/");
+      const stepNum = parseInt(step, 10);
+      if (range === "*") {
+        for (let i = min; i <= max; i += stepNum) {
+          values.add(i);
+        }
+      } else if (range.includes("-")) {
+        const [start, end] = range.split("-").map(Number);
+        if (start < min || end > max) {
+          throw new Error(`Value out of range: ${start}-${end} (expected ${min}-${max})`);
+        }
+        for (let i = start; i <= end; i += stepNum) {
+          values.add(i);
+        }
+      } else {
+        const start = parseInt(range, 10);
+        if (start < min || start > max) {
+          throw new Error(`Value out of range: ${start} (expected ${min}-${max})`);
+        }
+        for (let i = start; i <= max; i += stepNum) {
+          values.add(i);
+        }
+      }
+    } else if (part.includes("-")) {
+      const [start, end] = part.split("-").map(Number);
+      if (start < min || end > max) {
+        throw new Error(`Value out of range: ${start}-${end} (expected ${min}-${max})`);
+      }
+      for (let i = start; i <= end; i++) {
+        values.add(i);
+      }
+    } else {
+      const val = parseInt(part, 10);
+      if (val < min || val > max) {
+        throw new Error(`Value out of range: ${val} (expected ${min}-${max})`);
+      }
+      values.add(val);
+    }
+  }
+  return Array.from(values).sort((a, b) => a - b);
+}
+function parseCronExpression(expression) {
+  const parts = expression.trim().split(/\s+/);
+  let second, minute, hour, dayOfMonth, month, dayOfWeek;
+  if (parts.length === 5) {
+    second = [0];
+    [minute, hour, dayOfMonth, month, dayOfWeek] = [
+      parseField(parts[0], 0, 59),
+      parseField(parts[1], 0, 23),
+      parseField(parts[2], 1, 31),
+      parseField(parts[3], 1, 12),
+      parseField(parts[4], 0, 6)
+    ];
+  } else if (parts.length === 6) {
+    [second, minute, hour, dayOfMonth, month, dayOfWeek] = [
+      parseField(parts[0], 0, 59),
+      parseField(parts[1], 0, 59),
+      parseField(parts[2], 0, 23),
+      parseField(parts[3], 1, 31),
+      parseField(parts[4], 1, 12),
+      parseField(parts[5], 0, 6)
+    ];
+  } else {
+    throw new Error(`Invalid cron expression: expected 5 or 6 fields, got ${parts.length}`);
+  }
+  return { second, minute, hour, dayOfMonth, month, dayOfWeek };
+}
+function validateCron(expression) {
+  try {
+    parseCronExpression(expression);
+  } catch (err) {
+    throw new Error(`Invalid cron expression: ${expression}`);
+  }
+}
+function matchesCron(date, fields) {
+  const second = date.getSeconds();
+  const minute = date.getMinutes();
+  const hour = date.getHours();
+  const dayOfMonth = date.getDate();
+  const month = date.getMonth() + 1;
+  const dayOfWeek = date.getDay();
+  return fields.second.includes(second) && fields.minute.includes(minute) && fields.hour.includes(hour) && fields.month.includes(month) && (fields.dayOfMonth.includes(dayOfMonth) || fields.dayOfWeek.includes(dayOfWeek));
+}
+function getNextRun$1(expression, _timezone) {
+  const fields = parseCronExpression(expression);
+  const now = /* @__PURE__ */ new Date();
+  let candidate = new Date(now.getTime() + 1e3);
+  candidate.setMilliseconds(0);
+  const maxIterations = 4 * 365 * 24 * 60 * 60;
+  let iterations = 0;
+  while (iterations < maxIterations) {
+    if (matchesCron(candidate, fields)) {
+      return candidate;
+    }
+    const second = candidate.getSeconds();
+    const minute = candidate.getMinutes();
+    const hour = candidate.getHours();
+    if (!fields.second.includes(second)) {
+      const nextSecond = fields.second.find((s) => s > second) ?? fields.second[0];
+      if (nextSecond > second) {
+        candidate.setSeconds(nextSecond);
+      } else {
+        candidate.setMinutes(minute + 1, nextSecond);
+      }
+      candidate.setMilliseconds(0);
+      iterations++;
+      continue;
+    }
+    if (!fields.minute.includes(minute)) {
+      const nextMinute = fields.minute.find((m) => m > minute) ?? fields.minute[0];
+      if (nextMinute > minute) {
+        candidate.setMinutes(nextMinute, fields.second[0]);
+      } else {
+        candidate.setHours(hour + 1, nextMinute, fields.second[0]);
+      }
+      candidate.setMilliseconds(0);
+      iterations++;
+      continue;
+    }
+    if (!fields.hour.includes(hour)) {
+      const nextHour = fields.hour.find((h) => h > hour) ?? fields.hour[0];
+      if (nextHour > hour) {
+        candidate.setHours(nextHour, fields.minute[0], fields.second[0]);
+      } else {
+        candidate.setDate(candidate.getDate() + 1);
+        candidate.setHours(nextHour, fields.minute[0], fields.second[0]);
+      }
+      candidate.setMilliseconds(0);
+      iterations++;
+      continue;
+    }
+    candidate = new Date(candidate.getTime() + 1e3);
+    iterations++;
+  }
+  throw new Error(`Could not find next run time for cron expression: ${expression}`);
+}
+function parseSchedule(schedule) {
+  const intervalRegex = /^(\d+)(s|m|h|d)$/;
+  const match = schedule.match(intervalRegex);
+  if (match) {
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    let multiplier = 1e3;
+    switch (unit) {
+      case "s":
+        multiplier = 1e3;
+        break;
+      case "m":
+        multiplier = 60 * 1e3;
+        break;
+      case "h":
+        multiplier = 60 * 60 * 1e3;
+        break;
+      case "d":
+        multiplier = 24 * 60 * 60 * 1e3;
+        break;
+    }
+    return {
+      type: "interval",
+      value: value * multiplier
+    };
+  }
+  try {
+    validateCron(schedule);
+    return {
+      type: "cron",
+      value: schedule
+    };
+  } catch (err) {
+    throw new Error(`无效的调度格式: "${schedule}". 必须是有效的 Cron 表达式或间隔字符串 (例如 "10s")。`);
+  }
+}
+function getNextRun(schedule, options) {
+  let parsed;
+  if (typeof schedule === "string") {
+    parsed = parseSchedule(schedule);
+  } else {
+    parsed = schedule;
+  }
+  if (parsed.type === "interval") {
+    const intervalMs = parsed.value;
+    const lastRun = (options == null ? void 0 : options.lastRun) || Date.now();
+    return new Date(lastRun + intervalMs);
+  } else {
+    const cronExpression = parsed.value;
+    try {
+      return getNextRun$1(cronExpression, options == null ? void 0 : options.timezone);
+    } catch (err) {
+      throw new Error(`无法计算下一次 Cron 运行时间: ${cronExpression}`);
+    }
+  }
+}
+class RetryStrategy {
+  /**
+   * 计算下一次重试的延迟时间。
+   * 采用指数退避算法 (Exponential Backoff)。
+   * @param attempt 当前重试次数 (从 0 开始，0 表示第一次重试)
+   * @param options 任务的重试配置
+   * @returns 延迟毫秒数，如果超过最大尝试次数则返回 -1
+   */
+  static getDelay(attempt, options) {
+    if (!options) {
+      return -1;
+    }
+    const { maxAttempts, initialDelay, factor = 2 } = options;
+    if (attempt >= maxAttempts) {
+      return -1;
+    }
+    return initialDelay * Math.pow(factor, attempt);
+  }
+}
+let Scheduler$1 = class Scheduler {
+  /**
+   * 创建一个新的调度器实例。
+   * @param timerStrategy 默认计时策略（NodeTimer 或 BrowserTimer）
+   * @param config 调度器配置
+   * @param timerStrategyFactory 可选的定时器策略工厂，用于创建任务级别的定时器
+   */
+  constructor(timerStrategy, config = {}, timerStrategyFactory) {
+    __publicField(this, "registry");
+    __publicField(this, "config");
+    __publicField(this, "defaultTimerStrategy");
+    __publicField(this, "timerStrategyFactory");
+    __publicField(this, "taskTimerStrategies");
+    // Task ID -> TimerStrategy
+    __publicField(this, "running");
+    __publicField(this, "timers");
+    // Task ID -> Timer Handle
+    __publicField(this, "listeners");
+    __publicField(this, "eventListeners");
+    this.registry = new TaskRegistry();
+    this.defaultTimerStrategy = timerStrategy;
+    this.timerStrategyFactory = timerStrategyFactory;
+    this.taskTimerStrategies = /* @__PURE__ */ new Map();
+    this.config = {
+      debug: false,
+      maxHistory: 50,
+      ...config
+    };
+    this.running = false;
+    this.timers = /* @__PURE__ */ new Map();
+    this.listeners = [];
+    this.eventListeners = /* @__PURE__ */ new Map();
+    if (this.config.plugins && Array.isArray(this.config.plugins)) {
+      this.config.plugins.forEach((plugin) => {
+        try {
+          this.log(`Initializing plugin: ${plugin.name}`);
+          plugin.init(this);
+        } catch (err) {
+          console.warn(`[HyperScheduler] Failed to initialize plugin ${plugin.name}:`, err);
+        }
+      });
+    }
+  }
+  /**
+   * 订阅任务列表变更事件。
+   * 当任务创建、状态改变或删除时触发。
+   * @param listener 回调函数
+   * @returns 取消订阅的函数
+   */
+  subscribe(listener) {
+    this.listeners.push(listener);
+    return () => {
+      this.listeners = this.listeners.filter((l) => l !== listener);
+    };
+  }
+  /**
+   * 订阅特定事件
+   * @param event 事件名称
+   * @param handler 事件处理函数
+   * @returns 取消订阅的函数
+   */
+  on(event, handler) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(handler);
+    return () => {
+      var _a;
+      (_a = this.eventListeners.get(event)) == null ? void 0 : _a.delete(handler);
+    };
+  }
+  emit(event, payload) {
+    const handlers = this.eventListeners.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => handler(payload));
+    }
+  }
+  /**
+   * 获取任务的定时器策略
+   * 优先使用任务级别配置，其次使用全局配置，最后使用默认策略
+   */
+  getTimerStrategy(task) {
+    var _a;
+    const taskDriver = (_a = task.options) == null ? void 0 : _a.driver;
+    const globalDriver = this.config.driver;
+    const driver = taskDriver || globalDriver;
+    if (!driver || !this.timerStrategyFactory) {
+      return this.defaultTimerStrategy;
+    }
+    const cacheKey = `${task.id}_${driver}`;
+    if (this.taskTimerStrategies.has(cacheKey)) {
+      return this.taskTimerStrategies.get(cacheKey);
+    }
+    const strategy = this.timerStrategyFactory(driver);
+    this.taskTimerStrategies.set(cacheKey, strategy);
+    return strategy;
+  }
+  notify() {
+    if (this.listeners.length > 0) {
+      const tasks = this.registry.getAllTasks();
+      this.listeners.forEach((l) => l(tasks));
+    }
+  }
+  /**
+   * 创建并注册一个新任务。
+   * @param definition 任务定义
+   */
+  createTask(definition) {
+    validateId(definition.id);
+    parseSchedule(definition.schedule);
+    const task = {
+      ...definition,
+      tags: definition.tags || [],
+      // 新创建的任务默认是 stopped 状态，需要手动启动或等调度器启动
+      status: TaskStatus.STOPPED,
+      history: [],
+      executionCount: 0
+    };
+    this.registry.addTask(task);
+    this.log(`Task created: ${task.id}`);
+    this.emit(SchedulerEvents.TASK_REGISTERED, { taskId: task.id, task });
+    this.notify();
+    if (this.running) {
+      task.status = TaskStatus.IDLE;
+      this.scheduleTask(task);
+    }
+  }
+  /**
+   * 删除指定 ID 的任务。
+   * @param id 任务 ID
+   * @returns 如果删除成功返回 true，否则返回 false
+   */
+  deleteTask(id) {
+    this.stopTask(id);
+    const deleted = this.registry.deleteTask(id);
+    if (deleted) {
+      this.log(`Task deleted: ${id}`);
+      this.emit(SchedulerEvents.TASK_REMOVED, { taskId: id });
+      this.notify();
+    }
+    return deleted;
+  }
+  /**
+   * 手动启动一个任务（将其置为 idle 状态并重新加入调度）。
+   * 即使调度器未启动，也可以单独启动某个任务。
+   * @param id 任务 ID
+   */
+  startTask(id) {
+    const task = this.registry.getTask(id);
+    if (!task) {
+      throw new Error(`Task not found: ${id}`);
+    }
+    if (task.status === TaskStatus.RUNNING) {
+      return;
+    }
+    const existingHandle = this.timers.get(id);
+    if (existingHandle) {
+      this.getTimerStrategy(task).cancel(existingHandle);
+      this.timers.delete(id);
+    }
+    task.status = TaskStatus.IDLE;
+    this.log(`Starting task: ${id}`);
+    this.emit(SchedulerEvents.TASK_STARTED, { taskId: id, task });
+    this.notify();
+    this.scheduleTaskForce(task);
+  }
+  /**
+   * 强制调度任务，即使调度器未启动
+   */
+  scheduleTaskForce(task) {
+    var _a;
+    try {
+      const nextRun = getNextRun(task.schedule, {
+        timezone: ((_a = task.options) == null ? void 0 : _a.timezone) || this.config.timezone,
+        lastRun: task.lastRun
+      });
+      task.nextRun = nextRun.getTime();
+      const now = Date.now();
+      const delay = Math.max(0, nextRun.getTime() - now);
+      this.log(`Scheduling task ${task.id} for ${nextRun.toISOString()} (in ${delay}ms)`);
+      const timerStrategy = this.getTimerStrategy(task);
+      const handle = timerStrategy.schedule(() => {
+        this.executeTaskIndividual(task);
+      }, delay);
+      this.timers.set(task.id, handle);
+    } catch (err) {
+      this.log(`Error scheduling task ${task.id}: ${err}`);
+      task.status = TaskStatus.ERROR;
+      this.notify();
+    }
+  }
+  /**
+   * 执行单个任务（用于独立启动的任务）
+   */
+  async executeTaskIndividual(task, attempt = 0) {
+    var _a, _b;
+    this.timers.delete(task.id);
+    if (task.status === TaskStatus.STOPPED) return;
+    task.status = TaskStatus.RUNNING;
+    task.lastRun = Date.now();
+    task.executionCount = (task.executionCount || 0) + 1;
+    const startTime = Date.now();
+    this.log(`Executing task: ${task.id} (Attempt ${attempt})`);
+    this.emit(SchedulerEvents.TASK_STARTED, { taskId: task.id, task });
+    this.notify();
+    try {
+      await task.handler();
+      const duration = Date.now() - startTime;
+      this.recordHistory(task, {
+        timestamp: startTime,
+        duration,
+        success: true
+      });
+      task.status = TaskStatus.IDLE;
+      this.log(`Task execution success: ${task.id}`);
+      this.emit(SchedulerEvents.TASK_COMPLETED, { taskId: task.id, task, duration });
+      this.notify();
+      this.scheduleTaskForce(task);
+    } catch (err) {
+      const duration = Date.now() - startTime;
+      this.recordHistory(task, {
+        timestamp: startTime,
+        duration,
+        success: false,
+        error: err.message
+      });
+      this.log(`Task execution failed: ${task.id} - ${err.message}`);
+      this.emit(SchedulerEvents.TASK_FAILED, { taskId: task.id, task, error: err.message, duration });
+      if ((_a = task.options) == null ? void 0 : _a.onError) {
+        try {
+          task.options.onError(err, task.id);
+        } catch (e) {
+          this.log(`onError callback failed: ${e}`);
+        }
+      }
+      const retryDelay = RetryStrategy.getDelay(attempt, (_b = task.options) == null ? void 0 : _b.retry);
+      if (retryDelay >= 0) {
+        this.log(`Retrying task ${task.id} in ${retryDelay}ms (Attempt ${attempt + 1})`);
+        const timerStrategy = this.getTimerStrategy(task);
+        const handle = timerStrategy.schedule(() => {
+          this.executeTaskIndividual(task, attempt + 1);
+        }, retryDelay);
+        this.timers.set(task.id, handle);
+        task.status = TaskStatus.ERROR;
+        this.notify();
+      } else {
+        task.status = TaskStatus.ERROR;
+        this.notify();
+        this.scheduleTaskForce(task);
+      }
+    }
+  }
+  /**
+   * 停止一个任务（取消当前的定时器并标记为 stopped）。
+   * @param id 任务 ID
+   */
+  stopTask(id) {
+    const task = this.registry.getTask(id);
+    const handle = this.timers.get(id);
+    if (handle && task) {
+      this.getTimerStrategy(task).cancel(handle);
+      this.timers.delete(id);
+    } else if (handle) {
+      this.defaultTimerStrategy.cancel(handle);
+      this.timers.delete(id);
+    }
+    if (task) {
+      task.status = TaskStatus.STOPPED;
+      this.log(`Task stopped: ${id}`);
+      this.emit(SchedulerEvents.TASK_STOPPED, { taskId: id, task });
+      this.notify();
+    }
+  }
+  /**
+   * 获取任务信息。
+   * @param id 任务 ID
+   */
+  getTask(id) {
+    return this.registry.getTask(id);
+  }
+  /**
+   * 获取所有任务。
+   */
+  getAllTasks() {
+    return this.registry.getAllTasks();
+  }
+  /**
+   * 获取调度器运行状态。
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * 获取任务的实际驱动方式。
+   * 优先使用任务级配置，其次使用全局配置，默认为 'worker'。
+   */
+  getTaskDriver(id) {
+    var _a;
+    const task = this.registry.getTask(id);
+    if (!task) return this.config.driver || "worker";
+    return ((_a = task.options) == null ? void 0 : _a.driver) || this.config.driver || "worker";
+  }
+  /**
+   * 获取全局驱动配置。
+   */
+  getGlobalDriver() {
+    return this.config.driver || "worker";
+  }
+  /**
+   * 手动触发任务执行（忽略调度器状态，立即执行一次）。
+   * 执行完成后恢复到之前的状态。
+   * @param id 任务 ID
+   */
+  async triggerTask(id) {
+    const task = this.getTask(id);
+    if (!task) return;
+    if (task.status === TaskStatus.RUNNING) return;
+    const previousStatus = task.status;
+    task.status = TaskStatus.RUNNING;
+    task.lastRun = Date.now();
+    task.executionCount = (task.executionCount || 0) + 1;
+    const startTime = Date.now();
+    this.log(`Triggering task: ${task.id}`);
+    this.emit(SchedulerEvents.TASK_STARTED, { taskId: task.id, task });
+    this.notify();
+    try {
+      await task.handler();
+      const duration = Date.now() - startTime;
+      this.recordHistory(task, {
+        timestamp: startTime,
+        duration,
+        success: true
+      });
+      task.status = previousStatus;
+      this.log(`Task trigger success: ${task.id}`);
+      this.emit(SchedulerEvents.TASK_COMPLETED, { taskId: task.id, task, duration });
+      this.notify();
+    } catch (err) {
+      const duration = Date.now() - startTime;
+      this.recordHistory(task, {
+        timestamp: startTime,
+        duration,
+        success: false,
+        error: err.message
+      });
+      this.log(`Task trigger failed: ${task.id} - ${err.message}`);
+      this.emit(SchedulerEvents.TASK_FAILED, { taskId: task.id, task, error: err.message, duration });
+      task.status = previousStatus;
+      this.notify();
+    }
+  }
+  /**
+   * 启动调度器。
+   * 开始处理所有任务（除了手动停止的任务）。
+   */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.log("Scheduler started");
+    this.emit(SchedulerEvents.SCHEDULER_STARTED, { running: true });
+    this.registry.getAllTasks().forEach((task) => {
+      if (task.status === TaskStatus.STOPPED) {
+        task.status = TaskStatus.IDLE;
+        this.emit(SchedulerEvents.TASK_UPDATED, { taskId: task.id, task });
+      }
+      if (task.status !== TaskStatus.RUNNING) {
+        this.scheduleTask(task);
+      }
+    });
+    this.notify();
+  }
+  /**
+   * 停止调度器。
+   * 取消所有正在等待的定时器。
+   */
+  stop() {
+    this.running = false;
+    this.log("Scheduler stopped");
+    this.emit(SchedulerEvents.SCHEDULER_STOPPED, { running: false });
+    this.timers.forEach((handle, taskId) => {
+      const task = this.registry.getTask(taskId);
+      if (task) {
+        this.getTimerStrategy(task).cancel(handle);
+      } else {
+        this.defaultTimerStrategy.cancel(handle);
+      }
+    });
+    this.timers.clear();
+    this.registry.getAllTasks().forEach((task) => {
+      if (task.status !== TaskStatus.STOPPED) {
+        task.status = TaskStatus.STOPPED;
+        this.emit(SchedulerEvents.TASK_UPDATED, { taskId: task.id, task });
+      }
+    });
+    this.notify();
+  }
+  scheduleTask(task) {
+    var _a;
+    if (!this.running && task.status !== TaskStatus.RUNNING) return;
+    try {
+      const nextRun = getNextRun(task.schedule, {
+        timezone: ((_a = task.options) == null ? void 0 : _a.timezone) || this.config.timezone,
+        lastRun: task.lastRun
+        // 对于 interval 任务，需要上次运行时间
+      });
+      task.nextRun = nextRun.getTime();
+      const now = Date.now();
+      const delay = Math.max(0, nextRun.getTime() - now);
+      this.log(`Scheduling task ${task.id} for ${nextRun.toISOString()} (in ${delay}ms)`);
+      const timerStrategy = this.getTimerStrategy(task);
+      const handle = timerStrategy.schedule(() => {
+        this.executeTask(task);
+      }, delay);
+      this.timers.set(task.id, handle);
+    } catch (err) {
+      this.log(`Error scheduling task ${task.id}: ${err}`);
+      task.status = TaskStatus.ERROR;
+    }
+  }
+  async executeTask(task, attempt = 0, force = false) {
+    var _a, _b;
+    this.timers.delete(task.id);
+    if (!force && (!this.running || task.status === TaskStatus.STOPPED)) return;
+    task.status = TaskStatus.RUNNING;
+    task.lastRun = Date.now();
+    task.executionCount = (task.executionCount || 0) + 1;
+    const startTime = Date.now();
+    this.log(`Executing task: ${task.id} (Attempt ${attempt})`);
+    this.emit(SchedulerEvents.TASK_STARTED, { taskId: task.id, task });
+    this.notify();
+    try {
+      await task.handler();
+      const duration = Date.now() - startTime;
+      this.recordHistory(task, {
+        timestamp: startTime,
+        duration,
+        success: true
+      });
+      task.status = TaskStatus.IDLE;
+      this.log(`Task execution success: ${task.id}`);
+      this.emit(SchedulerEvents.TASK_COMPLETED, { taskId: task.id, task, duration });
+      this.notify();
+      this.scheduleTask(task);
+    } catch (err) {
+      const duration = Date.now() - startTime;
+      this.recordHistory(task, {
+        timestamp: startTime,
+        duration,
+        success: false,
+        error: err.message
+      });
+      this.log(`Task execution failed: ${task.id} - ${err.message}`);
+      this.emit(SchedulerEvents.TASK_FAILED, { taskId: task.id, task, error: err.message, duration });
+      if ((_a = task.options) == null ? void 0 : _a.onError) {
+        try {
+          task.options.onError(err, task.id);
+        } catch (e) {
+          this.log(`onError callback failed: ${e}`);
+        }
+      }
+      const retryDelay = RetryStrategy.getDelay(attempt, (_b = task.options) == null ? void 0 : _b.retry);
+      if (retryDelay >= 0) {
+        this.log(`Retrying task ${task.id} in ${retryDelay}ms (Attempt ${attempt + 1})`);
+        const timerStrategy = this.getTimerStrategy(task);
+        const handle = timerStrategy.schedule(() => {
+          this.executeTask(task, attempt + 1);
+        }, retryDelay);
+        this.timers.set(task.id, handle);
+        task.status = TaskStatus.ERROR;
+        this.notify();
+      } else {
+        task.status = TaskStatus.ERROR;
+        this.notify();
+        this.scheduleTask(task);
+      }
+    }
+  }
+  recordHistory(task, record) {
+    task.history.unshift(record);
+    if (this.config.maxHistory && task.history.length > this.config.maxHistory) {
+      task.history.pop();
+    }
+  }
+  log(message) {
+    if (this.config.debug) {
+      console.log(`[HyperScheduler] ${message}`);
+    }
+  }
+};
+class NodeTimer {
+  schedule(callback, delay) {
+    return setTimeout(callback, delay);
+  }
+  cancel(handle) {
+    clearTimeout(handle);
+  }
+}
+const encodedJs = "IWZ1bmN0aW9uKCl7InVzZSBzdHJpY3QiO2NvbnN0IGU9bmV3IE1hcDtzZWxmLm9ubWVzc2FnZT1zPT57Y29uc3R7aWQ6dCxkZWxheTpjLHR5cGU6bH09cy5kYXRhO2lmKCJzY2hlZHVsZSI9PT1sKXtjb25zdCBzPXNlbGYuc2V0VGltZW91dCgoKT0+e3NlbGYucG9zdE1lc3NhZ2Uoe2lkOnQsdHlwZToidGljayJ9KSxlLmRlbGV0ZSh0KX0sYyk7ZS5zZXQodCxzKX1lbHNlIGlmKCJjYW5jZWwiPT09bCl7Y29uc3Qgcz1lLmdldCh0KTt2b2lkIDAhPT1zJiYoc2VsZi5jbGVhclRpbWVvdXQocyksZS5kZWxldGUodCkpfX19KCk7Cg==";
+const decodeBase64 = (base64) => Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+const blob = typeof self !== "undefined" && self.Blob && new Blob([decodeBase64(encodedJs)], { type: "text/javascript;charset=utf-8" });
+function WorkerWrapper(options) {
+  let objURL;
+  try {
+    objURL = blob && (self.URL || self.webkitURL).createObjectURL(blob);
+    if (!objURL) throw "";
+    const worker = new Worker(objURL, {
+      name: options == null ? void 0 : options.name
+    });
+    worker.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(objURL);
+    });
+    return worker;
+  } catch (e) {
+    return new Worker(
+      "data:text/javascript;base64," + encodedJs,
+      {
+        name: options == null ? void 0 : options.name
+      }
+    );
+  } finally {
+    objURL && (self.URL || self.webkitURL).revokeObjectURL(objURL);
+  }
+}
+class BrowserTimer {
+  constructor() {
+    __publicField(this, "worker");
+    __publicField(this, "callbacks");
+    __publicField(this, "nextId");
+    if (typeof WorkerWrapper !== "undefined") {
+      this.worker = new WorkerWrapper();
+    } else {
+      this.worker = {
+        postMessage: () => {
+        },
+        onmessage: null,
+        terminate: () => {
+        },
+        addEventListener: () => {
+        },
+        removeEventListener: () => {
+        },
+        dispatchEvent: () => false
+      };
+    }
+    this.callbacks = /* @__PURE__ */ new Map();
+    this.nextId = 1;
+    this.worker.onmessage = (e) => {
+      const { id, type } = e.data;
+      if (type === "tick") {
+        const callback = this.callbacks.get(id);
+        if (callback) {
+          callback();
+          this.callbacks.delete(id);
+        }
+      }
+    };
+  }
+  /**
+   * 安排一个定时任务。
+   * 向 Web Worker 发送消息以注册计时器。
+   */
+  schedule(callback, delay) {
+    const id = this.nextId++;
+    this.callbacks.set(id, callback);
+    this.worker.postMessage({ id, delay, type: "schedule" });
+    return id;
+  }
+  /**
+   * 取消一个定时任务。
+   */
+  cancel(handle) {
+    this.worker.postMessage({ id: handle, type: "cancel" });
+    this.callbacks.delete(handle);
+  }
+}
+class MainThreadTimer {
+  schedule(callback, delay) {
+    return window.setTimeout(callback, delay);
+  }
+  cancel(handle) {
+    window.clearTimeout(handle);
+  }
+}
+class DevTools {
+  constructor(options = {}) {
+    __publicField(this, "name", "DevTools");
+    __publicField(this, "options");
+    this.options = options;
+  }
+  init(scheduler) {
+    if (typeof window === "undefined" || typeof window.document === "undefined") {
+      return;
+    }
+    this.mount(scheduler);
+  }
+  async mount(scheduler) {
+    try {
+      await import("./devtools-4xVHTaUz.js");
+      await customElements.whenDefined("hs-devtools");
+      this.setupElement(scheduler);
+    } catch (e) {
+      console.error("[DevTools] Failed to mount:", e);
+    }
+  }
+  setupElement(scheduler) {
+    try {
+      let el = document.querySelector("hs-devtools");
+      if (el) {
+        el.remove();
+      }
+      el = document.createElement("hs-devtools");
+      const options = this.options;
+      console.log("[DevTools Plugin] options:", JSON.stringify(options));
+      if (options.theme) el.setAttribute("theme", options.theme);
+      if (options.dockPosition) el.setAttribute("dock", options.dockPosition);
+      if (options.language) el.setAttribute("language", options.language);
+      if (options.defaultZoom) el.setAttribute("default-zoom", options.defaultZoom.toString());
+      if (options.trigger) {
+        if (options.trigger.backgroundColor) el.setAttribute("trigger-bg", options.trigger.backgroundColor);
+        if (options.trigger.textColor) el.setAttribute("trigger-color", options.trigger.textColor);
+        if (options.trigger.position) el.setAttribute("trigger-position", options.trigger.position);
+      }
+      console.log("[DevTools Plugin] attributes set:", el.getAttribute("dock"), el.getAttribute("trigger-position"));
+      document.body.appendChild(el);
+      if (typeof el.setScheduler === "function") {
+        el.setScheduler({
+          getTasks: () => {
+            return scheduler.getAllTasks().map((task) => ({
+              id: task.id,
+              status: task.status,
+              lastRun: task.lastRun || null,
+              nextRun: task.nextRun || null,
+              executionCount: task.executionCount || 0,
+              schedule: task.schedule,
+              tags: task.tags || [],
+              error: task.status === TaskStatus.ERROR ? "Execution failed" : null,
+              driver: scheduler.getTaskDriver(task.id)
+            }));
+          },
+          on: (evt, handler) => {
+            return scheduler.on(evt, handler);
+          },
+          isRunning: () => scheduler.isRunning(),
+          trigger: (id) => scheduler.triggerTask(id),
+          pause: (id) => scheduler.stopTask(id),
+          resume: (id) => scheduler.startTask(id),
+          remove: (id) => scheduler.deleteTask(id)
+        });
+      } else {
+        console.warn("[DevTools] hs-devtools element does not have setScheduler method.");
+      }
+    } catch (e) {
+      console.error("[DevTools] Failed to setup element:", e);
+    }
+  }
+}
+const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+let workerTimerInstance = null;
+let mainTimerInstance = null;
+function getDefaultTimerStrategy(config) {
+  if (isBrowser) {
+    const driver = (config == null ? void 0 : config.driver) || "worker";
+    if (driver === "main") {
+      if (!mainTimerInstance) mainTimerInstance = new MainThreadTimer();
+      return mainTimerInstance;
+    }
+    if (!workerTimerInstance) workerTimerInstance = new BrowserTimer();
+    return workerTimerInstance;
+  }
+  return new NodeTimer();
+}
+function createTimerStrategyFactory() {
+  if (!isBrowser) return void 0;
+  return (driver) => {
+    if (driver === "main") {
+      if (!mainTimerInstance) mainTimerInstance = new MainThreadTimer();
+      return mainTimerInstance;
+    }
+    if (!workerTimerInstance) workerTimerInstance = new BrowserTimer();
+    return workerTimerInstance;
+  };
+}
+class Scheduler2 extends Scheduler$1 {
+  /**
+   * 创建调度器实例。
+   * @param config 配置项
+   */
+  constructor(config) {
+    super(
+      getDefaultTimerStrategy(config),
+      config,
+      createTimerStrategyFactory()
+    );
+  }
+}
+export {
+  Scheduler$1 as CoreScheduler,
+  DevTools,
+  Scheduler2 as Scheduler,
+  SchedulerEvents,
+  TaskStatus
+};