@adriangalilea/utils 0.17.1 → 0.19.0

package/dist/bot/callbacks.js

@@ -0,0 +1,128 @@
+/**
+ * Namespaced callback-data registry.
+ *
+ * gramio's `CallbackData` schemas are dispatched by name (hashed to a
+ * 6-char prefix on the wire). When multiple plugins each declare their
+ * own short schema names (`payWcs`, `acA`, `mNav`, …) two real risks
+ * accumulate:
+ *
+ *   1. **Cross-plugin name collision.** A future plugin picks a name
+ *      another plugin already uses and gramio dispatches to the wrong
+ *      handler. Silent.
+ *
+ *   2. **Drift in name shape.** Each plugin invents its own
+ *      abbreviation style. `payWcs` vs `pay_w_consent` vs
+ *      `payments:waiver:consent` — no convention.
+ *
+ * `callbackNs(prefix)` solves both:
+ *
+ *   - Reserves a prefix per plugin (`pay`, `ac`, `m`, …) so names
+ *     can't collide across plugins by construction (`pay:wcs` is
+ *     disjoint from `ac:wcs`).
+ *
+ *   - Maintains a process-wide `Set<string>` of registered fully-
+ *     qualified names. A second registration of the same name with
+ *     conflicting field shape throws at construction (loud + early);
+ *     an identical re-registration is idempotent (HMR / dual-import
+ *     safe).
+ *
+ * The encoded callback_data length is unaffected — gramio hashes the
+ * full name to a 6-char prefix regardless of how long the name is. So
+ * `pay:waiver:consent` packs as compactly as `pwc`.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * // src/bot/payments/waiver.ts
+ * import { callbackNs } from "../callbacks.js";
+ *
+ * const cb = callbackNs("pay");
+ *
+ * export const waiverConsent = cb.data("waiver:consent", { pk: "string" });
+ * export const waiverCancel  = cb.data("waiver:cancel",  {});
+ *
+ * // usage matches gramio's CallbackData verbatim — same .pack / .unpack:
+ * waiverConsent.pack({ pk: "vip.1" })
+ * bot.callbackQuery(waiverConsent, (ctx) => { ctx.queryData.pk })
+ * ```
+ */
+import { CallbackData } from "gramio";
+import { panic } from "../offensive.js";
+/** Process-wide registry of every fully-qualified schema name we've seen. */
+const registry = new Map();
+const fieldsEqual = (a, b) => {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (const k of aKeys)
+        if (a[k] !== b[k])
+            return false;
+    return true;
+};
+const buildCallbackData = (fullName, fields) => {
+    let cb = new CallbackData(fullName);
+    for (const [key, type] of Object.entries(fields)) {
+        const optional = type.endsWith("?");
+        const base = optional ? type.slice(0, -1) : type;
+        if (base === "string") {
+            cb = cb.string(key, optional ? { optional: true } : undefined);
+        }
+        else {
+            cb = cb.number(key, optional ? { optional: true } : undefined);
+        }
+    }
+    return cb;
+};
+/**
+ * Reserve a callback-data prefix for a plugin. Returns a namespace
+ * with a `data(name, fields)` factory.
+ *
+ * Prefix must be `[a-z][a-z0-9]*` — lowercased letter + alphanumerics,
+ * no separator chars. Names within a namespace can use `:` for
+ * sub-grouping (`waiver:consent`, `refund:approve`).
+ */
+export const callbackNs = (prefix) => {
+    if (!/^[a-z][a-z0-9]*$/.test(prefix)) {
+        panic(`bot/callbacks: callbackNs prefix "${prefix}" must match /^[a-z][a-z0-9]*$/ — ` +
+            `lowercased letter + alphanumerics, no colons or hyphens.`);
+    }
+    return {
+        prefix,
+        data: (name, fields) => {
+            if (!/^[a-zA-Z][a-zA-Z0-9_:]*$/.test(name)) {
+                panic(`bot/callbacks: callback name "${name}" must match /^[a-zA-Z][a-zA-Z0-9_:]*$/`);
+            }
+            const fullName = `${prefix}:${name}`;
+            const existing = registry.get(fullName);
+            if (existing) {
+                if (!fieldsEqual(existing.fields, fields)) {
+                    panic(`bot/callbacks: collision — "${fullName}" already registered ` +
+                        `with different fields ${JSON.stringify(existing.fields)}; ` +
+                        `re-registration tried ${JSON.stringify(fields)}.`);
+                }
+                return existing.cb;
+            }
+            const cb = buildCallbackData(fullName, fields);
+            registry.set(fullName, { fullName, fields, cb });
+            return cb;
+        },
+    };
+};
+// ─── introspection ────────────────────────────────────────────────
+/**
+ * Read-only view of every callback schema registered so far. Useful in
+ * tests or boot-time sanity checks. Not part of the hot path.
+ */
+export const registeredCallbacks = () => Array.from(registry.values(), (r) => ({
+    fullName: r.fullName,
+    fields: r.fields,
+}));
+/**
+ * Internal — for tests that need a clean slate. Don't call from app code.
+ * @internal
+ */
+export const _resetCallbackRegistry = () => {
+    registry.clear();
+};
+//# sourceMappingURL=callbacks.js.map

