novac 2.2.1 → 2.3.0

package/kits/libtasker/kitdef.js

@@ -1,125 +1,1414 @@
+'use strict';
+// ============================================================
+//  kitasker.js  —  Comprehensive Task Scheduling Library
+//  120+ features: classes, methods, utilities, and structures
+// ============================================================
+
+// ─── Time Units ──────────────────────────────────────────────────────────────
 const units = {
-    ms: 1,
-    s: 1000,
-    m: 60 * 1000,
-    h: 60 * 60 * 1000,
-    day: 24 * 60 * 60 * 1000,
-    week: 7 * 24 * 60 * 60 * 1000,
-    month: 30 * 24 * 60 * 60 * 1000,
-    year: 365 * 24 * 60 * 60 * 1000,
+  ns:        1 / 1e6,
+  ms:        1,
+  s:         1_000,
+  m:         60_000,
+  h:         3_600_000,
+  day:       86_400_000,
+  week:      604_800_000,
+  fortnight: 1_209_600_000,
+  month:     2_592_000_000,
+  quarter:   7_776_000_000,
+  year:      31_536_000_000,
+  decade:    315_360_000_000,
+};
+
+// ─── Task State Enum ─────────────────────────────────────────────────────────
+const State = Object.freeze({
+  PENDING:   'pending',
+  RUNNING:   'running',
+  RESOLVED:  'resolved',
+  CANCELLED: 'cancelled',
+  FAILED:    'failed',
+});
+
+// ╔══════════════════════════════════════════════════════════════════════════╗
+// ║  SECTION 1 — Utility Functions (20)                                     ║
+// ╚══════════════════════════════════════════════════════════════════════════╝
+
+/** 1. Convert delay + unit string to milliseconds */
+function parseUnit(delay, unit) {
+  return delay * (units[unit] ?? units.s);
+}
+
+/** 2. Format milliseconds into a human-readable string */
+function humanDuration(ms) {
+  if (ms < 1_000)        return `${ms}ms`;
+  if (ms < 60_000)       return `${(ms / 1_000).toFixed(2)}s`;
+  if (ms < 3_600_000)    return `${(ms / 60_000).toFixed(2)}m`;
+  if (ms < 86_400_000)   return `${(ms / 3_600_000).toFixed(2)}h`;
+  return `${(ms / 86_400_000).toFixed(2)}d`;
+}
+
+/** 3. Clamp a number between min and max */
+function clamp(val, min, max) {
+  return Math.min(Math.max(val, min), max);
+}
+
+/** 4. Generate a short unique ID */
+function uid() {
+  return Math.random().toString(36).slice(2, 10) + Date.now().toString(36);
+}
+
+/** 5. Deep clone a plain object/array via JSON round-trip */
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+
+/** 6. No-operation placeholder function */
+function noop() {}
+
+/** 7. Check if a value is a thenable (Promise-like) */
+function isPromise(val) {
+  return !!val && typeof val === 'object' && typeof val.then === 'function';
+}
+
+/** 8. Memoize a function (cache by first arg JSON key) */
+function memoize(fn) {
+  const cache = new Map();
+  return function (...args) {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) return cache.get(key);
+    const result = fn.apply(this, args);
+    cache.set(key, result);
+    return result;
   };
-class Task {
-    constructor(name, fn, options = {}) {
-        this.name = name;
-        this.fn = fn;
-        this.options = options;
-        this.resolved = false;
-        process.on('exit', () => {
-            if (!this.resolved) {
-                console.warn(`Task "${this.name}" was not resolved before process exit.`);
-            }
-        });
-    }
-    schedule(delay, unit) {
-      const delayMs = delay * (units[unit] || 1000);
-        setTimeout(() => {
-            this.fn();
-            this.resolved = true;
-        }, delayMs);
-    }
-    interval(delay, unit) {
-        const delayMs = delay * (units[unit] || 1000);
-            setInterval(() => {
-                this.fn();
-                this.resolved = true;
-            }, delayMs);
-    }
-    run() {
-      return new Promise((resolve, reject) => {
-        try {
-          const result = this.fn();
-          this.resolved = true; 
-          resolve(result);
-        } catch (error) {
-          reject(error);
-        }
-        this.remove();
-      });
-    }
-    remove() {
-        this.resolved = true;
-        delete this;
-    }
 }
