@diegoaltoworks/chatter 0.27.0 → 0.29.0

package/dist/bin/wa-pair.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// bin/wa-pair.ts
+var import_client = require("@libsql/client");
+
+// src/channels/whatsapp/crypto.ts
+var import_node_crypto = require("node:crypto");
+var IV_LENGTH = 12;
+var TAG_LENGTH = 16;
+function deriveKey(secret) {
+  return (0, import_node_crypto.createHash)("sha256").update(secret, "utf-8").digest();
+}
+function encrypt(plaintext, secret) {
+  const iv = (0, import_node_crypto.randomBytes)(IV_LENGTH);
+  const cipher = (0, import_node_crypto.createCipheriv)("aes-256-gcm", deriveKey(secret), iv);
+  const ciphertext = Buffer.concat([cipher.update(plaintext, "utf-8"), cipher.final()]);
+  return Buffer.concat([iv, cipher.getAuthTag(), ciphertext]).toString("base64");
+}
+function decrypt(payload, secret) {
+  const raw = Buffer.from(payload, "base64");
+  const iv = raw.subarray(0, IV_LENGTH);
+  const tag = raw.subarray(IV_LENGTH, IV_LENGTH + TAG_LENGTH);
+  const ciphertext = raw.subarray(IV_LENGTH + TAG_LENGTH);
+  const decipher = (0, import_node_crypto.createDecipheriv)("aes-256-gcm", deriveKey(secret), iv);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf-8");
+}
+
+// src/channels/whatsapp/authState.ts
+var schemaReady = /* @__PURE__ */ new WeakMap();
+function ensureAuthSchema(client) {
+  let ready = schemaReady.get(client);
+  if (!ready) {
+    ready = client.execute("CREATE TABLE IF NOT EXISTS wa_auth (id TEXT PRIMARY KEY, value TEXT NOT NULL)").catch((error) => {
+      schemaReady.delete(client);
+      throw error;
+    });
+    schemaReady.set(client, ready);
+  }
+  return ready;
+}
+async function useTursoAuthState(db2, secret, sessionId2, runtime) {
+  await ensureAuthSchema(db2);
+  const rowId = (id) => sessionId2 === "default" ? id : `s:${sessionId2}/${id}`;
+  async function read(id) {
+    const result = await db2.execute({
+      sql: "SELECT value FROM wa_auth WHERE id = ?",
+      args: [rowId(id)]
+    });
+    const row = result.rows[0];
+    if (!row) return null;
+    return JSON.parse(decrypt(row.value, secret), runtime.bufferJSON.reviver);
+  }
+  async function write(id, value) {
+    const payload = encrypt(JSON.stringify(value, runtime.bufferJSON.replacer), secret);
+    await db2.execute({
+      sql: "INSERT OR REPLACE INTO wa_auth (id, value) VALUES (?, ?)",
+      args: [rowId(id), payload]
+    });
+  }
+  async function remove(id) {
+    await db2.execute({ sql: "DELETE FROM wa_auth WHERE id = ?", args: [rowId(id)] });
+  }
+  const creds = await read("creds") ?? runtime.initAuthCreds();
+  return {
+    state: {
+      creds,
+      keys: {
+        get: async (type, ids) => {
+          const data = {};
+          await Promise.all(
+            ids.map(async (id) => {
+              let value = await read(`${type}-${id}`);
+              if (type === "app-state-sync-key" && value) {
+                value = runtime.appStateSyncKeyFromObject(
+                  value
+                );
+              }
+              if (value) data[id] = value;
+            })
+          );
+          return data;
+        },
+        set: async (data) => {
+          const jobs = [];
+          for (const category of Object.keys(data)) {
+            const entries = data[category];
+            if (!entries) continue;
+            for (const id of Object.keys(entries)) {
+              const value = entries[id];
+              jobs.push(value ? write(`${category}-${id}`, value) : remove(`${category}-${id}`));
+            }
+          }
+          await Promise.all(jobs);
+        }
+      }
+    },
+    saveCreds: () => write("creds", creds),
+    clear: async () => {
+      if (sessionId2 === "default") {
+        await db2.execute("DELETE FROM wa_auth WHERE id NOT LIKE 's:%'");
+      } else {
+        await db2.execute({
+          sql: "DELETE FROM wa_auth WHERE id LIKE ?",
+          args: [`s:${sessionId2}/%`]
+        });
+      }
+    }
+  };
+}
+
+// src/channels/whatsapp/baileys.ts
+function wrapMissingBaileysError(cause) {
+  return new Error(
+    "The WhatsApp channel ('@diegoaltoworks/chatter/whatsapp') requires the optional peer dependency '@whiskeysockets/baileys', which is not installed. Install it with `bun add @whiskeysockets/baileys` (or npm/pnpm/yarn) to use this channel.",
+    { cause }
+  );
+}
+var cached;
+function loadBaileys() {
+  if (!cached) {
+    cached = import("@whiskeysockets/baileys").catch((error) => {
+      cached = void 0;
+      throw wrapMissingBaileysError(error);
+    });
+  }
+  return cached;
+}
+
+// bin/wa-pair.ts
+var args = process.argv.slice(2);
+function flagValue(name) {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : void 0;
+}
+if (args.includes("--help") || args.includes("-h")) {
+  console.log(`
+WhatsApp pairing CLI
+
+Usage:
+  bun run wa-pair [sessionId] [options]
+
+Arguments:
+  sessionId               Which session to pair (default: "default"). Use a
+                           distinct id per WhatsApp number for multi-session.
+
+Options:
+  --code <phoneNumber>    Pair via pairing code instead of QR (digits only,
+                           e.g. 447700900123). For headless setups.
+  --reset                 Wipe the stored session first, then pair fresh.
+  --help, -h               Show this help.
+
+Environment:
+  TURSO_URL, TURSO_AUTH_TOKEN   Required. The database auth state is stored in.
+  WA_SESSION_SECRET             Required. Encrypts the stored session at rest.
+`);
+  process.exit(0);
+}
+var sessionId = args.find((a, i) => !a.startsWith("--") && args[i - 1] !== "--code") ?? "default";
+if (args.includes("--code") && !flagValue("--code")) {
+  console.error("\u274C --code requires a phone number, e.g. --code 447700900123");
+  process.exit(1);
+}
+var phoneNumber = flagValue("--code")?.replace(/[^0-9]/g, "");
+var reset = args.includes("--reset");
+var sessionSecret = process.env.WA_SESSION_SECRET;
+if (!sessionSecret) {
+  console.error("\u274C WA_SESSION_SECRET is required (any strong passphrase; keep it stable).");
+  process.exit(1);
+}
+if (!process.env.TURSO_URL) {
+  console.error("\u274C TURSO_URL is required.");
+  process.exit(1);
+}
+var db = (0, import_client.createClient)({
+  url: process.env.TURSO_URL,
+  authToken: process.env.TURSO_AUTH_TOKEN || ""
+});
+var MAX_RECONNECTS = 12;
+var codeRequested = false;
+var reconnects = 0;
+var didReset = false;
+async function start() {
+  const baileys = await loadBaileys().catch((error) => {
+    console.error(`\u274C ${error.message}`);
+    process.exit(1);
+  });
+  const runtime = {
+    bufferJSON: baileys.BufferJSON,
+    initAuthCreds: baileys.initAuthCreds,
+    appStateSyncKeyFromObject: (value) => baileys.proto.Message.AppStateSyncKeyData.fromObject(value)
+  };
+  const { state, saveCreds, clear } = await useTursoAuthState(
+    db,
+    sessionSecret,
+    sessionId,
+    runtime
+  );
+  if (reset && !didReset) {
+    didReset = true;
+    await clear();
+    console.log(`Session "${sessionId}" wiped. Pairing fresh...`);
+    return start();
+  }
+  if (state.creds.registered && !codeRequested) {
+    console.log(
+      `Already paired. Session "${sessionId}" is connected-ready. Run with --reset to re-pair.`
+    );
+    process.exit(0);
+  }
+  const { version } = await baileys.fetchLatestBaileysVersion();
+  const noop = () => void 0;
+  const logger = {
+    level: "silent",
+    trace: noop,
+    debug: noop,
+    info: noop,
+    warn: noop,
+    error: noop,
+    fatal: noop
+  };
+  logger.child = () => logger;
+  const sock = baileys.makeWASocket({
+    version,
+    auth: {
+      creds: state.creds,
+      // biome-ignore lint/suspicious/noExplicitAny: structural pino-compatible logger
+      keys: baileys.makeCacheableSignalKeyStore(state.keys, logger)
+    },
+    // biome-ignore lint/suspicious/noExplicitAny: structural pino-compatible logger
+    logger,
+    markOnlineOnConnect: false
+  });
+  sock.ev.on("creds.update", saveCreds);
+  sock.ev.on("connection.update", async (update) => {
+    const { connection, lastDisconnect, qr } = update;
+    if (qr && !phoneNumber) {
+      const qrcodeTerminal = await import("qrcode-terminal").catch(() => void 0);
+      if (!qrcodeTerminal) {
+        console.error(
+          "\u274C QR mode requires the optional peer dependency 'qrcode-terminal'. Install it with `bun add qrcode-terminal`, or re-run with --code <phoneNumber> for pairing-code mode instead."
+        );
+        process.exit(1);
+      }
+      console.log(
+        "\nScan this QR code: WhatsApp -> Settings -> Linked Devices -> Link a Device.\n"
+      );
+      qrcodeTerminal.default.generate(qr, { small: true });
+    }
+    if (connection === "open") {
+      console.log(
+        `
+\u2705 Paired session "${sessionId}" as ${sock.user?.id}. Session saved (encrypted).`
+      );
+      console.log("The running server will pick this session up on its next connect.");
+      process.exit(0);
+    }
+    if (connection === "close") {
+      const statusCode = lastDisconnect?.error?.output?.statusCode;
+      if (codeRequested && reconnects < MAX_RECONNECTS) {
+        reconnects++;
+        console.log(
+          `Connection closed (${statusCode ?? "?"}) - reconnecting (code STILL VALID, keep going on the phone) (${reconnects}/${MAX_RECONNECTS})...`
+        );
+        setTimeout(() => void start(), 2e3);
+        return;
+      }
+      if (statusCode === baileys.DisconnectReason.loggedOut) {
+        console.error("\u274C Pairing rejected (logged out). Run wa-pair again for a fresh code.");
+      } else {
+        console.error(`\u274C Connection closed (${statusCode ?? "?"}). Run wa-pair again.`);
+      }
+      process.exit(1);
+    }
+  });
+  if (phoneNumber && !codeRequested && !state.creds.registered) {
+    setTimeout(async () => {
+      try {
+        const code = await sock.requestPairingCode(phoneNumber);
+        codeRequested = true;
+        console.log("\n==============================================");
+        console.log(`  Pairing code for +${phoneNumber}:  ${code}`);
+        console.log("==============================================");
+        console.log("On the phone: WhatsApp -> Settings -> Linked Devices ->");
+        console.log("Link a Device -> 'Link with phone number instead' -> enter the code.");
+        console.log("Waiting for confirmation (leave this running)...");
+      } catch (error) {
+        console.error("\u274C Failed to request pairing code:", error);
+        process.exit(1);
+      }
+    }, 3e3);
+  }
+}
+start().catch((error) => {
+  console.error("\u274C Unexpected error:", error);
+  process.exit(1);
+});

