@xbibzlibrary/telebibz 0.4.4 → 3.0.1

package/examples/07-inline-query.js

@@ -0,0 +1,18 @@
+// examples/07-inline-query.js — mode inline: ketik @botkamu apa saja di chat apa pun.
+'use strict';
+
+const { TeleBibz, iq } = require('..');
+
+const bot = new TeleBibz(process.env.BOT_TOKEN);
+
+bot.inlineQuery('*', async (ctx) => {
+  const q = (ctx.inline_query.query || '').trim();
+  const hasil = [
+    iq.article('echo', `Echo: ${q || '…'}`, { message_text: q || 'ketik sesuatu setelah @botkamu' }),
+    iq.article('caps', 'HURUF BESAR', { message_text: (q || 'HALO').toUpperCase() }),
+    iq.article('terbalik', 'Balik teks', { message_text: [...(q || 'halo')].reverse().join('') }),
+  ];
+  await ctx.answerInlineQuery(hasil, { cache_time: 0, is_personal: true });
+});
+
+bot.launch();

package/index.d.ts

@@ -0,0 +1,81 @@
+// index.d.ts — tipe ringkas untuk autocompletion editor (autocorrect).
+// v3: tipe longgar (JS-first) — parity grammY.
+type Context = any; type Bot = any;
+
+declare module '@xbibzlibrary/telebibz' {
+  type Color = 'danger' | 'success' | 'primary';
+  type Handler = (ctx: Context) => unknown;
+
+  interface WizardStep {
+    key: string;
+    ask: string | ((ctx: Context) => string | Promise<string>);
+    parse?: (text: string, ctx: Context) => unknown | Promise<unknown>;
+    validate?: (value: unknown, ctx: Context) => string | null | Promise<string | null>;
+    opts?: Record<string, unknown>;
+  }
+  interface WizardDef {
+    steps: WizardStep[];
+    done: (answers: Record<string, unknown>, ctx: Context) => unknown;
+    cancelWords?: string[];
+    onCancel?: (ctx: Context) => unknown;
+  }
+
+  interface TeleBibzOpts {
+    allowedUpdates?: string[];
+    onError?: (err: unknown, ctx?: Context) => unknown;
+    silent?: boolean;
+    dropPending?: boolean;
+    grammy?: Record<string, unknown>;
+  }
+
+  class TeleBibz {
+    constructor(token: string, opts?: TeleBibzOpts);
+    bot: Bot<Context>;
+    api: Bot<Context>['api'];
+    botInfo: any;
+    use(...mw: any[]): this;
+    cmd(names: string | string[], ...mw: Handler[]): this;
+    hears(match: string | RegExp, ...mw: Handler[]): this;
+    action(trigs: string | RegExp | string[], ...mw: Handler[]): this;
+    on(filter: string | string[], ...mw: Handler[]): this;
+    start(replies: string | Handler): this;
+    wizard(id: string, def: WizardDef, bindCommand?: boolean): this;
+    wizardStart(ctx: Context, id: string): Promise<unknown>;
+    wizardActive(ctx: Context): boolean;
+    broadcast(ids: Array<number | string>, pesan: any, opts?: { delay?: number }): Promise<{ terkirim: number; gagal: number; errors: Array<{ chatId: any; pesan: string }> }>;
+    launch(opts?: Record<string, unknown>): Promise<this>;
+    handleUpdate(update: any): Promise<void>;
+    webhook(...args: any[]): any;
+    stop(): Promise<void>;
+  }
+
+  function btn(text: string, callbackData: string | number, style?: Color, iconId?: string): any;
+  function url(text: string, link: string, style?: Color, iconId?: string): any;
+  function webApp(text: string, link: string, iconId?: string): any;
+  function copy(text: string, value: string, iconId?: string): any;
+  function kb(rows: any[][]): { reply_markup: { inline_keyboard: any[][] } };
+  namespace kb {
+    function markup(rows: any[][]): { inline_keyboard: any[][] };
+    function confirm(yesData: string, noData: string, labelYes?: string, labelNo?: string): any;
+  }
+
+  const wizard: {
+    define: (id: string, def: WizardDef) => string;
+    start: (ctx: Context, id: string) => Promise<unknown>;
+    active: (ctx: Context) => boolean;
+  };
+
+  function humanize(err: unknown): { pesan: string; saran: string | null; method?: string; code?: number };
+  const log: { info: Function; ok: Function; warn: Function; error: Function; banner: Function };
+  const say: { html: (text: string, extra?: object) => object };
+
+  class File { constructor(src: any, filename?: string, type?: string); src: any; filename: string; data(): Promise<Buffer>; }
+  const InputFile: typeof File;
+  const InlineKeyboard: any;
+  const Keyboard: any;
+  class ApiError extends Error { description: string; error_code?: number; method?: string; payload?: any; }
+  const Composer: any; const BotError: any; const session: any; const Api: any;
+}
+
+import { Menu as _M } from './lib/menus';
+export {};

