oqronkit 0.0.1-alpha.1

package/dist/index.js

@@ -0,0 +1,2738 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var zod = require('zod');
+var url = require('url');
+var findUp = require('find-up');
+var eventemitter3 = require('eventemitter3');
+var voltlogIo = require('voltlog-io');
+var Database2 = require('better-sqlite3');
+var _cronParser = require('cron-parser');
+var crypto = require('crypto');
+var rrule = require('rrule');
+var fs = require('fs/promises');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Database2__default = /*#__PURE__*/_interopDefault(Database2);
+var _cronParser__default = /*#__PURE__*/_interopDefault(_cronParser);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/.bun/tsup@8.5.1+b62311710f622f18/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "../../node_modules/.bun/tsup@8.5.1+b62311710f622f18/node_modules/tsup/assets/cjs_shims.js"() {
+  }
+});
+
+// src/core/config/default-config.ts
+function reconfigureConfig(config) {
+  const isIOqronAdapter2 = (val) => val && typeof val === "object" && typeof val.upsertSchedule === "function";
+  const isILockAdapter2 = (val) => val && typeof val === "object" && typeof val.acquire === "function";
+  return {
+    project: config.project ?? defaultConfig.project,
+    environment: config.environment ?? defaultConfig.environment,
+    db: config.db ? isIOqronAdapter2(config.db) ? config.db : { ...defaultConfig.db, ...config.db } : defaultConfig.db,
+    lock: config.lock ? isILockAdapter2(config.lock) ? config.lock : { ...defaultConfig.lock, ...config.lock } : defaultConfig.lock,
+    broker: config.broker,
+    modules: config.modules ?? defaultConfig.modules,
+    cron: {
+      ...defaultConfig.cron,
+      ...config.cron
+    },
+    scheduler: {
+      ...defaultConfig.scheduler,
+      ...config.scheduler
+    },
+    jobsDir: config.jobsDir ?? defaultConfig.jobsDir,
+    tags: config.tags ?? defaultConfig.tags,
+    worker: {
+      ...defaultConfig.worker,
+      ...config.worker
+    },
+    logger: config.logger === false ? false : {
+      ...defaultConfig.logger,
+      ...config.logger
+    },
+    telemetry: {
+      prometheus: {
+        ...defaultConfig.telemetry.prometheus,
+        ...config.telemetry?.prometheus
+      },
+      opentelemetry: {
+        ...defaultConfig.telemetry.opentelemetry,
+        ...config.telemetry?.opentelemetry
+      }
+    },
+    shutdown: {
+      ...defaultConfig.shutdown,
+      ...config.shutdown
+    }
+  };
+}
+var defaultConfig;
+var init_default_config = __esm({
+  "src/core/config/default-config.ts"() {
+    init_cjs_shims();
+    defaultConfig = {
+      project: "oqronkit",
+      environment: "development",
+      db: {
+        adapter: "memory",
+        poolMin: 2,
+        poolMax: 10,
+        tablePrefix: "chrono_",
+        migrations: "auto",
+        ssl: false
+      },
+      lock: {
+        adapter: "memory",
+        ttl: 3e4,
+        retryDelay: 200,
+        retryCount: 5
+      },
+      modules: [],
+      cron: {
+        enable: true,
+        timezone: "UTC",
+        tickInterval: 1e3,
+        missedFirePolicy: "run-once",
+        maxConcurrentJobs: 5,
+        leaderElection: true,
+        keepJobHistory: true,
+        keepFailedJobHistory: true
+      },
+      scheduler: {
+        enable: true,
+        tickInterval: 1e3,
+        keepJobHistory: true,
+        keepFailedJobHistory: true
+      },
+      jobsDir: "./src/jobs",
+      tags: [],
+      worker: {
+        concurrency: 50,
+        gracefulShutdownMs: 3e4
+      },
+      logger: {
+        enabled: true,
+        level: "info",
+        prettify: false,
+        showMetadata: true,
+        redact: []
+      },
+      telemetry: {
+        prometheus: {
+          enabled: false,
+          path: "/metrics"
+        },
+        opentelemetry: {
+          enabled: false
+        }
+      },
+      shutdown: {
+        enabled: true,
+        timeout: 3e4,
+        signals: ["SIGINT", "SIGTERM"]
+      }
+    };
+  }
+});
+var isIOqronAdapter, isILockAdapter, OqronConfigSchema;
+var init_schema = __esm({
+  "src/core/config/schema.ts"() {
+    init_cjs_shims();
+    isIOqronAdapter = (val) => {
+      if (!val || typeof val !== "object") return false;
+      return typeof val.upsertSchedule === "function" && typeof val.getDueSchedules === "function";
+    };
+    isILockAdapter = (val) => {
+      if (!val || typeof val !== "object") return false;
+      return typeof val.acquire === "function" && typeof val.renew === "function";
+    };
+    OqronConfigSchema = zod.z.object({
+      project: zod.z.string().optional(),
+      environment: zod.z.string().default("development"),
+      // Infrastructure — Union of explicit DI or declarative config
+      db: zod.z.union([
+        zod.z.custom(
+          isIOqronAdapter,
+          "db must be an instance of IOqronAdapter"
+        ),
+        zod.z.object({
+          adapter: zod.z.enum([
+            "sqlite",
+            "memory",
+            "postgres",
+            "mysql",
+            "mongodb",
+            "redis"
+          ]),
+          url: zod.z.string().optional(),
+          poolMin: zod.z.number().default(2),
+          poolMax: zod.z.number().default(10),
+          tablePrefix: zod.z.string().default("chrono_"),
+          migrations: zod.z.union([zod.z.enum(["auto", "manual"]), zod.z.literal(false)]).default("auto"),
+          ssl: zod.z.boolean().default(false)
+        })
+      ]).optional(),
+      lock: zod.z.union([
+        zod.z.custom(
+          isILockAdapter,
+          "lock must be an instance of ILockAdapter"
+        ),
+        zod.z.object({
+          adapter: zod.z.enum(["db", "memory", "redis"]),
+          url: zod.z.string().optional(),
+          ttl: zod.z.number().default(3e4),
+          retryDelay: zod.z.number().default(200),
+          retryCount: zod.z.number().default(5)
+        })
+      ]).optional(),
+      broker: zod.z.any().optional(),
+      // Modules
+      modules: zod.z.array(
+        zod.z.enum([
+          "cron",
+          "scheduler",
+          "queue",
+          "workflow",
+          "batch",
+          "webhook",
+          "pipeline"
+        ])
+      ).default([]),
+      // Module-specific configs
+      cron: zod.z.object({
+        enable: zod.z.boolean().default(true),
+        timezone: zod.z.string().optional(),
+        tickInterval: zod.z.number().default(1e3),
+        missedFirePolicy: zod.z.enum(["skip", "run-once", "run-all"]).default("run-once"),
+        maxConcurrentJobs: zod.z.number().default(5),
+        leaderElection: zod.z.boolean().default(true),
+        keepJobHistory: zod.z.union([zod.z.boolean(), zod.z.number()]).default(true),
+        keepFailedJobHistory: zod.z.union([zod.z.boolean(), zod.z.number()]).default(true)
+      }).default({}),
+      scheduler: zod.z.object({
+        enable: zod.z.boolean().default(true),
+        tickInterval: zod.z.number().default(1e3),
+        keepJobHistory: zod.z.union([zod.z.boolean(), zod.z.number()]).default(true),
+        keepFailedJobHistory: zod.z.union([zod.z.boolean(), zod.z.number()]).default(true)
+      }).default({}),
+      // Auto-discovery directory
+      jobsDir: zod.z.string().default("./src/jobs"),
+      // Global tags
+      tags: zod.z.array(zod.z.string()).default([]),
+      // Worker
+      worker: zod.z.object({
+        concurrency: zod.z.number().default(50),
+        gracefulShutdownMs: zod.z.number().default(3e4)
+      }).default({ concurrency: 50, gracefulShutdownMs: 3e4 }),
+      // Logger (voltlog-io config or false to disable)
+      logger: zod.z.union([
+        zod.z.literal(false),
+        zod.z.object({
+          enabled: zod.z.boolean().default(true),
+          level: zod.z.string().default("info"),
+          prettify: zod.z.boolean().default(false),
+          showMetadata: zod.z.boolean().default(true),
+          redact: zod.z.array(zod.z.string()).default([])
+        })
+      ]).default({
+        enabled: true,
+        level: "info",
+        prettify: false,
+        showMetadata: true,
+        redact: []
+      }),
+      // Telemetry
+      telemetry: zod.z.object({
+        prometheus: zod.z.object({
+          enabled: zod.z.boolean().default(false),
+          path: zod.z.string().default("/metrics")
+        }).default({}),
+        opentelemetry: zod.z.object({
+          enabled: zod.z.boolean().default(false)
+        }).default({})
+      }).default({}),
+      // Shutdown
+      shutdown: zod.z.object({
+        enabled: zod.z.boolean().default(true),
+        timeout: zod.z.number().default(3e4),
+        signals: zod.z.array(zod.z.string()).default(["SIGINT", "SIGTERM"])
+      }).default({})
+    });
+  }
+});
+async function loadConfig(cwd = process.cwd()) {
+  const configPath = await findUp.findUp("oqron.config.ts", { cwd }) || await findUp.findUp("oqron.config.js", { cwd });
+  if (!configPath) {
+    return OqronConfigSchema.parse({});
+  }
+  let rawConfig;
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      url.pathToFileURL(configPath).href
+    );
+    rawConfig = mod;
+    while (rawConfig && typeof rawConfig === "object" && "default" in rawConfig) {
+      rawConfig = rawConfig.default;
+    }
+  } catch (err) {
+    throw new Error(
+      `[OqronKit] Failed to load config from: ${configPath}
+${err}`
+    );
+  }
+  const parseResult = OqronConfigSchema.safeParse(rawConfig);
+  if (!parseResult.success) {
+    throw new Error(
+      `[OqronKit] Invalid oqron.config.ts:
+${parseResult.error.message}`
+    );
+  }
+  return reconfigureConfig(parseResult.data);
+}
+var init_config_loader = __esm({
+  "src/core/config/config-loader.ts"() {
+    init_cjs_shims();
+    init_default_config();
+    init_schema();
+  }
+});
+
+// src/core/config/define-config.ts
+function defineConfig(config) {
+  return config;
+}
+var init_define_config = __esm({
+  "src/core/config/define-config.ts"() {
+    init_cjs_shims();
+  }
+});
+
+// src/core/context/job-context.ts
+var JobContext;
+var init_job_context = __esm({
+  "src/core/context/job-context.ts"() {
+    init_cjs_shims();
+    JobContext = class {
+      id;
+      log;
+      signal;
+      environment;
+      project;
+      _progress = 0;
+      _onProgress;
+      constructor(opts) {
+        this.id = opts.id;
+        this.log = opts.logger;
+        this.signal = opts.signal;
+        this.environment = opts.environment;
+        this.project = opts.project;
+        this._onProgress = opts.onProgress;
+        this.progress = this.progress.bind(this);
+      }
+      progress(value, label) {
+        this._progress = Math.max(0, Math.min(100, value));
+        if (this._onProgress) {
+          this._onProgress(this._progress, label);
+        }
+      }
+      getProgress() {
+        return this._progress;
+      }
+    };
+  }
+});
+
+// src/core/context/cron-context.ts
+var CronContext;
+var init_cron_context = __esm({
+  "src/core/context/cron-context.ts"() {
+    init_cjs_shims();
+    init_job_context();
+    CronContext = class extends JobContext {
+      firedAt;
+      scheduleName;
+      startedLocalAt;
+      constructor(opts) {
+        super(opts);
+        this.firedAt = opts.firedAt;
+        this.scheduleName = opts.scheduleName;
+        this.startedLocalAt = Date.now();
+      }
+      get duration() {
+        return Date.now() - this.startedLocalAt;
+      }
+    };
+  }
+});
+
+// src/core/context/schedule-context.ts
+var ScheduleContext;
+var init_schedule_context = __esm({
+  "src/core/context/schedule-context.ts"() {
+    init_cjs_shims();
+    ScheduleContext = class {
+      id;
+      name;
+      firedAt;
+      payload;
+      environment;
+      project;
+      logger;
+      signal;
+      startedLocalAt;
+      _onProgress;
+      constructor(opts) {
+        this.id = opts.id;
+        this.name = opts.scheduleName;
+        this.firedAt = opts.firedAt;
+        this.payload = opts.payload;
+        this.logger = opts.logger;
+        this.signal = opts.signal;
+        this.environment = opts.environment;
+        this.project = opts.project;
+        this.startedLocalAt = Date.now();
+        this._onProgress = opts.onProgress;
+        this.log = this.log.bind(this);
+        this.progress = this.progress.bind(this);
+      }
+      get aborted() {
+        return this.signal.aborted;
+      }
+      get duration() {
+        return Date.now() - this.startedLocalAt;
+      }
+      log(level, message, meta) {
+        if (this.logger && typeof this.logger[level] === "function") {
+          this.logger[level](message, meta);
+        }
+      }
+      progress(percent, label) {
+        if (this._onProgress) {
+          this._onProgress(percent, label);
+        } else {
+          this.logger.debug("Progress updated", { percent, label, runId: this.id });
+        }
+      }
+    };
+  }
+});
+
+// src/core/errors/base.error.ts
+var init_base_error = __esm({
+  "src/core/errors/base.error.ts"() {
+    init_cjs_shims();
+  }
+});
+var OqronEventBusClass; exports.OqronEventBus = void 0;
+var init_event_bus = __esm({
+  "src/core/events/event-bus.ts"() {
+    init_cjs_shims();
+    OqronEventBusClass = class _OqronEventBusClass extends eventemitter3.EventEmitter {
+      static _instance;
+      static getInstance() {
+        if (!_OqronEventBusClass._instance) {
+          _OqronEventBusClass._instance = new _OqronEventBusClass();
+        }
+        return _OqronEventBusClass._instance;
+      }
+    };
+    exports.OqronEventBus = OqronEventBusClass.getInstance();
+  }
+});
+function createLogger(config, context) {
+  if (typeof config?.enabled !== "undefined" && config?.enabled === false)
+    return NOOP_LOGGER;
+  if (config?.logger) return config.logger;
+  const level = (config?.level ?? "INFO").toUpperCase();
+  const opts = {
+    level,
+    transports: [],
+    context
+  };
+  if (config?.redact?.length) {
+    const keys = config.redact;
+    opts.middleware = [
+      voltlogIo.redactionMiddleware({
+        paths: keys,
+        deep: true
+      })
+    ];
+  }
+  if (config?.prettify) {
+    opts.transports.push(voltlogIo.prettyTransport());
+  } else {
+    opts.transports.push(voltlogIo.consoleTransport());
+  }
+  return voltlogIo.createLogger(opts);
+}
+var NOOP_LOGGER;
+var init_logger = __esm({
+  "src/core/logger/index.ts"() {
+    init_cjs_shims();
+    NOOP_LOGGER = {
+      trace() {
+      },
+      debug() {
+      },
+      info() {
+      },
+      warn() {
+      },
+      error() {
+      },
+      fatal() {
+      },
+      child() {
+        return NOOP_LOGGER;
+      },
+      addTransport() {
+      },
+      removeTransport() {
+      },
+      addMiddleware() {
+      },
+      removeMiddleware() {
+      },
+      setLevel() {
+      },
+      getLevel() {
+        return "SILENT";
+      },
+      isLevelEnabled() {
+        return false;
+      },
+      startTimer() {
+        return { done() {
+        }, elapsed: () => 0 };
+      },
+      async flush() {
+      },
+      async close() {
+      }
+    };
+  }
+});
+
+// src/core/registry.ts
+var OqronRegistry;
+var init_registry = __esm({
+  "src/core/registry.ts"() {
+    init_cjs_shims();
+    OqronRegistry = class _OqronRegistry {
+      static _instance;
+      _modules = /* @__PURE__ */ new Map();
+      constructor() {
+      }
+      static getInstance() {
+        if (!_OqronRegistry._instance) {
+          _OqronRegistry._instance = new _OqronRegistry();
+        }
+        return _OqronRegistry._instance;
+      }
+      register(mod) {
+        if (this._modules.has(mod.name)) {
+          throw new Error(`[OqronKit] Module "${mod.name}" is already registered.`);
+        }
+        this._modules.set(mod.name, mod);
+      }
+      get(name) {
+        return this._modules.get(name);
+      }
+      getAll() {
+        return [...this._modules.values()];
+      }
+      /** Reset registry — useful for testing */
+      _reset() {
+        this._modules.clear();
+      }
+    };
+  }
+});
+
+// src/core/index.ts
+var init_core = __esm({
+  "src/core/index.ts"() {
+    init_cjs_shims();
+    init_config_loader();
+    init_default_config();
+    init_define_config();
+    init_schema();
+    init_cron_context();
+    init_job_context();
+    init_schedule_context();
+    init_base_error();
+    init_event_bus();
+    init_logger();
+    init_registry();
+  }
+});
+exports.DbLockAdapter = void 0;
+var init_db_lock_adapter = __esm({
+  "src/lock/adapters/db-lock.adapter.ts"() {
+    init_cjs_shims();
+    exports.DbLockAdapter = class {
+      db;
+      defaultTtl;
+      /**
+       * @param dbOrPath - Either a `better-sqlite3` Database instance or a file path.
+       *                   When sharing the same SQLite file as SqliteAdapter, pass the same path.
+       * @param defaultTtlMs - Default TTL for locks if not provided in acquire (optional)
+       */
+      constructor(dbOrPath = "oqron.sqlite", defaultTtlMs = 3e4) {
+        this.defaultTtl = defaultTtlMs;
+        if (typeof dbOrPath === "string") {
+          this.db = new Database2__default.default(dbOrPath);
+        } else {
+          this.db = dbOrPath;
+        }
+      }
+      async acquire(key, ownerId, ttlMs) {
+        const finalTtl = ttlMs ?? this.defaultTtl;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const expiresAt = new Date(Date.now() + finalTtl).toISOString();
+        this.db.prepare(
+          `
+      INSERT INTO chrono_locks (resourceKey, ownerId, expiresAt)
+      VALUES (?, ?, ?)
+      ON CONFLICT(resourceKey) DO UPDATE SET
+        ownerId   = CASE WHEN expiresAt < ? THEN excluded.ownerId   ELSE ownerId   END,
+        expiresAt = CASE WHEN expiresAt < ? THEN excluded.expiresAt ELSE expiresAt END
+    `
+        ).run(key, ownerId, expiresAt, now, now);
+        const row = this.db.prepare(`SELECT ownerId FROM chrono_locks WHERE resourceKey = ?`).get(key);
+        return row?.ownerId === ownerId;
+      }
+      async renew(key, ownerId, ttlMs) {
+        const finalTtl = ttlMs ?? this.defaultTtl;
+        const expiresAt = new Date(Date.now() + finalTtl).toISOString();
+        const result = this.db.prepare(
+          `
+      UPDATE chrono_locks SET expiresAt = ?
+      WHERE resourceKey = ? AND ownerId = ?
+    `
+        ).run(expiresAt, key, ownerId);
+        return result.changes > 0;
+      }
+      async release(key, ownerId) {
+        this.db.prepare(`DELETE FROM chrono_locks WHERE resourceKey = ? AND ownerId = ?`).run(key, ownerId);
+      }
+      async isOwner(key, ownerId) {
+        const row = this.db.prepare(
+          `SELECT ownerId, expiresAt FROM chrono_locks WHERE resourceKey = ?`
+        ).get(key);
+        if (!row) return false;
+        const expired = new Date(row.expiresAt) < /* @__PURE__ */ new Date();
+        return !expired && row.ownerId === ownerId;
+      }
+    };
+  }
+});
+
+// src/lock/adapters/memory-lock.adapter.ts
+exports.MemoryLockAdapter = void 0;
+var init_memory_lock_adapter = __esm({
+  "src/lock/adapters/memory-lock.adapter.ts"() {
+    init_cjs_shims();
+    exports.MemoryLockAdapter = class {
+      locks = /* @__PURE__ */ new Map();
+      async acquire(key, ownerId, ttlMs) {
+        const existing = this.locks.get(key);
+        if (existing && existing.expiresAt > Date.now()) {
+          return existing.ownerId === ownerId;
+        }
+        this.locks.set(key, { ownerId, expiresAt: Date.now() + ttlMs });
+        return true;
+      }
+      async renew(key, ownerId, ttlMs) {
+        const existing = this.locks.get(key);
+        if (!existing || existing.ownerId !== ownerId) return false;
+        existing.expiresAt = Date.now() + ttlMs;
+        return true;
+      }
+      async release(key, ownerId) {
+        const existing = this.locks.get(key);
+        if (existing?.ownerId === ownerId) this.locks.delete(key);
+      }
+      async isOwner(key, ownerId) {
+        const existing = this.locks.get(key);
+        return !!existing && existing.ownerId === ownerId && existing.expiresAt > Date.now();
+      }
+    };
+  }
+});
+
+// src/lock/adapters/namespaced-lock.adapter.ts
+var NamespacedLockAdapter;
+var init_namespaced_lock_adapter = __esm({
+  "src/lock/adapters/namespaced-lock.adapter.ts"() {
+    init_cjs_shims();
+    NamespacedLockAdapter = class {
+      constructor(base, project = "default", environment = "development") {
+        this.base = base;
+        this.prefix = `${project}:${environment}:`;
+      }
+      prefix;
+      ns(key) {
+        return `${this.prefix}${key}`;
+      }
+      async acquire(key, ownerId, ttlMs) {
+        return this.base.acquire(this.ns(key), ownerId, ttlMs);
+      }
+      async renew(key, ownerId, ttlMs) {
+        return this.base.renew(this.ns(key), ownerId, ttlMs);
+      }
+      async release(key, ownerId) {
+        return this.base.release(this.ns(key), ownerId);
+      }
+      async isOwner(key, ownerId) {
+        return this.base.isOwner(this.ns(key), ownerId);
+      }
+      /**
+       * Note: Some lock adapters might implement advanced prefixing natively,
+       * but we proxy all core lock operations through the namespace.
+       */
+    };
+  }
+});
+
+// src/lock/heartbeat-worker.ts
+var HeartbeatWorker;
+var init_heartbeat_worker = __esm({
+  "src/lock/heartbeat-worker.ts"() {
+    init_cjs_shims();
+    HeartbeatWorker = class {
+      constructor(lock, logger, key, ownerId, ttlMs = 3e4, heartbeatMs) {
+        this.lock = lock;
+        this.logger = logger;
+        this.key = key;
+        this.ownerId = ownerId;
+        this.ttlMs = ttlMs;
+        this.heartbeatMs = heartbeatMs;
+      }
+      heartbeatTimer;
+      _active = false;
+      async start() {
+        const acquired = await this.lock.acquire(
+          this.key,
+          this.ownerId,
+          this.ttlMs
+        );
+        if (!acquired) return false;
+        this._active = true;
+        const pingInterval = this.heartbeatMs ?? Math.floor(this.ttlMs / 3);
+        this.heartbeatTimer = setInterval(async () => {
+          if (!this._active) return;
+          try {
+            const renewed = await this.lock.renew(
+              this.key,
+              this.ownerId,
+              this.ttlMs
+            );
+            if (!renewed) {
+              this.logger.warn("Heartbeat renewal failed \u2014 lock lost", {
+                key: this.key,
+                ownerId: this.ownerId
+              });
+              this._active = false;
+              clearInterval(this.heartbeatTimer);
+            }
+          } catch (err) {
+            this.logger.error("Heartbeat renewal threw", {
+              key: this.key,
+              err: String(err)
+            });
+          }
+        }, pingInterval);
+        return true;
+      }
+      async stop() {
+        this._active = false;
+        if (this.heartbeatTimer) {
+          clearInterval(this.heartbeatTimer);
+          this.heartbeatTimer = void 0;
+        }
+        try {
+          await this.lock.release(this.key, this.ownerId);
+        } catch (err) {
+          this.logger.error("Failed to release lock cleanly", {
+            key: this.key,
+            err: String(err)
+          });
+        }
+      }
+      get isActive() {
+        return this._active;
+      }
+    };
+  }
+});
+
+// src/lock/leader-election.ts
+var LeaderElection;
+var init_leader_election = __esm({
+  "src/lock/leader-election.ts"() {
+    init_cjs_shims();
+    LeaderElection = class {
+      constructor(lock, logger, leaderKey, nodeId, ttlMs = 3e4) {
+        this.lock = lock;
+        this.logger = logger;
+        this.leaderKey = leaderKey;
+        this.nodeId = nodeId;
+        this.ttlMs = ttlMs;
+      }
+      electionTimer;
+      _isLeader = false;
+      async start() {
+        await this.campaign();
+        const interval = Math.floor(this.ttlMs / 3);
+        this.electionTimer = setInterval(() => void this.campaign(), interval);
+      }
+      async campaign() {
+        try {
+          if (this._isLeader) {
+            const ok = await this.lock.renew(
+              this.leaderKey,
+              this.nodeId,
+              this.ttlMs
+            );
+            if (!ok) {
+              this._isLeader = false;
+              this.logger.warn("Lost leadership", {
+                leaderKey: this.leaderKey,
+                nodeId: this.nodeId
+              });
+            }
+          } else {
+            const ok = await this.lock.acquire(
+              this.leaderKey,
+              this.nodeId,
+              this.ttlMs
+            );
+            if (ok) {
+              this._isLeader = true;
+              this.logger.info("Became leader", {
+                leaderKey: this.leaderKey,
+                nodeId: this.nodeId
+              });
+            }
+          }
+        } catch (err) {
+          this.logger.error("Leader election error", {
+            leaderKey: this.leaderKey,
+            err: String(err)
+          });
+          this._isLeader = false;
+        }
+      }
+      get isLeader() {
+        return this._isLeader;
+      }
+      async stop() {
+        if (this.electionTimer) {
+          clearInterval(this.electionTimer);
+          this.electionTimer = void 0;
+        }
+        if (this._isLeader) {
+          try {
+            await this.lock.release(this.leaderKey, this.nodeId);
+          } catch {
+          }
+          this._isLeader = false;
+        }
+      }
+    };
+  }
+});
+
+// src/lock/stall-detector.ts
+var StallDetector;
+var init_stall_detector = __esm({
+  "src/lock/stall-detector.ts"() {
+    init_cjs_shims();
+    StallDetector = class {
+      constructor(lock, logger, checkIntervalMs = 15e3) {
+        this.lock = lock;
+        this.logger = logger;
+        this.checkIntervalMs = checkIntervalMs;
+      }
+      timer;
+      /**
+       * Start the stall detection loop.
+       * @param getActiveJobs - Returns a list of { key, ownerId } for all currently tracked jobs.
+       * @param onStalled     - Called when a job is detected as stalled (lock lost).
+       */
+      start(getActiveJobs, onStalled) {
+        this.timer = setInterval(async () => {
+          try {
+            const jobs = getActiveJobs();
+            for (const job of jobs) {
+              const owned = await this.lock.isOwner(job.key, job.ownerId);
+              if (!owned) {
+                this.logger.warn("Stalled job detected \u2014 lock lost", {
+                  key: job.key,
+                  ownerId: job.ownerId
+                });
+                onStalled(job.key);
+              }
+            }
+          } catch (err) {
+            this.logger.error("StallDetector tick error", { err: String(err) });
+          }
+        }, this.checkIntervalMs);
+      }
+      stop() {
+        if (this.timer) {
+          clearInterval(this.timer);
+          this.timer = void 0;
+        }
+      }
+    };
+  }
+});
+
+// src/lock/index.ts
+var init_lock = __esm({
+  "src/lock/index.ts"() {
+    init_cjs_shims();
+    init_db_lock_adapter();
+    init_memory_lock_adapter();
+    init_namespaced_lock_adapter();
+    init_heartbeat_worker();
+    init_leader_election();
+    init_stall_detector();
+  }
+});
+function getNextRunDate(expression, timezone, from = /* @__PURE__ */ new Date()) {
+  const opts = { currentDate: from };
+  if (timezone) opts.tz = timezone;
+  return cronParser.parseExpression(expression, opts).next().toDate();
+}
+var cronParser;
+var init_expression_parser = __esm({
+  "src/scheduler/expression-parser.ts"() {
+    init_cjs_shims();
+    cronParser = _cronParser__default.default.default ?? _cronParser__default.default;
+  }
+});
+var cronParser2, MissedFireHandler;
+var init_missed_fire_handler = __esm({
+  "src/scheduler/missed-fire.handler.ts"() {
+    init_cjs_shims();
+    cronParser2 = _cronParser__default.default.default ?? _cronParser__default.default;
+    MissedFireHandler = class {
+      constructor(logger, _db2) {
+        this.logger = logger;
+        this._db = _db2;
+      }
+      async checkMissed(def, lastRunAt, now) {
+        if (!lastRunAt) return false;
+        try {
+          let missed = false;
+          if (def.expression) {
+            const opts = { currentDate: now, tz: def.timezone };
+            const prevRun = cronParser2.parseExpression(def.expression, opts).prev().toDate();
+            missed = prevRun > lastRunAt;
+          } else if (def.intervalMs) {
+            const elapsed = now.getTime() - lastRunAt.getTime();
+            missed = elapsed > def.intervalMs;
+          }
+          if (missed) {
+            this.logger.warn("Missed execution detected", {
+              name: def.name,
+              policy: def.missedFire
+            });
+            if (def.hooks?.onMissedFire) {
+              try {
+                const ctx = {
+                  id: crypto.randomUUID(),
+                  log: this.logger.child({
+                    schedule: def.name,
+                    scope: "missed-fire"
+                  }),
+                  logger: this.logger.child({
+                    schedule: def.name,
+                    scope: "missed-fire"
+                  }),
+                  signal: new AbortController().signal,
+                  firedAt: now,
+                  scheduleName: def.name,
+                  progress: () => {
+                  }
+                };
+                await def.hooks.onMissedFire(ctx, lastRunAt);
+              } catch (err) {
+                this.logger.error("onMissedFire hook threw", {
+                  name: def.name,
+                  err: String(err)
+                });
+              }
+            }
+            if (def.missedFire === "run-once" || def.missedFire === "run-all") {
+              return true;
+            }
+          }
+        } catch {
+        }
+        return false;
+      }
+    };
+  }
+});
+var SchedulerModule;
+var init_cron_engine = __esm({
+  "src/scheduler/cron-engine.ts"() {
+    init_cjs_shims();
+    init_core();
+    init_lock();
+    init_expression_parser();
+    init_missed_fire_handler();
+    SchedulerModule = class {
+      constructor(schedules, db, lock, logger, environment, project, config) {
+        this.schedules = schedules;
+        this.db = db;
+        this.lock = lock;
+        this.environment = environment;
+        this.project = project;
+        this.config = config;
+        this.nodeId = crypto.randomUUID();
+        this.logger = logger ?? createLogger({ level: "info" }, { module: "scheduler" });
+        this.stallDetector = new StallDetector(this.lock, this.logger, 15e3);
+        this.missedFireHandler = new MissedFireHandler(this.logger, this.db);
+      }
+      name = "cron";
+      enabled = true;
+      nodeId;
+      logger;
+      leader;
+      stallDetector;
+      missedFireHandler;
+      tickTimer;
+      activeJobs = /* @__PURE__ */ new Map();
+      _hasRunLeaderInit = false;
+      // ── Lifecycle ───────────────────────────────────────────────────────────────
+      async init() {
+        this.logger.info("Initializing scheduler", {
+          nodeId: this.nodeId,
+          count: this.schedules.length
+        });
+        for (const def of this.schedules) {
+          await this.db.upsertSchedule(def);
+          this.logger.debug("Registered schedule", {
+            name: def.name,
+            expression: def.expression,
+            intervalMs: def.intervalMs
+          });
+        }
+        const existing = await this.db.getSchedules();
+        const now = /* @__PURE__ */ new Date();
+        for (const record of existing) {
+          if (record.nextRunAt !== null) continue;
+          const def = this.schedules.find((s) => s.name === record.name);
+          if (!def) continue;
+          const nextRun = this.computeNextRun(def, now);
+          if (nextRun) {
+            await this.db.updateNextRun(def.name, nextRun);
+            this.logger.debug("Seeded nextRunAt", {
+              name: def.name,
+              nextRunAt: nextRun.toISOString()
+            });
+          }
+        }
+      }
+      async start() {
+        if (this.config?.leaderElection !== false) {
+          this.leader = new LeaderElection(
+            this.lock,
+            this.logger,
+            "oqron:scheduler:leader",
+            this.nodeId,
+            3e4
+          );
+          await this.leader.start();
+        }
+        const interval = this.config?.tickInterval ?? 1e3;
+        this.tickTimer = setInterval(() => {
+          void this.tick();
+        }, interval);
+        this.logger.info("Scheduler started", { nodeId: this.nodeId, interval });
+      }
+      async stop() {
+        if (this.tickTimer) clearInterval(this.tickTimer);
+        if (this.leader) await this.leader.stop();
+        this.stallDetector.stop();
+        for (const job of this.activeJobs.values()) {
+          if (job.abort) job.abort.abort();
+          if (job.worker) {
+            await job.worker.stop();
+          } else {
+            await this.lock.release(job.lockKey, this.nodeId).catch(() => {
+            });
+          }
+        }
+        this.activeJobs.clear();
+        this.logger.info("Scheduler stopped");
+      }
+      // ── Core scheduling helpers ─────────────────────────────────────────────────
+      /**
+       * Compute the next fire time for a definition.
+       * Returns null if computation fails (invalid expression, etc).
+       */
+      computeNextRun(def, from) {
+        if (def.expression) {
+          try {
+            const timezone = def.timezone ?? this.config?.timezone;
+            return getNextRunDate(def.expression, timezone, from);
+          } catch (err) {
+            this.logger.error("Failed to compute next run from expression", {
+              name: def.name,
+              expression: def.expression,
+              err: String(err)
+            });
+            return null;
+          }
+        }
+        if (def.intervalMs) {
+          return new Date(from.getTime() + def.intervalMs);
+        }
+        this.logger.error("Schedule has neither expression nor intervalMs", {
+          name: def.name
+        });
+        return null;
+      }
+      // ── Leader init (missed-fire recovery + stall detector) ─────────────────────
+      async handleLeaderInit() {
+        this.logger.info("Performing leader initialization...");
+        const knownSchedules = await this.db.getSchedules();
+        const now = /* @__PURE__ */ new Date();
+        for (const record of knownSchedules) {
+          const def = this.schedules.find((s) => s.name === record.name);
+          if (!def) continue;
+          const missed = await this.missedFireHandler.checkMissed(
+            def,
+            record.lastRunAt,
+            now
+          );
+          if (missed) {
+            this.logger.info("Triggering recovery run for missed schedule", {
+              name: def.name
+            });
+            void this.fire(def);
+          }
+        }
+        this.stallDetector.start(
+          () => {
+            return Array.from(this.activeJobs.values()).filter((job) => job.worker !== void 0).map((job) => ({
+              key: job.lockKey,
+              ownerId: this.nodeId
+            }));
+          },
+          (key) => {
+            this.logger.warn("Local stall detected", { key });
+          }
+        );
+      }
+      async detectClusterStalls() {
+        try {
+          const activeDbJobs = await this.db.getActiveJobs();
+          for (const job of activeDbJobs) {
+            if (!job.scheduleId) continue;
+            const def = this.schedules.find((s) => s.name === job.scheduleId);
+            if (!def?.guaranteedWorker) continue;
+            const ageMs = Date.now() - job.startedAt.getTime();
+            const ttl = def.lockTtlMs ?? 5e4;
+            if (ageMs > ttl + 1e4) {
+              this.logger.warn("Cluster stall detected", { runId: job.id });
+              await this.db.recordExecution({
+                id: job.id,
+                scheduleId: job.scheduleId,
+                status: "failed",
+                error: "Stall detected (lock assumed expired)",
+                startedAt: job.startedAt,
+                completedAt: /* @__PURE__ */ new Date()
+              });
+            }
+          }
+        } catch (err) {
+          this.logger.error("Failed to detect cluster stalls", {
+            err: String(err)
+          });
+        }
+      }
+      // ── Tick loop ───────────────────────────────────────────────────────────────
+      async tick() {
+        if (this.leader && !this.leader.isLeader) return;
+        if (!this._hasRunLeaderInit) {
+          this._hasRunLeaderInit = true;
+          await this.handleLeaderInit();
+        }
+        try {
+          if (Math.random() < 0.1) {
+            void this.detectClusterStalls();
+          }
+          const now = /* @__PURE__ */ new Date();
+          const due = await this.db.getDueSchedules(now, 50);
+          for (const { name } of due) {
+            const def = this.schedules.find((s) => s.name === name);
+            if (!def) continue;
+            const nextRun = this.computeNextRun(def, now);
+            if (!nextRun) {
+              this.logger.error(
+                "Cannot compute next run \u2014 suspending cron to prevent runaway loop",
+                { name: def.name }
+              );
+              await this.db.updateNextRun(def.name, null).catch(() => {
+              });
+              continue;
+            }
+            await this.db.updateNextRun(def.name, nextRun);
+            void this.fire(def);
+          }
+        } catch (err) {
+          this.logger.error("Tick error", { err: String(err) });
+        }
+      }
+      // ── Fire handler ────────────────────────────────────────────────────────────
+      async fire(def) {
+        const isOverlapSkip = def.overlap === "skip" || def.overlap === false;
+        if (isOverlapSkip) {
+          for (const job of this.activeJobs.values()) {
+            if (job.lockKey === `oqron:run:${def.name}`) {
+              this.logger.debug("Skipping overlapping run", { name: def.name });
+              return;
+            }
+          }
+        }
+        const runId = crypto.randomUUID();
+        const lockKey = isOverlapSkip ? `oqron:run:${def.name}` : `oqron:run:${def.name}:${runId}`;
+        const startedAt = /* @__PURE__ */ new Date();
+        let worker;
+        let acquired = false;
+        if (def.guaranteedWorker) {
+          worker = new HeartbeatWorker(
+            this.lock,
+            this.logger,
+            lockKey,
+            this.nodeId,
+            def.lockTtlMs ?? 3e4,
+            def.heartbeatMs ?? 1e4
+          );
+          acquired = await worker.start();
+        } else {
+          acquired = await this.lock.acquire(
+            lockKey,
+            this.nodeId,
+            def.lockTtlMs ?? 3e4
+          );
+        }
+        if (!acquired) return;
+        const abort = new AbortController();
+        this.activeJobs.set(runId, { runId, lockKey, worker, abort });
+        await this.db.recordExecution({
+          id: runId,
+          scheduleId: def.name,
+          status: "running",
+          startedAt
+        });
+        void Promise.resolve().then(async () => {
+          const ctx = new CronContext({
+            id: runId,
+            logger: this.logger.child({ schedule: def.name }),
+            signal: abort.signal,
+            firedAt: startedAt,
+            scheduleName: def.name,
+            environment: this.environment,
+            project: this.project,
+            onProgress: (percent, label) => {
+              this.db.updateJobProgress(runId, percent, label).catch(
+                (err) => this.logger.error("Failed to update progress", { runId, err })
+              );
+            }
+          });
+          let status = "completed";
+          let error;
+          let timeoutHandle;
+          let finalResult;
+          let attempts = 1;
+          const maxAttempts = (def.retries?.max ?? 0) + 1;
+          while (attempts <= maxAttempts) {
+            try {
+              if (def.hooks?.beforeRun) await def.hooks.beforeRun(ctx);
+              if (def.timeout) {
+                const timeoutPromise = new Promise((_, reject) => {
+                  timeoutHandle = setTimeout(() => {
+                    abort.abort();
+                    reject(new Error(`Handler timed out after ${def.timeout}ms`));
+                  }, def.timeout);
+                });
+                finalResult = await Promise.race([
+                  def.handler(ctx),
+                  timeoutPromise
+                ]);
+              } else {
+                finalResult = await def.handler(ctx);
+              }
+              if (def.hooks?.afterRun) {
+                await def.hooks.afterRun(ctx, finalResult);
+              }
+              status = "completed";
+              error = void 0;
+              break;
+            } catch (err) {
+              error = err instanceof Error ? err.message : String(err);
+              status = "failed";
+              if (def.hooks?.onError && err instanceof Error) {
+                try {
+                  await Promise.resolve(def.hooks.onError(ctx, err));
+                } catch (e) {
+                  this.logger.error("onError hook threw", { err: String(e) });
+                }
+              }
+              if (attempts < maxAttempts) {
+                this.logger.warn("Job handler threw, retrying...", {
+                  name: def.name,
+                  runId,
+                  attempt: attempts,
+                  error
+                });
+                const baseDelay = def.retries?.baseDelay ?? 2e3;
+                const delay = def.retries?.strategy === "exponential" ? baseDelay * 2 ** (attempts - 1) : baseDelay;
+                attempts++;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+              } else {
+                this.logger.error("Job handler failed completely", {
+                  name: def.name,
+                  runId,
+                  attempts,
+                  error
+                });
+                break;
+              }
+            } finally {
+              if (timeoutHandle) clearTimeout(timeoutHandle);
+            }
+          }
+          const completedAt = /* @__PURE__ */ new Date();
+          await this.db.recordExecution({
+            id: runId,
+            scheduleId: def.name,
+            status,
+            startedAt,
+            completedAt,
+            error,
+            result: finalResult !== void 0 ? JSON.stringify(finalResult) : void 0,
+            attempts,
+            durationMs: completedAt.getTime() - startedAt.getTime(),
+            ...status === "completed" ? { progressPercent: 100, progressLabel: "Completed" } : {}
+          });
+          if (worker) {
+            await worker.stop();
+          } else {
+            await this.lock.release(lockKey, this.nodeId).catch(() => {
+            });
+          }
+          this.activeJobs.delete(runId);
+          if (def.intervalMs) {
+            const nextRun = this.computeNextRun(def, /* @__PURE__ */ new Date());
+            if (nextRun) {
+              await this.db.updateNextRun(def.name, nextRun).catch(() => {
+              });
+            }
+          }
+          const keepJobHistory = def.keepHistory ?? this.config?.keepJobHistory ?? true;
+          const keepFailedHistory = def.keepFailedHistory ?? this.config?.keepFailedJobHistory ?? true;
+          if (keepJobHistory !== true || keepFailedHistory !== true) {
+            this.db.pruneHistoryForSchedule(def.name, keepJobHistory, keepFailedHistory).catch(
+              (err) => this.logger.debug("Failed to prune history", {
+                err,
+                name: def.name
+              })
+            );
+          }
+          this.logger.info("Job finished", {
+            name: def.name,
+            runId,
+            status,
+            attempts
+          });
+        });
+      }
+    };
+  }
+});
+
+// src/scheduler/registry.ts
+function _getPending() {
+  if (!globalThis[GLOBAL_KEY]) {
+    globalThis[GLOBAL_KEY] = [];
+  }
+  return globalThis[GLOBAL_KEY];
+}
+function _registerCron(def) {
+  _getPending().push(def);
+}
+function _drainPending() {
+  const pending = _getPending();
+  return pending.splice(0);
+}
+var GLOBAL_KEY;
+var init_registry2 = __esm({
+  "src/scheduler/registry.ts"() {
+    init_cjs_shims();
+    GLOBAL_KEY = "__oqronkit_pending_crons__";
+  }
+});
+function everyToIntervalMs(every) {
+  let ms = 0;
+  if (every.seconds) ms += every.seconds * 1e3;
+  if (every.minutes) ms += every.minutes * 6e4;
+  if (every.hours) ms += every.hours * 36e5;
+  if (ms <= 0)
+    throw new Error(
+      "[OqronKit] `every` config must resolve to a positive interval"
+    );
+  return ms;
+}
+var cronParser3; exports.cron = void 0;
+var init_define_cron = __esm({
+  "src/scheduler/define-cron.ts"() {
+    init_cjs_shims();
+    init_registry2();
+    cronParser3 = _cronParser__default.default.default ?? _cronParser__default.default;
+    exports.cron = (options) => {
+      let expression;
+      let intervalMs;
+      if ("expression" in options && options.expression) {
+        try {
+          cronParser3.parseExpression(options.expression, { tz: options.timezone });
+        } catch {
+          throw new Error(
+            `[OqronKit] Invalid cron expression for "${options.name}": "${options.expression}"`
+          );
+        }
+        expression = options.expression;
+      } else if ("every" in options && options.every) {
+        intervalMs = everyToIntervalMs(options.every);
+      } else {
+        throw new Error(
+          `[OqronKit] Cron "${options.name}" must specify either "expression" or "every"`
+        );
+      }
+      const def = {
+        name: options.name,
+        expression,
+        intervalMs,
+        timezone: options.timezone,
+        missedFire: options.missedFire ?? "skip",
+        overlap: options.overlap ?? "skip",
+        guaranteedWorker: options.guaranteedWorker ?? false,
+        heartbeatMs: options.heartbeatMs,
+        lockTtlMs: options.lockTtlMs,
+        timeout: options.timeout,
+        tags: options.tags ?? [],
+        handler: options.handler,
+        hooks: options.hooks,
+        retries: options.retries
+      };
+      _registerCron(def);
+      return def;
+    };
+  }
+});
+
+// src/scheduler/registry-schedule.ts
+function _getPending2() {
+  if (!globalThis[GLOBAL_KEY2]) {
+    globalThis[GLOBAL_KEY2] = [];
+  }
+  return globalThis[GLOBAL_KEY2];
+}
+function _registerSchedule(def) {
+  _getPending2().push(def);
+}
+function _drainPendingSchedules() {
+  const pending = _getPending2();
+  return pending.splice(0);
+}
+var GLOBAL_KEY2;
+var init_registry_schedule = __esm({
+  "src/scheduler/registry-schedule.ts"() {
+    init_cjs_shims();
+    GLOBAL_KEY2 = "__oqronkit_pending_schedules__";
+  }
+});
+
+// src/scheduler/define-schedule.ts
+function _attachScheduleEngine(engine) {
+  engineRef.current = engine;
+}
+var engineRef; exports.schedule = void 0;
+var init_define_schedule = __esm({
+  "src/scheduler/define-schedule.ts"() {
+    init_cjs_shims();
+    init_registry_schedule();
+    engineRef = { current: null };
+    exports.schedule = (options) => {
+      const def = {
+        name: options.name,
+        runAt: options.runAt,
+        runAfter: options.runAfter,
+        recurring: options.recurring,
+        rrule: options.rrule,
+        every: options.every,
+        timezone: options.timezone,
+        missedFire: options.missedFire ?? "skip",
+        overlap: options.overlap ?? "skip",
+        guaranteedWorker: options.guaranteedWorker ?? false,
+        heartbeatMs: options.heartbeatMs,
+        lockTtlMs: options.lockTtlMs,
+        timeout: options.timeout,
+        tags: options.tags ?? [],
+        condition: options.condition,
+        handler: options.handler,
+        hooks: options.hooks,
+        payload: options.payload,
+        retries: options.retries
+      };
+      _registerSchedule(def);
+      return {
+        ...def,
+        trigger: async (opts) => {
+          if (!engineRef.current) {
+            throw new Error(
+              `[OqronKit] Cannot trigger "${options.name}" \u2014 ScheduleEngine is not running.`
+            );
+          }
+          const dynamicDef = { ...def };
+          if (opts) {
+            if (opts.nameSuffix) dynamicDef.name = `${def.name}:${opts.nameSuffix}`;
+            if (opts.runAt) dynamicDef.runAt = opts.runAt;
+            if (opts.runAfter) dynamicDef.runAfter = opts.runAfter;
+            if (opts.recurring) dynamicDef.recurring = opts.recurring;
+            if (opts.rrule) dynamicDef.rrule = opts.rrule;
+            if (opts.every) dynamicDef.every = opts.every;
+            if (opts.payload) dynamicDef.payload = opts.payload;
+          }
+          if (!opts?.runAt && !opts?.runAfter && !opts?.recurring && !opts?.rrule && !opts?.every) {
+            dynamicDef.runAt = /* @__PURE__ */ new Date();
+          }
+          await engineRef.current.registerDynamic(dynamicDef);
+        },
+        schedule: async (opts) => {
+          if (!engineRef.current) {
+            throw new Error(
+              `[OqronKit] Cannot schedule "${options.name}" \u2014 ScheduleEngine is not running.`
+            );
+          }
+          const dynamicDef = { ...def };
+          if (opts) {
+            if (opts.nameSuffix) dynamicDef.name = `${def.name}:${opts.nameSuffix}`;
+            if (opts.runAt) dynamicDef.runAt = opts.runAt;
+            if (opts.runAfter) dynamicDef.runAfter = opts.runAfter;
+            if (opts.recurring) dynamicDef.recurring = opts.recurring;
+            if (opts.rrule) dynamicDef.rrule = opts.rrule;
+            if (opts.every) dynamicDef.every = opts.every;
+            if (opts.payload) dynamicDef.payload = opts.payload;
+          }
+          await engineRef.current.registerDynamic(dynamicDef);
+        },
+        cancel: async () => {
+          if (!engineRef.current) return;
+          await engineRef.current.cancel(def.name);
+        }
+      };
+    };
+  }
+});
+var ScheduleEngine;
+var init_schedule_engine = __esm({
+  "src/scheduler/schedule-engine.ts"() {
+    init_cjs_shims();
+    init_core();
+    init_lock();
+    init_define_schedule();
+    ScheduleEngine = class {
+      constructor(staticSchedules, db, lock, logger, environment, project, config) {
+        this.db = db;
+        this.lock = lock;
+        this.environment = environment;
+        this.project = project;
+        this.config = config;
+        this.nodeId = crypto.randomUUID();
+        this.logger = logger ?? createLogger({ level: "info" }, { module: "scheduler" });
+        this.stallDetector = new StallDetector(this.lock, this.logger, 15e3);
+        for (const def of staticSchedules) {
+          this.schedules.set(def.name, def);
+        }
+      }
+      name = "scheduler";
+      enabled = true;
+      nodeId;
+      logger;
+      leader;
+      stallDetector;
+      tickTimer;
+      activeJobs = /* @__PURE__ */ new Map();
+      // Includes static instances and dynamically triggered instances
+      schedules = /* @__PURE__ */ new Map();
+      _hasRunLeaderInit = false;
+      // ── Lifecycle ───────────────────────────────────────────────────────────────
+      async init() {
+        this.logger.info("Initializing schedule engine", {
+          nodeId: this.nodeId,
+          staticCount: this.schedules.size
+        });
+        _attachScheduleEngine(this);
+        const now = /* @__PURE__ */ new Date();
+        for (const def of this.schedules.values()) {
+          await this.upsertAndSeed(def, now);
+        }
+      }
+      async upsertAndSeed(def, now) {
+        await this.db.upsertSchedule(def);
+        const nextRun = this.computeNextRun(def, now);
+        if (nextRun) {
+          await this.db.updateNextRun(def.name, nextRun);
+        }
+      }
+      /** Dynamically register and schedule a definition from trigger/schedule call */
+      async registerDynamic(def) {
+        this.schedules.set(def.name, def);
+        await this.upsertAndSeed(def, /* @__PURE__ */ new Date());
+        this.logger.debug("Registered dynamic schedule", { name: def.name });
+      }
+      async cancel(name) {
+        this.schedules.delete(name);
+      }
+      async start() {
+        this.leader = new LeaderElection(
+          this.lock,
+          this.logger,
+          "oqron:scheduleengine:leader",
+          this.nodeId,
+          3e4
+        );
+        await this.leader.start();
+        const interval = this.config?.tickInterval ?? 1e3;
+        this.tickTimer = setInterval(() => {
+          void this.tick();
+        }, interval);
+        this.logger.info("Schedule engine started", {
+          nodeId: this.nodeId,
+          interval
+        });
+      }
+      async stop() {
+        if (this.tickTimer) clearInterval(this.tickTimer);
+        if (this.leader) await this.leader.stop();
+        this.stallDetector.stop();
+        for (const job of this.activeJobs.values()) {
+          if (job.abort) job.abort.abort();
+          if (job.worker) {
+            await job.worker.stop();
+          } else {
+            await this.lock.release(job.lockKey, this.nodeId).catch(() => {
+            });
+          }
+        }
+        this.activeJobs.clear();
+        this.logger.info("Schedule engine stopped");
+      }
+      // ── Core scheduling helpers ─────────────────────────────────────────────────
+      computeNextRun(def, from) {
+        try {
+          if (def.runAt) {
+            return new Date(def.runAt);
+          }
+          if (def.runAfter) {
+            const add = (def.runAfter.days ?? 0) * 864e5 + (def.runAfter.hours ?? 0) * 36e5 + (def.runAfter.minutes ?? 0) * 6e4 + (def.runAfter.seconds ?? 0) * 1e3;
+            return new Date(from.getTime() + add);
+          }
+          if (def.rrule) {
+            const rule = rrule.rrulestr(def.rrule);
+            return rule.after(from);
+          }
+          if (def.recurring) {
+            const freqMapHash = {
+              daily: rrule.RRule.DAILY,
+              weekly: rrule.RRule.WEEKLY,
+              monthly: rrule.RRule.MONTHLY,
+              yearly: rrule.RRule.YEARLY
+            };
+            const freq = freqMapHash[def.recurring.frequency] ?? rrule.RRule.DAILY;
+            const options = { freq };
+            if (def.recurring.months?.length)
+              options.bymonth = def.recurring.months;
+            if (def.recurring.dayOfMonth)
+              options.bymonthday = [def.recurring.dayOfMonth];
+            if (def.recurring.at) {
+              options.byhour = [def.recurring.at.hour];
+              options.byminute = [def.recurring.at.minute];
+              options.bysecond = [0];
+            }
+            const rule = new rrule.RRule(options);
+            return rule.after(from);
+          }
+          if (def.every) {
+            const add = (def.every.hours ?? 0) * 36e5 + (def.every.minutes ?? 0) * 6e4 + (def.every.seconds ?? 0) * 1e3;
+            return new Date(from.getTime() + add);
+          }
+        } catch (err) {
+          this.logger.error("Failed to compute next run", {
+            name: def.name,
+            err: String(err)
+          });
+        }
+        return null;
+      }
+      // ── Leader init (missed-fire recovery + stall detector) ─────────────────────
+      async handleLeaderInit() {
+        this.logger.info("Schedule Engine: Performing leader initialization...");
+        this.stallDetector.start(
+          () => {
+            return Array.from(this.activeJobs.values()).filter((job) => job.worker !== void 0).map((job) => ({
+              key: job.lockKey,
+              ownerId: this.nodeId
+            }));
+          },
+          (key) => {
+            this.logger.warn("Local stall detected", { key });
+          }
+        );
+      }
+      // ── Tick loop ───────────────────────────────────────────────────────────────
+      async tick() {
+        if (!this.leader?.isLeader) return;
+        if (!this._hasRunLeaderInit) {
+          this._hasRunLeaderInit = true;
+          await this.handleLeaderInit();
+        }
+        try {
+          const now = /* @__PURE__ */ new Date();
+          const due = await this.db.getDueSchedules(now, 50);
+          for (const { name } of due) {
+            const def = this.schedules.get(name);
+            if (!def) continue;
+            if (def.condition) {
+              try {
+                const conditionVal = await def.condition(
+                  new ScheduleContext({
+                    id: "eval",
+                    scheduleName: def.name,
+                    firedAt: now,
+                    logger: this.logger,
+                    signal: new AbortController().signal,
+                    payload: def.payload,
+                    environment: this.environment,
+                    project: this.project
+                  })
+                );
+                if (!conditionVal) {
+                  const nextRun2 = this.computeNextRun(def, now);
+                  if (nextRun2) await this.db.updateNextRun(def.name, nextRun2);
+                  continue;
+                }
+              } catch (e) {
+                this.logger.error("Condition crashed", {
+                  name: def.name,
+                  error: String(e)
+                });
+                continue;
+              }
+            }
+            let nextRun = null;
+            if (!def.runAt && !def.runAfter) {
+              nextRun = this.computeNextRun(def, now);
+              if (!nextRun) {
+                this.logger.error(
+                  "Cannot compute next run \u2014 suspending schedule to prevent runaway loop",
+                  { name: def.name }
+                );
+                await this.db.updateNextRun(def.name, null).catch(() => {
+                });
+                continue;
+              }
+            }
+            await this.db.updateNextRun(def.name, nextRun);
+            void this.fire(def);
+          }
+        } catch (err) {
+          this.logger.error("Tick error", { err: String(err) });
+        }
+      }
+      // ── Fire handler ────────────────────────────────────────────────────────────
+      async fire(def) {
+        const isOverlapSkip = def.overlap === "skip" || def.overlap === false;
+        if (isOverlapSkip) {
+          for (const job of this.activeJobs.values()) {
+            if (job.lockKey === `oqron:schedule:run:${def.name}`) {
+              this.logger.debug("Skipping overlapping run", { name: def.name });
+              return;
+            }
+          }
+        }
+        const runId = crypto.randomUUID();
+        const lockKey = isOverlapSkip ? `oqron:schedule:run:${def.name}` : `oqron:schedule:run:${def.name}:${runId}`;
+        const startedAt = /* @__PURE__ */ new Date();
+        let worker;
+        let acquired = false;
+        if (def.guaranteedWorker) {
+          worker = new HeartbeatWorker(
+            this.lock,
+            this.logger,
+            lockKey,
+            this.nodeId,
+            def.lockTtlMs ?? 3e4,
+            def.heartbeatMs ?? 1e4
+          );
+          acquired = await worker.start();
+        } else {
+          acquired = await this.lock.acquire(
+            lockKey,
+            this.nodeId,
+            def.lockTtlMs ?? 3e4
+          );
+        }
+        if (!acquired) return;
+        const abort = new AbortController();
+        this.activeJobs.set(runId, { runId, lockKey, worker, abort });
+        await this.db.recordExecution({
+          id: runId,
+          scheduleId: def.name,
+          status: "running",
+          startedAt
+        });
+        void Promise.resolve().then(async () => {
+          const ctx = new ScheduleContext({
+            id: runId,
+            logger: this.logger.child({ schedule: def.name }),
+            signal: abort.signal,
+            firedAt: startedAt,
+            scheduleName: def.name,
+            payload: def.payload,
+            environment: this.environment,
+            project: this.project,
+            onProgress: (percent, label) => {
+              this.db.updateJobProgress(runId, percent, label).catch(
+                (err) => this.logger.error("Failed to update schedule progress", {
+                  runId,
+                  err
+                })
+              );
+            }
+          });
+          let status = "completed";
+          let error;
+          let timeoutHandle;
+          let finalResult;
+          let attempts = 1;
+          const maxAttempts = (def.retries?.max ?? 0) + 1;
+          while (attempts <= maxAttempts) {
+            try {
+              if (def.hooks?.beforeRun) await def.hooks.beforeRun(ctx);
+              if (def.timeout) {
+                const timeoutPromise = new Promise((_, reject) => {
+                  timeoutHandle = setTimeout(() => {
+                    abort.abort();
+                    reject(new Error(`Handler timed out after ${def.timeout}ms`));
+                  }, def.timeout);
+                });
+                finalResult = await Promise.race([
+                  def.handler(ctx),
+                  timeoutPromise
+                ]);
+              } else {
+                finalResult = await def.handler(ctx);
+              }
+              if (def.hooks?.afterRun) {
+                await def.hooks.afterRun(ctx, finalResult);
+              }
+              status = "completed";
+              error = void 0;
+              break;
+            } catch (err) {
+              error = err instanceof Error ? err.message : String(err);
+              status = "failed";
+              if (def.hooks?.onError && err instanceof Error) {
+                try {
+                  await Promise.resolve(def.hooks.onError(ctx, err));
+                } catch (e) {
+                  this.logger.error("onError hook threw", { err: String(e) });
+                }
+              }
+              if (attempts < maxAttempts) {
+                this.logger.warn("Schedule handler threw, retrying...", {
+                  name: def.name,
+                  runId,
+                  attempt: attempts,
+                  error
+                });
+                const baseDelay = def.retries?.baseDelay ?? 2e3;
+                const delay = def.retries?.strategy === "exponential" ? baseDelay * 2 ** (attempts - 1) : baseDelay;
+                attempts++;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+              } else {
+                this.logger.error("Schedule handler failed completely", {
+                  name: def.name,
+                  runId,
+                  attempts,
+                  error
+                });
+                break;
+              }
+            } finally {
+              if (timeoutHandle) clearTimeout(timeoutHandle);
+            }
+          }
+          const completedAt = /* @__PURE__ */ new Date();
+          await this.db.recordExecution({
+            id: runId,
+            scheduleId: def.name,
+            status,
+            startedAt,
+            completedAt,
+            error,
+            result: finalResult !== void 0 ? JSON.stringify(finalResult) : void 0,
+            attempts,
+            durationMs: completedAt.getTime() - startedAt.getTime(),
+            ...status === "completed" ? { progressPercent: 100, progressLabel: "Completed" } : {}
+          });
+          if (worker) {
+            await worker.stop();
+          } else {
+            await this.lock.release(lockKey, this.nodeId).catch(() => {
+            });
+          }
+          this.activeJobs.delete(runId);
+          const keepJobHistory = def.keepHistory ?? this.config?.keepJobHistory ?? true;
+          const keepFailedHistory = def.keepFailedHistory ?? this.config?.keepFailedJobHistory ?? true;
+          if (keepJobHistory !== true || keepFailedHistory !== true) {
+            this.db.pruneHistoryForSchedule(def.name, keepJobHistory, keepFailedHistory).catch(
+              (err) => this.logger.debug("Failed to prune history", {
+                err,
+                name: def.name
+              })
+            );
+          }
+          this.logger.info("Schedule finished", {
+            name: def.name,
+            runId,
+            status,
+            attempts
+          });
+        });
+      }
+    };
+  }
+});
+
+// src/scheduler/index.ts
+var scheduler_exports = {};
+__export(scheduler_exports, {
+  ScheduleEngine: () => ScheduleEngine,
+  SchedulerModule: () => SchedulerModule,
+  _drainPending: () => _drainPending,
+  _drainPendingSchedules: () => _drainPendingSchedules,
+  _registerCron: () => _registerCron,
+  _registerSchedule: () => _registerSchedule,
+  cron: () => exports.cron,
+  getNextRunDate: () => getNextRunDate,
+  schedule: () => exports.schedule
+});
+var init_scheduler = __esm({
+  "src/scheduler/index.ts"() {
+    init_cjs_shims();
+    init_cron_engine();
+    init_define_cron();
+    init_define_schedule();
+    init_expression_parser();
+    init_registry2();
+    init_registry_schedule();
+    init_schedule_engine();
+  }
+});
+
+// src/index.ts
+init_cjs_shims();
+init_core();
+
+// src/db/index.ts
+init_cjs_shims();
+
+// src/db/adapters/memory.adapter.ts
+init_cjs_shims();
+var MemoryOqronAdapter = class {
+  schedules = /* @__PURE__ */ new Map();
+  jobs = /* @__PURE__ */ new Map();
+  async upsertSchedule(def) {
+    if (!this.schedules.has(def.name)) {
+      this.schedules.set(def.name, {
+        name: def.name,
+        nextRunAt: null,
+        lastRunAt: null
+      });
+    }
+  }
+  async getDueSchedules(now, limit, prefix) {
+    const due = [];
+    for (const s of this.schedules.values()) {
+      if (prefix && !s.name.startsWith(prefix)) continue;
+      if (s.nextRunAt !== null && s.nextRunAt <= now) {
+        due.push({ name: s.name });
+      }
+      if (due.length >= limit) break;
+    }
+    return due;
+  }
+  async getSchedules(prefix) {
+    const filtered = prefix ? Array.from(this.schedules.values()).filter(
+      (s) => s.name.startsWith(prefix)
+    ) : Array.from(this.schedules.values());
+    return filtered.map((s) => ({
+      name: s.name,
+      lastRunAt: s.lastRunAt,
+      nextRunAt: s.nextRunAt
+    }));
+  }
+  async updateNextRun(scheduleId, nextRunAt) {
+    const s = this.schedules.get(scheduleId);
+    if (s) {
+      s.nextRunAt = nextRunAt;
+    }
+  }
+  async recordExecution(job) {
+    const existing = this.jobs.get(job.id);
+    if (existing) {
+      this.jobs.set(job.id, {
+        ...existing,
+        ...job,
+        progressPercent: job.progressPercent ?? existing.progressPercent,
+        progressLabel: job.progressLabel ?? existing.progressLabel
+      });
+    } else {
+      this.jobs.set(job.id, { ...job });
+    }
+    if (job.scheduleId && (job.status === "completed" || job.status === "failed")) {
+      const s = this.schedules.get(job.scheduleId);
+      if (s) {
+        s.lastRunAt = job.completedAt ?? /* @__PURE__ */ new Date();
+      }
+    }
+  }
+  async updateJobProgress(id, progressPercent, progressLabel) {
+    const job = this.jobs.get(id);
+    if (job) {
+      job.progressPercent = progressPercent;
+      job.progressLabel = progressLabel ?? job.progressLabel;
+    }
+  }
+  async getExecutions(scheduleId, opts) {
+    const records = Array.from(this.jobs.values()).filter((j) => j.scheduleId === scheduleId).sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
+    return records.slice(opts.offset, opts.offset + opts.limit);
+  }
+  async getActiveJobs() {
+    return Array.from(this.jobs.values()).filter((j) => j.status === "running");
+  }
+  async cleanOldExecutions(before) {
+    let removed = 0;
+    for (const [id, job] of this.jobs.entries()) {
+      if (job.startedAt < before) {
+        this.jobs.delete(id);
+        removed++;
+      }
+    }
+    return removed;
+  }
+  async pruneHistoryForSchedule(scheduleId, keepJobHistory, keepFailedJobHistory) {
+    if (keepJobHistory === false && keepFailedJobHistory === false) return;
+    const all = Array.from(this.jobs.values()).filter(
+      (j) => j.scheduleId === scheduleId && ["completed", "failed", "dead"].includes(j.status)
+    );
+    all.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
+    const successes = all.filter((j) => j.status === "completed");
+    const failures = all.filter((j) => ["failed", "dead"].includes(j.status));
+    if (typeof keepJobHistory === "number" && successes.length > keepJobHistory) {
+      const toRemove = successes.slice(keepJobHistory);
+      for (const j of toRemove) this.jobs.delete(j.id);
+    }
+    if (typeof keepFailedJobHistory === "number" && failures.length > keepFailedJobHistory) {
+      const toRemove = failures.slice(keepFailedJobHistory);
+      for (const j of toRemove) this.jobs.delete(j.id);
+    }
+  }
+};
+
+// src/db/adapters/namespaced.adapter.ts
+init_cjs_shims();
+var NamespacedOqronAdapter = class {
+  constructor(base, project = "default", environment = "development") {
+    this.base = base;
+    this.prefix = `${project}:${environment}:`;
+  }
+  prefix;
+  ns(id) {
+    return `${this.prefix}${id}`;
+  }
+  un(id) {
+    return id.startsWith(this.prefix) ? id.slice(this.prefix.length) : id;
+  }
+  async upsertSchedule(def) {
+    return this.base.upsertSchedule({ ...def, name: this.ns(def.name) });
+  }
+  async getDueSchedules(now, limit, prefix) {
+    const combinedPrefix = prefix ? `${this.prefix}${prefix}` : this.prefix;
+    const records = await this.base.getDueSchedules(now, limit, combinedPrefix);
+    return records.filter((r) => r.name.startsWith(this.prefix)).map((r) => ({ name: this.un(r.name) }));
+  }
+  async getSchedules(prefix) {
+    const combinedPrefix = prefix ? `${this.prefix}${prefix}` : this.prefix;
+    const records = await this.base.getSchedules(combinedPrefix);
+    return records.filter((r) => r.name.startsWith(this.prefix)).map((r) => ({
+      ...r,
+      name: this.un(r.name)
+    }));
+  }
+  async updateNextRun(scheduleId, nextRunAt) {
+    return this.base.updateNextRun(this.ns(scheduleId), nextRunAt);
+  }
+  async recordExecution(job) {
+    return this.base.recordExecution({
+      ...job,
+      scheduleId: job.scheduleId ? this.ns(job.scheduleId) : void 0
+    });
+  }
+  async updateJobProgress(id, progressPercent, progressLabel) {
+    return this.base.updateJobProgress(id, progressPercent, progressLabel);
+  }
+  async getExecutions(scheduleId, opts) {
+    const records = await this.base.getExecutions(this.ns(scheduleId), opts);
+    return records.map((r) => ({
+      ...r,
+      scheduleId: r.scheduleId ? this.un(r.scheduleId) : void 0
+    }));
+  }
+  async getActiveJobs() {
+    const records = await this.base.getActiveJobs();
+    return records.filter((r) => r.scheduleId?.startsWith(this.prefix)).map((r) => ({
+      ...r,
+      scheduleId: r.scheduleId ? this.un(r.scheduleId) : void 0
+    }));
+  }
+  async cleanOldExecutions(before) {
+    return this.base.cleanOldExecutions(before);
+  }
+  async pruneHistoryForSchedule(scheduleId, keepJobHistory, keepFailedJobHistory) {
+    return this.base.pruneHistoryForSchedule(
+      this.ns(scheduleId),
+      keepJobHistory,
+      keepFailedJobHistory
+    );
+  }
+};
+
+// src/db/adapters/sqlite.adapter.ts
+init_cjs_shims();
+var SqliteAdapter = class {
+  db;
+  /**
+   * @param dbOrPath - Either a `better-sqlite3` Database instance (for testing with `:memory:`)
+   *                   or a file path string. Defaults to `"oqron.sqlite"`.
+   */
+  constructor(dbOrPath = "oqron.sqlite") {
+    if (typeof dbOrPath === "string") {
+      this.db = new Database2__default.default(dbOrPath);
+    } else {
+      this.db = dbOrPath;
+    }
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("foreign_keys = ON");
+    this.migrate();
+  }
+  /** Create tables if they don't exist */
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS oqron_schedules (
+        id              TEXT PRIMARY KEY,
+        expression      TEXT, -- Can be null now since rrule/runAt are supported
+        timezone        TEXT,
+        missedFirePolicy TEXT NOT NULL DEFAULT 'skip',
+        overlap         INTEGER NOT NULL DEFAULT 1,
+        tags            TEXT NOT NULL DEFAULT '[]',
+        
+        -- Advanced Scheduling Columns
+        runAt           TEXT,
+        runAfterOpts    TEXT,
+        rrule           TEXT,
+        recurring       TEXT,
+        
+        lastRunAt       TEXT,
+        nextRunAt       TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS oqron_jobs (
+        id          TEXT PRIMARY KEY,
+        scheduleId  TEXT,
+        status      TEXT NOT NULL,
+        startedAt   TEXT NOT NULL,
+        completedAt TEXT,
+        error       TEXT,
+        result      TEXT,
+        progressPercent INTEGER,
+        progressLabel TEXT,
+        attempts    INTEGER DEFAULT 1,
+        FOREIGN KEY(scheduleId) REFERENCES oqron_schedules(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS chrono_locks (
+        resourceKey TEXT PRIMARY KEY,
+        ownerId     TEXT NOT NULL,
+        expiresAt   TEXT NOT NULL
+      );
+    `);
+    const alters = [
+      "ALTER TABLE oqron_schedules ADD COLUMN runAt TEXT",
+      "ALTER TABLE oqron_schedules ADD COLUMN runAfterOpts TEXT",
+      "ALTER TABLE oqron_schedules ADD COLUMN rrule TEXT",
+      "ALTER TABLE oqron_schedules ADD COLUMN recurring TEXT",
+      "ALTER TABLE oqron_jobs ADD COLUMN result TEXT",
+      "ALTER TABLE oqron_jobs ADD COLUMN progressPercent INTEGER",
+      "ALTER TABLE oqron_jobs ADD COLUMN progressLabel TEXT",
+      "ALTER TABLE oqron_jobs ADD COLUMN attempts INTEGER",
+      "ALTER TABLE oqron_jobs ADD COLUMN durationMs INTEGER"
+    ];
+    for (const sql of alters) {
+      try {
+        this.db.exec(sql);
+      } catch (_e) {
+      }
+    }
+  }
+  async upsertSchedule(def) {
+    const isSchedule = "runAt" in def || "rrule" in def || "recurring" in def || "runAfter" in def;
+    this.db.prepare(
+      `INSERT INTO oqron_schedules (
+           id, expression, timezone, missedFirePolicy, overlap, tags,
+           runAt, runAfterOpts, rrule, recurring
+         )
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           expression       = excluded.expression,
+           timezone         = excluded.timezone,
+           missedFirePolicy = excluded.missedFirePolicy,
+           overlap          = excluded.overlap,
+           tags             = excluded.tags,
+           runAt            = excluded.runAt,
+           runAfterOpts     = excluded.runAfterOpts,
+           rrule            = excluded.rrule,
+           recurring        = excluded.recurring`
+    ).run(
+      def.name,
+      "expression" in def ? def.expression ?? (def.intervalMs ? `every:${def.intervalMs}ms` : null) : "every" in def && def.every ? JSON.stringify(def.every) : null,
+      def.timezone ?? null,
+      def.missedFire,
+      def.overlap !== "skip" && def.overlap !== false ? 1 : 0,
+      JSON.stringify(def.tags),
+      isSchedule && def.runAt ? def.runAt.toISOString() : null,
+      isSchedule && def.runAfter ? JSON.stringify(def.runAfter) : null,
+      isSchedule && def.rrule ? def.rrule : null,
+      isSchedule && def.recurring ? JSON.stringify(def.recurring) : null
+    );
+  }
+  async getDueSchedules(now, limit, prefix) {
+    let sql = `SELECT id as name FROM oqron_schedules WHERE nextRunAt <= ?`;
+    const params = [now.toISOString()];
+    if (prefix) {
+      sql += ` AND id LIKE ?`;
+      params.push(`${prefix}%`);
+    }
+    sql += ` LIMIT ?`;
+    params.push(limit);
+    return this.db.prepare(sql).all(...params);
+  }
+  async getSchedules(prefix) {
+    let sql = `SELECT id, lastRunAt, nextRunAt FROM oqron_schedules`;
+    const params = [];
+    if (prefix) {
+      sql += ` WHERE id LIKE ?`;
+      params.push(`${prefix}%`);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({
+      name: r.id,
+      lastRunAt: r.lastRunAt ? new Date(r.lastRunAt) : null,
+      nextRunAt: r.nextRunAt ? new Date(r.nextRunAt) : null
+    }));
+  }
+  async updateNextRun(scheduleId, nextRunAt) {
+    this.db.prepare(`UPDATE oqron_schedules SET nextRunAt = ? WHERE id = ?`).run(nextRunAt ? nextRunAt.toISOString() : null, scheduleId);
+  }
+  async updateJobProgress(id, progressPercent, progressLabel) {
+    this.db.prepare(
+      `UPDATE oqron_jobs SET progressPercent = ?, progressLabel = ? WHERE id = ?`
+    ).run(progressPercent, progressLabel ?? null, id);
+  }
+  async recordExecution(job) {
+    this.db.prepare(
+      `INSERT INTO oqron_jobs (id, scheduleId, status, startedAt, completedAt, error, result, attempts, progressPercent, progressLabel, durationMs)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           status          = excluded.status,
+           completedAt     = excluded.completedAt,
+           error           = excluded.error,
+           result          = excluded.result,
+           attempts        = excluded.attempts,
+           progressPercent = coalesce(excluded.progressPercent, progressPercent),
+           progressLabel   = coalesce(excluded.progressLabel, progressLabel),
+           durationMs      = excluded.durationMs`
+    ).run(
+      job.id,
+      job.scheduleId ?? null,
+      job.status,
+      job.startedAt.toISOString(),
+      job.completedAt?.toISOString() ?? null,
+      job.error ?? null,
+      job.result ?? null,
+      job.attempts ?? 1,
+      job.progressPercent ?? null,
+      job.progressLabel ?? null,
+      job.durationMs ?? null
+    );
+    if (job.scheduleId && (job.status === "completed" || job.status === "failed")) {
+      this.db.prepare(`UPDATE oqron_schedules SET lastRunAt = ? WHERE id = ?`).run((job.completedAt ?? /* @__PURE__ */ new Date()).toISOString(), job.scheduleId);
+    }
+  }
+  async getExecutions(scheduleId, opts) {
+    const rows = this.db.prepare(
+      `SELECT id, scheduleId, status, startedAt, completedAt, error, result, progressPercent, progressLabel, attempts, durationMs
+         FROM oqron_jobs WHERE scheduleId = ?
+         ORDER BY startedAt DESC
+         LIMIT ? OFFSET ?`
+    ).all(scheduleId, opts.limit, opts.offset);
+    return rows.map((r) => ({
+      id: r.id,
+      scheduleId: r.scheduleId ?? void 0,
+      status: r.status,
+      startedAt: new Date(r.startedAt),
+      completedAt: r.completedAt ? new Date(r.completedAt) : void 0,
+      error: r.error ?? void 0,
+      result: r.result ?? void 0,
+      progressPercent: r.progressPercent ?? void 0,
+      progressLabel: r.progressLabel ?? void 0,
+      attempts: r.attempts ?? void 0,
+      durationMs: r.durationMs ?? void 0
+    }));
+  }
+  async getActiveJobs() {
+    const rows = this.db.prepare(
+      `SELECT id, scheduleId, status, startedAt, completedAt, error, result, progressPercent, progressLabel, attempts, durationMs
+         FROM oqron_jobs WHERE status = 'running'`
+    ).all();
+    return rows.map((r) => ({
+      id: r.id,
+      scheduleId: r.scheduleId ?? void 0,
+      status: r.status,
+      startedAt: new Date(r.startedAt),
+      completedAt: r.completedAt ? new Date(r.completedAt) : void 0,
+      error: r.error ?? void 0,
+      result: r.result ?? void 0,
+      progressPercent: r.progressPercent ?? void 0,
+      progressLabel: r.progressLabel ?? void 0,
+      attempts: r.attempts ?? void 0,
+      durationMs: r.durationMs ?? void 0
+    }));
+  }
+  async cleanOldExecutions(before) {
+    const result = this.db.prepare(`DELETE FROM oqron_jobs WHERE startedAt < ?`).run(before.toISOString());
+    return result.changes;
+  }
+  async pruneHistoryForSchedule(scheduleId, keepJobHistory, keepFailedJobHistory) {
+    if (keepJobHistory === false && keepFailedJobHistory === false) return;
+    if (typeof keepJobHistory === "number") {
+      this.db.prepare(
+        `
+        DELETE FROM oqron_jobs 
+        WHERE scheduleId = ? AND status = 'completed'
+        AND id NOT IN (
+          SELECT id FROM oqron_jobs 
+          WHERE scheduleId = ? AND status = 'completed' 
+          ORDER BY startedAt DESC LIMIT ?
+        )
+      `
+      ).run(scheduleId, scheduleId, keepJobHistory);
+    }
+    if (typeof keepFailedJobHistory === "number") {
+      this.db.prepare(
+        `
+        DELETE FROM oqron_jobs 
+        WHERE scheduleId = ? AND status IN ('failed', 'dead')
+        AND id NOT IN (
+          SELECT id FROM oqron_jobs 
+          WHERE scheduleId = ? AND status IN ('failed', 'dead') 
+          ORDER BY startedAt DESC LIMIT ?
+        )
+      `
+      ).run(scheduleId, scheduleId, keepFailedJobHistory);
+    }
+  }
+};
+
+// src/index.ts
+init_lock();
+
+// src/server/express.ts
+init_cjs_shims();
+
+// src/server/handlers.ts
+init_cjs_shims();
+init_core();
+var recentEvents = [];
+function appendEvent(event, data) {
+  recentEvents.unshift({ ts: (/* @__PURE__ */ new Date()).toISOString(), event, data });
+  if (recentEvents.length > 500) recentEvents.pop();
+}
+exports.OqronEventBus.on(
+  "job:start",
+  (jobId, mod) => appendEvent("job:start", { jobId, mod })
+);
+exports.OqronEventBus.on(
+  "job:success",
+  (jobId) => appendEvent("job:success", { jobId })
+);
+exports.OqronEventBus.on(
+  "job:fail",
+  (jobId, err) => appendEvent("job:fail", { jobId, error: err.message })
+);
+exports.OqronEventBus.on("system:ready", () => appendEvent("system:ready", {}));
+exports.OqronEventBus.on("system:stop", () => appendEvent("system:stop", {}));
+async function handleHealth(_req) {
+  return {
+    status: 200,
+    body: {
+      ok: true,
+      status: "running",
+      uptime: process.uptime(),
+      env: process.env.CHRONO_ENV ?? "development",
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+async function handleEvents(req) {
+  const limit = Math.min(Number(req.query.limit ?? 50), 200);
+  return {
+    status: 200,
+    body: { ok: true, events: recentEvents.slice(0, limit) }
+  };
+}
+async function handleTrigger(req) {
+  const id = req.params.id;
+  if (!id)
+    return { status: 400, body: { ok: false, error: "Missing :id param" } };
+  appendEvent("manual:trigger", { id });
+  return {
+    status: 200,
+    body: { ok: true, message: `Trigger queued for "${id}"` }
+  };
+}
+async function dispatch(req) {
+  const { method, path: path2 } = req;
+  if (method === "GET" && path2 === "/health") return handleHealth();
+  if (method === "GET" && path2 === "/events") return handleEvents(req);
+  if (method === "POST" && path2.startsWith("/jobs/")) return handleTrigger(req);
+  return { status: 404, body: { ok: false, error: "Not found" } };
+}
+
+// src/server/express.ts
+function expressRouter() {
+  return async function chronoMiddleware(req, res, next) {
+    const matchPath = req.path;
+    try {
+      const result = await dispatch({
+        method: req.method,
+        path: matchPath,
+        query: req.query || {},
+        params: req.params || {}
+      });
+      if (result.status === 404 && result.body && result.body.error === "Not found") {
+        return next();
+      }
+      res.status(result.status).json(result.body);
+    } catch (err) {
+      next(err);
+    }
+  };
+}
+
+// src/server/fastify.ts
+init_cjs_shims();
+function fastifyPlugin(fastify, _opts, done) {
+  fastify.all("*", async (req, reply) => {
+    const pathParams = req.params["*"];
+    const path2 = pathParams ? `/${pathParams}` : req.url;
+    const result = await dispatch({
+      method: req.method,
+      path: path2,
+      query: req.query,
+      params: req.params
+    });
+    return reply.status(result.status).send(result.body);
+  });
+  done();
+}
+
+// src/index.ts
+init_core();
+init_lock();
+init_scheduler();
+var _config = null;
+var _db = null;
+var _lock = null;
+var _logger = null;
+var OqronKit = {
+  /**
+   * Initialize OqronKit: loads config, auto-discovers jobs, and boots modules.
+   *
+   * @param opts.cwd - Working directory for config file lookup and jobsDir resolution
+   * @param opts.config - Explicit config object (skips loadConfig)
+   */
+  async init(opts) {
+    const cwd = opts?.cwd ?? process.cwd();
+    _config = reconfigureConfig(opts?.config ?? await loadConfig(cwd));
+    const loggerConfig = _config.logger === false ? { enabled: true } : _config.logger;
+    _logger = createLogger(loggerConfig, { module: "oqronkit" });
+    _logger.info(`Starting OqronKit in "${_config.environment}" environment`);
+    if (!_config.db) {
+      const msg = "No 'db' adapter configured. Falling back to ephemeral 'MemoryOqronAdapter'. [WARNING: Data will not persist across restarts]";
+      if (_config.environment === "production") {
+        _logger.fatal(`STERN WARNING: ${msg}`);
+      } else {
+        _logger.warn(msg);
+      }
+      _db = new MemoryOqronAdapter();
+    } else if ("adapter" in _config.db) {
+      const { adapter, url } = _config.db;
+      if (adapter === "sqlite") {
+        _db = new SqliteAdapter(url ?? "oqron.sqlite");
+      } else if (adapter === "memory") {
+        const msg = "Using ephemeral 'memory' database adapter. [WARNING: Data will not persist across restarts]";
+        if (_config.environment === "production") {
+          _logger.fatal(`STERN WARNING: ${msg}`);
+        } else {
+          _logger.warn(msg);
+        }
+        _db = new MemoryOqronAdapter();
+      } else {
+        throw new Error(
+          `[OqronKit] Database adapter '${adapter}' not yet bundled. Please pass a custom IOqronAdapter instance.`
+        );
+      }
+    } else {
+      _db = _config.db;
+    }
+    if (!_config.lock) {
+      _logger.warn(
+        "No 'lock' adapter configured. Falling back to ephemeral 'MemoryLockAdapter'."
+      );
+      _lock = new exports.MemoryLockAdapter();
+    } else if ("adapter" in _config.lock) {
+      const { adapter, url, ttl } = _config.lock;
+      if (adapter === "db") {
+        if (_db instanceof SqliteAdapter) {
+          _lock = new exports.DbLockAdapter(_db.db, ttl);
+        } else {
+          _lock = new exports.DbLockAdapter(url ?? "oqron.sqlite", ttl);
+        }
+      } else if (adapter === "memory") {
+        _lock = new exports.MemoryLockAdapter();
+      } else {
+        throw new Error(
+          `[OqronKit] Lock adapter '${adapter}' not yet bundled. Please pass a custom ILockAdapter instance.`
+        );
+      }
+    } else {
+      _lock = _config.lock;
+    }
+    if (_config.shutdown.enabled) {
+      for (const signal of _config.shutdown.signals) {
+        process.on(signal, () => {
+          _logger?.info(`${signal} received \u2014 initiating graceful shutdown\u2026`);
+          void this.stop().then(() => process.exit(0));
+        });
+      }
+    }
+    if (_config.modules.includes("cron")) {
+      const { SchedulerModule: SchedulerModule2, _drainPending: _drainPending2 } = await Promise.resolve().then(() => (init_scheduler(), scheduler_exports));
+      if (_config.jobsDir) {
+        const jobsPath = path__default.default.resolve(cwd, _config.jobsDir);
+        _logger.debug(`Scanning jobsDir: ${jobsPath}`);
+        try {
+          async function scan(dir) {
+            try {
+              const entries = await fs__default.default.readdir(dir, { withFileTypes: true });
+              for (const entry of entries) {
+                const fullPath = path__default.default.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                  await scan(fullPath);
+                } else if (entry.isFile() && /\.(js|ts|mjs|cjs)$/.test(entry.name) && !entry.name.endsWith(".d.ts")) {
+                  _logger?.debug(`Auto-importing job file: ${entry.name}`);
+                  await import(url.pathToFileURL(fullPath).toString());
+                }
+              }
+            } catch (err) {
+              if (err.code !== "ENOENT") throw err;
+            }
+          }
+          await scan(jobsPath);
+        } catch (err) {
+          _logger.warn(`Failed to scan jobsDir: ${_config.jobsDir}`, {
+            error: String(err)
+          });
+        }
+      }
+      const schedules = _drainPending2();
+      for (const s of schedules) {
+        s.tags = [.../* @__PURE__ */ new Set([...s.tags ?? [], ..._config.tags])];
+      }
+      const nsDb = new NamespacedOqronAdapter(
+        _db,
+        _config.project,
+        _config.environment
+      );
+      const nsLock = new NamespacedLockAdapter(
+        _lock,
+        _config.project,
+        _config.environment
+      );
+      const scheduler = new SchedulerModule2(
+        schedules,
+        nsDb,
+        nsLock,
+        _logger,
+        _config.environment,
+        _config.project,
+        _config.cron
+      );
+      OqronRegistry.getInstance().register(scheduler);
+    }
+    if (_config.modules.includes("scheduler")) {
+      const { ScheduleEngine: ScheduleEngine2, _drainPendingSchedules: _drainPendingSchedules2 } = await Promise.resolve().then(() => (init_scheduler(), scheduler_exports));
+      if (!_config.modules.includes("cron") && _config.jobsDir) {
+        _logger.warn(
+          "jobsDir scanning currently bound to cron module block. Consider enabling 'cron' module or creating global scanner."
+        );
+      }
+      const schedules = _drainPendingSchedules2();
+      for (const s of schedules) {
+        s.tags = [.../* @__PURE__ */ new Set([...s.tags ?? [], ..._config.tags])];
+      }
+      const nsDb = new NamespacedOqronAdapter(
+        _db,
+        _config.project,
+        _config.environment
+      );
+      const nsLock = new NamespacedLockAdapter(
+        _lock,
+        _config.project,
+        _config.environment
+      );
+      const engine = new ScheduleEngine2(
+        schedules,
+        nsDb,
+        nsLock,
+        _logger,
+        _config.environment,
+        _config.project,
+        _config.scheduler
+      );
+      OqronRegistry.getInstance().register(engine);
+    }
+    const registry = OqronRegistry.getInstance();
+    const modules = registry.getAll();
+    for (const mod of modules) {
+      if (mod.enabled) {
+        _logger.debug(`init() \u2192 ${mod.name}`);
+        await mod.init();
+      }
+    }
+    for (const mod of modules) {
+      if (mod.enabled) {
+        _logger.info(`start() \u2192 ${mod.name}`);
+        await mod.start();
+      }
+    }
+    _logger.info("OqronKit ready \u2713");
+  },
+  /** Gracefully stop all modules */
+  async stop() {
+    const log = _logger ?? createLogger({ enabled: true, level: "info" }, { module: "oqronkit" });
+    log.info("Stopping OqronKit\u2026");
+    const timeoutMs = _config?.shutdown.timeout ?? 3e4;
+    const registry = OqronRegistry.getInstance();
+    const stopPromise = Promise.all(
+      registry.getAll().filter((m) => m.enabled).map((m) => m.stop())
+    );
+    const timeoutPromise = new Promise(
+      (_, reject) => setTimeout(
+        () => reject(new Error(`Graceful shutdown timed out after ${timeoutMs}ms`)),
+        timeoutMs
+      )
+    );
+    try {
+      await Promise.race([stopPromise, timeoutPromise]);
+      log.info("OqronKit stopped.");
+    } catch (err) {
+      log.error("Error during stop or shutdown timeout", {
+        error: String(err)
+      });
+    }
+  },
+  /** Get the current validated config */
+  getConfig() {
+    if (!_config)
+      throw new Error(
+        "[OqronKit] Not initialized yet. Call OqronKit.init() first."
+      );
+    return _config;
+  },
+  /** Get the database adapter (available after init()) */
+  getDb() {
+    if (!_db) throw new Error("[OqronKit] Not initialized yet.");
+    return _db;
+  },
+  /** Get the lock adapter (available after init()) */
+  getLock() {
+    if (!_lock) throw new Error("[OqronKit] Not initialized yet.");
+    return _lock;
+  },
+  /** Get the Express router for monitoring */
+  expressRouter() {
+    return expressRouter();
+  },
+  /** Get the Fastify plugin for monitoring */
+  fastifyPlugin(fastify, opts, done) {
+    return fastifyPlugin(fastify, opts, done);
+  }
+};
+var index_default = OqronKit;
+
+exports.OqronKit = OqronKit;
+exports.SqliteAdapter = SqliteAdapter;
+exports.createLogger = createLogger;
+exports.default = index_default;
+exports.defineConfig = defineConfig;