-class SyncTask {
-    constructor(name, fn, options = {}) {
-        this.name = name;
-        this.fn = fn;
-        this.options = options;
-        this.resolved = false;
-        process.on('exit', () => {
-            if (!this.resolved) {
-                console.warn(`Task "${this.name}" was not resolved before process exit.`);
-            }
-        });
+
+/** 9. Wrap a function so it executes at most once */
+function once(fn) {
+  let called = false, result;
+  return function (...args) {
+    if (!called) { called = true; result = fn.apply(this, args); }
+    return result;
+  };
+}
+
+/** 10. Debounce — delays fn until `delay` ms after the last call */
+function debounce(fn, delay) {
+  let timer;
+  return function (...args) {
+    clearTimeout(timer);
+    timer = setTimeout(() => fn.apply(this, args), delay);
+  };
+}
+
+/** 11. Throttle — fn executes at most once per `delay` ms */
+function throttle(fn, delay) {
+  let last = 0;
+  return function (...args) {
+    const now = Date.now();
+    if (now - last >= delay) { last = now; return fn.apply(this, args); }
+  };
+}
+
+/** 12. Return a Promise that resolves after `ms` milliseconds */
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+/** 13. Retry an async fn up to `times` times with `delay` ms between */
+async function retryFn(fn, times = 3, delay = 1_000) {
+  for (let i = 0; i < times; i++) {
+    try   { return await fn(); }
+    catch (err) {
+      if (i === times - 1) throw err;
+      await sleep(delay);
     }
-    schedule(delay, unit) {
-      const delayMs = delay * (units[unit] || 1000);
-      let execDate = delayMs + Date.now();
-      while (true) {
-        if (Date.now() >= execDate) {
-            this.fn();
-            this.resolved = true;
-            break;
-        }
-        /* spin */
+  }
+}
+
+/** 14. Race a promise against a hard timeout */
+function timeoutFn(promise, ms) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) =>
+      setTimeout(() => reject(new TaskError(`Timed out after ${ms}ms`, 'TIMEOUT')), ms)
+    ),
+  ]);
+}
+
+/** 15. Wrap a synchronous function to always return a Promise */
+function wrapAsync(fn) {
+  return async function (...args) { return fn.apply(this, args); };
+}
+
+/** 16. Format a Date object to ISO string (defaults to now) */
+function formatDate(d = new Date()) {
+  return d.toISOString();
+}
+
+/**
+ * 17. Very simple 5-field cron parser (s m h dom mon).
+ *     Returns ms until next scheduled run.
+ */
+function parseCron(expr) {
+  const fields = expr.trim().split(/\s+/);
+  if (fields.length !== 5) throw new TaskError('Cron must have 5 fields', 'CRON');
+  const [sec, min, hour, dom, mon] = fields.map(f => f === '*' ? null : parseInt(f, 10));
+  const now  = new Date();
+  const next = new Date(now);
+  next.setMilliseconds(0);
+  if (sec  !== null) next.setSeconds(sec);   else next.setSeconds(next.getSeconds() + 1);
+  if (min  !== null) next.setMinutes(min);
+  if (hour !== null) next.setHours(hour);
+  if (dom  !== null) next.setDate(dom);
+  if (mon  !== null) next.setMonth(mon - 1);
+  if (next <= now)   next.setDate(next.getDate() + 1);
+  return next.getTime() - now.getTime();
+}
+
+/** 18. Compose multiple functions left-to-right (pipeline style) */
+function compose(...fns) {
+  return (x) => fns.reduce((v, f) => f(v), x);
+}
+
+/** 19. Chunk an array into sub-arrays of size `n` */
+function chunk(arr, n) {
+  const out = [];
+  for (let i = 0; i < arr.length; i += n) out.push(arr.slice(i, i + n));
+  return out;
+}
+
+/** 20. Linear interpolation between `a` and `b` by factor `t` */
+function lerp(a, b, t) {
+  return a + (b - a) * clamp(t, 0, 1);
+}
+
+// ╔══════════════════════════════════════════════════════════════════════════╗
+// ║  SECTION 2 — Core Data Classes (6)                                      ║
+// ╚══════════════════════════════════════════════════════════════════════════╝
+
+// ─── TaskError ───────────────────────────────────────────────────────────────
+/** 21. Custom error class carrying a code and optional metadata */
+class TaskError extends Error {
+  constructor(message, code = 'TASK_ERROR', meta = {}) {
+    super(message);
+    this.name      = 'TaskError';
+    this.code      = code;
+    this.meta      = meta;
+    this.timestamp = Date.now();
+    if (Error.captureStackTrace) Error.captureStackTrace(this, TaskError);
+  }
+  toJSON() {
+    return {
+      name: this.name, message: this.message,
+      code: this.code, meta:    this.meta,
+      timestamp: this.timestamp,
+    };
+  }
+}
+
+// ─── TaskResult ──────────────────────────────────────────────────────────────
+/** 22. Immutable wrapper for the outcome of a task run */
+class TaskResult {
+  constructor(value, meta = {}) {
+    this.value     = value;
+    this.meta      = meta;
+    this.timestamp = Date.now();
+    this.ok        = true;
+    this.error     = null;
+  }
+
+  /** 23. Create a failed TaskResult */
+  static fail(error, meta = {}) {
+    const r = new TaskResult(null, meta);
+    r.ok    = false;
+    r.error = error;
+    return r;
+  }
+
+  /** 24. Map the result value (no-op on failure) */
+  map(fn) {
+    if (!this.ok) return this;
+    return new TaskResult(fn(this.value), this.meta);
+  }
+
+  /** 25. FlatMap / chain with a fn that returns a TaskResult */
+  chain(fn) {
+    if (!this.ok) return this;
+    return fn(this.value);
+  }
+
+  /** 26. Provide a fallback value if this result failed */
+  orElse(fallback) {
+    return this.ok ? this.value : fallback;
+  }
+
+  toJSON() {
+    return {
+      ok:        this.ok,
+      value:     this.value,
+      error:     this.error?.toJSON?.() ?? this.error,
+      timestamp: this.timestamp,
+    };
+  }
+}
+
+// ─── TaskStats ───────────────────────────────────────────────────────────────
+/** 27. Per-task runtime statistics */
+class TaskStats {
+  constructor() {
+    this.runCount   = 0;
+    this.errorCount = 0;
+    this.totalTime  = 0;
+    this.minTime    = Infinity;
+    this.maxTime    = 0;
+    this.lastRun    = null;
+    this.lastError  = null;
+    this._history   = [];
+    this.historyMax = 100;
+  }
+
+  /** 28. Record one completed execution */
+  record(durationMs, error = null) {
+    this.runCount++;
+    this.totalTime += durationMs;
+    if (durationMs < this.minTime) this.minTime = durationMs;
+    if (durationMs > this.maxTime) this.maxTime = durationMs;
+    this.lastRun = Date.now();
+    if (error) { this.errorCount++; this.lastError = error; }
+    this._history.push({ duration: durationMs, error: error?.message ?? null, ts: this.lastRun });
+    if (this._history.length > this.historyMax) this._history.shift();
+  }
+
+  /** 29. Average run time in ms */
+  get avgTime() { return this.runCount ? this.totalTime / this.runCount : 0; }
+
+  /** 30. Success rate 0–1 */
+  get successRate() {
+    return this.runCount ? (this.runCount - this.errorCount) / this.runCount : 1;
+  }
+
+  /** 31. Last N history entries */
+  getHistory(n = this.historyMax) { return this._history.slice(-n); }
+
+  /** 32. Reset all stats to zero */
+  reset() { Object.assign(this, new TaskStats()); }
+
+  toJSON() {
+    return {
+      runCount:    this.runCount,
+      errorCount:  this.errorCount,
+      avgTime:     this.avgTime,
+      minTime:     this.minTime === Infinity ? null : this.minTime,
+      maxTime:     this.maxTime,
+      successRate: this.successRate,
+      lastRun:     this.lastRun,
+      lastError:   this.lastError?.message ?? null,
+    };
+  }
+}
+
+// ─── TaskLogger ──────────────────────────────────────────────────────────────
+/** 33. Pluggable logger with level filtering and history */
+class TaskLogger {
+  constructor(opts = {}) {
+    this.prefix     = opts.prefix     ?? '[Tasker]';
+    this.level      = opts.level      ?? 'info';  // debug|info|warn|error|none
+    this.silent     = opts.silent     ?? false;
+    this.maxHistory = opts.maxHistory ?? 500;
+    this._history   = [];
+    this._LEVELS    = { debug: 0, info: 1, warn: 2, error: 3, none: 99 };
+  }
+
+  _log(lvl, ...args) {
+    const rank  = this._LEVELS[lvl]        ?? 1;
+    const floor = this._LEVELS[this.level] ?? 1;
+    const entry = { level: lvl, message: args.join(' '), ts: Date.now() };
+    this._history.push(entry);
+    if (this._history.length > this.maxHistory) this._history.shift();
+    if (this.silent || rank < floor) return;
+    (console[lvl] ?? console.log)(`${this.prefix} [${lvl.toUpperCase()}]`, ...args);
+  }
+
+  /** 34. Debug-level log */
+  debug(...a)    { this._log('debug', ...a); }
+  /** 35. Info-level log */
+  info(...a)     { this._log('info',  ...a); }
+  /** 36. Warn-level log */
+  warn(...a)     { this._log('warn',  ...a); }
+  /** 37. Error-level log */
+  error(...a)    { this._log('error', ...a); }
+  /** 38. Get a copy of the log history */
+  getHistory()   { return [...this._history]; }
+  /** 39. Clear log history */
+  clearHistory() { this._history = []; }
+}
+
+// ─── TaskEventEmitter ────────────────────────────────────────────────────────
+/** 40. Minimal typed event emitter used as base for all task classes */
+class TaskEventEmitter {
+  constructor() { this._listeners = {}; }
+
+  /** 41. Subscribe to an event */
+  on(event, fn) {
+    (this._listeners[event] ??= []).push(fn);
+    return this;
+  }
+
+  /** 42. Subscribe for a single emission only */
+  once(event, fn) {
+    const w = (...a) => { fn(...a); this.off(event, w); };
+    return this.on(event, w);
+  }
+
+  /** 43. Unsubscribe a specific listener */
+  off(event, fn) {
+    this._listeners[event] = (this._listeners[event] ?? []).filter(l => l !== fn);
+    return this;
+  }
+
+  /** 44. Emit an event to all subscribers (also fires wildcard '*') */
+  emit(event, ...args) {
+    (this._listeners[event] ?? []).forEach(fn => fn(...args));
+    (this._listeners['*']   ?? []).forEach(fn => fn(event, ...args));
+    return this;
+  }
+
+  /** 45. Remove all listeners for one event, or all events */
+  removeAllListeners(event) {
+    if (event) delete this._listeners[event];
+    else       this._listeners = {};
+    return this;
+  }
+
+  /** 46. List all event names with at least one listener */
+  eventNames() { return Object.keys(this._listeners); }
+}
+
+// ─── TaskMiddlewarePipeline ───────────────────────────────────────────────────
+/** 47. Koa-style async middleware pipeline for before/after hooks */
+class TaskMiddlewarePipeline {
+  constructor() { this._mw = []; }
+
+  /** 48. Register an async middleware fn(ctx, next) */
+  use(fn) { this._mw.push(fn); return this; }
+
+  /** 49. Execute pipeline with a shared context object */
+  async run(ctx) {
+    let i = 0;
+    const next = async () => {
+      if (i < this._mw.length) await this._mw[i++](ctx, next);
+    };
+    await next();
+    return ctx;
+  }
+}
+
+// ╔══════════════════════════════════════════════════════════════════════════╗
+// ║  SECTION 3 — Core Task Classes (Task + SyncTask, upgraded)             ║
+// ╚══════════════════════════════════════════════════════════════════════════╝
+
+// ─── Task ────────────────────────────────────────────────────────────────────
+/**
+ * 50. Async-friendly task with full lifecycle: state, hooks, retries,
+ *     timeout, tags, dependencies, scheduling, and serialisation.
+ */
+class Task extends TaskEventEmitter {
+  constructor(name, fn, options = {}) {
+    super();
+    this.id           = uid();
+    this.name         = name;
+    this.fn           = fn;
+    this.options      = options;
+    this.stats        = new TaskStats();
+    this._state       = State.PENDING;
+    this._tags        = new Set(options.tags ?? []);
+    this._meta        = {};
+    this._hooks       = { before: [], after: [], error: [], cancel: [] };
+    this._timers      = [];
+    this._runCount    = 0;
+    this._maxRuns     = options.maxRuns    ?? Infinity;
+    this._locked      = false;
+    this._retries     = options.retries    ?? 0;
+    this._retryDelay  = options.retryDelay ?? 1_000;
+    this._timeoutMs   = options.timeout    ?? null;
+    this._deps        = [];
+    this._logger      = options.logger     ?? null;
+
+    process.on('exit', () => {
+      if (this._state === State.PENDING || this._state === State.RUNNING) {
+        process.stderr.write(`[kitasker] Task "${this.name}" exited in state "${this._state}"\n`);
       }
+    });
+  }
+
+  // ── State Queries ──────────────────────────────────────────────────────
+  /** 51. True when task has not yet started */
+  isPending()   { return this._state === State.PENDING;   }
+  /** 52. True while the fn is executing */
+  isRunning()   { return this._state === State.RUNNING;   }
+  /** 53. True after a successful run */
+  isResolved()  { return this._state === State.RESOLVED;  }
+  /** 54. True after cancel() was called */
+  isCancelled() { return this._state === State.CANCELLED; }
+  /** 55. True if the last run threw and all retries failed */
+  isFailed()    { return this._state === State.FAILED;    }
+  /** 56. Current state string */
+  getState()    { return this._state; }
+
+  // ── Metadata & Tags ────────────────────────────────────────────────────
+  /** 57. Store an arbitrary key-value pair on this task */
+  setMeta(key, value) { this._meta[key] = value; return this; }
+  /** 58. Retrieve a stored metadata value */
+  getMeta(key)        { return this._meta[key]; }
+  /** 59. Attach one or more tags */
+  tag(...tags)        { tags.forEach(t => this._tags.add(t)); return this; }
+  /** 60. Check for a specific tag */
+  hasTag(t)           { return this._tags.has(t); }
+  /** 61. Return all tags as an array */
+  getTags()           { return [...this._tags]; }
+
+  // ── Lifecycle Hooks ────────────────────────────────────────────────────
+  /** 62. Run a callback immediately before execution */
+  onStart(fn)    { this._hooks.before.push(fn); return this; }
+  /** 63. Run a callback after successful execution */
+  onComplete(fn) { this._hooks.after.push(fn);  return this; }
+  /** 64. Run a callback on error (after all retries) */
+  onError(fn)    { this._hooks.error.push(fn);  return this; }
+  /** 65. Run a callback when cancel() is called */
+  onCancel(fn)   { this._hooks.cancel.push(fn); return this; }
+
+  // ── Configuration Chaining ─────────────────────────────────────────────
+  /** 66. Set retry count and optional delay between retries */
+  retry(n, delayMs = 1_000) { this._retries = n; this._retryDelay = delayMs; return this; }
+  /** 67. Fail task if it exceeds this many ms */
+  timeout(ms)  { this._timeoutMs = ms; return this; }
+  /** 68. Limit total runs (interval/recurring respect this) */
+  times(n)     { this._maxRuns = n;   return this; }
+  /** 69. Convenience: run exactly once, then auto-cancel on interval */
+  once()       { return this.times(1); }
+  /** 70. Prevent run() from executing */
+  lock()       { this._locked = true;  return this; }
+  /** 71. Allow run() again */
+  unlock()     { this._locked = false; return this; }
+  /** 72. Declare upstream Task dependencies (await them before running) */
+  depends(...tasks) { this._deps.push(...tasks); return this; }
+
+  // ── Internal Helpers ───────────────────────────────────────────────────
+  async _runHooks(hooks, ...args) {
+    for (const h of hooks) await h(...args);
+  }
+  _trackTimer(t) { this._timers.push(t); return t; }
+
+  // ── Core Execution ─────────────────────────────────────────────────────
+  /** 73. Execute the task asynchronously; returns a TaskResult */
+  async run() {
+    if (this._locked)
+      throw new TaskError(`Task "${this.name}" is locked.`, 'LOCKED');
+    if (this._runCount >= this._maxRuns)
+      throw new TaskError(`Task "${this.name}" reached max runs (${this._maxRuns}).`, 'MAX_RUNS');
+    if (this._state === State.CANCELLED)
+      throw new TaskError(`Task "${this.name}" is cancelled.`, 'CANCELLED');
+
+    // Resolve dependencies first
+    for (const dep of this._deps) {
+      if (!dep.isResolved()) await dep.run();
     }
-    interval(delay, unit) {
-      const delayMs = delay * (units[unit] || 1000);
-      let execDate = delayMs + Date.now();
-      while (true) {
-        if (Date.now() >= execDate) {
-            execDate += delayMs;
-            this.fn();
-            this.resolved = true;
+
+    this._state = State.RUNNING;
+    this._runCount++;
+    this.emit('start', this);
+    this._logger?.debug(`▶ ${this.name} starting (run #${this._runCount})`);
+    await this._runHooks(this._hooks.before, this);
+
+    const t0          = Date.now();
+    let result, error;
+    const maxAttempts = this._retries + 1;
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        let p = Promise.resolve().then(() => this.fn(this));
+        if (this._timeoutMs) p = timeoutFn(p, this._timeoutMs);
+        result = await p;
+        error  = null;
+        break;
+      } catch (err) {
+        error = err instanceof TaskError
+          ? err
+          : new TaskError(err.message, 'EXEC', { original: err });
+        if (attempt < maxAttempts) {
+          this._logger?.warn(`↺ ${this.name} retry ${attempt}/${this._retries}: ${error.message}`);
+          this.emit('retry', this, attempt, error);
+          await sleep(this._retryDelay);
         }
-        /* spin */
       }
     }
-    run() {
-      let result = null;
-      try {
-          result = this.fn();
-          this.resolved = true; 
-        } catch (error) {
-          throw error;
-        }
-      this.remove();
-      return result;
+
+    const duration = Date.now() - t0;
+    this.stats.record(duration, error);
+
+    if (error) {
+      this._state = State.FAILED;
+      this._logger?.error(`✗ ${this.name} failed in ${humanDuration(duration)}: ${error.message}`);
+      await this._runHooks(this._hooks.error, error, this);
+      this.emit('error', error, this);
+      return TaskResult.fail(error, { duration, task: this.name });
     }
-    remove() {
-        this.resolved = true;
-        delete this;
+
+    this._state = State.RESOLVED;
+    this._logger?.info(`✓ ${this.name} done in ${humanDuration(duration)}`);
+    const tr = new TaskResult(result, { duration, task: this.name });
+    await this._runHooks(this._hooks.after, tr, this);
+    this.emit('complete', tr, this);
+    return tr;
+  }
+
+  /** 74. Schedule a single delayed execution */
+  schedule(delay, unit) {
+    const ms = parseUnit(delay, unit);
+    this._trackTimer(setTimeout(() => this.run(), ms));
+    return this;
+  }
+
+  /** 75. Schedule a repeating execution; respects maxRuns */
+  interval(delay, unit) {
+    const ms = parseUnit(delay, unit);
+    const t  = setInterval(() => {
+      if (this._runCount >= this._maxRuns) { clearInterval(t); return; }
+      this.run();
+    }, ms);
+    this._trackTimer(t);
+    return this;
+  }
+
+  /** 76. Cancel all pending timers and mark the task cancelled */
+  cancel() {
+    this._timers.forEach(t => { clearTimeout(t); clearInterval(t); });
+    this._timers = [];
+    if (this._state !== State.RESOLVED) this._state = State.CANCELLED;
+    this._runHooks(this._hooks.cancel, this);
+    this.emit('cancel', this);
+    return this;
+  }
+
+  /** 77. Reset state so the task can be run again */
+  reset() {
+    this._state    = State.PENDING;
+    this._runCount = 0;
+    this.stats.reset();
+    return this;
+  }
+
+  /** 78. Clone this task with a new ID */
+  clone() {
+    const t = new Task(`${this.name}_clone`, this.fn, deepClone(this.options));
+    t._retries    = this._retries;
+    t._retryDelay = this._retryDelay;
+    t._timeoutMs  = this._timeoutMs;
+    t._maxRuns    = this._maxRuns;
+    this.getTags().forEach(tag => t.tag(tag));
+    return t;
+  }
+
+  /** 79. Serialize this task's configuration and stats */
+  toJSON() {
+    return {
+      id:       this.id,
+      name:     this.name,
+      state:    this._state,
+      tags:     this.getTags(),
+      meta:     this._meta,
+      runCount: this._runCount,
+      maxRuns:  this._maxRuns,
+      retries:  this._retries,
+      timeout:  this._timeoutMs,
+      stats:    this.stats.toJSON(),
+    };
+  }
+}
+
+// ─── SyncTask ────────────────────────────────────────────────────────────────
+/** 80. Synchronous task — blocks the event loop; only for very fast ops */
+class SyncTask extends TaskEventEmitter {
+  constructor(name, fn, options = {}) {
+    super();
+    this.id      = uid();
+    this.name    = name;
+    this.fn      = fn;
+    this.options = options;
+    this.stats   = new TaskStats();
+    this._state  = State.PENDING;
+    this._meta   = {};
+
+    process.on('exit', () => {
+      if (this._state === State.PENDING)
+        process.stderr.write(`[kitasker] SyncTask "${this.name}" never ran.\n`);
+    });
+  }
+
+  /** 81. Execute synchronously; returns a TaskResult */
+  run() {
+    const t0 = Date.now();
+    this._state = State.RUNNING;
+    this.emit('start', this);
+    try {
+      const result = this.fn(this);
+      this._state  = State.RESOLVED;
+      const d = Date.now() - t0;
+      this.stats.record(d);
+      this.emit('complete', result, this);
+      return new TaskResult(result, { duration: d, task: this.name });
+    } catch (err) {
+      this._state  = State.FAILED;
+      const e = new TaskError(err.message, 'SYNC_EXEC');
+      const d = Date.now() - t0;
+      this.stats.record(d, e);
+      this.emit('error', e, this);
+      return TaskResult.fail(e, { task: this.name });
     }
+  }
+
+  /** 82. Spin-wait then run once */
+  schedule(delay, unit) {
+    const end = Date.now() + parseUnit(delay, unit);
+    while (Date.now() < end) { /* busy-wait */ }
+    return this.run();
+  }
+
+  /** 83. Spin-wait interval (blocks forever — only for extremely short intervals) */
+  interval(delay, unit) {
+    const ms = parseUnit(delay, unit);
+    let next = Date.now() + ms;
+    while (true) { if (Date.now() >= next) { this.run(); next += ms; } }
+  }
+
+  /** 84. Set a metadata key */
+  setMeta(k, v) { this._meta[k] = v; return this; }
+  /** 85. Get a metadata key */
+  getMeta(k)    { return this._meta[k]; }
+
+  toJSON() {
+    return { id: this.id, name: this.name, state: this._state, stats: this.stats.toJSON() };
+  }
 }
 
-class Tasker {
-    constructor(name, opts = {}) {
-       this.name = name;
-       this.options = opts;
+// ╔══════════════════════════════════════════════════════════════════════════╗
+// ║  SECTION 4 — Specialised Task Subclasses (8)                           ║
+// ╚══════════════════════════════════════════════════════════════════════════╝
+
+// ─── RetryTask ───────────────────────────────────────────────────────────────
+/** 86. Task with configurable retry backoff strategies */
+class RetryTask extends Task {
+  constructor(name, fn, options = {}) {
+    super(name, fn, { retries: 3, retryDelay: 500, ...options });
+    this._backoff = options.backoff ?? 'linear'; // 'fixed' | 'linear' | 'exponential'
+  }
+
+  /** 87. Set backoff strategy: 'fixed' | 'linear' | 'exponential' */
+  backoff(strategy) { this._backoff = strategy; return this; }
+
+  /** 88. Compute delay for a given attempt number */
+  _nextDelay(attempt) {
+    if (this._backoff === 'exponential') return this._retryDelay * (2 ** (attempt - 1));
+    if (this._backoff === 'linear')      return this._retryDelay * attempt;
+    return this._retryDelay;
+  }
+}
+
+// ─── TimeoutTask ─────────────────────────────────────────────────────────────
+/** 89. Task that automatically fails if execution exceeds a time limit */
+class TimeoutTask extends Task {
+  constructor(name, fn, ms, options = {}) {
+    super(name, fn, { timeout: ms, ...options });
+  }
+
+  /** 90. Update timeout value at runtime */
+  setTimeout(ms) { this._timeoutMs = ms; return this; }
+}
+
+// ─── DebouncedTask ───────────────────────────────────────────────────────────
+/** 91. Task whose run() is debounced — only fires after a quiet period */
+class DebouncedTask extends Task {
+  constructor(name, fn, delay, options = {}) {
+    super(name, fn, options);
+    this._debounceDelay = delay;
+    this._debounced     = debounce(() => super.run(), delay);
+  }
+
+  /** 92. Debounced run() */
+  run() { return this._debounced(); }
+
+  /** 93. Update debounce delay and rebuild the debounced wrapper */
+  setDelay(ms) {
+    this._debounceDelay = ms;
+    this._debounced     = debounce(() => super.run(), ms);
+    return this;
+  }
+}
+
+// ─── ThrottledTask ───────────────────────────────────────────────────────────
+/** 94. Task whose run() is throttled to at most once per interval */
+class ThrottledTask extends Task {
+  constructor(name, fn, delay, options = {}) {
+    super(name, fn, options);
+    this._throttleDelay = delay;
+    this._throttled     = throttle(() => super.run(), delay);
+  }
+
+  /** 95. Throttled run() */
+  run() { return this._throttled(); }
+
+  /** 96. Update throttle delay */
+  setDelay(ms) {
+    this._throttleDelay = ms;
+    this._throttled     = throttle(() => super.run(), ms);
+    return this;
+  }
+}
+
+// ─── ConditionalTask ─────────────────────────────────────────────────────────
+/** 97. Task that only executes when a guard function returns truthy */
+class ConditionalTask extends Task {
+  constructor(name, fn, condition, options = {}) {
+    super(name, fn, options);
+    this._condition = condition;
+  }
+
+  /** 98. Check condition before delegating to super.run() */
+  async run() {
+    const ok = await Promise.resolve(this._condition());
+    if (!ok) {
+      this.emit('skip', this);
+      return TaskResult.fail(
+        new TaskError('Condition not met', 'CONDITION'),
+        { task: this.name }
+      );
     }
-    createTask(name, fn, opts) {
-        return new Task(name, fn, opts);
+    return super.run();
+  }
+
+  /** 99. Replace the guard function at runtime */
+  setCondition(fn) { this._condition = fn; return this; }
+}
+
+// ─── PriorityTask ────────────────────────────────────────────────────────────
+/** 100. Task with a numeric priority (higher = run first in queues) */
+class PriorityTask extends Task {
+  constructor(name, fn, priority = 0, options = {}) {
+    super(name, fn, options);
+    this.priority = priority;
+  }
+
+  /** 101. Update priority value */
+  setPriority(n) { this.priority = n; return this; }
+}
+
+// ─── RecurringTask ───────────────────────────────────────────────────────────
+/** 102. Interval-based task with pause/resume/stop controls */
+class RecurringTask extends Task {
+  constructor(name, fn, delay, unit = 'ms', options = {}) {
+    super(name, fn, options);
+    this._delay    = parseUnit(delay, unit);
+    this._paused   = false;
+    this._timer    = null;
+    this._runLimit = options.runLimit ?? Infinity;
+  }
+
+  /** 103. Start the recurring interval */
+  start() {
+    this._timer = setInterval(async () => {
+      if (this._paused) return;
+      if (this._runCount >= this._runLimit) { this.stop(); return; }
+      await this.run();
+    }, this._delay);
+    this._trackTimer(this._timer);
+    this.emit('start', this);
+    return this;
+  }
+
+  /** 104. Pause (timer ticks, fn is skipped) */
+  pause()  { this._paused = true;  this.emit('pause',  this); return this; }
+  /** 105. Resume after pause */
+  resume() { this._paused = false; this.emit('resume', this); return this; }
+  /** 106. Stop the interval entirely */
+  stop()   { clearInterval(this._timer); this.emit('stop', this); return this; }
+
+  /** 107. Change the interval delay (restarts the timer) */
+  setDelay(delay, unit = 'ms') {
+    this._delay = parseUnit(delay, unit);
+    this.stop();
+    return this.start();
+  }
+}
+
+// ─── CronTask ────────────────────────────────────────────────────────────────
+/** 108. Task driven by a 5-field cron expression */
+class CronTask extends Task {
+  constructor(name, fn, cronExpr, options = {}) {
+    super(name, fn, options);
+    this._expr  = cronExpr;
+    this._timer = null;
+  }
+
+  /** 109. Start the cron loop */
+  start() {
+    const schedule = () => {
+      try {
+        const ms    = parseCron(this._expr);
+        this._timer = setTimeout(async () => { await this.run(); schedule(); }, ms);
+        this._trackTimer(this._timer);
+      } catch (e) { this.emit('error', e, this); }
+    };
+    schedule();
+    return this;
+  }
+
+  /** 110. Stop the cron and cancel the task */
+  stop() {
+    clearTimeout(this._timer);
+    this.cancel();
+    return this;
+  }
+
+  /** 111. Swap cron expression and restart */
+  setExpr(expr) {
+    this._expr  = expr;
+    this.stop();
+    this._state = State.PENDING;
+    return this.start();
+  }
+}
+
+// ╔══════════════════════════════════════════════════════════════════════════╗
+// ║  SECTION 5 — Composite / Structural Classes (8)                         ║
+// ╚══════════════════════════════════════════════════════════════════════════╝
+
+// ─── BatchTask ───────────────────────────────────────────────────────────────
+/** 112. Runs an array of items through a function in configurable batches */
+class BatchTask extends TaskEventEmitter {
+  constructor(name, items, fn, options = {}) {
+    super();
+    this.id        = uid();
+    this.name      = name;
+    this.items     = items;
+    this.fn        = fn;
+    this.batchSize = options.batchSize ?? 10;
+    this.delay     = options.delay     ?? 0;
+    this.stats     = new TaskStats();
+    this._state    = State.PENDING;
+  }
+
+  /** 113. Execute all items in batches; resolves with allSettled array */
+  async run() {
+    this._state     = State.RUNNING;
+    const results   = [];
+    const batches   = chunk(this.items, this.batchSize);
+    const t0        = Date.now();
+
+    for (const [i, batch] of batches.entries()) {
+      this.emit('batch', i, batch);
+      const r = await Promise.allSettled(batch.map(item => this.fn(item)));
+      results.push(...r);
+      if (this.delay && i < batches.length - 1) await sleep(this.delay);
     }
-    createSyncTask(name, fn, opts) {
-        return new SyncTask(name, fn, opts);
+
+    this._state = State.RESOLVED;
+    this.stats.record(Date.now() - t0);
+    this.emit('complete', results);
+    return results;
+  }
+
+  /** 114. Set items batch size */
+  setBatchSize(n)  { this.batchSize = n;  return this; }
+  /** 115. Set delay between batches in ms */
+  setBatchDelay(ms){ this.delay     = ms; return this; }
+}
+
+// ─── TaskChain ───────────────────────────────────────────────────────────────
+/** 116. Runs Tasks sequentially, threading results forward */
+class TaskChain extends TaskEventEmitter {
+  constructor(name) {
+    super();
+    this.id     = uid();
+    this.name   = name;
+    this._chain = [];
+    this._err   = null;
+    this.stats  = new TaskStats();
+    this._state = State.PENDING;
+  }
+
+  /** 117. Append a task to the chain */
+  then(task)   { this._chain.push(task); return this; }
+  /** 118. Attach an error handler (stops re-throw on failure) */
+  catch(fn)    { this._err = fn;         return this; }
+
+  /** 119. Run every task in sequence; each receives the previous result */
+  async run() {
+    this._state = State.RUNNING;
+    let prev    = undefined;
+    const t0    = Date.now();
+
+    for (const task of this._chain) {
+      try {
+        task.setMeta?.('prevResult', prev);
+        const tr = await task.run();
+        prev     = tr.value;
+        this.emit('step', task, tr);
+      } catch (err) {
+        this._state = State.FAILED;
+        if (this._err) { this._err(err, task); return undefined; }
+        throw err;
+      }
     }
-    removeTask(task) {
-        task.remove();
+
+    this._state = State.RESOLVED;
+    this.stats.record(Date.now() - t0);
+    this.emit('complete', prev);
+    return prev;
+  }
+
+  /** 120. Number of tasks in the chain */
+  get length() { return this._chain.length; }
+}
+
+// ─── TaskPipeline ────────────────────────────────────────────────────────────
+/** Pipes the output of each function as the input to the next */
+class TaskPipeline extends TaskEventEmitter {
+  constructor(name) {
+    super();
+    this.id    = uid();
+    this.name  = name;
+    this._fns  = [];
+    this.stats = new TaskStats();
+  }
+
+  /** Add a transform step */
+  pipe(fn) { this._fns.push(fn); return this; }
+
+  /** Run the pipeline from an initial value */
+  async run(initial) {
+    const t0 = Date.now();
+    let val  = initial;
+    for (const fn of this._fns) {
+      val = await Promise.resolve(fn(val));
+      this.emit('step', fn, val);
     }
-    scheduleTask(task, delay, unit) {
-        task.schedule(delay, unit);
+    this.stats.record(Date.now() - t0);
+    this.emit('complete', val);
+    return val;
+  }
+}
+
+// ─── TaskGroup ───────────────────────────────────────────────────────────────
+/** Group of tasks runnable as all / race / any / settled / sequential */
+class TaskGroup extends TaskEventEmitter {
+  constructor(name, tasks = []) {
+    super();
+    this.id     = uid();
+    this.name   = name;
+    this._tasks = [...tasks];
+  }
+
+  /** Add a task to the group */
+  add(task)    { this._tasks.push(task); return this; }
+  /** Remove task by name */
+  remove(name) { this._tasks = this._tasks.filter(t => t.name !== name); return this; }
+
+  /** Run all in parallel (Promise.all) */
+  all()        { return Promise.all(      this._tasks.map(t => t.run())); }
+  /** Race — first to resolve or reject wins */
+  race()       { return Promise.race(     this._tasks.map(t => t.run())); }
+  /** All results regardless of individual failure */
+  settled()    { return Promise.allSettled(this._tasks.map(t => t.run())); }
+  /** First to resolve successfully (Promise.any) */
+  any()        { return Promise.any(      this._tasks.map(t => t.run())); }
+
+  /** Run tasks one after another */
+  async sequential() {
+    const results = [];
+    for (const t of this._tasks) results.push(await t.run());
+    return results;
+  }
+
+  /** Get tasks filtered by tag */
+  byTag(tag)  { return this._tasks.filter(t => t.hasTag?.(tag)); }
+  /** Cancel every task in the group */
+  cancelAll() { this._tasks.forEach(t => t.cancel?.()); return this; }
+}
+
+// ─── TaskQueue ───────────────────────────────────────────────────────────────
+/** FIFO queue processing tasks with a configurable concurrency limit */
+class TaskQueue extends TaskEventEmitter {
+  constructor(name, opts = {}) {
+    super();
+    this.id          = uid();
+    this.name        = name;
+    this.concurrency = opts.concurrency ?? 1;
+    this._queue      = [];
+    this._running    = 0;
+    this._paused     = false;
+  }
+
+  /** Add a task to the queue */
+  enqueue(task) {
+    if (this.concurrency > 1) {
+      // priority-aware sort if tasks carry priority
+      const p = task.priority ?? 0;
+      let i = this._queue.findIndex(t => (t.priority ?? 0) < p);
+      if (i === -1) i = this._queue.length;
+      this._queue.splice(i, 0, task);
+    } else {
+      this._queue.push(task);
+    }
+    this.emit('enqueue', task);
+    this._tick();
+    return this;
+  }
+
+  _tick() {
+    while (!this._paused && this._running < this.concurrency && this._queue.length) {
+      const task = this._queue.shift();
+      this._running++;
+      this.emit('dequeue', task);
+      Promise.resolve(task.run())
+        .then(r  => { this._running--; this.emit('done',  task, r); this._tick(); })
+        .catch(e => { this._running--; this.emit('error', task, e); this._tick(); });
     }
+    if (!this._queue.length && !this._running) this.emit('drain');
+  }
+
+  /** Pause queue processing */
+  pause()  { this._paused = true;  this.emit('pause');  return this; }
+  /** Resume queue processing */
+  resume() { this._paused = false; this.emit('resume'); this._tick(); return this; }
+  /** Pending items count */
+  get size()   { return this._queue.length; }
+  /** Currently running count */
+  get active() { return this._running; }
+  /** Discard all pending (not currently running) tasks */
+  clear()  { this._queue = []; return this; }
+}
+
+// ─── TaskPool ────────────────────────────────────────────────────────────────
+/** Fixed-size slot pool — limits maximum concurrent task executions */
+class TaskPool extends TaskEventEmitter {
+  constructor(name, size = 4) {
+    super();
+    this.id    = uid();
+    this.name  = name;
+    this.size  = size;
+    this._slots   = Array.from({ length: size }, (_, i) => ({ id: i, busy: false }));
+    this._waiting = [];
+  }
+
+  _getFreeSlot() { return this._slots.find(s => !s.busy) ?? null; }
+
+  /** Submit a task to the pool; resolves when a slot becomes available */
+  submit(task) {
+    return new Promise((resolve, reject) => {
+      const attempt = () => {
+        const slot = this._getFreeSlot();
+        if (!slot) { this._waiting.push(attempt); return; }
+        slot.busy = true;
+        this.emit('acquire', slot.id);
+        Promise.resolve(task.run())
+          .then(r  => { slot.busy = false; this.emit('release', slot.id); this._waiting.shift()?.(); resolve(r); })
+          .catch(e => { slot.busy = false; this.emit('release', slot.id); this._waiting.shift()?.(); reject(e);  });
+      };
+      attempt();
+    });
+  }
+
+  /** Submit multiple tasks at once */
+  submitAll(tasks) { return Promise.all(tasks.map(t => this.submit(t))); }
+
+  /** Count of currently idle slots */
+  get freeSlots() { return this._slots.filter(s => !s.busy).length; }
+}
+
+// ─── SequentialTask ──────────────────────────────────────────────────────────
+/** Runs raw async functions in series, piping output as input */
+class SequentialTask extends TaskEventEmitter {
+  constructor(name, fns = []) {
+    super();
+    this.id     = uid();
+    this.name   = name;
+    this._fns   = fns;
+    this.stats  = new TaskStats();
+    this._state = State.PENDING;
+  }
+
+  /** Append a step */
+  add(fn) { this._fns.push(fn); return this; }
+
+  async run(initial) {
+    this._state  = State.RUNNING;
+    const t0     = Date.now();
+    let val      = initial;
+    for (const fn of this._fns) val = await Promise.resolve(fn(val));
+    this._state  = State.RESOLVED;
+    this.stats.record(Date.now() - t0);
+    return val;
+  }
+}
+
+// ─── ParallelTask ────────────────────────────────────────────────────────────
+/** Runs raw async functions concurrently and returns all results */
+class ParallelTask extends TaskEventEmitter {
+  constructor(name, fns = []) {
+    super();
+    this.id    = uid();
+    this.name  = name;
+    this._fns  = fns;
+    this.stats = new TaskStats();
+  }
+
+  /** Append a parallel step */
+  add(fn) { this._fns.push(fn); return this; }
+
+  async run(input) {
+    const t0      = Date.now();
+    const results = await Promise.all(this._fns.map(fn => fn(input)));
+    this.stats.record(Date.now() - t0);
+    return results;
+  }
+}
+
+// ╔══════════════════════════════════════════════════════════════════════════╗
+// ║  SECTION 6 — Management: TaskMonitor + TaskScheduler                   ║
+// ╚══════════════════════════════════════════════════════════════════════════╝
+
+// ─── TaskMonitor ─────────────────────────────────────────────────────────────
+/** Aggregates health and metrics across every registered task */
+class TaskMonitor extends TaskEventEmitter {
+  constructor() {
+    super();
+    this._tasks = new Map();
+  }
+
+  /** Register a task for monitoring */
+  register(task) {
+    this._tasks.set(task.id, task);
+    task.on?.('complete', tr => this.emit('task:complete', task, tr));
+    task.on?.('error',    e  => this.emit('task:error',    task, e));
+    return this;
+  }
+
+  /** Deregister a task */
+  unregister(task) { this._tasks.delete(task.id); return this; }
+
+  /** Full report for every monitored task */
+  report() {
+    return [...this._tasks.values()].map(t => ({
+      id:    t.id,
+      name:  t.name,
+      state: t._state,
+      stats: t.stats?.toJSON(),
+    }));
+  }
+
+  /** Filter tasks by state */
+  byState(state) { return [...this._tasks.values()].filter(t => t._state === state); }
+  /** Filter tasks by tag */
+  byTag(tag)     { return [...this._tasks.values()].filter(t => t.hasTag?.(tag)); }
+  /** Cancel every monitored task */
+  cancelAll()    { this._tasks.forEach(t => t.cancel?.()); return this; }
+
+  /** Summary counts per state */
+  health() {
+    const counts = Object.fromEntries(Object.values(State).map(s => [s, 0]));
+    this._tasks.forEach(t => counts[t._state]++);
+    return { total: this._tasks.size, ...counts };
+  }
+}
+
+// ─── TaskScheduler ───────────────────────────────────────────────────────────
+/** Central registry, factory, and orchestrator for all task types */
+class TaskScheduler extends TaskEventEmitter {
+  constructor(name, opts = {}) {
+    super();
+    this.id      = uid();
+    this.name    = name;
+    this.options = opts;
+    this._tasks  = new Map();
+    this._mw     = new TaskMiddlewarePipeline();
+    this.logger  = new TaskLogger({ prefix: `[${name}]`, ...opts.logger });
+    this.monitor = new TaskMonitor();
+  }
+
+  // ── Registry ──────────────────────────────────────────────────────────
+  _register(task) {
+    this._tasks.set(task.id, task);
+    this.monitor.register(task);
+    this.logger.debug(`Registered: ${task.name}`);
+    this.emit('register', task);
+    return task;
+  }
+
+  /** Look up a task by name */
+  get(name)    { return [...this._tasks.values()].find(t => t.name === name); }
+  /** Look up a task by ID */
+  getById(id)  { return this._tasks.get(id); }
+  /** All registered tasks */
+  getAll()     { return [...this._tasks.values()]; }
+
+  /** Remove and cancel a task by ID */
+  remove(id) {
+    const t = this._tasks.get(id);
+    t?.cancel?.();
+    this._tasks.delete(id);
+    this.monitor.unregister({ id });
+    this.emit('remove', t);
+    return this;
+  }
+
+  /** Remove and cancel every task */
+  removeAll() { [...this._tasks.keys()].forEach(id => this.remove(id)); return this; }
+
+  // ── Factories ─────────────────────────────────────────────────────────
+  createTask(name, fn, opts)
+    { return this._register(new Task(name, fn, { logger: this.logger, ...opts })); }
+
+  createSyncTask(name, fn, opts)
+    { return this._register(new SyncTask(name, fn, opts)); }
+
+  createRetryTask(name, fn, opts)
+    { return this._register(new RetryTask(name, fn, opts)); }
+
+  createTimeoutTask(name, fn, ms, opts)
+    { return this._register(new TimeoutTask(name, fn, ms, opts)); }
+
+  createDebouncedTask(name, fn, delay, opts)
+    { return this._register(new DebouncedTask(name, fn, delay, opts)); }
+
+  createThrottledTask(name, fn, delay, opts)
+    { return this._register(new ThrottledTask(name, fn, delay, opts)); }
+
+  createConditionalTask(name, fn, cond, opts)
+    { return this._register(new ConditionalTask(name, fn, cond, opts)); }
+
+  createPriorityTask(name, fn, priority, opts)
+    { return this._register(new PriorityTask(name, fn, priority, opts)); }
+
+  createRecurringTask(name, fn, delay, unit, opts)
+    { return this._register(new RecurringTask(name, fn, delay, unit, opts)); }
+
+  createCronTask(name, fn, expr, opts)
+    { return this._register(new CronTask(name, fn, expr, opts)); }
+
+  createBatchTask(name, items, fn, opts)
+    { return this._register(new BatchTask(name, items, fn, opts)); }
+
+  /** Unregistered composite helpers — don't track internally */
+  createGroup(name, tasks)    { return new TaskGroup(name, tasks); }
+  createChain(name)           { return new TaskChain(name); }
+  createPipeline(name)        { return new TaskPipeline(name); }
+  createQueue(name, opts)     { return new TaskQueue(name, opts); }
+  createPool(name, size)      { return new TaskPool(name, size); }
+  createSequential(name, fns) { return new SequentialTask(name, fns); }
+  createParallel(name, fns)   { return new ParallelTask(name, fns); }
+
+  // ── Bulk Operations ───────────────────────────────────────────────────
+  /** Run all registered tasks concurrently */
+  runAll()    { return Promise.allSettled(this.getAll().map(t => t.run())); }
+  /** Cancel every registered task */
+  cancelAll() { this.getAll().forEach(t => t.cancel?.()); return this; }
+
+  /** Filter registered tasks by tag */
+  byTag(tag)   { return this.getAll().filter(t => t.hasTag?.(tag)); }
+  /** Filter registered tasks by state */
+  byState(s)   { return this.getAll().filter(t => t._state === s); }
+
+  /** Scheduler + monitor health summary */
+  health()  { return this.monitor.health(); }
+  /** Full stats report */
+  report()  { return this.monitor.report(); }
+  /** Register global middleware */
+  use(fn)   { this._mw.use(fn); return this; }
+
+  toJSON() {
+    return {
+      id:    this.id,
+      name:  this.name,
+      tasks: this.getAll().map(t => t.toJSON?.() ?? t.name),
+    };
+  }
+}
+
+// ─── Legacy Tasker alias ─────────────────────────────────────────────────────
+/**
+ * Backwards-compatible Tasker class.
+ * Extends TaskScheduler with the original API surface.
+ */
+class Tasker extends TaskScheduler {
+  createSyncTask(name, fn, opts) { return super.createSyncTask(name, fn, opts); }
+  removeTask(task)               { return this.remove(task.id); }
+  scheduleTask(task, delay, unit){ task.schedule(delay, unit); return this; }
+}
+
+// ╔══════════════════════════════════════════════════════════════════════════╗
+// ║  Exports                                                                 ║
+// ╚══════════════════════════════════════════════════════════════════════════╝
+module.exports = {
+  // Constants
+  units,
+  State,
+
+  // Utility functions
+  parseUnit,
+  humanDuration,
+  clamp,
+  uid,
+  deepClone,
+  noop,
+  isPromise,
+  memoize,
+  once,
+  debounce,
+  throttle,
+  sleep,
+  retryFn,
+  timeoutFn,
+  wrapAsync,
+  formatDate,
+  parseCron,
+  compose,
+  chunk,
+  lerp,
+
+  // Core data classes
+  TaskError,
+  TaskResult,
+  TaskStats,
+  TaskLogger,
+  TaskEventEmitter,
+  TaskMiddlewarePipeline,
+
+  // Task classes
+  Task,
+  SyncTask,
+  RetryTask,
+  TimeoutTask,
+  DebouncedTask,
+  ThrottledTask,
+  ConditionalTask,
+  PriorityTask,
+  RecurringTask,
+  CronTask,
+  BatchTask,
+
+  // Composite/structural classes
+  TaskChain,
+  TaskPipeline,
+  TaskGroup,
+  TaskQueue,
+  TaskPool,
+  SequentialTask,
+  ParallelTask,
+
+  // Management
+  TaskMonitor,
+  TaskScheduler,
 
-}
+  // Legacy alias
+  Tasker,
+};