package/dist/channels/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Channel SPI — the seam a transport (WhatsApp, or any future channel)
+ * implements to attach to a chatter server. `createServer` starts every
+ * configured channel with the same {@link ServerDependencies} route
+ * factories and custom routes receive, so a channel can call
+ * `prepareChat`/`answerOnce`, share `deps.db`, etc. without knowing how the
+ * server was assembled — and `channel.start(deps)` works identically when
+ * called directly, outside `createServer`, for standalone use.
+ *
+ * Published as the `@diegoaltoworks/chatter/channels` subpath alongside the
+ * pure decision gates ({@link decideChannelAction} and friends) and the
+ * {@link ChannelSenderRegistry}, so a transport package needs one import for
+ * the whole channel toolkit. Zero required dependencies beyond the core
+ * package itself.
+ *
+ * @packageDocumentation
+ */
+import type { ServerDependencies } from "../types";
+export interface Channel {
+    /** Human-readable name, used in start-failure log lines and as the sender-registry key. */
+    name: string;
+    /**
+     * Called once, after routes are mounted, with the full server dependencies.
+     * Awaited if it returns a promise. A rejection/throw is logged and isolated
+     * — one channel failing to start never crashes the server or the other
+     * configured channels.
+     *
+     * `createServer` awaits this before the app is handed back and starts
+     * serving requests, so `start` should return once the transport is
+     * *initiated* (a socket opened, a listener registered) — not once a remote
+     * connection or pairing flow completes. An implementation that awaits a
+     * slow handshake blocks the whole server from ever starting.
+     */
+    start(deps: ServerDependencies): void | Promise<void>;
+    /**
+     * Called by the host's own shutdown path via the disposer `createServer`
+     * returns (`app.stopChannels()`, see `ChatterApp` in `./server`) — never
+     * automatically on a process signal, since a library installing its own
+     * SIGTERM/SIGINT handler and exiting the process would race a host's
+     * shutdown logic.
+     */
+    stop?(): void | Promise<void>;
+}
+export * from "./gates";
+export type { ChannelSender, ChannelSenderRegistry } from "./senders";
+export { createSenderRegistry } from "./senders";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/channels/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEnD,MAAM,WAAW,OAAO;IACtB,2FAA2F;IAC3F,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD;;;;;;OAMG;IACH,IAAI,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AAED,cAAc,SAAS,CAAC;AACxB,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC"}