package/index.js

@@ -0,0 +1,42 @@
+// index.js — pintu masuk @xbibzlibrary/telebibz.
+// v3: set fitur production-grade setara grammY (lihat README -> FEATURE MATRIX).
+'use strict';
+
+const { TeleBibz } = require('./lib/telebibz');
+const { ApiError, createTransport } = require('./lib/net');
+const { File, InputFile, InputMediaBuilder } = require('./lib/file');
+const { btn, url, webApp, copy, kb, InlineKeyboard, Keyboard } = require('./lib/keyboard');
+const wizard = require('./lib/wizard');
+const { humanize } = require('./lib/errors');
+const log = require('./lib/logger');
+const { session } = require('./lib/session');
+const { Composer, BotError } = require('./lib/composer');
+const { makeApi } = require('./lib/api');
+const { Context } = require('./lib/context');
+const { broadcast } = require('./lib/broadcast');
+const { autoRetry, throttler, limiter } = require('./lib/ratelimit');
+const { matchInlineQuery, iq } = require('./lib/inline-query');
+const { Menu, MenuContainer } = require('./lib/menus');
+
+const say = {
+  html: (text, extra = {}) => ({ ...extra, text, parse_mode: 'HTML' }),
+};
+
+module.exports = {
+  // kelas utama
+  TeleBibz, Context, Composer, BotError, session,
+  // keyboard & menu
+  btn, url, webApp, copy, kb, InlineKeyboard, Keyboard, Menu, MenuContainer,
+  // percakapan
+  wizard,
+  // file & media
+  File, InputFile, InputMediaBuilder,
+  // api & transport
+  makeApi, createTransport, ApiError,
+  // anti-spam & keandalan
+  autoRetry, throttler, limiter, broadcast,
+  // inline mode
+  matchInlineQuery, iq,
+  // util
+  humanize, log, say,
+};

package/lib/api.js

