@c9up/ream 0.1.3

package/dist/scheduler/Scheduler.d.ts

@@ -0,0 +1,209 @@
+/**
+ * `Scheduler` — thin TypeScript wrapper around `ream-scheduler-napi`.
+ *
+ * The actual cron parser, task registry, and tick loop live in Rust
+ * (Story 28.1). This class:
+ *   - Lazily loads the NAPI `.node` binary on first instantiation.
+ *   - Adapts the native surface to a typed TS API.
+ *   - Translates `napi::Error` JSON payloads into `ReamError`.
+ *   - Tracks registered cron expressions locally so `listTasks()` can
+ *     return them (the Rust side does not expose task metadata today).
+ *
+ * @implements Story 28.2
+ */
+import type { LockBackend } from './locks/LockBackend.js';
+import type { ErrorReporter } from './observability/ErrorReporter.js';
+import type { ScheduleEventSink } from './observability/ScheduleEventSink.js';
+import type { TaskStats } from './observability/StatsTracker.js';
+/** Payload delivered to every task invocation by the Rust ticker. */
+export interface ScheduleInvocation {
+    taskName: string;
+    scheduledForMs: number;
+}
+/** Task listing entry returned by {@link Scheduler.listTasks}. */
+export interface TaskInfo {
+    name: string;
+    cronExpr: string;
+    nextRun: number | null;
+}
+/**
+ * Outcome returned by {@link Scheduler.runTaskNow}.
+ *
+ * - `completed` — the task body resolved without throwing.
+ * - `failed` — the task body threw / rejected; `error` carries a
+ *   plain-object projection of the throw. Also used when an optional
+ *   `timeoutMs` elapses before the task resolves.
+ * - `unknown` — no task is registered under the given name;
+ *   `durationMs` is `0` and no events are emitted. The `errorReporter`
+ *   (if configured) receives a synthetic error so the operator typo
+ *   is observable in audit pipelines.
+ * - `already-running` — an in-process invocation of the same task is
+ *   already in flight; this call was dropped to avoid double-execution.
+ *   A `schedule.task.skipped` event with reason `'already-running'`
+ *   was emitted.
+ */
+export interface RunTaskOutcome {
+    outcome: 'completed' | 'failed' | 'unknown' | 'already-running';
+    durationMs: number;
+    error?: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+}
+/** Options accepted by {@link Scheduler.runTaskNow}. */
+export interface RunTaskOptions {
+    /**
+     * Cancel the on-demand run after `timeoutMs` milliseconds. On
+     * timeout, `runTaskNow` returns `{ outcome: 'failed', error: ... }`
+     * with a `SCHEDULE_TASK_TIMEOUT` error. The user callback continues
+     * running in the background — JavaScript does not support
+     * pre-emptive cancellation; the timeout is observational only.
+     */
+    timeoutMs?: number;
+}
+/** Shape of the native class exposed by `ream-scheduler-napi`. */
+interface NativeScheduler {
+    register(name: string, cronExpr: string, callback: (payload: ScheduleInvocation) => void | Promise<void>): void;
+    unregister(name: string): void;
+    start(): void;
+    stop(): void;
+    nextRun(name: string): number | null;
+}
+interface NativeModule {
+    RustScheduler: new () => NativeScheduler;
+}
+/**
+ * Constructor options for {@link Scheduler}.
+ */
+export interface SchedulerOptions {
+    /**
+     * Inject a pre-loaded NAPI module. Intended for tests that bypass
+     * the `.node` binary lookup — production callers should omit this
+     * and let `loadNapi` resolve the platform-suffixed binary.
+     */
+    nativeModule?: NativeModule;
+    /**
+     * Distributed-lock backend. When provided, every task invocation
+     * is guarded by `acquire(name, defaultLockTtlMs)` / `release(name)`
+     * so horizontally-scaled deployments do not double-execute.
+     * Defaults to `undefined` (no locking — single-instance semantics).
+     */
+    lockBackend?: LockBackend;
+    /**
+     * Lock TTL in milliseconds. Defaults to 60_000 (one minute). Only
+     * used when `lockBackend` is provided.
+     */
+    defaultLockTtlMs?: number;
+    /**
+     * Destination for task-invocation events
+     * (`schedule.task.{started,completed,failed,skipped}`). Leave
+     * undefined to disable event emission — stats tracking still
+     * happens regardless, and `getStats` remains useful.
+     */
+    eventSink?: ScheduleEventSink;
+    /**
+     * Callback invoked when a task throws. Typically bridges to
+     * `ErrorBoundary.serviceError`. Leave undefined to disable
+     * boundary reporting.
+     */
+    errorReporter?: ErrorReporter;
+}
+/**
+ * Cron-style scheduler backed by a Rust Tokio ticker.
+ *
+ * ```ts
+ * const scheduler = new Scheduler()
+ * scheduler.register('cleanup', '0 *\/5 * * *', () => { ... })
+ * scheduler.start()
+ * // later
+ * scheduler.stop()
+ * ```
+ *
+ * All schedules evaluate in UTC. Missed fires after a runtime stall are
+ * dropped, not replayed (see `ream-scheduler` crate docs).
+ */
+export declare class Scheduler {
+    #private;
+    constructor(options?: SchedulerOptions);
+    /**
+     * Register a recurring task.
+     *
+     * The callback is invoked by the Rust ticker when the cron schedule
+     * fires. Exceptions thrown synchronously or rejected asynchronously
+     * are caught here so they never surface back to the Rust side; when
+     * an `eventSink` / `errorReporter` is configured, failures are
+     * emitted as `schedule.task.failed` events and forwarded to the
+     * reporter. Otherwise the error is dropped silently.
+     *
+     * Event ordering guarantees: within a single tick, events are emitted
+     * in the documented order (`started` → `completed` | `failed` |
+     * `skipped`). Ordering across ticks is NOT guaranteed when the sink
+     * returns a Promise — the scheduler does not chain sink promises, so
+     * a fast tick N+1 can deliver events before a slow tick N's events
+     * reach the sink. Sinks that need strict ordering should maintain
+     * their own sequencing.
+     */
+    register(name: string, cronExpr: string, callback: (payload: ScheduleInvocation) => void | Promise<void>): void;
+    /**
+     * Remove a registered task. Idempotent — unknown names are not an
+     * error. If the native side reports an unknown-task condition it is
+     * treated as already-removed rather than propagated.
+     */
+    unregister(name: string): void;
+    /**
+     * Start the Rust ticker. Safe to call when already running — the
+     * underlying `ream-scheduler` core is idempotent (Story 28.1: the
+     * ticker's internal cancel channel is only installed once per start).
+     */
+    start(): void;
+    /**
+     * Cancel the Rust ticker. Safe to call when not running — the
+     * underlying `ream-scheduler` core treats `stop()` as a no-op when no
+     * cancel channel is installed.
+     */
+    stop(): void;
+    /**
+     * Return the next fire time in ms since epoch, or `null` if the task
+     * is unknown.
+     */
+    nextRun(name: string): number | null;
+    /**
+     * Snapshot of every currently-registered task.
+     *
+     * NOTE: Makes one FFI call per task via `nextRun`. Acceptable for
+     * typical task counts (dozens); consumers iterating huge registries
+     * should cache the result.
+     */
+    listTasks(): TaskInfo[];
+    /**
+     * Invoke a registered task once immediately, bypassing the cron
+     * schedule AND the configured lock backend.
+     *
+     * **Admin override:** `runTaskNow` does NOT consult the
+     * `lockBackend`. Running a task manually is an explicit operator
+     * action that must not be blocked by a peer instance holding the
+     * distributed lock. Regular ticker-driven fires continue to honor
+     * the lock.
+     *
+     * Observability is preserved — the same `started` / `completed`
+     * / `failed` events fire and the `errorReporter` runs exactly as
+     * for a normal tick, updating `getStats(name)` identically.
+     *
+     * Unknown task names return `{ outcome: 'unknown', durationMs: 0 }`
+     * without emitting any event — mirrors the never-throws contract
+     * of {@link Scheduler.getStats}.
+     */
+    runTaskNow(name: string, options?: RunTaskOptions): Promise<RunTaskOutcome>;
+    /**
+     * Return a snapshot of observability counters for `taskName`.
+     *
+     * Unknown task names return a zeroed snapshot (all counters `0`,
+     * all timestamps `null`) — never throws. The `nextRunMs` field is
+     * read live from the Rust layer on each call; a native-side failure
+     * is swallowed here so that `getStats` always returns.
+     */
+    getStats(taskName: string): TaskStats;
+}
+export {};
+//# sourceMappingURL=Scheduler.d.ts.map