package/dist/bot/callbacks.js.map

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

package/dist/bot/ctx.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Canonical structural ctx types every plugin in this package imports.
+ *
+ * gramio's real `MessageContext` / `CallbackQueryContext` /
+ * `SuccessfulPaymentContext` / etc. are fully-typed classes, but to
+ * keep this library's handler signatures decoupled from gramio's exact
+ * import chain (and to let action callbacks in `bot/menu` stay
+ * plugin-agnostic), we declare the **minimum structural shape** each
+ * plugin handler needs. Real gramio ctxs satisfy these shapes by duck
+ * typing; the `narrow<T>(ctx)` helper documents the unavoidable cast.
+ *
+ * ## Why this exists
+ *
+ * Before this file, every plugin repeated the same dozen-line cast at
+ * the top of every callback / derive / handler:
+ *
+ *     const c = ctx as unknown as {
+ *       session: SessionLike; bot: { api: BotApi };
+ *       from?: { id: number }; answer: (p: { text?: string }) => Promise<unknown>;
+ *       editText: (text: string) => Promise<unknown>;
+ *       queryData: { cid: string };
+ *     };
+ *
+ * Same shape, redefined in 5 files, drifts independently. This module
+ * collects every shape we use into ~5 reusable structural types so the
+ * cast becomes `narrow<BotCallbackCtx<MySession, { cid: string }>>(ctx)`.
+ *
+ * ## What goes here vs the plugin
+ *
+ * - `bot/ctx.ts` (this file): structural ctx types that match
+ *   gramio's, plus the `narrow` cast helper. Plugin-agnostic.
+ * - Each plugin's own types module: the specific *derives* that plugin
+ *   adds to ctx (`{ payments: PaymentsApi }`, `{ access: AccessInfo }`,
+ *   `{ adminId: number; isAdmin: boolean }`). Composed with the
+ *   canonical ctx via TS intersection.
+ */
+import type { Storage } from "@gramio/storage";
+/** Minimum ctx shape needed by storage helpers (`bot/storage.ts`) —
+ *  carries the bot's identity for namespacing. */
+export type BotIdCtx = {
+    bot: {
+        info: {
+            id: number;
+        };
+    };
+};
+/**
+ * Bot API surface — deliberately loose **as a default**. Plugins
+ * usually want strict per-method typing (so a typo on
+ * `bot.api.refundStarPayment` is a compile error, and the params get
+ * type-checked). The canonical ctx types are generic over `Api`, so
+ * each plugin specializes:
+ *
+ *   type PaymentBotApi = {
+ *     answerPreCheckoutQuery: (p: {...}) => Promise<unknown>
+ *     refundStarPayment:      (p: {...}) => Promise<unknown>
+ *     editUserStarSubscription: (p: {...}) => Promise<unknown>
+ *   }
+ *   const c = narrow<BotPaymentCtx<MySession, PaymentBotApi>>(ctx)
+ *
+ * Default is this loose `BotApi` (any method-name + any params) so
+ * places that don't care about strict typing don't have to spell out
+ * a full API shape.
+ */
+export type BotApi = Record<string, (...args: never[]) => Promise<unknown>>;
+export type BotUser = {
+    id: number;
+    firstName?: string;
+    lastName?: string;
+    username?: string;
+    languageCode?: string;
+    isPremium?: boolean;
+};
+export type BotChat = {
+    id: number;
+    type: string;
+    title?: string;
+    username?: string;
+    firstName?: string;
+    lastName?: string;
+};
+/** Minimum shape we read from a `Message` payload. Includes everything
+ *  needed for cross-event ctx access (e.g. callback ctx → originating
+ *  message → chat / thread). */
+export type BotMessage = {
+    id?: number;
+    chat?: BotChat;
+    threadId?: number;
+    text?: string;
+    delete?: () => Promise<unknown>;
+};
+type SendParams = Record<string, unknown>;
+export type Sender = (text: string | {
+    toString(): string;
+}, params?: SendParams) => Promise<{
+    message_id: number;
+}>;
+export type Replier = (text: string | {
+    toString(): string;
+}, params?: SendParams) => Promise<{
+    message_id: number;
+}>;
+export type CallbackAnswerer = (params: {
+    text?: string;
+    show_alert?: boolean;
+    url?: string;
+    cache_time?: number;
+}) => Promise<unknown>;
+export type TextEditor = (text: string | {
+    toString(): string;
+}, params?: SendParams) => Promise<unknown>;
+/**
+ * Generic message-event ctx. `Session` is the shape of the shared
+ * session record across all plugins (`{ access?, language?, llm?, pay?,
+ * ... }`); pass it as the type parameter at each handler site.
+ *
+ * Matches gramio's `MessageContext` structurally — a real
+ * `MessageContext` is assignable here via duck typing.
+ */
+export type BotMessageCtx<Session = Record<string, unknown>, Api extends BotApi = BotApi> = BotIdCtx & {
+    bot: {
+        info: {
+            id: number;
+        };
+        api: Api;
+    };
+    from: BotUser;
+    chat: BotChat;
+    threadId?: number;
+    text?: string;
+    session: Session;
+    send: Sender;
+    reply: Replier;
+};
+/**
+ * Callback-query ctx. `QueryData` is the unpacked shape of whichever
+ * `CallbackData` schema matched (typically `{ cid: string }`,
+ * `{ uid: number }`, etc.).
+ */
+export type BotCallbackCtx<Session = Record<string, unknown>, QueryData = Record<string, unknown>, Api extends BotApi = BotApi> = BotIdCtx & {
+    bot: {
+        info: {
+            id: number;
+        };
+        api: Api;
+    };
+    from: BotUser;
+    chat?: BotChat;
+    message?: BotMessage;
+    threadId?: number;
+    session: Session;
+    queryData: QueryData;
+    answer: CallbackAnswerer;
+    editText: TextEditor;
+    send: Sender;
+};
+/**
+ * `pre_checkout_query` ctx. Different shape from message/callback —
+ * the query payload is mixed onto the ctx directly. We expose `bot`
+ * for `answerPreCheckoutQuery` calls.
+ */
+export type BotPreCheckoutCtx<Api extends BotApi = BotApi> = BotIdCtx & {
+    bot: {
+        info: {
+            id: number;
+        };
+        api: Api;
+    };
+    id: string;
+    from: BotUser;
+    currency: string;
+    totalAmount: number;
+    invoicePayload: string;
+};
+/**
+ * `successful_payment` ctx. Inherits the message-event surface plus
+ * gramio's `eventPayment` wrapper. We read `.payload` to get the raw
+ * snake_case `TelegramSuccessfulPayment` because every downstream
+ * consumer in this package speaks snake_case end-to-end.
+ *
+ * gramio's `SuccessfulPayment` wrapper is documented in
+ * `@gramio/contexts/dist/index.d.ts` around line 2705. The camelCase
+ * getters on the wrapper (`telegramPaymentChargeId`, `totalAmount`,
+ * `invoicePayload`) are NOT used by this library by convention —
+ * stick to one shape (raw snake_case via `.payload`) across all
+ * payment handlers to avoid the bug where it's easy to read
+ * `payment.telegram_payment_charge_id` on the wrapper and get
+ * `undefined`.
+ */
+export type BotPaymentCtx<Session = Record<string, unknown>, Api extends BotApi = BotApi> = BotMessageCtx<Session, Api> & {
+    eventPayment: {
+        payload: {
+            currency: string;
+            total_amount: number;
+            invoice_payload: string;
+            telegram_payment_charge_id: string;
+            provider_payment_charge_id?: string;
+            subscription_expiration_date?: number;
+            is_recurring?: true;
+            is_first_recurring?: true;
+        };
+    };
+};
+/**
+ * Casts an opaque `unknown` ctx to the structural shape `T` your
+ * handler needs. Documents the unavoidable cast that bridges gramio's
+ * exact ctx classes to this library's structural shapes.
+ *
+ * Use over `as unknown as T` so the intent is searchable and reviewers
+ * see WHY the cast exists (gramio's MenuCtx / Plugin-derive typing has
+ * limits that don't survive cross-plugin composition).
+ *
+ *   const c = narrow<BotCallbackCtx<MySession, { cid: string }>>(ctx)
+ *
+ * At runtime this is a no-op identity function.
+ */
+export declare const narrow: <T>(ctx: unknown) => T;
+export type { Storage };
+//# sourceMappingURL=ctx.d.ts.map