package/dist/channels/index.js

@@ -0,0 +1,137 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/channels/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createSenderRegistry: () => createSenderRegistry,
+  createSlidingWindowRateLimiter: () => createSlidingWindowRateLimiter,
+  decideChannelAction: () => decideChannelAction,
+  isEffectivelyFromSelf: () => isEffectivelyFromSelf,
+  isFromAnySession: () => isFromAnySession,
+  underReplyRateLimit: () => underReplyRateLimit
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/channels/gates.ts
+function matches(re, text) {
+  return new RegExp(re.source, re.flags.replace(/[gy]/g, "")).test(text);
+}
+function decideChannelAction(msg, config) {
+  if (msg.fromBot || !msg.text.trim()) return "ignore";
+  if (!msg.isDirectMessage) {
+    if (config.allowedChats.length > 0 && !config.allowedChats.includes(msg.chatId)) {
+      return "ignore";
+    }
+    if (config.muteRegex && matches(config.muteRegex, msg.text)) return "mute";
+    if (config.unmuteRegex && matches(config.unmuteRegex, msg.text)) return "unmute";
+    if (config.mutedChats.has(msg.chatId)) return "ignore";
+    return msg.mentionsBot || msg.isReplyToBot ? "reply" : "ignore";
+  }
+  return "reply";
+}
+function createSlidingWindowRateLimiter(maxPerWindow, windowMs, now = Date.now) {
+  const log = /* @__PURE__ */ new Map();
+  return function allow(key) {
+    const cutoff = now() - windowMs;
+    const entries = (log.get(key) ?? []).filter((t) => t > cutoff);
+    if (entries.length >= maxPerWindow) {
+      if (entries.length > 0) log.set(key, entries);
+      else log.delete(key);
+      return false;
+    }
+    entries.push(now());
+    log.set(key, entries);
+    return true;
+  };
+}
+function underReplyRateLimit(msg, limiters) {
+  return msg.isDirectMessage ? limiters.dm(msg.chatId) : limiters.group(msg.chatId);
+}
+function isFromAnySession(id, registry) {
+  if (!id) return false;
+  for (const ids of registry.values()) {
+    if (ids.includes(id)) return true;
+  }
+  return false;
+}
+function isEffectivelyFromSelf(msg, registry) {
+  return msg.fromBot || isFromAnySession(msg.senderId, registry);
+}
+
+// src/channels/senders.ts
+function createSenderRegistry() {
+  const senders = /* @__PURE__ */ new Map();
+  return {
+    register(name, sender) {
+      if (senders.has(name)) {
+        console.warn(`Channel sender "${name}" is already registered; overwriting.`);
+      }
+      senders.set(name, sender);
+    },
+    unregister(name) {
+      senders.delete(name);
+    },
+    available(name) {
+      return senders.has(name);
+    },
+    async sendText(name, chatId, text) {
+      const sender = senders.get(name);
+      if (!sender) return false;
+      try {
+        await sender.sendText(chatId, text);
+        return true;
+      } catch (error) {
+        console.warn(`Channel sender "${name}" sendText failed:`, error);
+        return false;
+      }
+    },
+    async sendVoice(name, chatId, payload) {
+      const sender = senders.get(name);
+      if (!sender?.sendVoice) return false;
+      try {
+        await sender.sendVoice(chatId, payload);
+        return true;
+      } catch (error) {
+        console.warn(`Channel sender "${name}" sendVoice failed:`, error);
+        return false;
+      }
+    },
+    async sendMedia(name, chatId, payload) {
+      const sender = senders.get(name);
+      if (!sender?.sendMedia) return false;
+      try {
+        await sender.sendMedia(chatId, payload);
+        return true;
+      } catch (error) {
+        console.warn(`Channel sender "${name}" sendMedia failed:`, error);
+        return false;
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSenderRegistry,
+  createSlidingWindowRateLimiter,
+  decideChannelAction,
+  isEffectivelyFromSelf,
+  isFromAnySession,
+  underReplyRateLimit
+});

package/dist/channels/index.mjs

@@ -0,0 +1,105 @@
+// src/channels/gates.ts
+function matches(re, text) {
+  return new RegExp(re.source, re.flags.replace(/[gy]/g, "")).test(text);
+}
+function decideChannelAction(msg, config) {
+  if (msg.fromBot || !msg.text.trim()) return "ignore";
+  if (!msg.isDirectMessage) {
+    if (config.allowedChats.length > 0 && !config.allowedChats.includes(msg.chatId)) {
+      return "ignore";
+    }
+    if (config.muteRegex && matches(config.muteRegex, msg.text)) return "mute";
+    if (config.unmuteRegex && matches(config.unmuteRegex, msg.text)) return "unmute";
+    if (config.mutedChats.has(msg.chatId)) return "ignore";
+    return msg.mentionsBot || msg.isReplyToBot ? "reply" : "ignore";
+  }
+  return "reply";
+}
+function createSlidingWindowRateLimiter(maxPerWindow, windowMs, now = Date.now) {
+  const log = /* @__PURE__ */ new Map();
+  return function allow(key) {
+    const cutoff = now() - windowMs;
+    const entries = (log.get(key) ?? []).filter((t) => t > cutoff);
+    if (entries.length >= maxPerWindow) {
+      if (entries.length > 0) log.set(key, entries);
+      else log.delete(key);
+      return false;
+    }
+    entries.push(now());
+    log.set(key, entries);
+    return true;
+  };
+}
+function underReplyRateLimit(msg, limiters) {
+  return msg.isDirectMessage ? limiters.dm(msg.chatId) : limiters.group(msg.chatId);
+}
+function isFromAnySession(id, registry) {
+  if (!id) return false;
+  for (const ids of registry.values()) {
+    if (ids.includes(id)) return true;
+  }
+  return false;
+}
+function isEffectivelyFromSelf(msg, registry) {
+  return msg.fromBot || isFromAnySession(msg.senderId, registry);
+}
+
+// src/channels/senders.ts
+function createSenderRegistry() {
+  const senders = /* @__PURE__ */ new Map();
+  return {
+    register(name, sender) {
+      if (senders.has(name)) {
+        console.warn(`Channel sender "${name}" is already registered; overwriting.`);
+      }
+      senders.set(name, sender);
+    },
+    unregister(name) {
+      senders.delete(name);
+    },
+    available(name) {
+      return senders.has(name);
+    },
+    async sendText(name, chatId, text) {
+      const sender = senders.get(name);
+      if (!sender) return false;
+      try {
+        await sender.sendText(chatId, text);
+        return true;
+      } catch (error) {
+        console.warn(`Channel sender "${name}" sendText failed:`, error);
+        return false;
+      }
+    },
+    async sendVoice(name, chatId, payload) {
+      const sender = senders.get(name);
+      if (!sender?.sendVoice) return false;
+      try {
+        await sender.sendVoice(chatId, payload);
+        return true;
+      } catch (error) {
+        console.warn(`Channel sender "${name}" sendVoice failed:`, error);
+        return false;
+      }
+    },
+    async sendMedia(name, chatId, payload) {
+      const sender = senders.get(name);
+      if (!sender?.sendMedia) return false;
+      try {
+        await sender.sendMedia(chatId, payload);
+        return true;
+      } catch (error) {
+        console.warn(`Channel sender "${name}" sendMedia failed:`, error);
+        return false;
+      }
+    }
+  };
+}
+export {
+  createSenderRegistry,
+  createSlidingWindowRateLimiter,
+  decideChannelAction,
+  isEffectivelyFromSelf,
+  isFromAnySession,
+  underReplyRateLimit
+};

package/dist/channels/senders.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Channel-agnostic outbound registry. Brain-side features (a scheduler, the
+ * flows engine) send messages by channel name without importing a transport
+ * or knowing whether it is currently connected — a channel registers its
+ * sender on start and unregisters it on stop, and every send degrades to
+ * `false` instead of throwing when the name is unknown or the underlying
+ * send fails, so a disconnected channel can never crash a caller.
+ */
+/** What a channel implements to receive outbound sends. Voice/media payload shapes are transport-defined. */
+export interface ChannelSender {
+    sendText(chatId: string, text: string): Promise<void>;
+    /** Optional: channels without voice support (or test fakes) stay valid without it. */
+    sendVoice?(chatId: string, payload: unknown): Promise<void>;
+    /** Optional: channels without media support (or test fakes) stay valid without it. */
+    sendMedia?(chatId: string, payload: unknown): Promise<void>;
+}
+export interface ChannelSenderRegistry {
+    register(name: string, sender: ChannelSender): void;
+    unregister(name: string): void;
+    /** True when a sender is registered under `name` (regardless of what it optionally supports). */
+    available(name: string): boolean;
+    sendText(name: string, chatId: string, text: string): Promise<boolean>;
+    /** False (not a throw) when the sender is missing, disconnected, or lacks voice support. */
+    sendVoice(name: string, chatId: string, payload: unknown): Promise<boolean>;
+    /** False (not a throw) when the sender is missing, disconnected, or lacks media support. */
+    sendMedia(name: string, chatId: string, payload: unknown): Promise<boolean>;
+}
+/** One registry per server: channels register on start, callers send by name. */
+export declare function createSenderRegistry(): ChannelSenderRegistry;
+//# sourceMappingURL=senders.d.ts.map

package/dist/channels/senders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"senders.d.ts","sourceRoot":"","sources":["../../src/channels/senders.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,6GAA6G;AAC7G,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,sFAAsF;IACtF,SAAS,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,sFAAsF;IACtF,SAAS,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7D;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;IACpD,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,iGAAiG;IACjG,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvE,4FAA4F;IAC5F,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5E,4FAA4F;IAC5F,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7E;AAED,iFAAiF;AACjF,wBAAgB,oBAAoB,IAAI,qBAAqB,CAkD5D"}

package/dist/channels/senders.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=senders.test.d.ts.map

package/dist/channels/senders.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"senders.test.d.ts","sourceRoot":"","sources":["../../src/channels/senders.test.ts"],"names":[],"mappings":""}