@zintrust/core 0.1.40 → 0.1.42

package/src/scheduler/ScheduleRunner.js

@@ -4,45 +4,184 @@
  */
 import { Logger } from '../config/logger.js';
 import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { Cron } from './cron/Cron.js';
+import { InMemoryScheduleStateStore, } from './state/ScheduleStateStore.js';
+const nowMs = () => Date.now();
+const randomInt = (min, maxInclusive) => {
+    if (!Number.isFinite(min) || !Number.isFinite(maxInclusive))
+        return 0;
+    if (maxInclusive <= min)
+        return Math.floor(min);
+    return Math.floor(min + Math.random() * (maxInclusive - min + 1)); //NOSONAR
+};
+const resolveBackoffDelayMs = (state) => {
+    const policy = state.schedule.backoff;
+    if (!policy)
+        return 0;
+    const initialMs = Number.isFinite(policy.initialMs)
+        ? Math.max(0, Math.floor(policy.initialMs))
+        : 0;
+    const maxMs = Number.isFinite(policy.maxMs) ? Math.max(0, Math.floor(policy.maxMs)) : 0;
+    if (initialMs <= 0 || maxMs <= 0)
+        return 0;
+    const factor = policy.factor === undefined || !Number.isFinite(policy.factor) || policy.factor <= 1
+        ? 2
+        : policy.factor;
+    const power = Math.max(0, state.consecutiveFailures - 1);
+    const raw = initialMs * Math.pow(factor, power);
+    return Math.min(maxMs, Math.floor(raw));
+};
+const resolveJitterMs = (jitterMs) => {
+    return typeof jitterMs === 'number' && jitterMs > 0 ? randomInt(0, Math.floor(jitterMs)) : 0;
+};
+const computeBackoffDelay = (state) => {
+    if (state.schedule.enabled === false)
+        return null;
+    const backoffDelayMs = resolveBackoffDelayMs(state);
+    if (backoffDelayMs > 0) {
+        const jitter = resolveJitterMs(state.schedule.jitterMs);
+        return backoffDelayMs + jitter;
+    }
+    return null;
+};
+const computeCronDelay = (schedule) => {
+    if (typeof schedule.cron !== 'string' || schedule.cron.trim().length === 0) {
+        return null;
+    }
+    const tz = typeof schedule.timezone === 'string' && schedule.timezone.trim().length > 0
+        ? schedule.timezone
+        : 'UTC';
+    const nextAt = Cron.nextRunAtMs(nowMs(), schedule.cron, tz);
+    const baseDelay = Math.max(0, nextAt - nowMs());
+    const jitter = resolveJitterMs(schedule.jitterMs);
+    return baseDelay + jitter;
+};
+const computeIntervalDelay = (schedule) => {
+    if (typeof schedule.intervalMs !== 'number' || schedule.intervalMs <= 0) {
+        return null;
+    }
+    const base = Math.floor(schedule.intervalMs);
+    const jitter = resolveJitterMs(schedule.jitterMs);
+    return base + jitter;
+};
+const computeNextDelayMs = (state, outcome) => {
+    const schedule = state.schedule;
+    if (schedule.enabled === false)
+        return null;
+    if (outcome === 'failure') {
+        const backoffDelay = computeBackoffDelay(state);
+        if (backoffDelay !== null)
+            return backoffDelay;
+    }
+    const cronDelay = computeCronDelay(schedule);
+    if (cronDelay !== null)
+        return cronDelay;
+    const intervalDelay = computeIntervalDelay(schedule);
+    if (intervalDelay !== null)
+        return intervalDelay;
+    return null;
+};
+const clearTimer = (state) => {
+    if (state.timeoutId !== undefined) {
+        globalThis.clearTimeout(state.timeoutId);
+        state.timeoutId = undefined;
+    }
+};
+const scheduleNext = (state, kernel, invoke, outcome, store) => {
+    clearTimer(state);
+    const delay = computeNextDelayMs(state, outcome);
+    if (delay === null)
+        return;
+    const nextRunAt = nowMs() + delay;
+    void store.set(state.schedule.name, {
+        nextRunAt,
+        consecutiveFailures: state.consecutiveFailures,
+    });
+    state.timeoutId = globalThis.setTimeout(() => {
+        void runOnceAndReschedule(state, kernel, invoke, store);
+    }, delay);
+};
+const runOnceAndReschedule = async (state, kernel, invoke, store) => {
+    const outcome = await invoke(state, kernel);
+    scheduleNext(state, kernel, invoke, outcome, store);
+};
 const createRegister = (runner, invokeHandler) => (schedule) => {
-    if (runner.schedules.has(schedule.name)) {
+    const existing = runner.schedules.get(schedule.name);
+    if (existing !== undefined) {
         Logger.warn(`Schedule replaced: ${schedule.name}`);
+        // Reuse the same internal state to avoid leaving old timers/reschedule loops behind.
+        existing.schedule = schedule;
+        // If disabled, ensure any pending timer is cleared.
+        if (schedule.enabled === false) {
+            clearTimer(existing);
+            return;
+        }
+        // If a run is currently in progress, let it finish and reschedule naturally.
+        if (existing.isRunning) {
+            return;
+        }
+        // If schedules are already started, apply the new schedule immediately.
+        if (runner.started) {
+            if (schedule.runOnStart === true) {
+                void runOnceAndReschedule(existing, runner.kernel, invokeHandler, runner.store);
+                return;
+            }
+            scheduleNext(existing, runner.kernel, invokeHandler, 'success', runner.store);
+        }
+        return;
     }
     const state = {
         schedule,
         isRunning: false,
+        consecutiveFailures: 0,
     };
     runner.schedules.set(schedule.name, state);
     // If schedules are already started, register should take effect immediately.
     if (runner.started && schedule.enabled !== false) {
         if (schedule.runOnStart === true) {
-            void invokeHandler(state, runner.kernel);
-        }
-        if (typeof schedule.intervalMs === 'number' && schedule.intervalMs > 0) {
-            state.intervalId = globalThis.setInterval(() => {
-                void invokeHandler(state, runner.kernel);
-            }, schedule.intervalMs);
+            void runOnceAndReschedule(state, runner.kernel, invokeHandler, runner.store);
+            return;
         }
+        // Auto scheduling
+        scheduleNext(state, runner.kernel, invokeHandler, 'success', runner.store);
     }
 };
-const createInvokeHandler = () => async (state, kernel) => {
+const createInvokeHandler = (store) => async (state, kernel) => {
     if (state.isRunning) {
         Logger.info(`Skipping overlapping run for schedule: ${state.schedule.name}`);
-        return;
+        return 'failure';
     }
     state.isRunning = true;
     try {
         const handlerPromise = Promise.resolve()
             .then(async () => state.schedule.handler(kernel))
             .then(() => {
-            state.lastRunAt = Date.now();
+            state.lastRunAt = nowMs();
+            state.consecutiveFailures = 0;
+            void store.set(state.schedule.name, {
+                lastRunAt: state.lastRunAt,
+                lastSuccessAt: state.lastRunAt,
+                lastErrorAt: undefined,
+                lastErrorMessage: undefined,
+                consecutiveFailures: state.consecutiveFailures,
+            });
+            return 'success';
         })
             .catch((error) => {
+            state.consecutiveFailures = Math.min(1_000_000, state.consecutiveFailures + 1);
+            const errMsg = error instanceof Error ? error.message : String(error);
+            const at = nowMs();
+            void store.set(state.schedule.name, {
+                lastRunAt: at,
+                lastErrorAt: at,
+                lastErrorMessage: errMsg,
+                consecutiveFailures: state.consecutiveFailures,
+            });
             Logger.error(`Schedule '${state.schedule.name}' failed:`, error);
-        })
-            .then(() => undefined);
-        state.runningPromise = handlerPromise;
-        await handlerPromise;
+            return 'failure';
+        });
+        state.runningPromise = handlerPromise.then(() => undefined);
+        return await handlerPromise;
     }
     finally {
         state.isRunning = false;
@@ -59,16 +198,12 @@ const createStart = (runner, invokeHandler) => (kernel) => {
         if (schedule.enabled === false)
             continue;
         if (schedule.runOnStart === true) {
-            // fire-and-forget (handled by invokeHandler which logs errors)
-            void invokeHandler(state, kernel);
-        }
-        if (typeof schedule.intervalMs === 'number' && schedule.intervalMs > 0) {
-            const id = globalThis.setInterval(() => {
-                // fire and forget invocation; overlapping runs are protected inside
-                void invokeHandler(state, kernel);
-            }, schedule.intervalMs);
-            state.intervalId = id;
+            // fire-and-forget; next scheduling happens after the handler completes
+            void runOnceAndReschedule(state, kernel, invokeHandler, runner.store);
+            continue;
         }
+        // Auto scheduling
+        scheduleNext(state, kernel, invokeHandler, 'success', runner.store);
     }
 };
 const createStop = (runner) => async () => {
@@ -76,12 +211,9 @@ const createStop = (runner) => async () => {
         return;
     runner.started = false;
     runner.kernel = undefined;
-    // Clear intervals
+    // Clear timers
     for (const [, state] of runner.schedules) {
-        if (state.intervalId !== undefined) {
-            globalThis.clearInterval(state.intervalId);
-            state.intervalId = undefined;
-        }
+        clearTimer(state);
     }
     // Await running handlers (runningPromise is guaranteed not to reject)
     const running = [];
@@ -136,20 +268,25 @@ export const create = () => {
         schedules: new Map(),
         started: false,
         kernel: undefined,
+        store: InMemoryScheduleStateStore.create(),
     };
-    const invokeHandler = createInvokeHandler();
+    const invokeHandler = createInvokeHandler(runner.store);
     const register = createRegister(runner, invokeHandler);
     const start = createStart(runner, invokeHandler);
     const stopRaw = createStop(runner);
     const stop = createStopWithTimeout(stopRaw);
     const list = createList(runner);
     const runOnce = createRunOnce(runner, invokeHandler);
+    const getState = async (name) => runner.store.get(name);
+    const listStates = async () => runner.store.list();
     return Object.freeze({
         register,
         start,
         stop,
         list,
         runOnce,
+        getState,
+        listStates,
     });
 };
 export default { create };

package/src/scheduler/SchedulerRuntime.d.ts

@@ -0,0 +1,15 @@
+import type { ScheduleRunState } from './state/ScheduleStateStore';
+import type { ISchedule, IScheduleKernel } from './types';
+export declare const SchedulerRuntime: Readonly<{
+    registerMany: (schedules: ReadonlyArray<ISchedule>, source?: "core" | "app") => void;
+    start(kernel?: IScheduleKernel): void;
+    stop(timeoutMs?: number): Promise<void>;
+    list(): ISchedule[];
+    listWithState(): Promise<Array<{
+        schedule: ISchedule;
+        state: ScheduleRunState | null;
+    }>>;
+    runOnce(name: string, kernel?: IScheduleKernel): Promise<void>;
+}>;
+export default SchedulerRuntime;
+//# sourceMappingURL=SchedulerRuntime.d.ts.map

package/src/scheduler/SchedulerRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchedulerRuntime.d.ts","sourceRoot":"","sources":["../../../src/scheduler/SchedulerRuntime.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAmDnE,eAAO,MAAM,gBAAgB;8BAzBhB,aAAa,CAAC,SAAS,CAAC,WAC3B,MAAM,GAAG,KAAK,KACrB,IAAI;mBAyBU,eAAe,GAAG,IAAI;qBAqBd,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAOrC,SAAS,EAAE;qBAGI,OAAO,CAAC,KAAK,CAAC;QAAE,QAAQ,EAAE,SAAS,CAAC;QAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;kBAkB1E,MAAM,WAAW,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;EAGtC,CAAC;AAEjC,eAAe,gBAAgB,CAAC"}

package/src/scheduler/SchedulerRuntime.js

@@ -0,0 +1,79 @@
+import { Logger } from '../config/logger.js';
+import { createScheduleRunner } from './index.js';
+import { SchedulerLeader } from './leader/SchedulerLeader.js';
+const state = {
+    runner: createScheduleRunner(),
+    registered: new Map(),
+    leader: SchedulerLeader.create(),
+    leaderStarted: false,
+};
+const registerMany = (schedules, source = 'core') => {
+    for (const schedule of schedules) {
+        if (schedule === undefined || schedule === null || typeof schedule.name !== 'string')
+            continue;
+        const name = schedule.name.trim();
+        if (name.length === 0)
+            continue;
+        const existing = state.registered.get(name);
+        // If app already registered, it always wins.
+        if (existing === 'app')
+            continue;
+        // Prevent repeated registrations from the same source.
+        if (existing === source)
+            continue;
+        if (existing === 'core' && source === 'app') {
+            Logger.info('Schedule overridden by app/Schedules', { name });
+        }
+        state.registered.set(name, source);
+        state.runner.register(schedule);
+    }
+};
+export const SchedulerRuntime = Object.freeze({
+    registerMany,
+    start(kernel) {
+        // If leader mode is enabled, only the leader instance starts timers.
+        if (state.leader.isEnabled()) {
+            if (state.leaderStarted)
+                return;
+            state.leaderStarted = true;
+            state.leader.start({
+                onBecameLeader: () => {
+                    state.runner.start(kernel);
+                },
+                onLostLeadership: () => {
+                    // Best-effort stop; leadership transitions should not crash the process.
+                    void state.runner.stop();
+                },
+            });
+            return;
+        }
+        state.runner.start(kernel);
+    },
+    async stop(timeoutMs) {
+        if (state.leaderStarted) {
+            state.leaderStarted = false;
+            await state.leader.stop();
+        }
+        await state.runner.stop(timeoutMs);
+    },
+    list() {
+        return state.runner.list();
+    },
+    async listWithState() {
+        const schedules = state.runner.list();
+        const getState = state.runner
+            .getState;
+        if (typeof getState !== 'function') {
+            return schedules.map((schedule) => ({ schedule, state: null }));
+        }
+        const rows = await Promise.all(schedules.map(async (schedule) => {
+            const stateRow = (await getState(schedule.name));
+            return { schedule, state: stateRow };
+        }));
+        return rows;
+    },
+    async runOnce(name, kernel) {
+        await state.runner.runOnce(name, kernel);
+    },
+});
+export default SchedulerRuntime;

package/src/scheduler/cron/Cron.d.ts

@@ -0,0 +1,19 @@
+type CronAllowed = Readonly<{
+    any: true;
+}> | Readonly<{
+    any: false;
+    values: ReadonlySet<number>;
+}>;
+export type CronSpec = Readonly<{
+    minute: CronAllowed;
+    hour: CronAllowed;
+    dayOfMonth: CronAllowed;
+    month: CronAllowed;
+    dayOfWeek: CronAllowed;
+}>;
+export declare const Cron: Readonly<{
+    parse(expr: string): CronSpec;
+    nextRunAtMs(nowMs: number, expr: string, timeZone?: string): number;
+}>;
+export default Cron;
+//# sourceMappingURL=Cron.d.ts.map

package/src/scheduler/cron/Cron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cron.d.ts","sourceRoot":"","sources":["../../../../src/scheduler/cron/Cron.ts"],"names":[],"mappings":"AAEA,KAAK,WAAW,GAAG,QAAQ,CAAC;IAAE,GAAG,EAAE,IAAI,CAAA;CAAE,CAAC,GAAG,QAAQ,CAAC;IAAE,GAAG,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC,CAAC;AAEnG,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC;IAC9B,MAAM,EAAE,WAAW,CAAC;IACpB,IAAI,EAAE,WAAW,CAAC;IAClB,UAAU,EAAE,WAAW,CAAC;IACxB,KAAK,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,WAAW,CAAC;CACxB,CAAC,CAAC;AA0LH,eAAO,MAAM,IAAI;gBACH,MAAM,GAAG,QAAQ;uBA+BV,MAAM,QAAQ,MAAM,aAAY,MAAM,GAAW,MAAM;EAoB1E,CAAC;AAEH,eAAe,IAAI,CAAC"}

package/src/scheduler/cron/Cron.js

@@ -0,0 +1,200 @@
+const ANY = Object.freeze({ any: true });
+const toInt = (value) => {
+    const n = Number.parseInt(value, 10);
+    return Number.isFinite(n) ? n : null;
+};
+const clamp = (n, range) => Math.min(range.max, Math.max(range.min, n));
+const expandStep = (step, range, out) => {
+    for (let i = range.min; i <= range.max; i += step)
+        out.add(i);
+};
+const expandRange = (trimmed, range, out) => {
+    const left = trimmed.slice(0, trimmed.indexOf('-'));
+    const rest = trimmed.slice(trimmed.indexOf('-') + 1);
+    const slashIdx = rest.indexOf('/');
+    const right = slashIdx === -1 ? rest : rest.slice(0, slashIdx);
+    const stepRaw = slashIdx === -1 ? null : rest.slice(slashIdx + 1);
+    const start = toInt(left);
+    const end = toInt(right);
+    const step = stepRaw === null ? 1 : toInt(stepRaw);
+    if (start === null || end === null || step === null || step <= 0)
+        return;
+    const a = clamp(start, range);
+    const b = clamp(end, range);
+    const lo = Math.min(a, b);
+    const hi = Math.max(a, b);
+    for (let i = lo; i <= hi; i += step)
+        out.add(i);
+};
+const expandPart = (part, range, out) => {
+    const trimmed = part.trim();
+    if (trimmed.length === 0)
+        return;
+    if (trimmed.startsWith('*/')) {
+        const step = toInt(trimmed.slice(2));
+        if (step !== null && step > 0)
+            expandStep(step, range, out);
+        return;
+    }
+    if (trimmed.includes('-')) {
+        expandRange(trimmed, range, out);
+        return;
+    }
+    const num = toInt(trimmed);
+    if (num !== null)
+        out.add(clamp(num, range));
+};
+const parseField = (raw, range, normalize) => {
+    const value = raw.trim();
+    if (value === '*' || value.length === 0)
+        return ANY;
+    const set = new Set();
+    for (const part of value.split(',')) {
+        expandPart(part, range, set);
+    }
+    if (normalize !== undefined) {
+        const normalized = new Set();
+        for (const n of set)
+            normalized.add(normalize(n));
+        return Object.freeze({ any: false, values: normalized });
+    }
+    return Object.freeze({ any: false, values: set });
+};
+const matches = (allowed, value) => {
+    if (allowed.any)
+        return true;
+    return allowed.values.has(value);
+};
+const weekdayToDow = (weekdayShort) => {
+    switch (weekdayShort) {
+        case 'Sun':
+            return 0;
+        case 'Mon':
+            return 1;
+        case 'Tue':
+            return 2;
+        case 'Wed':
+            return 3;
+        case 'Thu':
+            return 4;
+        case 'Fri':
+            return 5;
+        case 'Sat':
+            return 6;
+        default:
+            return 0;
+    }
+};
+const dtfCache = new Map();
+const getFormatter = (timeZone) => {
+    const key = `en-US|${timeZone}`;
+    const cached = dtfCache.get(key);
+    if (cached)
+        return cached;
+    const fmt = new Intl.DateTimeFormat('en-US', {
+        timeZone,
+        weekday: 'short',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        hourCycle: 'h23',
+    });
+    dtfCache.set(key, fmt);
+    return fmt;
+};
+const getZonedParts = (date, timeZone) => {
+    // Fallback to UTC if Intl timeZone support is unavailable.
+    try {
+        const fmt = getFormatter(timeZone);
+        const parts = fmt.formatToParts(date);
+        const get = (type) => parts.find((p) => p.type === type)?.value;
+        const minute = Number.parseInt(get('minute') ?? '0', 10);
+        const hour = Number.parseInt(get('hour') ?? '0', 10);
+        const day = Number.parseInt(get('day') ?? '1', 10);
+        const month = Number.parseInt(get('month') ?? '1', 10);
+        const weekday = get('weekday') ?? 'Sun';
+        const dow = weekdayToDow(weekday);
+        return { minute, hour, day, month, dow };
+    }
+    catch {
+        return {
+            minute: date.getUTCMinutes(),
+            hour: date.getUTCHours(),
+            day: date.getUTCDate(),
+            month: date.getUTCMonth() + 1,
+            dow: date.getUTCDay(),
+        };
+    }
+};
+const domDowMatches = (spec, parts) => {
+    const domAny = spec.dayOfMonth.any;
+    const dowAny = spec.dayOfWeek.any;
+    const domOk = matches(spec.dayOfMonth, parts.day);
+    const dowOk = matches(spec.dayOfWeek, parts.dow);
+    // Vixie cron semantics:
+    // - if either DOM or DOW is '*', require the other field to match
+    // - if both are restricted, match if either matches
+    if (domAny && dowAny)
+        return true;
+    if (domAny)
+        return dowOk;
+    if (dowAny)
+        return domOk;
+    return domOk || dowOk;
+};
+const matchesSpec = (spec, parts) => {
+    return (matches(spec.minute, parts.minute) &&
+        matches(spec.hour, parts.hour) &&
+        matches(spec.month, parts.month) &&
+        domDowMatches(spec, parts));
+};
+export const Cron = Object.freeze({
+    parse(expr) {
+        const raw = String(expr ?? '').trim();
+        const parts = raw.split(/\s+/).filter(Boolean);
+        if (parts.length !== 5) {
+            // Return an "any" spec for invalid inputs; runner will treat it as "every minute".
+            return Object.freeze({
+                minute: ANY,
+                hour: ANY,
+                dayOfMonth: ANY,
+                month: ANY,
+                dayOfWeek: ANY,
+            });
+        }
+        const [min, hour, dom, month, dow] = parts;
+        const normalizeDow = (n) => {
+            // allow 7 as Sunday
+            if (n === 7)
+                return 0;
+            return clamp(n, { min: 0, max: 6 });
+        };
+        return Object.freeze({
+            minute: parseField(min, { min: 0, max: 59 }),
+            hour: parseField(hour, { min: 0, max: 23 }),
+            dayOfMonth: parseField(dom, { min: 1, max: 31 }),
+            month: parseField(month, { min: 1, max: 12 }),
+            dayOfWeek: parseField(dow, { min: 0, max: 7 }, normalizeDow),
+        });
+    },
+    nextRunAtMs(nowMs, expr, timeZone = 'UTC') {
+        const spec = this.parse(expr);
+        const base = new Date(nowMs);
+        // Cron is minute-resolution; start from next minute boundary.
+        base.setUTCSeconds(0, 0);
+        base.setTime(base.getTime() + 60_000);
+        // Bound search to 366 days (minute granularity). This is defensive; typical crons resolve quickly.
+        const maxIterations = 366 * 24 * 60;
+        for (let i = 0; i < maxIterations; i++) {
+            const parts = getZonedParts(base, timeZone);
+            if (matchesSpec(spec, parts))
+                return base.getTime();
+            base.setTime(base.getTime() + 60_000);
+        }
+        // Fallback: run in 60s.
+        return nowMs + 60_000;
+    },
+});
+export default Cron;

package/src/scheduler/leader/SchedulerLeader.d.ts

@@ -0,0 +1,14 @@
+export type SchedulerLeaderHooks = Readonly<{
+    onBecameLeader: () => void;
+    onLostLeadership: () => void;
+}>;
+export type SchedulerLeaderApi = Readonly<{
+    isEnabled: () => boolean;
+    start: (hooks: SchedulerLeaderHooks) => void;
+    stop: () => Promise<void>;
+}>;
+export declare const SchedulerLeader: Readonly<{
+    create(): SchedulerLeaderApi;
+}>;
+export default SchedulerLeader;
+//# sourceMappingURL=SchedulerLeader.d.ts.map

package/src/scheduler/leader/SchedulerLeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchedulerLeader.d.ts","sourceRoot":"","sources":["../../../../src/scheduler/leader/SchedulerLeader.ts"],"names":[],"mappings":"AAoFA,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,cAAc,EAAE,MAAM,IAAI,CAAC;IAC3B,gBAAgB,EAAE,MAAM,IAAI,CAAC;CAC9B,CAAC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IACxC,SAAS,EAAE,MAAM,OAAO,CAAC;IACzB,KAAK,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC7C,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B,CAAC,CAAC;AAgGH,eAAO,MAAM,eAAe;cAChB,kBAAkB;EAkD5B,CAAC;AAEH,eAAe,eAAe,CAAC"}