package/dist/bot/ctx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ctx.d.ts","sourceRoot":"","sources":["../../src/bot/ctx.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAI/C;kDACkD;AAClD,MAAM,MAAM,QAAQ,GAAG;IACtB,GAAG,EAAE;QAAE,IAAI,EAAE;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;CAC9B,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AAOH,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;AAI5E,MAAM,MAAM,OAAO,GAAG;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;gCAEgC;AAChC,MAAM,MAAM,UAAU,GAAG;IACxB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;CAChC,CAAC;AAIF,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE1C,MAAM,MAAM,MAAM,GAAG,CACpB,IAAI,EAAE,MAAM,GAAG;IAAE,QAAQ,IAAI,MAAM,CAAA;CAAE,EACrC,MAAM,CAAC,EAAE,UAAU,KACf,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAErC,MAAM,MAAM,OAAO,GAAG,CACrB,IAAI,EAAE,MAAM,GAAG;IAAE,QAAQ,IAAI,MAAM,CAAA;CAAE,EACrC,MAAM,CAAC,EAAE,UAAU,KACf,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAErC,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAEvB,MAAM,MAAM,UAAU,GAAG,CACxB,IAAI,EAAE,MAAM,GAAG;IAAE,QAAQ,IAAI,MAAM,CAAA;CAAE,EACrC,MAAM,CAAC,EAAE,UAAU,KACf,OAAO,CAAC,OAAO,CAAC,CAAC;AAItB;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,CACxB,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,GAAG,SAAS,MAAM,GAAG,MAAM,IACxB,QAAQ,GAAG;IACd,GAAG,EAAE;QAAE,IAAI,EAAE;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,GAAG,EAAE,GAAG,CAAA;KAAE,CAAC;IACxC,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;CACf,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,cAAc,CACzB,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,GAAG,SAAS,MAAM,GAAG,MAAM,IACxB,QAAQ,GAAG;IACd,GAAG,EAAE;QAAE,IAAI,EAAE;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,GAAG,EAAE,GAAG,CAAA;KAAE,CAAC;IACxC,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,UAAU,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,SAAS,CAAC;IACrB,MAAM,EAAE,gBAAgB,CAAC;IACzB,QAAQ,EAAE,UAAU,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAAC,GAAG,SAAS,MAAM,GAAG,MAAM,IAAI,QAAQ,GAAG;IACvE,GAAG,EAAE;QAAE,IAAI,EAAE;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,GAAG,EAAE,GAAG,CAAA;KAAE,CAAC;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,aAAa,CACxB,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,GAAG,SAAS,MAAM,GAAG,MAAM,IACxB,aAAa,CAAC,OAAO,EAAE,GAAG,CAAC,GAAG;IACjC,YAAY,EAAE;QACb,OAAO,EAAE;YACR,QAAQ,EAAE,MAAM,CAAC;YACjB,YAAY,EAAE,MAAM,CAAC;YACrB,eAAe,EAAE,MAAM,CAAC;YACxB,0BAA0B,EAAE,MAAM,CAAC;YACnC,0BAA0B,CAAC,EAAE,MAAM,CAAC;YACpC,4BAA4B,CAAC,EAAE,MAAM,CAAC;YACtC,YAAY,CAAC,EAAE,IAAI,CAAC;YACpB,kBAAkB,CAAC,EAAE,IAAI,CAAC;SAC1B,CAAC;KACF,CAAC;CACF,CAAC;AAIF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,KAAK,OAAO,KAAG,CAAa,CAAC;AAIvD,YAAY,EAAE,OAAO,EAAE,CAAC"}

