@xbibzlibrary/telebibz 0.4.4 → 3.0.1

package/dist-cjs/src/keyboard/index.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReplyKeyboard = exports.InlineKeyboard = void 0;
-exports.removeKeyboard = removeKeyboard;
-exports.forceReply = forceReply;
-class InlineKeyboard {
-    rows = [];
-    static from(rows) { const keyboard = new InlineKeyboard(); keyboard.rows.push(...rows.map((row) => [...row])); return keyboard; }
-    text(text, callbackData) { return this.button({ text, callback_data: callbackData }); }
-    url(text, url) { return this.button({ text, url }); }
-    webApp(text, url) { return this.button({ text, web_app: { url } }); }
-    pay(text = "Pay") { return this.button({ text, pay: true }); }
-    copy(text, copiedText) { return this.button({ text, copy_text: { text: copiedText } }); }
-    switchInline(text, query = "") { return this.button({ text, switch_inline_query: query }); }
-    switchInlineCurrent(text, query = "") { return this.button({ text, switch_inline_query_current_chat: query }); }
-    login(text, url, options = {}) { return this.button({ text, login_url: { url, ...options } }); }
-    game(text) { return this.button({ text, callback_game: {} }); }
-    button(button) { this.ensureRow().push(validateInlineButton(button)); return this; }
-    row(...buttons) { this.rows.push(buttons.map(validateInlineButton)); return this; }
-    conditional(condition, factory) { return condition ? factory(this) : this; }
-    grid(buttons, columns) { if (!Number.isInteger(columns) || columns < 1)
-        throw new RangeError("columns must be a positive integer"); for (let index = 0; index < buttons.length; index += columns)
-        this.rows.push(buttons.slice(index, index + columns).map(validateInlineButton)); return this; }
-    build() { return { inline_keyboard: this.rows.map((row) => [...row]) }; }
-    asReplyMarkup() { return this.build(); }
-    ensureRow() { const row = this.rows.at(-1); if (row)
-        return row; const next = []; this.rows.push(next); return next; }
-}
-exports.InlineKeyboard = InlineKeyboard;
-class ReplyKeyboard {
-    rows = [];
-    options = {};
-    text(text) { return this.button({ text }); }
-    contact(text) { return this.button({ text, request_contact: true }); }
-    location(text) { return this.button({ text, request_location: true }); }
-    poll(text, type) { return this.button({ text, request_poll: type ? { type } : {} }); }
-    webApp(text, url) { return this.button({ text, web_app: { url } }); }
-    requestUsers(text, options = {}) { return this.button({ text, request_users: options }); }
-    requestChat(text, options = {}) { return this.button({ text, request_chat: options }); }
-    resized(resize = true) { this.options.resize_keyboard = resize; return this; }
-    oneTime(oneTime = true) { this.options.one_time_keyboard = oneTime; return this; }
-    persistent(persistent = true) { this.options.is_persistent = persistent; return this; }
-    placeholder(text) { this.options.input_field_placeholder = text; return this; }
-    selective(selective = true) { this.options.selective = selective; return this; }
-    button(button) { this.ensureRow().push(button); return this; }
-    row(...buttons) { this.rows.push([...buttons]); return this; }
-    grid(buttons, columns) { if (!Number.isInteger(columns) || columns < 1)
-        throw new RangeError("columns must be a positive integer"); for (let index = 0; index < buttons.length; index += columns)
-        this.rows.push(buttons.slice(index, index + columns)); return this; }
-    build(options = {}) { return { keyboard: this.rows.map((row) => [...row]), ...this.options, ...options }; }
-    asReplyMarkup() { return this.build(); }
-    ensureRow() { const row = this.rows.at(-1); if (row)
-        return row; const next = []; this.rows.push(next); return next; }
-}
-exports.ReplyKeyboard = ReplyKeyboard;
-function removeKeyboard(selective = false) { return { remove_keyboard: true, ...(selective ? { selective: true } : {}) }; }
-function forceReply(placeholder, selective = false) { return { force_reply: true, ...(placeholder ? { input_field_placeholder: placeholder } : {}), ...(selective ? { selective: true } : {}) }; }
-function validateInlineButton(button) { if (!button.text)
-    throw new Error("Inline keyboard button text is required."); const actions = [button.url, button.callback_data, button.web_app, button.login_url, button.switch_inline_query, button.switch_inline_query_current_chat, button.callback_game, button.pay, button.copy_text].filter((value) => value !== undefined); if (actions.length !== 1)
-    throw new Error(`Inline button ${button.text} must contain exactly one action.`); if (button.callback_data && new TextEncoder().encode(button.callback_data).length > 64)
-    throw new RangeError("callback_data must be at most 64 bytes."); return { ...button }; }