@@ -0,0 +1,154 @@
+// lib/api.js — akses penuh Bot API: ~60 shortcut + PROXY untuk SEGALA metode +
+// transformer pipeline (api.config.use) gaya grammY + download file.
+'use strict';
+
+const { createTransport } = require('./net');
+
+class ApiConfig {
+  constructor() { this.transformers = []; }
+  /** Sisipkan transformer: (prev, method, payload) => result */
+  use(t) { this.transformers.push(t); return this; }
+}
+
+class ApiBase {
+  constructor(token, transport) {
+    this.token = token;
+    this.config = new ApiConfig();
+    this._base = transport || createTransport(token, {});
+    this.raw = (method, payload = {}) => this.callApi(method, payload);
+  }
+
+  async callApi(method, payload = {}) {
+    let fn = this._base;
+    for (const t of this.config.transformers) {
+      const prev = fn;
+      fn = (m, p) => t(prev, m, p);
+    }
+    return fn(method, payload);
+  }
+
+  /* =============== metode umum =============== */
+  getMe() { return this.callApi('getMe'); }
+  logOut() { return this.callApi('logOut'); }
+  close() { return this.callApi('close'); }
+
+  /* ---- pesan ---- */
+  sendMessage(chat_id, text, extra = {}) { return this.callApi('sendMessage', { chat_id, text, ...extra }); }
+  forwardMessage(chat_id, from_chat_id, message_id, extra = {}) { return this.callApi('forwardMessage', { chat_id, from_chat_id, message_id, ...extra }); }
+  forwardMessages(chat_id, from_chat_id, message_ids, extra = {}) { return this.callApi('forwardMessages', { chat_id, from_chat_id, message_ids, ...extra }); }
+  copyMessage(chat_id, from_chat_id, message_id, extra = {}) { return this.callApi('copyMessage', { chat_id, from_chat_id, message_id, ...extra }); }
+  copyMessages(chat_id, from_chat_id, message_ids, extra = {}) { return this.callApi('copyMessages', { chat_id, from_chat_id, message_ids, ...extra }); }
+  editMessageText(chat_id, message_id, text, extra = {}) { return this.callApi('editMessageText', { chat_id, message_id, text, ...extra }); }
+  editMessageCaption(chat_id, message_id, extra = {}) { return this.callApi('editMessageCaption', { chat_id, message_id, ...extra }); }
+  editMessageMedia(chat_id, message_id, media, extra = {}) { return this.callApi('editMessageMedia', { chat_id, message_id, media, ...extra }); }
+  editMessageReplyMarkup(chat_id, message_id, extra = {}) { return this.callApi('editMessageReplyMarkup', { chat_id, message_id, ...extra }); }
+  deleteMessage(chat_id, message_id) { return this.callApi('deleteMessage', { chat_id, message_id }); }
+  deleteMessages(chat_id, message_ids) { return this.callApi('deleteMessages', { chat_id, message_ids }); }
+  setMessageReaction(chat_id, message_id, reaction, extra = {}) { return this.callApi('setMessageReaction', { chat_id, message_id, reaction, ...extra }); }
+  sendChatAction(chat_id, action, extra = {}) { return this.callApi('sendChatAction', { chat_id, action, ...extra }); }
+
+  /* ---- media ---- */
+  sendPhoto(c, photo, e = {}) { return this.callApi('sendPhoto', { chat_id: c, photo, ...e }); }
+  sendVideo(c, video, e = {}) { return this.callApi('sendVideo', { chat_id: c, video, ...e }); }
+  sendAudio(c, audio, e = {}) { return this.callApi('sendAudio', { chat_id: c, audio, ...e }); }
+  sendDocument(c, document, e = {}) { return this.callApi('sendDocument', { chat_id: c, document, ...e }); }
+  sendAnimation(c, animation, e = {}) { return this.callApi('sendAnimation', { chat_id: c, animation, ...e }); }
+  sendVoice(c, voice, e = {}) { return this.callApi('sendVoice', { chat_id: c, voice, ...e }); }
+  sendVideoNote(c, vn, e = {}) { return this.callApi('sendVideoNote', { chat_id: c, video_note: vn, ...e }); }
+  sendSticker(c, sticker, e = {}) { return this.callApi('sendSticker', { chat_id: c, sticker, ...e }); }
+  sendMediaGroup(c, media, e = {}) { return this.callApi('sendMediaGroup', { chat_id: c, media, ...e }); }
+  sendLocation(c, lat, lon, e = {}) { return this.callApi('sendLocation', { chat_id: c, latitude: lat, longitude: lon, ...e }); }
+  sendVenue(c, lat, lon, title, address, e = {}) { return this.callApi('sendVenue', { chat_id: c, latitude: lat, longitude: lon, title, address, ...e }); }
+  sendContact(c, phone, first, e = {}) { return this.callApi('sendContact', { chat_id: c, phone_number: phone, first_name: first, ...e }); }
+  sendPoll(c, question, options, e = {}) { return this.callApi('sendPoll', { chat_id: c, question, options, ...e }); }
+  sendDice(c, emoji, e = {}) { return this.callApi('sendDice', { chat_id: c, ...(emoji ? { emoji } : {}), ...e }); }
+  stopPoll(c, message_id, e = {}) { return this.callApi('stopPoll', { chat_id: c, message_id, ...e }); }
+
+  /* ---- file ---- */
+  getFile(file_id) { return this.callApi('getFile', { file_id }); }
+  /** Unduh file_id ke disk; return path tujuan. */
+  async downloadFile(file_id, dest, axiosOpts = {}) {
+    const f = await this.getFile(file_id);
+    const axios = require('axios');
+    const fs = require('fs');
+    const url = `https://api.telegram.org/file/bot${this.token}/${f.file_path}`;
+    const res = await axios.get(url, { responseType: 'stream', ...axiosOpts });
+    const out = fs.createWriteStream(dest);
+    await new Promise((ok, no) => { res.data.pipe(out); out.on('finish', ok); out.on('error', no); res.data.on('error', no); });
+    return dest;
+  }
+
+  /* ---- callback & inline ---- */
+  answerCallbackQuery(id, e = {}) { return this.callApi('answerCallbackQuery', { callback_query_id: id, ...e }); }
+  answerInlineQuery(id, results, e = {}) { return this.callApi('answerInlineQuery', { inline_query_id: id, results, ...e }); }
+
+  /* ---- grup & admin ---- */
+  banChatMember(c, u, e = {}) { return this.callApi('banChatMember', { chat_id: c, user_id: u, ...e }); }
+  unbanChatMember(c, u, e = {}) { return this.callApi('unbanChatMember', { chat_id: c, user_id: u, ...e }); }
+  restrictChatMember(c, u, permissions, e = {}) { return this.callApi('restrictChatMember', { chat_id: c, user_id: u, permissions, ...e }); }
+  promoteChatMember(c, u, e = {}) { return this.callApi('promoteChatMember', { chat_id: c, user_id: u, ...e }); }
+  setChatAdministratorCustomTitle(c, u, t) { return this.callApi('setChatAdministratorCustomTitle', { chat_id: c, user_id: u, custom_title: t }); }
+  approveChatJoinRequest(c, u) { return this.callApi('approveChatJoinRequest', { chat_id: c, user_id: u }); }
+  declineChatJoinRequest(c, u) { return this.callApi('declineChatJoinRequest', { chat_id: c, user_id: u }); }
+  getChat(c) { return this.callApi('getChat', { chat_id: c }); }
+  getChatAdministrators(c) { return this.callApi('getChatAdministrators', { chat_id: c }); }
+  getChatMemberCount(c) { return this.callApi('getChatMemberCount', { chat_id: c }); }
+  getChatMember(c, u) { return this.callApi('getChatMember', { chat_id: c, user_id: u }); }
+  leaveChat(c) { return this.callApi('leaveChat', { chat_id: c }); }
+  setChatTitle(c, title) { return this.callApi('setChatTitle', { chat_id: c, title }); }
+  setChatDescription(c, description) { return this.callApi('setChatDescription', { chat_id: c, description }); }
+  setChatPhoto(c, photo) { return this.callApi('setChatPhoto', { chat_id: c, photo }); }
+  setChatPermissions(c, permissions, e = {}) { return this.callApi('setChatPermissions', { chat_id: c, permissions, ...e }); }
+  pinChatMessage(c, m, e = {}) { return this.callApi('pinChatMessage', { chat_id: c, message_id: m, ...e }); }
+  unpinChatMessage(c, e = {}) { return this.callApi('unpinChatMessage', { chat_id: c, ...e }); }
+  unpinAllChatMessages(c) { return this.callApi('unpinAllChatMessages', { chat_id: c }); }
+  exportChatInviteLink(c) { return this.callApi('exportChatInviteLink', { chat_id: c }); }
+
+  /* ---- konfigurasi bot ---- */
+  setMyCommands(commands, e = {}) { return this.callApi('setMyCommands', { commands, ...e }); }
+  getMyCommands(e = {}) { return this.callApi('getMyCommands', e); }
+  deleteMyCommands(e = {}) { return this.callApi('deleteMyCommands', e); }
+  setMyName(e = {}) { return this.callApi('setMyName', e); }
+  getMyName(e = {}) { return this.callApi('getMyName', e); }
+  setMyDescription(e = {}) { return this.callApi('setMyDescription', e); }
+  getMyDescription(e = {}) { return this.callApi('getMyDescription', e); }
+  setMyShortDescription(e = {}) { return this.callApi('setMyShortDescription', e); }
+  setChatMenuButton(e = {}) { return this.callApi('setChatMenuButton', e); }
+
+  /* ---- webhook ---- */
+  setWebhook(url, e = {}) { return this.callApi('setWebhook', { url, ...e }); }
+  deleteWebhook(e = {}) { return this.callApi('deleteWebhook', e); }
+  getWebhookInfo() { return this.callApi('getWebhookInfo'); }
+
+  /* ---- forum topic ---- */
+  createForumTopic(c, name, e = {}) { return this.callApi('createForumTopic', { chat_id: c, name, ...e }); }
+  closeForumTopic(c, tid) { return this.callApi('closeForumTopic', { chat_id: c, message_thread_id: tid }); }
+
+  /* ---- pembayaran & stars ---- */
+  sendInvoice(c, title, description, payload, currency, prices, e = {}) { return this.callApi('sendInvoice', { chat_id: c, title, description, payload, currency, prices, ...e }); }
+  refundStarPayment(user_id, telegram_payment_charge_id) { return this.callApi('refundStarPayment', { user_id, telegram_payment_charge_id }); }
+  getStarTransactions(e = {}) { return this.callApi('getStarTransactions', e); }
+}
+
+/**
+ * Api = ApiBase + Proxy: metode APA PUN di Bot API bisa dipanggil
+ *   api.setWebhookCustom({ url })  →  callApi('setWebhookCustom', {...})
+ * Implementasi: kalau nama ada di ApiBase, pakai definisi resminya; kalau
+ * tidak, fallback jadi satu-argumen-payload.
+ */
+function makeApi(token, transport) {
+  const base = new ApiBase(token, transport);
+  return new Proxy(base, {
+    get(target, prop, recv) {
+      const v = Reflect.get(target, prop, recv);
+      if (v !== undefined) return typeof v === 'function' ? v.bind(target) : v;
+      if (typeof prop === 'string' && /^[a-z][a-zA-Z0-9]*$/.test(prop)) {
+        return (payload = {}) => target.callApi(prop, payload);
+      }
+      return undefined;
+    },
+    set(target, prop, value) { Reflect.set(target, prop, value); return true; },
+  });
+}
+
+module.exports = { makeApi, ApiBase };