package/dist/bot/ctx.js

@@ -0,0 +1,52 @@
+/**
+ * Canonical structural ctx types every plugin in this package imports.
+ *
+ * gramio's real `MessageContext` / `CallbackQueryContext` /
+ * `SuccessfulPaymentContext` / etc. are fully-typed classes, but to
+ * keep this library's handler signatures decoupled from gramio's exact
+ * import chain (and to let action callbacks in `bot/menu` stay
+ * plugin-agnostic), we declare the **minimum structural shape** each
+ * plugin handler needs. Real gramio ctxs satisfy these shapes by duck
+ * typing; the `narrow<T>(ctx)` helper documents the unavoidable cast.
+ *
+ * ## Why this exists
+ *
+ * Before this file, every plugin repeated the same dozen-line cast at
+ * the top of every callback / derive / handler:
+ *
+ *     const c = ctx as unknown as {
+ *       session: SessionLike; bot: { api: BotApi };
+ *       from?: { id: number }; answer: (p: { text?: string }) => Promise<unknown>;
+ *       editText: (text: string) => Promise<unknown>;
+ *       queryData: { cid: string };
+ *     };
+ *
+ * Same shape, redefined in 5 files, drifts independently. This module
+ * collects every shape we use into ~5 reusable structural types so the
+ * cast becomes `narrow<BotCallbackCtx<MySession, { cid: string }>>(ctx)`.
+ *
+ * ## What goes here vs the plugin
+ *
+ * - `bot/ctx.ts` (this file): structural ctx types that match
+ *   gramio's, plus the `narrow` cast helper. Plugin-agnostic.
+ * - Each plugin's own types module: the specific *derives* that plugin
+ *   adds to ctx (`{ payments: PaymentsApi }`, `{ access: AccessInfo }`,
+ *   `{ adminId: number; isAdmin: boolean }`). Composed with the
+ *   canonical ctx via TS intersection.
+ */
+// ─── narrowing helper ──────────────────────────────────────────────
+/**
+ * Casts an opaque `unknown` ctx to the structural shape `T` your
+ * handler needs. Documents the unavoidable cast that bridges gramio's
+ * exact ctx classes to this library's structural shapes.
+ *
+ * Use over `as unknown as T` so the intent is searchable and reviewers
+ * see WHY the cast exists (gramio's MenuCtx / Plugin-derive typing has
+ * limits that don't survive cross-plugin composition).
+ *
+ *   const c = narrow<BotCallbackCtx<MySession, { cid: string }>>(ctx)
+ *
+ * At runtime this is a no-op identity function.
+ */
+export const narrow = (ctx) => ctx;
+//# sourceMappingURL=ctx.js.map

