@yaebal/rich 0.0.1 → 0.0.2

package/src/inline.ts

@@ -1,105 +1,115 @@
 import type { User } from "@yaebal/core";
-import { escapeAttr, escapeText } from "./escape.js";
+import { escapeAttr, escapeMarkdownUrl } from "./escape.js";
+import { type Dialect, makeNode, type RichNode } from "./node.js";
+import { escapeFor, type Insertable, render } from "./render.js";
 
-/**
- * a fragment of the extended html telegram parses into a `RichMessage` (see
- * `InputRichMessage.html`). unlike `@yaebal/fmt`'s `FormatResult` (a flat
- * `{ text, entities }` pair), rich messages are a block tree parsed server-side —
- * there is nothing to build client-side except this html string.
- */
-export interface RichNode {
-	readonly html: string;
-}
-
-export type Insertable = RichNode | string | number | bigint | boolean | null | undefined;
+// every builder here returns a dialect-agnostic `RichNode` — the html/markdown
+// choice happens once, at the `html`/`md`/`document()` boundary. children render
+// lazily, so a node built from user input is safe in either dialect.
 
-export function isRichNode(value: unknown): value is RichNode {
-	return (
-		typeof value === "object" && value !== null && typeof (value as RichNode).html === "string"
-	);
+function children(items: Insertable[], dialect: Dialect): string {
+	return items.map((item) => render(item, dialect)).join("");
 }
 
-/** render one interpolation: a `RichNode` is spliced raw, anything else is escaped text. */
-export function toHtml(value: Insertable): string {
-	if (isRichNode(value)) return value.html;
-	return value == null ? "" : escapeText(String(value));
+// a wrapper mark: same shape in both dialects, differing only in the surrounding tokens.
+function wrap(md: (inner: string) => string, html: (inner: string) => string) {
+	return (...items: Insertable[]): RichNode =>
+		makeNode("inline", (d) => (d === "markdown" ? md : html)(children(items, d)));
 }
 
-function join(children: Insertable[]): string {
-	return children.map(toHtml).join("");
-}
+// --- inline marks — confirmed tags (same dialect as classic parse_mode html) ---
 
-function wrap(tag: string) {
-	return (...children: Insertable[]): RichNode => ({ html: `<${tag}>${join(children)}</${tag}>` });
+/** `RichTextBold` — `<b>` / `**x**`. */
+export const bold = wrap(
+	(x) => `**${x}**`,
+	(x) => `<b>${x}</b>`,
+);
+/** `RichTextItalic` — `<i>` / `*x*`. */
+export const italic = wrap(
+	(x) => `*${x}*`,
+	(x) => `<i>${x}</i>`,
+);
+/** `RichTextUnderline` — `<u>`; no markdown token, the raw tag is embedded there too. */
+export const underline = wrap(
+	(x) => `<u>${x}</u>`,
+	(x) => `<u>${x}</u>`,
+);
+/** `RichTextStrikethrough` — `<s>` / `~~x~~`. */
+export const strikethrough = wrap(
+	(x) => `~~${x}~~`,
+	(x) => `<s>${x}</s>`,
+);
+/** `RichTextSpoiler` — `<tg-spoiler>` / `||x||`. */
+export const spoiler = wrap(
+	(x) => `||${x}||`,
+	(x) => `<tg-spoiler>${x}</tg-spoiler>`,
+);
+/** `RichTextCode` — `<code>` / `` `x` ``. */
+export const code = wrap(
+	(x) => `\`${x}\``,
+	(x) => `<code>${x}</code>`,
+);
+
+/** line break — hard newline in markdown, `<br/>` in html. */
+export function br(): RichNode {
+	return makeNode("inline", (d) => (d === "markdown" ? "\n" : "<br/>"));
 }
 
 /**
- * an extended-html template: interpolations are auto-escaped (never re-parsed as
- * markup), and a nested `RichNode` (from these builders, or another `html`
- * template) is spliced in raw. mirrors `@yaebal/fmt`'s `html` tag, but for the
- * rich-message dialect instead of the classic entity one.
+ * `RichTextCustomEmoji` — `<tg-emoji emoji-id="…">`, the same custom tag classic
+ * `parse_mode: "HTML"` uses (telegram documents it as reused verbatim here);
+ * best-effort `![fallback](tg://emoji?id=…)` in markdown. `fallback` is the
+ * plain emoji shown where custom emoji can't render.
  */
-export function html(strings: TemplateStringsArray, ...subs: Insertable[]): RichNode {
-	let out = "";
-
-	for (let i = 0; i < strings.length; i++) {
-		out += strings[i] ?? "";
-		if (i < subs.length) out += toHtml(subs[i]);
-	}
-
-	return { html: out };
+export function customEmoji(emojiId: string, fallback: string): RichNode {
+	return makeNode("inline", (d) =>
+		d === "markdown"
+			? `![${escapeFor(fallback, d)}](${escapeMarkdownUrl(`tg://emoji?id=${emojiId}`)})`
+			: `<tg-emoji emoji-id="${escapeAttr(emojiId)}">${escapeFor(fallback, d)}</tg-emoji>`,
+	);
 }
 
-// --- inline marks — confirmed tags (same dialect as classic parse_mode html) ---
-
-/** `RichTextBold`, `<b>`. */
-export const bold = wrap("b");
-/** `RichTextItalic`, `<i>`. */
-export const italic = wrap("i");
-/** `RichTextUnderline`, `<u>`. */
-export const underline = wrap("u");
-/** `RichTextStrikethrough`, `<s>`. */
-export const strikethrough = wrap("s");
-/** `RichTextSpoiler`, `<tg-spoiler>`. */
-export const spoiler = wrap("tg-spoiler");
-/** `RichTextCode`, `<code>`. */
-export const code = wrap("code");
+// a markdown link destination: `[text](url)` is terminated by `)` or whitespace,
+// so the url must be escaped to keep an attacker-controlled value inside the link.
+function mdLink(text: string, url: string): string {
+	return `[${text}](${escapeMarkdownUrl(url)})`;
+}
 
-/**
- * `RichTextCustomEmoji`, `<tg-emoji emoji-id="…">`. same custom tag classic
- * `parse_mode: "HTML"` uses for custom emoji — telegram documents it as reused
- * verbatim here. `fallback` is the plain emoji shown where custom emoji can't render.
- */
-export function customEmoji(emojiId: string, fallback: string): RichNode {
-	return { html: `<tg-emoji emoji-id="${escapeAttr(emojiId)}">${escapeText(fallback)}</tg-emoji>` };
+/** `RichTextUrl`, an explicit link. for a bare auto-linked url, just write it as plain text. */
+export function link(url: string, ...items: Insertable[]): RichNode {
+	return makeNode("inline", (d) =>
+		d === "markdown"
+			? mdLink(children(items, d), url)
+			: `<a href="${escapeAttr(url)}">${children(items, d)}</a>`,
+	);
 }
 
 /**
- * `RichTextTextMention`, a mention of a user who may have no `@username` — same
- * `tg://user?id=…` link telegram's classic html dialect uses for `text_mention`.
+ * `RichTextTextMention`, a mention of a user who may have no `@username` — the
+ * same `tg://user?id=…` link telegram's classic dialects use for `text_mention`.
  * for `@username` mentions (`RichTextMention`), just write `@username` as plain
- * text — the schema lists it as auto-detected (see `skipEntityDetection`).
+ * text — the schema lists it as auto-detected (see `noEntityDetection`).
  */
-export function textMention(user: Pick<User, "id">, ...children: Insertable[]): RichNode {
-	return { html: `<a href="tg://user?id=${user.id}">${join(children)}</a>` };
-}
-
-/** `RichTextUrl`, an explicit link. for a bare auto-linked url, just write it as plain text. */
-export function link(url: string, ...children: Insertable[]): RichNode {
-	return { html: `<a href="${escapeAttr(url)}">${join(children)}</a>` };
+export function textMention(user: Pick<User, "id">, ...items: Insertable[]): RichNode {
+	return link(`tg://user?id=${user.id}`, ...items);
 }
 
-/** `RichTextAnchor` (inline form) — a named jump target, `<a name="…">`. */
+/** `RichTextAnchor` (inline form) — a named jump target, `<a name="…">` in both dialects. */
 export function anchor(name: string): RichNode {
-	return { html: `<a name="${escapeAttr(name)}"></a>` };
+	return makeNode("inline", () => `<a name="${escapeAttr(name)}"></a>`);
 }
 
 /**
  * `RichTextAnchorLink`, a link to an `anchor()` elsewhere in the message —
- * `<a href="#name">`. an empty `name` jumps back to the top (per the schema).
+ * `<a href="#name">` / `[text](#name)`. an empty `name` jumps back to the top
+ * (per the schema).
  */
-export function anchorLink(name: string, ...children: Insertable[]): RichNode {
-	return { html: `<a href="#${escapeAttr(name)}">${join(children)}</a>` };
+export function anchorLink(name: string, ...items: Insertable[]): RichNode {
+	return makeNode("inline", (d) =>
+		d === "markdown"
+			? mdLink(children(items, d), `#${name}`)
+			: `<a href="#${escapeAttr(name)}">${children(items, d)}</a>`,
+	);
 }
 
 // --- inline marks — best-effort tags ---
@@ -111,42 +121,66 @@ export function anchorLink(name: string, ...children: Insertable[]): RichNode {
 // convention — verify against the live "rich message formatting options" docs
 // before depending on the exact tag/attribute spelling in production.
 
-/** `RichTextMarked`, best-effort `<mark>` (standard html5 highlight). */
-export const marked = wrap("mark");
-/** `RichTextSubscript`, best-effort `<sub>`. */
-export const subscript = wrap("sub");
-/** `RichTextSuperscript`, best-effort `<sup>`. */
-export const superscript = wrap("sup");
+/** `RichTextMarked`, highlighted text — best-effort `<mark>` / `==x==`. */
+export const marked = wrap(
+	(x) => `==${x}==`,
+	(x) => `<mark>${x}</mark>`,
+);
+/** `RichTextSubscript` — best-effort `<sub>`; no markdown token, raw tag embedded there too. */
+export const subscript = wrap(
+	(x) => `<sub>${x}</sub>`,
+	(x) => `<sub>${x}</sub>`,
+);
+/** `RichTextSuperscript` — best-effort `<sup>`; no markdown token, raw tag embedded there too. */
+export const superscript = wrap(
+	(x) => `<sup>${x}</sup>`,
+	(x) => `<sup>${x}</sup>`,
+);
 
 /**
- * `RichTextMathematicalExpression` (inline), best-effort `<tg-math>` (the block
- * form is confirmed as `<tg-math-block>` — see `mathBlock` in blocks.ts).
+ * `RichTextMathematicalExpression` (inline) — best-effort `<tg-math>` / `$x$`
+ * (the block form is confirmed as `<tg-math-block>` — see `mathBlock` in
+ * blocks.ts). `expression` is raw LaTeX — not markdown-escaped.
  */
 export function math(expression: string): RichNode {
-	return { html: `<tg-math>${escapeText(expression)}</tg-math>` };
+	return makeNode("inline", (d) =>
+		d === "markdown" ? `$${expression}$` : `<tg-math>${escapeFor(expression, "html")}</tg-math>`,
+	);
 }
 
 /**
- * `RichTextDateTime`, best-effort `<time>`. `format` is telegram's date-time
- * entity format string; attribute name is a guess (`data-format`).
+ * `RichTextDateTime`, auto-formatted date-time — best-effort `<time>` (attribute
+ * name `data-format` is a guess) / `![label](tg://time?unix=…&format=…)`.
+ * `format` is telegram's date-time entity format string.
  */
-export function dateTime(unixTime: number, format: string, ...children: Insertable[]): RichNode {
-	return {
-		html: `<time datetime="${unixTime}" data-format="${escapeAttr(format)}">${join(children)}</time>`,
-	};
+export function dateTime(unixTime: number, format: string, ...items: Insertable[]): RichNode {
+	const query = `tg://time?unix=${unixTime}${format ? `&format=${format}` : ""}`;
+
+	return makeNode("inline", (d) =>
+		d === "markdown"
+			? `![${children(items, d)}](${escapeMarkdownUrl(query)})`
+			: `<time datetime="${unixTime}" data-format="${escapeAttr(format)}">${children(items, d)}</time>`,
+	);
 }
 
 /**
  * `RichTextReference`, a footnote definition. no tag is documented anywhere in
- * the scraped schema — this is a from-scratch `tg-*`-style guess.
+ * the scraped schema — `<tg-reference>` is a from-scratch `tg-*`-style guess,
+ * `[^name]: …` the standard markdown footnote line (place it at line start).
  */
-export function reference(name: string, ...children: Insertable[]): RichNode {
-	return { html: `<tg-reference name="${escapeAttr(name)}">${join(children)}</tg-reference>` };
+export function reference(name: string, ...items: Insertable[]): RichNode {
+	return makeNode("inline", (d) =>
+		d === "markdown"
+			? `[^${name}]: ${children(items, d)}`
+			: `<tg-reference name="${escapeAttr(name)}">${children(items, d)}</tg-reference>`,
+	);
 }
 
-/** `RichTextReferenceLink`, a link to a `reference()`. same caveat as `reference`. */
-export function referenceLink(name: string, ...children: Insertable[]): RichNode {
-	return {
-		html: `<tg-reference-link name="${escapeAttr(name)}">${join(children)}</tg-reference-link>`,
-	};
+/** `RichTextReferenceLink`, a link to a `reference()` — same caveat as `reference`. */
+export function referenceLink(name: string, ...items: Insertable[]): RichNode {
+	return makeNode("inline", (d) =>
+		d === "markdown"
+			? `[^${name}]`
+			: `<tg-reference-link name="${escapeAttr(name)}">${children(items, d)}</tg-reference-link>`,
+	);
 }

package/src/node.ts

@@ -0,0 +1,43 @@
+/** the two wire dialects of `InputRichMessage` — `html` and `markdown`. */
+export type Dialect = "html" | "markdown";
+
+/** whether a node is an inline mark (bold, link, …) or a top-level block (paragraph, table, …). */
+export type Level = "inline" | "block";
+
+// `Symbol.for` so two copies of the package in one node_modules tree still
+// recognise each other's nodes (a duck-typed `.html` check would false-positive
+// on any object that happens to carry an `html: string` field).
+const RICH_NODE = Symbol.for("yaebal.rich.node");
+
+/**
+ * one builder result — a dialect-agnostic fragment of a rich message. every
+ * builder (`bold`, `paragraph`, `table`, …) returns one of these; nothing is
+ * serialized until the node lands in an `html`/`md` template or a `document()`,
+ * which picks the dialect and calls `render` once.
+ */
+export interface RichNode {
+	readonly [RICH_NODE]: true;
+	readonly level: Level;
+	render(dialect: Dialect): string;
+}
+
+/** construct a `RichNode` from a level + per-dialect renderer. */
+export function makeNode(level: Level, render: (dialect: Dialect) => string): RichNode {
+	return { [RICH_NODE]: true as const, level, render };
+}
+
+export function isRichNode(value: unknown): value is RichNode {
+	return (
+		typeof value === "object" &&
+		value !== null &&
+		(value as Record<symbol, unknown>)[RICH_NODE] === true
+	);
+}
+
+/** thrown on misuse — a dialect-mismatched interpolation, unsupported content. */
+export class RichError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "RichError";
+	}
+}

package/src/plaintext.test.ts

@@ -0,0 +1,141 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { RichBlock, RichMessage } from "@yaebal/types";
+import { richBlockToPlainText, richMessageToPlainText, richTextToPlainText } from "./plaintext.js";
+
+test("richTextToPlainText flattens a plain string, nested marks, and arrays", () => {
+	assert.equal(richTextToPlainText("hi"), "hi");
+	assert.equal(richTextToPlainText({ type: "bold", text: "hi" } as never), "hi");
+	assert.equal(
+		richTextToPlainText([{ type: "bold", text: "a" }, " ", { type: "italic", text: "b" }] as never),
+		"a b",
+	);
+});
+
+test("richTextToPlainText special-cases custom_emoji/mathematical_expression/anchor", () => {
+	assert.equal(
+		richTextToPlainText({ type: "custom_emoji", alternative_text: "😀" } as never),
+		"😀",
+	);
+	assert.equal(
+		richTextToPlainText({ type: "mathematical_expression", expression: "a^2" } as never),
+		"a^2",
+	);
+	assert.equal(richTextToPlainText({ type: "anchor", name: "top" } as never), "");
+});
+
+test("richTextToPlainText returns empty string for undefined", () => {
+	assert.equal(richTextToPlainText(undefined), "");
+});
+
+test("richBlockToPlainText flattens simple text-bearing blocks with a trailing newline", () => {
+	assert.equal(richBlockToPlainText({ type: "paragraph", text: "hi" } as never), "hi\n");
+	assert.equal(
+		richBlockToPlainText({ type: "heading", text: "title", size: 1 } as never),
+		"title\n",
+	);
+	assert.equal(richBlockToPlainText({ type: "pre", text: "code" } as never), "code\n");
+	assert.equal(richBlockToPlainText({ type: "footer", text: "f" } as never), "f\n");
+	assert.equal(richBlockToPlainText({ type: "thinking", text: "…" } as never), "…\n");
+	assert.equal(richBlockToPlainText({ type: "divider" } as never), "---\n");
+	assert.equal(richBlockToPlainText({ type: "anchor", name: "top" } as never), "");
+	assert.equal(
+		richBlockToPlainText({ type: "mathematical_expression", expression: "a^2" } as never),
+		"a^2\n",
+	);
+});
+
+test("richBlockToPlainText flattens a list, one `- ` item per line", () => {
+	const block = {
+		type: "list",
+		items: [
+			{ blocks: [{ type: "paragraph", text: "one" }] },
+			{ blocks: [{ type: "paragraph", text: "two" }] },
+		],
+	} as never;
+
+	assert.equal(richBlockToPlainText(block), "- one\n- two\n");
+});
+
+test("richBlockToPlainText flattens blockquote/pullquote with an optional ' — credit' suffix", () => {
+	assert.equal(
+		richBlockToPlainText({
+			type: "blockquote",
+			blocks: [{ type: "paragraph", text: "x" }],
+		} as never),
+		"x\n\n",
+	);
+	assert.equal(
+		richBlockToPlainText({
+			type: "blockquote",
+			blocks: [{ type: "paragraph", text: "x" }],
+			credit: "author",
+		} as never),
+		"x\n — author\n",
+	);
+	assert.equal(richBlockToPlainText({ type: "pullquote", text: "x" } as never), "x\n");
+	assert.equal(
+		richBlockToPlainText({ type: "pullquote", text: "x", credit: "author" } as never),
+		"x — author\n",
+	);
+});
+
+test("richBlockToPlainText flattens collage/slideshow blocks with a captioned trailer", () => {
+	const block = {
+		type: "collage",
+		blocks: [{ type: "photo", photo: [], caption: undefined }],
+		caption: { text: "a cat", credit: "photographer" },
+	} as never;
+
+	assert.equal(richBlockToPlainText(block), "a cat (photographer)\n");
+});
+
+test("richBlockToPlainText flattens a table, ` | `-joined cells, one row per line", () => {
+	const block = {
+		type: "table",
+		cells: [
+			[{ text: "a" }, { text: "b" }],
+			[{ text: "c" }, { text: "d" }],
+		],
+	} as never;
+
+	assert.equal(richBlockToPlainText(block), "a | b\nc | d\n");
+});
+
+test("richBlockToPlainText flattens details as its summary followed by its blocks", () => {
+	const block = {
+		type: "details",
+		summary: "more",
+		blocks: [{ type: "paragraph", text: "hidden" }],
+	} as never;
+
+	assert.equal(richBlockToPlainText(block), "more\nhidden\n");
+});
+
+test("richBlockToPlainText flattens map/media blocks down to just their caption", () => {
+	assert.equal(richBlockToPlainText({ type: "map", caption: { text: "here" } } as never), "here\n");
+	assert.equal(richBlockToPlainText({ type: "photo", photo: [], caption: undefined } as never), "");
+	for (const type of ["animation", "audio", "photo", "video", "voice_note"] as const) {
+		assert.equal(richBlockToPlainText({ type, caption: { text: "cap" } } as never), "cap\n");
+	}
+});
+
+test("richBlockToPlainText falls back to empty string for an unrecognized block type", () => {
+	assert.equal(richBlockToPlainText({ type: "not-a-real-type" } as unknown as RichBlock), "");
+});
+
+test("richMessageToPlainText flattens a full block tree, joined and trimmed", () => {
+	const message = {
+		blocks: [
+			{ type: "heading", text: "title", size: 1 },
+			{ type: "paragraph", text: [{ type: "bold", text: "hi" }, " there"] },
+			{ type: "divider" },
+			{
+				type: "list",
+				items: [{ label: "1", blocks: [{ type: "paragraph", text: "one" }] }],
+			},
+		],
+	} as unknown as RichMessage;
+
+	assert.equal(richMessageToPlainText(message), "title\nhi there\n---\n- one");
+});

package/src/render.ts

@@ -0,0 +1,54 @@
+import { RichDocument } from "./document.js";
+import { escapeMarkdown, escapeText } from "./escape.js";
+import { type Dialect, isRichNode, RichError, type RichNode } from "./node.js";
+
+/**
+ * anything a builder or template accepts as content:
+ *
+ * - `string` / `number` / `bigint` — escaped for the target dialect, renders literally;
+ * - a `RichNode` (builder result) — rendered into the target dialect;
+ * - a `RichDocument` — inlined as-is (its dialect must match, else `RichError`);
+ * - `null` / `undefined` / `false` — empty string, so `cond && bold(…)` composes;
+ * - an array — each item rendered and concatenated.
+ */
+export type Insertable =
+	| RichNode
+	| RichDocument
+	| string
+	| number
+	| bigint
+	| null
+	| undefined
+	| false
+	| readonly Insertable[];
+
+/** escape plain text for a dialect so it can never be re-parsed as markup. */
+export function escapeFor(text: string, dialect: Dialect): string {
+	return dialect === "html" ? escapeText(text) : escapeMarkdown(text);
+}
+
+/** resolve one piece of content into a dialect string (text escaped, nodes rendered). */
+export function render(value: Insertable, dialect: Dialect): string {
+	if (value === null || value === undefined || value === false) return "";
+
+	if (typeof value === "string") return escapeFor(value, dialect);
+	if (typeof value === "number" || typeof value === "bigint") {
+		return escapeFor(String(value), dialect);
+	}
+
+	if (Array.isArray(value)) {
+		return value.map((item) => render(item as Insertable, dialect)).join("");
+	}
+
+	if (value instanceof RichDocument) {
+		if (value.dialect !== dialect) {
+			throw new RichError(`cannot inline a ${value.dialect} document into a ${dialect} template`);
+		}
+
+		return value.content;
+	}
+
+	if (isRichNode(value)) return value.render(dialect);
+
+	throw new RichError(`unsupported rich content: ${typeof value}`);
+}

package/src/send.ts

@@ -1,9 +1,15 @@
 import type { Api, Context, Message, Plugin } from "@yaebal/core";
 import type { InputRichMessage } from "@yaebal/types";
+import { RichDocument } from "./document.js";
 import { RichMessageDraft, type RichMessageDraftOptions } from "./draft.js";
 
-function toInput(input: InputRichMessage | string): InputRichMessage {
-	return typeof input === "string" ? { html: input } : input;
+/** everything the send/draft surface accepts: a template/`document()` result, a raw payload, or an html string. */
+export type RichSource = RichDocument | InputRichMessage | string;
+
+function toInput(input: RichSource): InputRichMessage {
+	if (typeof input === "string") return { html: input };
+	if (input instanceof RichDocument) return input.toInputRichMessage();
+	return input;
 }
 
 /**
@@ -17,7 +23,7 @@ function toInput(input: InputRichMessage | string): InputRichMessage {
 export function sendRichMessage(
 	api: Api,
 	chatId: number | string,
-	input: InputRichMessage | string,
+	input: RichSource,
 	extra: Record<string, unknown> = {},
 ): Promise<Message> {
 	return api.call<Message>("sendRichMessage", {
@@ -36,7 +42,7 @@ export function sendRichMessageDraft(
 	api: Api,
 	chatId: number,
 	draftId: number,
-	input: InputRichMessage | string,
+	input: RichSource,
 	extra: Record<string, unknown> = {},
 ): Promise<boolean> {
 	return api.call<boolean>("sendRichMessageDraft", {
@@ -49,10 +55,7 @@ export function sendRichMessageDraft(
 
 export interface RichContext {
 	/** `ctx.send`-flavored `sendRichMessage`, bound to the current chat. */
-	sendRichMessage(
-		input: InputRichMessage | string,
-		extra?: Record<string, unknown>,
-	): Promise<Message>;
+	sendRichMessage(input: RichSource, extra?: Record<string, unknown>): Promise<Message>;
 	/** open a `RichMessageDraft` streaming session bound to the current chat. */
 	richMessageDraft(draftId: number, options?: RichMessageDraftOptions): RichMessageDraft;
 }
@@ -67,7 +70,7 @@ export function rich(): Plugin<Context, RichContext> {
 					return Promise.reject(new Error("sendRichMessage(): no chat in this update"));
 				}
 
-				return sendRichMessage(this.api, chatId, input, extra);
+				return sendRichMessage(this.api, chatId, input, { ...this.routing(), ...extra });
 			},
 			richMessageDraft(this: Context, draftId, options) {
 				const chatId = this.chat?.id;
@@ -75,7 +78,11 @@ export function rich(): Plugin<Context, RichContext> {
 					throw new Error("richMessageDraft(): no chat in this update");
 				}
 
-				return new RichMessageDraft(this.api, chatId, draftId, options);
+				return new RichMessageDraft(this.api, chatId, draftId, {
+					messageThreadId: this.messageThreadId,
+					businessConnectionId: this.businessConnectionId,
+					...options,
+				});
 			},
 		});
 }