package/lib/broadcast.js

@@ -0,0 +1,35 @@
+// lib/broadcast.js — kirim ke banyak chat dengan pacing aman rate-limit.
+'use strict';
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/**
+ * bot.broadcast(ids, pesan, opts)
+ *   ids   : array chat id
+ *   pesan : string  → { text: string }
+ *           object  → payload sendMessage/salinan
+ *           fungsi  → (chatId) => payload (personal per penerima)
+ *   opts  : { delay = 35 } ms antar kirim (≈28 pesan/detik, di bawah limit Telegram)
+ *
+ * Return: { terkirim, gagal, errors: [{ chatId, pesan }] }
+ */
+async function broadcast(api, ids, pesan, opts = {}) {
+  const delay = Number.isFinite(opts.delay) ? opts.delay : 35;
+  const failures = [];
+  let terkirim = 0;
+
+  for (const chatId of ids) {
+    let p = typeof pesan === 'function' ? await pesan(chatId) : pesan;
+    if (typeof p === 'string') p = { text: p };
+    try {
+      await api.callApi('sendMessage', { chat_id: chatId, ...p });
+      terkirim += 1;
+    } catch (err) {
+      failures.push({ chatId, pesan: (err && (err.description || err.message)) || String(err) });
+    }
+    if (delay > 0) await sleep(delay);
+  }
+  return { terkirim, gagal: failures.length, errors: failures };
+}
+
+module.exports = { broadcast };