package/dist/bot/ctx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ctx.js","sourceRoot":"","sources":["../../src/bot/ctx.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AA4LH,sEAAsE;AAEtE;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAI,GAAY,EAAK,EAAE,CAAC,GAAQ,CAAC"}

package/dist/bot/index.d.ts

@@ -12,9 +12,13 @@
  *   import { ... } from '@adriangalilea/utils/bot'
  */
 export * from "./access-control.js";
+export * from "./callbacks.js";
 export * from "./coalesce.js";
+export * from "./ctx.js";
 export * from "./kit.js";
 export * from "./language.js";
 export * from "./llm.js";
 export * from "./menu.js";
+export * from "./payments/index.js";
+export * from "./storage.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/bot/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bot/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bot/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC"}

package/dist/bot/index.js

@@ -12,9 +12,13 @@
  *   import { ... } from '@adriangalilea/utils/bot'
  */
 export * from "./access-control.js";
+export * from "./callbacks.js";
 export * from "./coalesce.js";
+export * from "./ctx.js";
 export * from "./kit.js";
 export * from "./language.js";
 export * from "./llm.js";
 export * from "./menu.js";
+export * from "./payments/index.js";
+export * from "./storage.js";
 //# sourceMappingURL=index.js.map

package/dist/bot/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/bot/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/bot/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC"}