package/dist/scheduler/Scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scheduler.d.ts","sourceRoot":"","sources":["../../src/scheduler/Scheduler.ts"],"names":[],"mappings":"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"}

package/dist/scheduler/Scheduler.js

@@ -0,0 +1,432 @@
+/**
+ * `Scheduler` — thin TypeScript wrapper around `ream-scheduler-napi`.
+ *
+ * The actual cron parser, task registry, and tick loop live in Rust
+ * (Story 28.1). This class:
+ *   - Lazily loads the NAPI `.node` binary on first instantiation.
+ *   - Adapts the native surface to a typed TS API.
+ *   - Translates `napi::Error` JSON payloads into `ReamError`.
+ *   - Tracks registered cron expressions locally so `listTasks()` can
+ *     return them (the Rust side does not expose task metadata today).
+ *
+ * @implements Story 28.2
+ */
+import { performance } from 'node:perf_hooks';
+import { ReamError } from '../errors/ReamError.js';
+import { loadNapi } from '../helpers/napi-loader.js';
+import { StatsTracker } from './observability/StatsTracker.js';
+const DEFAULT_LOCK_TTL_MS = 60_000;
+let native;
+function loadNative() {
+    if (native)
+        return native;
+    native = loadNapi({
+        binaryName: 'scheduler',
+        callerMetaUrl: import.meta.url,
+        errorCodePrefix: 'SCHEDULER',
+    });
+    return native;
+}
+/**
+ * Convert a thrown native error into a `ReamError`. Prefers parsing the
+ * JSON payload shipped by Rust (`ream_napi_core::ReamError::into()`);
+ * falls back to wrapping opaque errors under `SCHEDULER_NATIVE_ERROR`
+ * so scheduler context is never lost.
+ */
+function translateNativeError(e) {
+    const asError = e;
+    const parsed = ReamError.fromNapi(asError);
+    // `fromNapi` returns an `UNKNOWN`-coded error when the message is not
+    // a JSON payload. Preserve that context under a scheduler-specific
+    // code so callers can trace the failure back to this layer.
+    if (parsed.code === 'UNKNOWN') {
+        return new ReamError('SCHEDULER_NATIVE_ERROR', `ream-scheduler NAPI call failed: ${asError.message}`, {
+            hint: 'This is likely a bug in the scheduler. Please file an issue with the stack trace.',
+        });
+    }
+    return parsed;
+}
+/**
+ * Cron-style scheduler backed by a Rust Tokio ticker.
+ *
+ * ```ts
+ * const scheduler = new Scheduler()
+ * scheduler.register('cleanup', '0 *\/5 * * *', () => { ... })
+ * scheduler.start()
+ * // later
+ * scheduler.stop()
+ * ```
+ *
+ * All schedules evaluate in UTC. Missed fires after a runtime stall are
+ * dropped, not replayed (see `ream-scheduler` crate docs).
+ */
+export class Scheduler {
+    #inner;
+    /** Mirror of registrations — Rust does not expose this today. */
+    #tasks = new Map();
+    #lockBackend;
+    #defaultLockTtlMs;
+    #eventSink;
+    #errorReporter;
+    #stats = new StatsTracker();
+    /** Set of task names currently in flight — prevents concurrent
+     *  double-execution when the ticker and `runTaskNow` (or two
+     *  simultaneous `runTaskNow` calls) collide on the same name. */
+    #running = new Set();
+    constructor(options = {}) {
+        if (options.lockBackend !== undefined) {
+            const be = options.lockBackend;
+            if (typeof be.acquire !== 'function' || typeof be.release !== 'function') {
+                throw new ReamError('SCHEDULE_INVALID_LOCK_BACKEND', 'Scheduler options.lockBackend must implement acquire(name, ttlMs) and release(name)');
+            }
+        }
+        if (options.defaultLockTtlMs !== undefined) {
+            if (!Number.isFinite(options.defaultLockTtlMs) || options.defaultLockTtlMs <= 0) {
+                throw new ReamError('SCHEDULE_INVALID_LOCK_TTL', `Scheduler options.defaultLockTtlMs must be a finite positive number, got ${options.defaultLockTtlMs}`, {
+                    hint: 'Use a millisecond value greater than zero (typical range 1_000 – 600_000).',
+                });
+            }
+        }
+        if (options.eventSink !== undefined) {
+            const sink = options.eventSink;
+            if (typeof sink.emit !== 'function') {
+                throw new ReamError('SCHEDULE_INVALID_EVENT_SINK', 'Scheduler options.eventSink must implement emit(event)');
+            }
+        }
+        if (options.errorReporter !== undefined && typeof options.errorReporter !== 'function') {
+            throw new ReamError('SCHEDULE_INVALID_ERROR_REPORTER', 'Scheduler options.errorReporter must be a function');
+        }
+        const mod = options.nativeModule ?? loadNative();
+        this.#inner = new mod.RustScheduler();
+        this.#lockBackend = options.lockBackend ?? null;
+        this.#defaultLockTtlMs = options.defaultLockTtlMs ?? DEFAULT_LOCK_TTL_MS;
+        this.#eventSink = options.eventSink ?? null;
+        this.#errorReporter = options.errorReporter ?? null;
+    }
+    #emit(event) {
+        if (!this.#eventSink)
+            return;
+        try {
+            const result = this.#eventSink.emit(event);
+            // Detect a thenable and swallow any async rejection so the
+            // ticker cannot be crashed by a buggy async adapter. Use the
+            // `.then`-based detection + `Promise.resolve` wrap so non-native
+            // thenables (e.g. RxJS-style) are handled uniformly.
+            if (result !== null &&
+                result !== undefined &&
+                typeof result.then === 'function') {
+                Promise.resolve(result).catch(() => { });
+            }
+        }
+        catch {
+            // Swallow — a buggy sink adapter must not kill the ticker.
+        }
+    }
+    /**
+     * Shared observability core: emit started, invoke the callback,
+     * emit completed/failed, record stats, forward to the error
+     * reporter. Returns the terminal outcome so callers (the ticker
+     * wrapped closure and `runTaskNow`) can act on the result without
+     * re-reading the stats map.
+     *
+     * Does NOT touch the lock backend — lock handling is the caller's
+     * responsibility so the admin-override path can bypass it cleanly.
+     */
+    async #runOnce(name, callback, scheduledForMs) {
+        // Concurrent-execution guard. The distributed lock prevents
+        // double-fire across instances; this Set prevents double-fire
+        // WITHIN a single process (ticker racing with runTaskNow, or two
+        // operators hitting runTaskNow at once). A duplicate invocation
+        // is recorded as a skip with reason `'already-running'`.
+        if (this.#running.has(name)) {
+            this.#stats.recordSkipped(name);
+            this.#emit({ type: 'schedule.task.skipped', taskName: name, reason: 'already-running' });
+            return { outcome: 'already-running', durationMs: 0 };
+        }
+        this.#running.add(name);
+        const startedAt = Date.now();
+        const perfStart = performance.now();
+        this.#stats.recordStarted(name, startedAt);
+        this.#emit({
+            type: 'schedule.task.started',
+            taskName: name,
+            scheduledForMs,
+            startedAtMs: startedAt,
+        });
+        try {
+            await callback({ taskName: name, scheduledForMs });
+            const durationMs = performance.now() - perfStart;
+            this.#stats.recordCompleted(name, durationMs);
+            this.#emit({ type: 'schedule.task.completed', taskName: name, durationMs });
+            return { outcome: 'completed', durationMs };
+        }
+        catch (err) {
+            const durationMs = performance.now() - perfStart;
+            this.#stats.recordFailed(name, durationMs);
+            const errObj = err instanceof Error ? err : new Error(String(err));
+            this.#emit({
+                type: 'schedule.task.failed',
+                taskName: name,
+                error: { name: errObj.name, message: errObj.message, stack: errObj.stack },
+                durationMs,
+            });
+            this.#report(err, name);
+            return { outcome: 'failed', durationMs, error: errObj };
+        }
+        finally {
+            this.#running.delete(name);
+        }
+    }
+    #report(err, taskName) {
+        if (!this.#errorReporter)
+            return;
+        try {
+            // The `ErrorReporter` type declares `void` return, but a user
+            // adapter that declares an `async` function still satisfies the
+            // callable shape and will return a Promise at runtime. Swallow
+            // any async rejection in addition to sync throws so a bad
+            // reporter never crashes the ticker.
+            const result = this.#errorReporter(err, { taskName });
+            if (result !== null &&
+                result !== undefined &&
+                typeof result.then === 'function') {
+                Promise.resolve(result).catch(() => { });
+            }
+        }
+        catch {
+            // Swallow — a reporter that itself throws cannot propagate.
+        }
+    }
+    /**
+     * Register a recurring task.
+     *
+     * The callback is invoked by the Rust ticker when the cron schedule
+     * fires. Exceptions thrown synchronously or rejected asynchronously
+     * are caught here so they never surface back to the Rust side; when
+     * an `eventSink` / `errorReporter` is configured, failures are
+     * emitted as `schedule.task.failed` events and forwarded to the
+     * reporter. Otherwise the error is dropped silently.
+     *
+     * Event ordering guarantees: within a single tick, events are emitted
+     * in the documented order (`started` → `completed` | `failed` |
+     * `skipped`). Ordering across ticks is NOT guaranteed when the sink
+     * returns a Promise — the scheduler does not chain sink promises, so
+     * a fast tick N+1 can deliver events before a slow tick N's events
+     * reach the sink. Sinks that need strict ordering should maintain
+     * their own sequencing.
+     */
+    register(name, cronExpr, callback) {
+        if (typeof callback !== 'function') {
+            throw new ReamError('SCHEDULE_INVALID_CALLBACK', `Scheduler.register expected a function callback for task '${name}', got ${typeof callback}`);
+        }
+        if (name === '') {
+            throw new ReamError('SCHEDULE_INVALID_TASK_NAME', 'Scheduler.register requires a non-empty task name');
+        }
+        // Capture-at-register: the active lock backend is frozen per-task
+        // at registration time (observability sinks are read live via
+        // #runOnce so they can be replaced in the future non-breakingly).
+        const lockBackend = this.#lockBackend;
+        const lockTtlMs = this.#defaultLockTtlMs;
+        // Wrapped closure delegated to #runOnce for the observability
+        // core — lock handling layered around it when a backend is
+        // configured. `runTaskNow` reuses `#runOnce` directly, bypassing
+        // the lock.
+        const wrapped = async (payload) => {
+            if (lockBackend !== null) {
+                let acquired;
+                try {
+                    acquired = await lockBackend.acquire(name, lockTtlMs);
+                }
+                catch (acquireErr) {
+                    this.#stats.recordSkipped(name);
+                    this.#emit({
+                        type: 'schedule.task.skipped',
+                        taskName: name,
+                        reason: 'acquire-failed',
+                    });
+                    this.#report(acquireErr, name);
+                    return;
+                }
+                if (!acquired) {
+                    this.#stats.recordSkipped(name);
+                    this.#emit({ type: 'schedule.task.skipped', taskName: name, reason: 'locked' });
+                    return;
+                }
+            }
+            try {
+                await this.#runOnce(name, callback, payload.scheduledForMs);
+            }
+            finally {
+                if (lockBackend !== null) {
+                    try {
+                        await lockBackend.release(name);
+                    }
+                    catch {
+                        // Swallow — lock auto-frees via TTL.
+                    }
+                }
+            }
+        };
+        try {
+            this.#inner.register(name, cronExpr, wrapped);
+        }
+        catch (e) {
+            throw translateNativeError(e);
+        }
+        this.#tasks.set(name, { cronExpr, callback });
+    }
+    /**
+     * Remove a registered task. Idempotent — unknown names are not an
+     * error. If the native side reports an unknown-task condition it is
+     * treated as already-removed rather than propagated.
+     */
+    unregister(name) {
+        try {
+            this.#inner.unregister(name);
+        }
+        catch (e) {
+            const err = translateNativeError(e);
+            // Rust's `unregister` is itself idempotent (Story 28.1) so a
+            // thrown error here is unexpected. Drop the local entry anyway
+            // — the doc promises idempotence — but surface any unexpected
+            // native failure that is not a missing-task situation.
+            if (err.code !== 'UNKNOWN_TASK' && err.code !== 'SCHEDULER_NATIVE_ERROR') {
+                this.#tasks.delete(name);
+                throw err;
+            }
+        }
+        this.#tasks.delete(name);
+    }
+    /**
+     * Start the Rust ticker. Safe to call when already running — the
+     * underlying `ream-scheduler` core is idempotent (Story 28.1: the
+     * ticker's internal cancel channel is only installed once per start).
+     */
+    start() {
+        try {
+            this.#inner.start();
+        }
+        catch (e) {
+            throw translateNativeError(e);
+        }
+    }
+    /**
+     * Cancel the Rust ticker. Safe to call when not running — the
+     * underlying `ream-scheduler` core treats `stop()` as a no-op when no
+     * cancel channel is installed.
+     */
+    stop() {
+        try {
+            this.#inner.stop();
+        }
+        catch (e) {
+            throw translateNativeError(e);
+        }
+    }
+    /**
+     * Return the next fire time in ms since epoch, or `null` if the task
+     * is unknown.
+     */
+    nextRun(name) {
+        try {
+            return this.#inner.nextRun(name);
+        }
+        catch (e) {
+            throw translateNativeError(e);
+        }
+    }
+    /**
+     * Snapshot of every currently-registered task.
+     *
+     * NOTE: Makes one FFI call per task via `nextRun`. Acceptable for
+     * typical task counts (dozens); consumers iterating huge registries
+     * should cache the result.
+     */
+    listTasks() {
+        const out = [];
+        for (const [name, { cronExpr }] of this.#tasks) {
+            out.push({ name, cronExpr, nextRun: this.nextRun(name) });
+        }
+        return out;
+    }
+    /**
+     * Invoke a registered task once immediately, bypassing the cron
+     * schedule AND the configured lock backend.
+     *
+     * **Admin override:** `runTaskNow` does NOT consult the
+     * `lockBackend`. Running a task manually is an explicit operator
+     * action that must not be blocked by a peer instance holding the
+     * distributed lock. Regular ticker-driven fires continue to honor
+     * the lock.
+     *
+     * Observability is preserved — the same `started` / `completed`
+     * / `failed` events fire and the `errorReporter` runs exactly as
+     * for a normal tick, updating `getStats(name)` identically.
+     *
+     * Unknown task names return `{ outcome: 'unknown', durationMs: 0 }`
+     * without emitting any event — mirrors the never-throws contract
+     * of {@link Scheduler.getStats}.
+     */
+    async runTaskNow(name, options = {}) {
+        const entry = this.#tasks.get(name);
+        if (!entry) {
+            // Notify the observability boundary so operator typos leave a
+            // trace. No event is emitted — events are reserved for
+            // real task invocations.
+            this.#report(new ReamError('SCHEDULE_TASK_UNKNOWN', `runTaskNow called with unknown task name: '${name}'`), name);
+            return { outcome: 'unknown', durationMs: 0 };
+        }
+        const runPromise = this.#runOnce(name, entry.callback, Date.now());
+        // Optional timeout: whichever wins, runPromise stays running in
+        // the background — JS has no pre-emptive cancellation.
+        const result = options.timeoutMs !== undefined && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0
+            ? await Promise.race([
+                runPromise,
+                new Promise((resolve) => {
+                    setTimeout(() => {
+                        resolve({
+                            outcome: 'failed',
+                            durationMs: options.timeoutMs ?? 0,
+                            error: new ReamError('SCHEDULE_TASK_TIMEOUT', `Task '${name}' did not complete within ${options.timeoutMs} ms (background execution continues)`),
+                        });
+                    }, options.timeoutMs);
+                }),
+            ])
+            : await runPromise;
+        if (result.outcome === 'already-running') {
+            return { outcome: 'already-running', durationMs: 0 };
+        }
+        if (result.outcome === 'failed') {
+            return {
+                outcome: 'failed',
+                durationMs: result.durationMs,
+                error: {
+                    name: result.error?.name ?? 'Error',
+                    message: result.error?.message ?? 'unknown error',
+                    stack: result.error?.stack,
+                },
+            };
+        }
+        return { outcome: 'completed', durationMs: result.durationMs };
+    }
+    /**
+     * Return a snapshot of observability counters for `taskName`.
+     *
+     * Unknown task names return a zeroed snapshot (all counters `0`,
+     * all timestamps `null`) — never throws. The `nextRunMs` field is
+     * read live from the Rust layer on each call; a native-side failure
+     * is swallowed here so that `getStats` always returns.
+     */
+    getStats(taskName) {
+        const snapshot = this.#stats.get(taskName);
+        let nextRunMs = null;
+        try {
+            nextRunMs = this.nextRun(taskName);
+        }
+        catch {
+            // Swallow — getStats guarantees no-throw.
+        }
+        return { ...snapshot, nextRunMs };
+    }
+}
+//# sourceMappingURL=Scheduler.js.map

package/dist/scheduler/Scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scheduler.js","sourceRoot":"","sources":["../../src/scheduler/Scheduler.ts"],"names":[],"mappings":"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"}