package/lib/composer.js

@@ -0,0 +1,174 @@
+// lib/composer.js — mesin middleware & routing filter (recoded, konsep gaya grammY).
+'use strict';
+
+const { msgOf } = require('./context');
+
+/* ---------- matcher filter ---------- */
+const UPDATE_FIELDS = {
+  message: (u) => u.message, edited_message: (u) => u.edited_message,
+  channel_post: (u) => u.channel_post, edited_channel_post: (u) => u.edited_channel_post,
+  business_message: (u) => u.business_message, edited_business_message: (u) => u.edited_business_message,
+  callback_query: (u) => u.callback_query, inline_query: (u) => u.inline_query,
+  chat_join_request: (u) => u.chat_join_request, chat_member: (u) => u.chat_member,
+  my_chat_member: (u) => u.my_chat_member, message_reaction: (u) => u.message_reaction,
+  message_reaction_count: (u) => u.message_reaction_count,
+  business_connection: (u) => u.business_connection, poll: (u) => u.poll, poll_answer: (u) => u.poll_answer,
+  chosen_inline_result: (u) => u.chosen_inline_result, shipping_query: (u) => u.shipping_query,
+  pre_checkout_query: (u) => u.pre_checkout_query, purchased_paid_media: (u) => u.purchased_paid_media,
+};
+const MSG_PROPS = {
+  text: (m) => typeof m.text === 'string', caption: (m) => typeof m.caption === 'string',
+  photo: (m) => Array.isArray(m.photo), video: (m) => !!m.video, audio: (m) => !!m.audio,
+  voice: (m) => !!m.voice, video_note: (m) => !!m.video_note, document: (m) => !!m.document,
+  sticker: (m) => !!m.sticker, animation: (m) => !!m.animation, location: (m) => !!m.location,
+  contact: (m) => !!m.contact, poll: (m) => !!m.poll, venue: (m) => !!m.venue,
+  dice: (m) => !!m.dice, game: (m) => !!m.game, invoice: (m) => !!m.invoice,
+  new_chat_members: (m) => Array.isArray(m.new_chat_members), left_chat_member: (m) => !!m.left_chat_member,
+  successful_payment: (m) => !!m.successful_payment, web_app_data: (m) => !!m.web_app_data,
+  via_bot: (m) => !!m.via_bot, reply_to_message: (m) => !!m.reply_to_message, entities: (m) => Array.isArray(m.entities),
+  media: (m) => Array.isArray(m.photo) || !!m.video || !!m.document || !!m.audio,
+  data: () => false, // khusus callback_query ditangani di bawah
+  successful_payment: (m) => !!m.successful_payment,
+};
+
+/** filter 'message:photo', ':text', 'callback_query': → fungsi (ctx) => boolean */
+function compileFilter(str) {
+  // ':prop' → pesan (atau edited/channel/business) dengan properti tsb — gaya grammY
+  if (String(str).startsWith(':')) {
+    const prop = String(str).slice(1);
+    const test = MSG_PROPS[prop];
+    if (test) return (ctx) => { const m = msgOf(ctx.update); return !!m && test(m); };
+    return () => false;
+  }
+  const [head, prop] = String(str).split(':');
+  if (head === 'chat_type') return (ctx) => { const c = ctx.chat; return !!c && c.type === prop; };
+  if (head === 'callback_query' && prop === 'data') return (ctx) => !!(ctx.callback_query && typeof ctx.callback_query.data === 'string');
+  if (head && prop) {
+    const get = UPDATE_FIELDS[head];
+    const test = MSG_PROPS[prop];
+    if (get && test) return (ctx) => { const m = get(ctx.update); return !!m && test(m); };
+    if (get) return (ctx) => !!get(ctx.update);
+    if (test) return (ctx) => { const m = msgOf(ctx.update); return !!m && test(m); };
+  }
+  if (UPDATE_FIELDS[head]) return (ctx) => !!UPDATE_FIELDS[head](ctx.update);
+  if (MSG_PROPS[head]) return (ctx) => { const m = msgOf(ctx.update); return !!m && MSG_PROPS[head](m); };
+  return () => false;
+}
+
+/* ---------- composer ---------- */
+class Composer {
+  constructor(...mw) { this.stack = []; for (const m of mw) this.use(m); }
+
+  use(...mw) {
+    for (const m of mw) {
+      const fn = m instanceof Composer ? m.middleware() : m;
+      this.stack.push({ match: () => true, fns: [fn] });
+    }
+    return this;
+  }
+  on(filter, ...mw) { [].concat(filter).forEach((f) => this.stack.push({ match: compileFilter(f), fns: mw })); return this; }
+  hears(re, ...mw) {
+    [].concat(re).forEach((r) => this.stack.push({
+      match: (ctx) => { const m = msgOf(ctx.update); const t = m && (m.text || m.caption || ''); return !!t && r.test(t); },
+      fns: mw,
+    }));
+    return this;
+  }
+  command(names, ...mw) {
+    const set = [].concat(names).map((n) => String(n).toLowerCase());
+    this.stack.push({
+      match: (ctx) => {
+        const m = msgOf(ctx.update);
+        if (!m || typeof m.text !== 'string') return false;
+        const mobj = /^\/([A-Za-z0-9_]+)(?:@([A-Za-z0-9_]+))?(\s|$)/.exec(m.text);
+        if (!mobj) return false;
+        if (!set.includes(mobj[1].toLowerCase())) return false;
+        if (mobj[2] && ctx.me && ctx.me.username && mobj[2].toLowerCase() !== ctx.me.username.toLowerCase()) return false;
+        ctx.match = m.text.slice(mobj[0].length); // argumen setelah perintah
+        return true;
+      },
+      fns: mw,
+    });
+    return this;
+  }
+  callbackQuery(trigs, ...mw) {
+    const list = [].concat(trigs);
+    this.stack.push({
+      match: (ctx) => {
+        const q = ctx.callback_query || ctx.update.callback_query;
+        if (!q || typeof q.data !== 'string') return false;
+        return list.some((t) => t instanceof RegExp ? t.test(q.data) : String(t) === q.data);
+      },
+      fns: mw,
+    });
+    return this;
+  }
+
+  /** Jalankan mw hanya jika pred true. */
+  filter(pred, ...mw) { const c = new Composer(...mw); this.use(async (ctx, next) => (await pred(ctx) ? c.run(ctx, next) : next())); return c; }
+  /** Lewati mw jika pred true. */
+  drop(pred, ...mw) { const c = new Composer(...mw); this.use(async (ctx, next) => (await pred(ctx) ? undefined : c.run(ctx, next))); return c; }
+  /** Cabang dua: pred ? A : B. */
+  branch(pred, a, b) { const ca = new Composer(a), cb = new Composer(b); this.use(async (ctx, next) => (await pred(ctx) ? ca.run(ctx, next) : cb.run(ctx, next))); return this; }
+  /** Petakan ctx→key ke composer berbeda: route('type',{private:c, group:c2}) */
+  route(router, by) {
+    const map = new Map(Object.entries(by).map(([k, v]) => [k, v instanceof Composer ? v : new Composer(v)]));
+    this.use(async (ctx, next) => { const k = typeof router === 'function' ? await router(ctx) : ctx[router]; const c = map.get(k); return c ? c.run(ctx, next) : next(); });
+    return this;
+  }
+  /** Bangun mw malas per-update: lazy((ctx)=>ctx.from?.is_bot?botmw:usermw) */
+  lazy(factory) { this.use(async (ctx, next) => { const mw = await factory(ctx); const c = new Composer(...(Array.isArray(mw) ? mw : [mw]).filter(Boolean)); return c.run(ctx, next); }); return this; }
+  /** Jalankan mw DI LATAR BELAKANG (tidak menahan next) — cocok untuk tugas lambat. */
+  fork(...mw) { const c = new Composer(...mw); this.use((ctx, next) => { c.run(ctx).then(()=>{},(e)=>ctx.api && console.error('[telebibz:fork]', e.message)); return next(); }); return this; }
+
+  /** Lindungi subpohon middleware dengan handler error — pola batas rambu grammY. */
+  errorBoundary(handler, ...mw) {
+    const sub = new Composer(...mw);
+    this.use(async (ctx, next) => {
+      let called = false;
+      const cont = () => ((called = true), Promise.resolve());
+      try { await sub.run(ctx, cont); }
+      catch (err) { called = false; await handler(new BotError(err, ctx), cont); }
+      if (called) return next();
+    });
+    return sub;
+  }
+
+  /** Jalankan rantai middleware terhadap satu ctx. */
+  async run(ctx, next) {
+    const entries = this.stack;
+    let idx = -1;
+    const dispatch = async (i) => {
+      if (i <= idx) throw new Error('next() dipanggil dua kali');
+      idx = i;
+      if (i >= entries.length) return next ? next() : undefined;
+      const e = entries[i];
+      if (!e.match(ctx)) return dispatch(i + 1);
+      let continued = false;
+      for (let j = 0; j < e.fns.length; j++) {
+        const isLast = j === e.fns.length - 1;
+        let stepNext = false;
+        const r = await e.fns[j](ctx, async () => {
+          stepNext = true;
+          if (isLast) { continued = true; return dispatch(i + 1); }
+        });
+        if (!stepNext) return r; // handler berhenti di sini (tak lanjut middleware)
+      }
+      if (!continued) return undefined;
+    };
+    return dispatch(0);
+  }
+  middleware() { return (ctx, next) => this.run(ctx, next); }
+}
+
+/** Error yang dibungkus konteksnya, gaya BotError grammY. */
+class BotError extends Error {
+  constructor(err, ctx) {
+    super(err && err.message ? err.message : String(err));
+    this.name = 'BotError';
+    this.error = err;
+    this.ctx = ctx;
+  }
+}
+
+module.exports = { Composer, BotError, compileFilter };