package/dist/bot/kit.d.ts

@@ -1,5 +1,5 @@
 /**
- * Foundational helpers every bot wants. Three things:
+ * Foundational helpers every bot wants.
  *
  *   `gracefulStart(bot, opts?)` — wires SIGINT/SIGTERM to bot.stop(),
  *     runs an optional shutdown hook, force-kills if it hangs. DMs the
@@ -12,31 +12,37 @@
  *     every context with `ctx.adminId` (number) and `ctx.isAdmin`
  *     (boolean). Throws at startup if neither source provides an id.
  *
- *   `prefixStorage(storage, prefix)` — wraps any `@gramio/storage`
- *     adapter to namespace every key with a fixed prefix. ESSENTIAL
- *     when several bots share the same backend (e.g. one Redis): the
- *     session plugin keys records by `String(senderId)`, so the same
- *     user's id collides across bots and the last writer wins.
+ *   `botSession(opts)` — drop-in replacement for `@gramio/session`'s
+ *     `session()` that AUTOMATICALLY namespaces every key with the
+ *     calling bot's id (parsed from `ctx.bot.options.token`). When
+ *     several bots share one Redis instance, each writes to a disjoint
+ *     keyspace (`bot-<id>:<senderId>`) with no manual wiring. Every
+ *     plugin in this package (`accessControl`, `botMenu`,
+ *     `llmHistory`, …) derives the SAME prefix from `ctx.bot` for its
+ *     own storage access, so the whole package stays isolated by
+ *     construction. Use this instead of `session()` — full stop.
  *
- * Peer deps: `gramio`, `@gramio/storage`.
+ * Peer deps: `gramio`, `@gramio/session`, `@gramio/storage`.
  *
  * @example
  * import { Bot } from 'gramio'
  * import { redisStorage } from '@gramio/storage-redis'
- * import { adminContext, gracefulStart, prefixStorage } from '@adriangalilea/utils/bot/kit'
+ * import { adminContext, gracefulStart, botSession } from '@adriangalilea/utils/bot/kit'
  *
- * // ONE prefixed storage instance — pass it to session AND every plugin.
- * const storage = prefixStorage(redisStorage(), 'mybot:')
+ * const storage = redisStorage()                          // share across bots, safe
+ * const userSession = botSession({ storage, initial: () => ({}) })
  *
  * const bot = new Bot(process.env.BOT_TOKEN!)
- *   .extend(adminContext({ adminId: 190202471 }))   // KEV wins, 190… is fallback
+ *   .extend(adminContext({ adminId: 190202471 }))         // KEV wins, 190… is fallback
+ *   .extend(userSession)
  *   .command('whoami', (ctx) => ctx.send(`admin? ${ctx.isAdmin}`))
  *
  * await gracefulStart(bot, { onShutdown: () => db.end() })
  */
+import { type SessionOptions, session } from "@gramio/session";
 import type { Storage } from "@gramio/storage";
