oqronkit 0.0.1-alpha.1

package/dist/index.mjs

@@ -0,0 +1,747 @@
+import { OqronEventBus, createLogger, OqronRegistry, reconfigureConfig, loadConfig, MemoryLockAdapter, DbLockAdapter, NamespacedLockAdapter } from './chunk-I6QFT3MR.mjs';
+export { DbLockAdapter, MemoryLockAdapter, OqronEventBus, createLogger, cron, defineConfig, schedule } from './chunk-I6QFT3MR.mjs';
+import fs from 'fs/promises';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import Database from 'better-sqlite3';
+
+// src/db/adapters/memory.adapter.ts
+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
+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
+    );
+  }
+};
+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 Database(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/server/handlers.ts
+var recentEvents = [];
+function appendEvent(event, data) {
+  recentEvents.unshift({ ts: (/* @__PURE__ */ new Date()).toISOString(), event, data });
+  if (recentEvents.length > 500) recentEvents.pop();
+}
+OqronEventBus.on(
+  "job:start",
+  (jobId, mod) => appendEvent("job:start", { jobId, mod })
+);
+OqronEventBus.on(
+  "job:success",
+  (jobId) => appendEvent("job:success", { jobId })
+);
+OqronEventBus.on(
+  "job:fail",
+  (jobId, err) => appendEvent("job:fail", { jobId, error: err.message })
+);
+OqronEventBus.on("system:ready", () => appendEvent("system:ready", {}));
+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
+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
+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 MemoryLockAdapter();
+    } else if ("adapter" in _config.lock) {
+      const { adapter, url, ttl } = _config.lock;
+      if (adapter === "db") {
+        if (_db instanceof SqliteAdapter) {
+          _lock = new DbLockAdapter(_db.db, ttl);
+        } else {
+          _lock = new DbLockAdapter(url ?? "oqron.sqlite", ttl);
+        }
+      } else if (adapter === "memory") {
+        _lock = new 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, _drainPending } = await import('./scheduler-HRR3UXGE.mjs');
+      if (_config.jobsDir) {
+        const jobsPath = path.resolve(cwd, _config.jobsDir);
+        _logger.debug(`Scanning jobsDir: ${jobsPath}`);
+        try {
+          async function scan(dir) {
+            try {
+              const entries = await fs.readdir(dir, { withFileTypes: true });
+              for (const entry of entries) {
+                const fullPath = path.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(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 = _drainPending();
+      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 SchedulerModule(
+        schedules,
+        nsDb,
+        nsLock,
+        _logger,
+        _config.environment,
+        _config.project,
+        _config.cron
+      );
+      OqronRegistry.getInstance().register(scheduler);
+    }
+    if (_config.modules.includes("scheduler")) {
+      const { ScheduleEngine, _drainPendingSchedules } = await import('./scheduler-HRR3UXGE.mjs');
+      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 = _drainPendingSchedules();
+      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 ScheduleEngine(
+        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;
+
+export { OqronKit, SqliteAdapter, index_default as default };