package/dist-cjs/src/middleware/compose.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compose = compose;
-exports.middleware = middleware;
-function compose(middleware) {
-    return async function run(ctx) {
-        let index = -1;
-        const dispatch = async (position) => {
-            if (position <= index)
-                throw new Error("next() called multiple times");
-            index = position;
-            const handler = middleware[position];
-            if (!handler)
-                return;
-            await handler(ctx, () => dispatch(position + 1));
-        };
-        await dispatch(0);
-    };
-}
-function middleware(handler) { return handler; }

package/dist-cjs/src/observability/logger.js

@@ -1,293 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = exports.INCOMING_TEXT_LIMIT = void 0;
-exports.redact = redact;
-exports.formatLocalStamp = formatLocalStamp;
-exports.describeIncomingUpdate = describeIncomingUpdate;
-exports.summarizeUpdate = summarizeUpdate;
-exports.createLogger = createLogger;
-// Higher number = more verbose. `silent` must sort BELOW `error` so that every
-// message level is filtered out (a value above all others would let every
-// message through, including errors).
-const priorities = { silent: -1, error: 0, warn: 1, info: 2, debug: 3, trace: 4 };
-const defaultRedactKeys = ["token", "secret", "password", "authorization", "cookie", "private_key", "api_key", "npm_token", "bot_token"];
-const ANSI = {
-    reset: "\u001b[0m",
-    dim: "\u001b[2m",
-    red: "\u001b[31m",
-    yellow: "\u001b[33m",
-    green: "\u001b[32m",
-    cyan: "\u001b[36m",
-    blue: "\u001b[34m",
-    magenta: "\u001b[35m",
-};
-function isObject(value) { return typeof value === "object" && value !== null; }
-function shouldRedact(key, keys) { const normalized = key.toLowerCase().replace(/[-_]/g, ""); return keys.some((candidate) => normalized.includes(candidate.toLowerCase().replace(/[-_]/g, ""))); }
-function redactString(value) {
-    return value
-        .replace(/\b\d{6,12}:[A-Za-z0-9_-]{20,}\b/g, "[REDACTED_TELEGRAM_TOKEN]")
-        .replace(/\bnpm_[A-Za-z0-9]{20,}\b/g, "[REDACTED_NPM_TOKEN]");
-}
-function safeValue(value, keys, seen = new WeakSet()) {
-    if (typeof value === "string")
-        return redactString(value);
-    if (typeof value === "bigint")
-        return `${value}n`;
-    if (value instanceof Error)
-        return safeValue({ name: value.name, message: value.message, stack: value.stack }, keys, seen);
-    if (Array.isArray(value)) {
-        if (seen.has(value))
-            return "[Circular]";
-        seen.add(value);
-        return value.map((item) => safeValue(item, keys, seen));
-    }
-    if (!isObject(value))
-        return value;
-    if (seen.has(value))
-        return "[Circular]";
-    seen.add(value);
-    const result = {};
-    for (const [key, nested] of Object.entries(value))
-        result[key] = shouldRedact(key, keys) ? "[REDACTED]" : safeValue(nested, keys, seen);
-    return result;
-}
-function redact(value, keys = defaultRedactKeys) { return safeValue(value, keys); }
-function updateType(update) {
-    if (update.callback_query)
-        return "callback_query";
-    if (update.inline_query)
-        return "inline_query";
-    if (update.business_message)
-        return "business_message";
-    if (update.edited_business_message)
-        return "edited_business_message";
-    if (update.guest_message)
-        return "guest_message";
-    if (update.edited_guest_message)
-        return "edited_guest_message";
-    if (update.message_reaction)
-        return "message_reaction";
-    if (update.message_reaction_count)
-        return "message_reaction_count";
-    if (update.chat_boost)
-        return "chat_boost";
-    if (update.removed_chat_boost)
-        return "removed_chat_boost";
-    if (update.message)
-        return "message";
-    if (update.edited_message)
-        return "edited_message";
-    if (update.channel_post)
-        return "channel_post";
-    if (update.edited_channel_post)
-        return "edited_channel_post";
-    if (update.my_chat_member)
-        return "my_chat_member";
-    if (update.chat_member)
-        return "chat_member";
-    if (update.chat_join_request)
-        return "chat_join_request";
-    if (update.poll)
-        return "poll";
-    if (update.poll_answer)
-        return "poll_answer";
-    return "unknown";
-}
-exports.INCOMING_TEXT_LIMIT = 50;
-function padNumber(value) { return String(value).padStart(2, "0"); }
-/** Formats a date as `dd/mm/yyyy hh:mm:ss` in local time. */
-function formatLocalStamp(date = new Date()) {
-    return `${padNumber(date.getDate())}/${padNumber(date.getMonth() + 1)}/${date.getFullYear()} ${padNumber(date.getHours())}:${padNumber(date.getMinutes())}:${padNumber(date.getSeconds())}`;
-}
-function truncateForDisplay(value, limit = exports.INCOMING_TEXT_LIMIT) {
-    if (value.length <= limit)
-        return { text: value, truncated: false };
-    return { text: `${value.slice(0, limit)}…`, truncated: true };
-}
-function nicknameFromUser(user) {
-    if (!user)
-        return undefined;
-    const name = [user.first_name, user.last_name].filter(Boolean).join(" ").trim();
-    return name.length > 0 ? name : user.username ?? String(user.id);
-}
-function messageMediaType(message) {
-    for (const key of ["photo", "video", "video_note", "animation", "document", "audio", "voice", "sticker", "location", "venue", "contact", "dice", "poll", "story", "paid_media"]) {
-        if (message[key] !== undefined)
-            return key;
-    }
-    return undefined;
-}
-/**
- * Builds the human-readable description of an incoming update used for the
- * `[ => ] Message From ...` terminal lines. Text messages and commands are
- * truncated to 50 characters; callback button data is shown in full.
- */
-function describeIncomingUpdate(update) {
-    const callback = update.callback_query;
-    if (callback) {
-        const result = { kind: "Callback", fromId: callback.from.id, nickname: nicknameFromUser(callback.from), contentLabel: "Data", content: callback.data };
-        return result;
-    }
-    const message = (update.message ?? update.edited_message ?? update.channel_post ?? update.edited_channel_post ?? update.business_message ?? update.edited_business_message ?? update.guest_message ?? update.edited_guest_message);
-    if (message) {
-        const from = message.from;
-        const nickname = nicknameFromUser(from) ?? (message.chat.title !== undefined ? String(message.chat.title) : message.chat.id !== undefined ? String(message.chat.id) : undefined);
-        const input = { kind: "Message", fromId: from?.id ?? message.chat.id, nickname };
-        const text = message.text;
-        if (text !== undefined) {
-            const truncated = truncateForDisplay(text);
-            input.contentLabel = "Text";
-            input.content = truncated.text;
-            input.truncated = truncated.truncated;
-        }
-        else if (message.caption !== undefined) {
-            const truncated = truncateForDisplay(message.caption);
-            input.contentLabel = "Caption";
-            input.content = truncated.text;
-            input.truncated = truncated.truncated;
-        }
-        else {
-            const media = messageMediaType(message);
-            if (media !== undefined)
-                input.contentLabel = media === "photo" ? "Photo" : media.replace(/_/g, " ").replace(/^./, (character) => character.toUpperCase());
-        }
-        return input;
-    }
-    const inline = update.inline_query;
-    if (inline) {
-        const truncated = truncateForDisplay(inline.query);
-        return { kind: "Inline Query", fromId: inline.from.id, nickname: nicknameFromUser(inline.from), contentLabel: "Query", content: truncated.text, truncated: truncated.truncated };
-    }
-    const chosen = update.chosen_inline_result;
-    if (chosen)
-        return { kind: "Inline Result", fromId: chosen.from.id, nickname: nicknameFromUser(chosen.from), contentLabel: "Result", content: chosen.result_id };
-    const chatScoped = update.chat_member ?? update.my_chat_member ?? update.chat_join_request;
-    if (chatScoped) {
-        return { kind: "Update", fromId: chatScoped.from.id, nickname: nicknameFromUser(chatScoped.from), contentLabel: "Chat", content: chatScoped.chat.title ?? String(chatScoped.chat.id) };
-    }
-    const reaction = update.message_reaction;
-    const reactor = nicknameFromUser(reaction?.from);
-    if (reactor)
-        return { kind: "Reaction", fromId: reaction?.from?.id, nickname: reactor };
-    return { kind: "Update", context: { type: updateType(update) } };
-}
-function summarizeUpdate(update, includeContent = false) {
-    const callback = update.callback_query;
-    const message = (update.message ?? update.edited_message ?? update.channel_post ?? update.edited_channel_post ?? update.business_message ?? update.edited_business_message ?? update.guest_message ?? update.edited_guest_message ?? callback?.message);
-    const summary = { updateId: update.update_id, type: updateType(update) };
-    if (message?.chat?.id !== undefined)
-        summary.chatId = message.chat.id;
-    if (message?.from?.id !== undefined)
-        summary.fromUserId = message.from.id;
-    if (message?.message_id !== undefined)
-        summary.messageId = message.message_id;
-    if (includeContent) {
-        const text = message?.text ?? message?.caption;
-        if (text !== undefined)
-            summary.text = text;
-        if (callback?.data !== undefined)
-            summary.callbackData = callback.data;
-    }
-    return summary;
-}
-function levelColor(level) {
-    if (level === "error")
-        return ANSI.red;
-    if (level === "warn")
-        return ANSI.yellow;
-    if (level === "debug")
-        return ANSI.blue;
-    if (level === "trace")
-        return ANSI.magenta;
-    return ANSI.green;
-}
-function formatEntry(entry, color, format) {
-    if (format === "json") {
-        const line = JSON.stringify(entry);
-        return color ? `${ANSI.dim}${line}${ANSI.reset}` : line;
-    }
-    const time = entry.timestamp.slice(11, 23);
-    const label = entry.level.toUpperCase().padEnd(5, " ");
-    const context = entry.context && Object.keys(entry.context).length ? ` ${JSON.stringify(entry.context)}` : "";
-    const line = `${time} ${label} ${entry.event}${context}`;
-    return color ? `${levelColor(entry.level)}${line}${ANSI.reset}` : line;
-}
-function createDefaultSink(options, redactKeys) {
-    const stream = options.stream ?? process.stdout;
-    const color = options.color ?? Boolean(stream.isTTY && !process.env.NO_COLOR);
-    const format = options.format ?? "pretty";
-    return (entry) => {
-        if (typeof entry.text === "string") {
-            stream.write(`${redactString(entry.text)}\n`);
-            return;
-        }
-        const safeEntry = redact(entry, redactKeys);
-        const line = formatEntry(safeEntry, color, format);
-        stream.write(`${line}\n`);
-    };
-}
-class Logger {
-    level;
-    format;
-    color;
-    includeUpdateContent;
-    sink;
-    redactKeys;
-    baseContext;
-    constructor(options = {}) {
-        this.level = options.level ?? "info";
-        this.format = options.format ?? "pretty";
-        const stream = options.stream ?? process.stdout;
-        this.color = options.color ?? Boolean(stream.isTTY && !process.env.NO_COLOR);
-        this.includeUpdateContent = options.includeUpdateContent ?? false;
-        this.redactKeys = options.redactKeys ?? defaultRedactKeys;
-        this.sink = options.sink ?? createDefaultSink({ color: this.color, format: this.format, stream }, this.redactKeys);
-        this.baseContext = options.context ?? {};
-    }
-    child(context) { return new Logger({ level: this.level, format: this.format, color: this.color, sink: this.sink, includeUpdateContent: this.includeUpdateContent, redactKeys: this.redactKeys, context: { ...this.baseContext, ...context } }); }
-    trace(event, context) { this.write("trace", event, context); }
-    debug(event, context) { this.write("debug", event, context); }
-    info(event, context) { this.write("info", event, context); }
-    warn(event, context) { this.write("warn", event, context); }
-    error(event, context) { this.write("error", event, context); }
-    /**
-     * Logs an incoming update as the human-readable terminal line:
-     * `[ => ] Message From {id} {nickname} {dd/mm/yyyy} {hh:mm:ss}` followed by
-     * an indented content line. In `json` format it emits a structured entry
-     * with the event name `update.received`.
-     */
-    incoming(input) {
-        if (priorities.info > priorities[this.level])
-            return;
-        if (this.format === "json") {
-            const context = { kind: input.kind, ...(input.fromId !== undefined ? { fromId: input.fromId } : {}), ...(input.nickname !== undefined ? { nickname: input.nickname } : {}), ...(input.content !== undefined ? { content: input.content } : {}), ...(input.truncated ? { truncated: true } : {}), ...input.context };
-            this.write("info", "update.received", context);
-            return;
-        }
-        const stamp = formatLocalStamp();
-        const identity = [input.fromId !== undefined ? String(input.fromId) : undefined, input.nickname].filter(Boolean).join(" ");
-        const arrow = this.color ? `\u001b[36m\u001b[1m[ => ]\u001b[0m` : "[ => ]";
-        const kind = this.color ? `\u001b[1m${input.kind}\u001b[0m` : input.kind;
-        const header = `${arrow} ${kind} From ${identity} ${this.color ? `\u001b[2m${stamp}\u001b[0m` : stamp}`;
-        const lines = [redactString(header)];
-        if (input.content !== undefined || input.contentLabel !== undefined) {
-            const label = input.contentLabel ?? "Content";
-            const value = input.content ?? "";
-            const contentLine = `        ↳ ${label}: ${value}`;
-            lines.push(this.color ? `\u001b[2m${redactString(contentLine)}\u001b[0m` : redactString(contentLine));
-        }
-        this.sink({ timestamp: new Date().toISOString(), level: "info", event: "update.received", text: lines.join("\n") });
-    }
-    write(level, event, context = {}) {
-        if (priorities[level] > priorities[this.level])
-            return;
-        const merged = { ...this.baseContext, ...context };
-        const safe = redact(merged, this.redactKeys);
-        const entry = { timestamp: new Date().toISOString(), level, event };
-        if (Object.keys(safe).length)
-            entry.context = safe;
-        this.sink(entry);
-    }
-}
-exports.Logger = Logger;
-function createLogger(options) { return new Logger(options); }

package/dist-cjs/src/plugins/plugin.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginManager = exports.ServiceContainer = void 0;
-class ServiceContainer {
-    values = new Map();
-    register(name, value) { this.values.set(name, value); return this; }
-    get(name) { if (!this.values.has(name))
-        throw new Error(`Service not registered: ${String(name)}`); return this.values.get(name); }
-    has(name) { return this.values.has(name); }
-    delete(name) { return this.values.delete(name); }
-}
-exports.ServiceContainer = ServiceContainer;
-class PluginManager {
-    plugins = [];
-    api;
-    setupComplete = false;
-    constructor(bot) {
-        const host = bot;
-        this.api = {
-            bot,
-            services: new ServiceContainer(),
-            registerMiddleware: (middleware) => {
-                if (typeof middleware !== "function" || !host.use)
-                    throw new TypeError("Plugin middleware must be a function and the bot must support use().");
-                host.use(middleware);
-            },
-            registerRoute: (route) => {
-                if (typeof route === "function") {
-                    route(bot);
-                    return;
-                }
-                if (!route || typeof route !== "object" || !host.router?.route)
-                    throw new TypeError("Plugin route must be a registration function or route descriptor.");
-                const descriptor = route;
-                if (typeof descriptor.matcher !== "function" || !Array.isArray(descriptor.middleware) || descriptor.middleware.some((item) => typeof item !== "function"))
-                    throw new TypeError("Plugin route descriptor is invalid.");
-                host.router.route(descriptor.matcher, ...descriptor.middleware);
-            },
-        };
-    }
-    use(plugin) { if (this.plugins.some((existing) => existing.name === plugin.name))
-        throw new Error(`Plugin already registered: ${plugin.name}`); this.plugins.push(plugin); return this; }
-    /** Installs plugins once; re-running setup after a restart must not double-register middleware. */
-    async setup() {
-        if (this.setupComplete)
-            return;
-        for (const plugin of this.plugins) {
-            await plugin.install?.(this.api);
-            await plugin.setup?.(this.api);
-        }
-        this.setupComplete = true;
-    }
-    async start() { for (const plugin of this.plugins)
-        await plugin.onStart?.(this.api); }
-    async update(context) { for (const plugin of this.plugins)
-        await plugin.onUpdate?.(context); }
-    async stop() { for (const plugin of this.plugins)
-        await plugin.onStop?.(this.api); }
-    async dispose() { for (const plugin of [...this.plugins].reverse())
-        await plugin.dispose?.(this.api); }
-    list() { return this.plugins; }
-}
-exports.PluginManager = PluginManager;

package/dist-cjs/src/queue/queue.js

@@ -1,219 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Scheduler = exports.TaskQueue = void 0;
-exports.parseCronExpression = parseCronExpression;
-exports.nextCronOccurrence = nextCronOccurrence;
-function sleep(delayMs) { return new Promise((resolve) => setTimeout(resolve, delayMs)); }
-class TaskQueue {
-    worker;
-    options;
-    pending = [];
-    jobs = new Map();
-    controllers = new Map();
-    active = 0;
-    sequence = 0;
-    draining = false;
-    closed = false;
-    constructor(worker, options = {}) {
-        this.worker = worker;
-        this.options = options;
-        if ((options.concurrency ?? 1) < 1 || !Number.isInteger(options.concurrency ?? 1))
-            throw new RangeError("concurrency must be a positive integer");
-        if ((options.retries ?? 0) < 0 || !Number.isInteger(options.retries ?? 0))
-            throw new RangeError("retries must be a non-negative integer");
-    }
-    add(data, options = {}) {
-        if (this.closed)
-            throw new Error("TaskQueue is closed");
-        const id = options.id ?? `job_${Date.now()}_${this.sequence++}`;
-        if (this.jobs.has(id))
-            throw new Error(`Job already exists: ${id}`);
-        if (options.delayMs !== undefined && options.delayMs < 0)
-            throw new RangeError("delayMs must be non-negative");
-        const job = { id, data, attempts: 0, priority: options.priority ?? 0, runAt: Date.now() + (options.delayMs ?? 0), status: "queued" };
-        this.jobs.set(id, job);
-        this.pending.push(job);
-        this.pending.sort((a, b) => b.priority - a.priority || a.runAt - b.runAt);
-        void this.drain();
-        return { ...job };
-    }
-    get(id) { const job = this.jobs.get(id); return job ? { ...job } : undefined; }
-    cancel(id) { const job = this.jobs.get(id); if (!job || ["completed", "failed", "cancelled"].includes(job.status))
-        return false; job.status = "cancelled"; this.controllers.get(id)?.abort(); return true; }
-    async onIdle() { while (this.pending.some((job) => job.status === "queued") || this.active)
-        await sleep(10); }
-    async close() {
-        this.closed = true;
-        this.draining = false;
-        for (const id of this.controllers.keys())
-            this.cancel(id);
-        for (const job of this.pending)
-            if (job.status === "queued")
-                job.status = "cancelled";
-        this.pending.length = 0;
-        await this.onIdle();
-    }
-    async drain() {
-        if (this.draining || this.closed)
-            return;
-        this.draining = true;
-        try {
-            while (!this.closed && this.pending.some((job) => job.status === "queued") && this.active < (this.options.concurrency ?? 1)) {
-                const index = this.pending.findIndex((job) => job.runAt <= Date.now() && job.status === "queued");
-                if (index < 0) {
-                    const next = Math.min(...this.pending.filter((job) => job.status === "queued").map((job) => job.runAt));
-                    await sleep(Math.max(1, next - Date.now()));
-                    continue;
-                }
-                const [job] = this.pending.splice(index, 1);
-                if (!job)
-                    continue;
-                this.active += 1;
-                void this.run(job).finally(() => { this.active -= 1; void this.drain(); });
-            }
-        }
-        finally {
-            this.draining = false;
-        }
-    }
-    async run(job) {
-        const maxAttempts = this.options.retries ?? 0;
-        const controller = new AbortController();
-        this.controllers.set(job.id, controller);
-        try {
-            while (job.attempts <= maxAttempts && job.status !== "cancelled") {
-                job.status = "running";
-                job.attempts += 1;
-                try {
-                    await this.worker(job, controller.signal);
-                    job.status = "completed";
-                    return;
-                }
-                catch (error) {
-                    job.error = error;
-                    const wasCancelled = job.status === "cancelled";
-                    if (job.attempts > maxAttempts || wasCancelled) {
-                        job.status = wasCancelled ? "cancelled" : "failed";
-                        await this.options.onError?.(error, { ...job });
-                        return;
-                    }
-                    const delay = Math.min(this.options.maxBackoffMs ?? 30_000, (this.options.backoffMs ?? 250) * 2 ** (job.attempts - 1));
-                    await sleep(delay);
-                }
-            }
-        }
-        finally {
-            this.controllers.delete(job.id);
-        }
-    }
-}
-exports.TaskQueue = TaskQueue;
-function parseCronField(token, min, max, normalize) {
-    if (!token)
-        throw new Error("Cron fields cannot be empty");
-    const values = new Set();
-    for (const part of token.split(",")) {
-        const [rangePart, stepPart] = part.split("/");
-        const step = stepPart === undefined ? 1 : Number(stepPart);
-        if (!Number.isInteger(step) || step < 1)
-            throw new Error(`Invalid cron step: ${part}`);
-        const bounds = rangePart === "*" ? [min, max] : rangePart?.split("-").map(Number);
-        if (!bounds || bounds.length < 1 || bounds.some((value) => !Number.isInteger(value)))
-            throw new Error(`Invalid cron range: ${part}`);
-        const start = bounds[0];
-        const end = (bounds[1] ?? start);
-        if (start < min || end > max || start > end)
-            throw new Error(`Cron value out of range: ${part}`);
-        for (let value = start; value <= end; value += step)
-            values.add(normalize ? normalize(value) : value);
-    }
-    return { min, max, values };
-}
-function parseCronExpression(expression) {
-    const fields = expression.trim().split(/\s+/);
-    if (fields.length !== 5)
-        throw new Error("Cron expression must contain exactly five fields: minute hour day-of-month month day-of-week");
-    return {
-        minute: parseCronField(fields[0], 0, 59),
-        hour: parseCronField(fields[1], 0, 23),
-        dayOfMonth: parseCronField(fields[2], 1, 31),
-        month: parseCronField(fields[3], 1, 12),
-        dayOfWeek: parseCronField(fields[4], 0, 7, (value) => value === 7 ? 0 : value),
-    };
-}
-function nextCronOccurrence(expression, from = new Date()) {
-    const cron = typeof expression === "string" ? parseCronExpression(expression) : expression;
-    const candidate = new Date(from);
-    candidate.setSeconds(0, 0);
-    candidate.setMinutes(candidate.getMinutes() + 1);
-    const maxMinutes = 366 * 24 * 60 * 5;
-    for (let index = 0; index < maxMinutes; index += 1) {
-        const dayOfMonthMatches = cron.dayOfMonth.values.has(candidate.getDate());
-        const dayOfWeekMatches = cron.dayOfWeek.values.has(candidate.getDay());
-        const dayMatches = cron.dayOfMonth.values.size === cron.dayOfMonth.max - cron.dayOfMonth.min + 1
-            || cron.dayOfWeek.values.size === cron.dayOfWeek.max - cron.dayOfWeek.min + 1
-            ? dayOfMonthMatches && dayOfWeekMatches
-            : dayOfMonthMatches || dayOfWeekMatches;
-        if (cron.month.values.has(candidate.getMonth() + 1) && cron.hour.values.has(candidate.getHours()) && cron.minute.values.has(candidate.getMinutes()) && dayMatches)
-            return new Date(candidate);
-        candidate.setMinutes(candidate.getMinutes() + 1);
-    }
-    throw new Error(`Cron expression has no occurrence within five years: ${typeof expression === "string" ? expression : "[parsed]"}`);
-}
-class Scheduler {
-    options;
-    timers = new Map();
-    nextRuns = new Map();
-    constructor(options = {}) {
-        this.options = options;
-    }
-    every(id, intervalMs, task) {
-        if (!Number.isFinite(intervalMs) || intervalMs <= 0)
-            throw new RangeError("intervalMs must be positive");
-        this.cancel(id);
-        const timer = setInterval(() => { void this.run(id, task); }, intervalMs);
-        this.timers.set(id, timer);
-        return { id, cancel: () => this.cancel(id) };
-    }
-    after(id, delayMs, task) {
-        if (!Number.isFinite(delayMs) || delayMs < 0)
-            throw new RangeError("delayMs must be non-negative");
-        this.cancel(id);
-        const timer = setTimeout(() => { this.timers.delete(id); void this.run(id, task); }, delayMs);
-        this.timers.set(id, timer);
-        return { id, cancel: () => this.cancel(id) };
-    }
-    cron(id, expression, task) {
-        const parsed = parseCronExpression(expression);
-        this.cancel(id);
-        const scheduleNext = () => {
-            const nextRunAt = nextCronOccurrence(parsed);
-            this.nextRuns.set(id, nextRunAt);
-            const timer = setTimeout(() => {
-                this.timers.delete(id);
-                void this.run(id, task).finally(() => { if (this.nextRuns.has(id))
-                    scheduleNext(); });
-            }, Math.max(1, nextRunAt.getTime() - Date.now()));
-            this.timers.set(id, timer);
-        };
-        scheduleNext();
-        const scheduler = this;
-        return { id, cancel: () => scheduler.cancel(id), get nextRunAt() { return scheduler.nextRuns.get(id); } };
-    }
-    getNextRun(id) { const value = this.nextRuns.get(id); return value ? new Date(value) : undefined; }
-    cancel(id) { const timer = this.timers.get(id); if (!timer) {
-        this.nextRuns.delete(id);
-        return false;
-    } clearTimeout(timer); clearInterval(timer); this.timers.delete(id); this.nextRuns.delete(id); return true; }
-    clear() { for (const id of [...this.timers.keys()])
-        this.cancel(id); }
-    async run(id, task) {
-        try {
-            await task();
-        }
-        catch (error) {
-            await this.options.onError?.(error, id);
-        }
-    }
-}
-exports.Scheduler = Scheduler;