-import type { AnyBot } from "gramio";
-import { Plugin } from "gramio";
+import type { Plugin as PluginType } from "gramio";
+import { type AnyBot } from "gramio";
 export type GracefulStartOptions = {
     /** Runs after `bot.stop()` resolves, before `process.exit`. Close DBs, flush logs. */
     onShutdown?: () => Promise<void> | void;
@@ -73,7 +79,7 @@ export type AdminContextOptions = {
     /** Hardcoded fallback used when `KEV.TELEGRAM_ADMIN_ID` is unset. */
     adminId?: number;
 };
-export declare const adminContext: (opts?: AdminContextOptions) => Plugin<{}, import("gramio").DeriveDefinitions & {
+export declare const adminContext: (opts?: AdminContextOptions) => PluginType<{}, import("gramio").DeriveDefinitions & {
     global: {
         adminId: number;
     };
@@ -83,42 +89,88 @@ export declare const adminContext: (opts?: AdminContextOptions) => Plugin<{}, im
     };
 }, {}>;
 /**
- * Wraps any `@gramio/storage` adapter so every read / write goes
- * through `${prefix}${key}`. Pass the wrapped instance to your
- * `session({...})` AND to every plugin's `storage` option — they all
- * inherit the namespace, no per-plugin wiring needed.
+ * Returns the calling bot's numeric id from `ctx.bot.info.id`. Throws
+ * if called before `bot.start()` / `bot.init()` populates it — should
+ * never happen from inside an event handler, where gramio guarantees
+ * `bot.info` is set.
+ *
+ * Note on the structural cast: gramio's `BotLike` (the interface
+ * contexts are typed against) intentionally omits `info` to decouple
+ * Context types from the full Bot class. At runtime `ctx.bot` IS the
+ * full Bot, so the cast is sound — just papering over a deliberate
+ * type-vs-runtime gap.
+ */
+export declare const botId: (ctx: {
+    bot: unknown;
+}) => number;
+/**
+ * Computes the storage key for an arbitrary user under the CALLING
+ * bot's namespace. Use whenever a plugin needs to read or write
+ * **another user's** session record from inside a handler (typical:
+ * admin approves a stranger, /forget wipes a stranger after a takedown
+ * request). For the current user, the session plugin handles keying
+ * automatically when wired via `botSession`.
+ */
+export declare const botStorageKey: (ctx: {
+    bot: unknown;
+}, userId: number) => string;
+/**
+ * Static-key variant — namespace an arbitrary sub-key (e.g. an admin
+ * index, a feature flag, a counter) under the calling bot's prefix.
+ * Use this for bot-side state that isn't keyed by a specific user.
  *
- * **Why this exists.** `@gramio/session`'s default `getSessionKey` is
- * `String(senderId)`. If two bots share the same Redis (or any
- * shared-backend storage), the same Telegram user id collides across
- * bots — the last writer wins, `/settings → 📥 Export` returns whatever
- * the other bot last wrote, etc. A unique prefix per bot makes the
- * keyspace disjoint.
+ *   botSubKey(ctx, 'ac:index')   →  'bot-<id>:ac:index'
+ *   botSubKey(ctx, 'metrics')    →  'bot-<id>:metrics'
+ */
+export declare const botSubKey: (ctx: {
+    bot: unknown;
+}, subKey: string) => string;
+/**
+ * Drop-in replacement for `@gramio/session`'s `session()` that forces
+ * the storage key to include the calling bot's id. Equivalent to
+ * passing `getSessionKey: (ctx) => bot-${id}:${senderId}` explicitly,
+ * but baked in so no consumer can forget.
  *
- * Recommended prefix shapes:
- *   - `'mybot:'` — explicit, human-readable in Redis GUIs.
- *   - `'<bot-username>:'` — derive from BotFather handle once at start.
- *   - `'<bot-id>:'` — Telegram's numeric bot id from `getMe`.
+ * Returns a plain `@gramio/session` plugin — same shape, same derives,
+ * fully interchangeable in `.extend(userSession)` chains and plugin
+ * options like `accessControl({ session: userSession, … })`.
  *
- * **Storage layout** with `prefixStorage(s, 'mybot:')`:
+ * `getSessionKey` can still be overridden for advanced cases (e.g. a
+ * per-chat session in groups); the override is wrapped so it still
+ * receives the `bot-<id>:` prefix. Don't override unless you know what
+ * you're doing — every plugin in this package expects the
+ * `bot-<id>:<userId>` shape for cross-user storage reads.
  *
- *     s['mybot:190202471']    = { access, language, llm }   ← user 190…'s record
- *     s['mybot:ac:index']     = { pending, approved, denied }
+ * @example
+ * import { redisStorage } from '@gramio/storage-redis'
+ * import { botSession } from '@adriangalilea/utils/bot/kit'
  *
- *     s['otherbot:190202471'] = { … }                       ← same user, other bot
+ * const storage = redisStorage()    // shared across N bots, safe
  *
- * No two bots can read each other's data. Forget / Export operate on
- * the prefixed keys via the same wrapper.
+ * const userSession = botSession({
+ *   storage,
+ *   key: 'session',
+ *   initial: () => ({}),
+ * })
  *
- * @example
- * import { prefixStorage } from '@adriangalilea/utils/bot/kit'
- * import { redisStorage } from '@gramio/storage-redis'
+ * bot.extend(userSession)
+ */
+export declare const botSession: <Data = unknown, Key extends string = "session", Lazy extends boolean = false>(opts: SessionOptions<Data, Key, Lazy>) => ReturnType<typeof session<Data, Key, Lazy>>;
+/**
+ * Wraps any `@gramio/storage` adapter so every key gets a fixed
+ * `${prefix}` prepended.
+ *
+ * **You almost never need this.** The library's plugins are isolated
+ * by bot id automatically when you wire `botSession` (see above) —
+ * `prefixStorage` exists for edge cases:
  *
- * const storage = prefixStorage(redisStorage(), 'mybot:')
+ *   - Sharing a Redis instance with a NON-bot system, and you want a
+ *     top-level prefix on top of the bot-id namespace.
+ *   - Migrating from an older deployment that used a custom prefix.
  *
- * const userSession = session({ storage, key: 'session', initial: () => ({}) })
- * const menu = botMenu({ adminContact: '@me', personalData: { storage }, ... })
- * bot.extend(accessControl({ session: userSession, storage, defaults: [] }))
+ * In those cases the wrapper composes cleanly with `botSession`'s
+ * internal prefix: final keys look like `${prefix}bot-<id>:<userId>`.
  */
 export declare const prefixStorage: (storage: Storage, prefix: string) => Storage;
+export type { PluginType };
 //# sourceMappingURL=kit.d.ts.map

package/dist/bot/kit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kit.d.ts","sourceRoot":"","sources":["../../src/bot/kit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAKhC,MAAM,MAAM,oBAAoB,GAAG;IAClC,sFAAsF;IACtF,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACxC,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,6DAA6D;IAC7D,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,KAAK,CAAC;IACtC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,WAAW,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CAC/B,CAAC;AAEF,eAAO,MAAM,aAAa,GACzB,KAAK,MAAM,EACX,OAAM,oBAAyB,KAC7B,OAAO,CAAC,IAAI,CA+Ed,CAAC;AAIF,MAAM,MAAM,mBAAmB,GAAG;IACjC,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,OAAM,mBAAwB;;;;;;;;MAqB1D,CAAC;AAIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,OAAO,EAAE,QAAQ,MAAM,KAAG,OAQhE,CAAC"}
+{"version":3,"file":"kit.d.ts","sourceRoot":"","sources":["../../src/bot/kit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,EAAE,KAAK,cAAc,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,QAAQ,CAAC;AACnD,OAAO,EAAE,KAAK,MAAM,EAAU,MAAM,QAAQ,CAAC;AAK7C,MAAM,MAAM,oBAAoB,GAAG;IAClC,sFAAsF;IACtF,UAAU,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACxC,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,6DAA6D;IAC7D,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,KAAK,CAAC;IACtC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,WAAW,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CAC/B,CAAC;AAEF,eAAO,MAAM,aAAa,GACzB,KAAK,MAAM,EACX,OAAM,oBAAyB,KAC7B,OAAO,CAAC,IAAI,CAiFd,CAAC;AAIF,MAAM,MAAM,mBAAmB,GAAG;IACjC,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,OAAM,mBAAwB;;;;;;;;MAqB1D,CAAC;AAiBF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,KAAK,GAAI,KAAK;IAAE,GAAG,EAAE,OAAO,CAAA;CAAE,KAAG,MAO7C,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GAAI,KAAK;IAAE,GAAG,EAAE,OAAO,CAAA;CAAE,EAAE,QAAQ,MAAM,KAAG,MACxC,CAAC;AAE/B;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK;IAAE,GAAG,EAAE,OAAO,CAAA;CAAE,EAAE,QAAQ,MAAM,KAAG,MACpC,CAAC;AAI/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,UAAU,GACtB,IAAI,GAAG,OAAO,EACd,GAAG,SAAS,MAAM,GAAG,SAAS,EAC9B,IAAI,SAAS,OAAO,GAAG,KAAK,EAE5B,MAAM,cAAc,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,KACnC,UAAU,CAAC,OAAO,OAAO,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,CA0B5C,CAAC;AAIF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,OAAO,EAAE,QAAQ,MAAM,KAAG,OAShE,CAAC;AAIF,YAAY,EAAE,UAAU,EAAE,CAAC"}