@excitedjs/feishu-transport 0.0.1

package/dist/render/render.js

@@ -0,0 +1,630 @@
+/**
+ * Render a Markdown source into one or more Feishu v2 interactive cards.
+ *
+ * Feishu's `tag: markdown` body element accepts only the "lark_md" subset —
+ * bold, italic, strikethrough, inline code, fenced code, links, and (on
+ * Feishu 7.6+) lists. It does NOT support headings or GFM tables: a `#` is
+ * shown as a literal `#`, and `| a | b |` is shown as the source pipes.
+ * Routing every block through `tag: markdown` therefore leaks raw markup into
+ * the rendered card whenever the body has a heading or a table.
+ *
+ * This module parses the source into block tokens (via `marked.lexer`) and
+ * routes each block to the v2 card component that actually renders it:
+ *
+ *   - The first `# h1` becomes the card's `header.title` plain-text slot.
+ *     A later `# h1`, and every `##`/`###`/... heading, becomes a body
+ *     element wrapping the flattened heading text in `**...**` so lark_md
+ *     renders it as visible bold.
+ *   - A GFM `| ... |` table becomes a dedicated `tag: table` element with
+ *     the header alignment markers mapped to each column's
+ *     `horizontal_align`. Cells that contain inline markup flip the
+ *     column's `data_type` from `text` to `lark_md`. A cell over
+ *     `CELL_MAX_BYTES` is a render-time error — splitting one row's cell
+ *     across multiple rows would break alignment, and silently truncating
+ *     hides the data the caller asked to deliver.
+ *   - A horizontal rule (`---`) becomes a `tag: hr` element.
+ *   - Every other block — paragraphs, lists, blockquotes, fenced code —
+ *     is emitted as a `tag: markdown` element with the block's raw source,
+ *     since lark_md renders those natively.
+ *
+ * Elements are then packed greedily into cards by a dual budget: Feishu's
+ * ~30 KB request body cap AND the v2 card per-card element-count cap.
+ * Only the first card carries the header — splitting the body produces
+ * follow-up cards with no header, the way a long thread reads. A markdown
+ * element body too large for one card is split with `splitMarkdownByBytes`,
+ * which counts UTF-8 bytes (so a CJK-heavy body is not budgeted as if it
+ * were ASCII) and respects grapheme cluster boundaries (so a ZWJ emoji
+ * does not get cut in half).
+ *
+ * `renderMarkdownToCards` validates every produced card against both
+ * budgets before returning; if any card would still exceed them despite
+ * splitting, it throws. Callers therefore know that the array they get
+ * back is wire-ready — there is no path where the renderer hands the
+ * sender a card Feishu would reject. This is the structural half of the
+ * "atomic" semantic the channel offers; the network half (every send
+ * succeeds or all sends fail) cannot be guaranteed on Feishu's IM API,
+ * which has no message-batch transaction.
+ *
+ * The result is `RenderedCard[]`. `cardToContent(card)` turns one card into
+ * the JSON string the `im.message.create` `content` field expects.
+ *
+ * The 9-row × 9-column limit in `markdown-ref.md` belongs to a different
+ * surface (the docs-create pipeline that turns markdown into Feishu document
+ * blocks); v2 card tables accept up to 50 columns, paginate rows in-card via
+ * `page_size`, and have no per-table row cap of their own. This renderer
+ * therefore column-splits at 50 (with the first column preserved on each
+ * split half as the identifier) and never row-splits when row-splitting
+ * would not actually reduce a card's size.
+ */
+import { marked } from 'marked';
+/**
+ * Feishu's documented hard limit for a card request body. Past this the API
+ * rejects the call outright; the packer keeps each card's serialised content
+ * below `CARD_CONTENT_SAFE_BYTES` so HTTP headers and the request envelope
+ * still fit underneath the hard cap.
+ */
+export const FEISHU_CARD_REQUEST_LIMIT_BYTES = 30 * 1024;
+const CARD_CONTENT_SAFE_BYTES = 28 * 1024;
+/**
+ * v2 card per-card element-count cap. Observed in PR #73 review: a card with
+ * 250 short markdown elements is rejected by Feishu, though the JSON itself
+ * is well under the byte cap. The exact upper bound is not in the open
+ * docs; the reviewer-cited 200 figure is treated as the hard limit and a
+ * lower number is used as the safe budget so a card on the boundary does
+ * not silently fail under server-side counting differences.
+ */
+export const FEISHU_CARD_ELEMENT_HARD_CAP = 200;
+const CARD_ELEMENT_SAFE_CAP = 180;
+/**
+ * v2 table column cap from the Feishu card API. A wider table is split into
+ * several adjacent table elements; each split half repeats the original
+ * first column as an identifier the reader can still align rows against.
+ */
+const TABLE_COLUMN_HARD_CAP = 50;
+/** In-card paginator page size for tables. The API caps this at 10. */
+const TABLE_DEFAULT_PAGE_SIZE = 10;
+/**
+ * Per-cell byte cap. A cell larger than this is rejected at render time:
+ * splitting one row's cell across multiple rows breaks alignment with the
+ * other columns, and silently truncating drops the data the caller asked
+ * to deliver. The author is expected to move the oversized content into a
+ * paragraph or fenced code block, where the byte-aware splitter handles
+ * arbitrary sizes.
+ *
+ * 4 KB is comfortably above any reasonable cell value (a long sentence is
+ * ~200 bytes) while small enough that a 50-column table of full-budget
+ * cells still leaves room for the card envelope inside the byte cap.
+ */
+export const CELL_MAX_BYTES = 4 * 1024;
+/**
+ * Convert `<@ou_...>` shorthand into the lark_md `<at id="ou_..."></at>`
+ * mention tag, leaving inline code spans untouched. Fenced code block tokens
+ * are excluded upstream by the `token.type === 'code'` guard in
+ * `tokensToElements`; this function only needs to skip backtick-delimited
+ * inline code spans (single or multi-backtick) within the raw text of other
+ * block types.
+ */
+function replaceAtMentions(text) {
+    const parts = [];
+    let lastIndex = 0;
+    // Match any inline code span — one or more backticks as the delimiter.
+    const codeSpan = /`+[\s\S]*?`+/g;
+    let match;
+    while ((match = codeSpan.exec(text)) !== null) {
+        // Non-code segment before this span — apply the substitution.
+        parts.push(text.slice(lastIndex, match.index).replace(/<@(ou_[A-Za-z0-9_-]+)>/g, '<at id="$1"></at>'));
+        // Inline code span — pass through unchanged.
+        parts.push(match[0]);
+        lastIndex = match.index + match[0].length;
+    }
+    // Trailing non-code segment.
+    parts.push(text.slice(lastIndex).replace(/<@(ou_[A-Za-z0-9_-]+)>/g, '<at id="$1"></at>'));
+    return parts.join('');
+}
+/**
+ * Render a Markdown source into one or more v2 cards.
+ *
+ * The output is always non-empty: an empty source produces one card with a
+ * single empty `tag: markdown` element, so the caller always has something
+ * to send. Splitting happens automatically when the serialised card would
+ * exceed Feishu's 30 KB request cap, when the body would exceed the
+ * 200-element cap, or when a table has more than 50 columns.
+ *
+ * Throws when a single block cannot be made to fit even after splitting —
+ * for example a table whose row, after every cell has been validated under
+ * `CELL_MAX_BYTES`, still serialises above the per-card byte cap. The
+ * caller therefore sees a render-time error before any send is attempted,
+ * instead of the channel posting some cards and then failing on a later
+ * one (partial visible state).
+ */
+export function renderMarkdownToCards(text) {
+    const tokens = marked.lexer(text);
+    const { header, elements } = tokensToElements(tokens);
+    const cards = packIntoCards(elements, header);
+    // Final structural check. By construction every card already fits both
+    // budgets, but a defensive assertion makes a future packing-loop bug
+    // surface here as a clear error rather than a Feishu reject downstream.
+    for (let i = 0; i < cards.length; i++) {
+        const card = cards[i];
+        const bytes = cardContentBytes(card);
+        const count = card.body.elements.length;
+        if (bytes > CARD_CONTENT_SAFE_BYTES) {
+            throw new Error(`rendered card ${i + 1} of ${cards.length} is ${bytes} bytes; ` +
+                `Feishu rejects a card body over ${FEISHU_CARD_REQUEST_LIMIT_BYTES} bytes. ` +
+                'Reduce the content (shorter paragraphs, fewer rows in any one table).');
+        }
+        if (count > FEISHU_CARD_ELEMENT_HARD_CAP) {
+            throw new Error(`rendered card ${i + 1} of ${cards.length} has ${count} elements; ` +
+                `Feishu rejects a card with more than ${FEISHU_CARD_ELEMENT_HARD_CAP} elements. ` +
+                'Combine adjacent paragraphs or send fewer items per reply.');
+        }
+    }
+    return cards;
+}
+/**
+ * Serialise one card into the JSON string Feishu's `im.message.create`
+ * `content` field expects. Pure: no side effects, no I/O.
+ */
+export function cardToContent(card) {
+    return JSON.stringify(card);
+}
+/** Byte length of `card`'s serialised content, in UTF-8. */
+export function cardContentBytes(card) {
+    return Buffer.byteLength(cardToContent(card), 'utf8');
+}
+/**
+ * Walk every block token, route it to the right v2 component, and emit
+ * `{ header, elements }`. The header slot is filled by the first heading
+ * with depth 1; any later h1 falls through to the bold-body fallback so its
+ * text is not silently dropped.
+ */
+function tokensToElements(tokens) {
+    let header;
+    const elements = [];
+    for (const token of tokens) {
+        if (token.type === 'space')
+            continue;
+        if (token.type === 'heading') {
+            const heading = token;
+            const flat = flattenInline(heading.tokens);
+            if (heading.depth === 1 && header === undefined) {
+                header = { title: { tag: 'plain_text', content: flat } };
+                continue;
+            }
+            // h2+, or a later h1 — lark_md has no heading syntax, so the rendered
+            // text would otherwise show the literal `##`. Wrap the flattened text
+            // in `**...**` so it renders as visible bold.
+            elements.push({ tag: 'markdown', content: `**${flat}**` });
+            continue;
+        }
+        if (token.type === 'hr') {
+            elements.push({ tag: 'hr' });
+            continue;
+        }
+        if (token.type === 'table') {
+            for (const t of tableTokenToElements(token)) {
+                elements.push(t);
+            }
+            continue;
+        }
+        // Everything else — paragraph, list, blockquote, code, html block — has
+        // a `raw` field that preserves the original markdown source. lark_md
+        // renders the supported subset; unsupported markup (e.g. blockquote `>`)
+        // passes through and may show its leading characters literally.
+        const raw = token.raw ?? '';
+        const trimmed = raw.replace(/\n+$/, '');
+        if (trimmed.length === 0)
+            continue;
+        // Fenced and indented code blocks must not have <@> patterns substituted —
+        // a code example like `<@ou_abc>` must not ping anyone. All other blocks
+        // (paragraphs, lists, blockquotes, …) run through replaceAtMentions, which
+        // skips inline code spans within them.
+        const content = token.type === 'code' ? trimmed : replaceAtMentions(trimmed);
+        elements.push({ tag: 'markdown', content });
+    }
+    if (elements.length === 0 && header === undefined) {
+        // Always emit something so the send loop has at least one card to post.
+        elements.push({ tag: 'markdown', content: '' });
+    }
+    return { header, elements };
+}
+/**
+ * Walk a `marked` inline-token tree and produce the plain-text equivalent —
+ * `**bold**` becomes `bold`, `[link](url)` becomes `link`, etc. Used for the
+ * card's plain-text header slot, which renders markup characters literally.
+ */
+function flattenInline(tokens) {
+    if (!tokens)
+        return '';
+    let out = '';
+    for (const t of tokens) {
+        if ('tokens' in t && Array.isArray(t.tokens)) {
+            out += flattenInline(t.tokens);
+            continue;
+        }
+        out += t.text ?? '';
+    }
+    return out;
+}
+/**
+ * Convert one GFM table token into one or more `tag: table` body elements.
+ * A table wider than the API's 50-column cap is split into adjacent halves;
+ * each half repeats the original first column so the reader can still align
+ * a row across the split. Returns at least one element.
+ *
+ * Throws when any cell exceeds `CELL_MAX_BYTES` — a giant cell does not
+ * render usefully and would either force silent truncation or cell-level
+ * row splitting that breaks alignment with the other columns. The author
+ * should move the oversized content into a paragraph or fenced code block.
+ */
+function tableTokenToElements(table) {
+    validateCellSizes(table);
+    const headerCells = table.header;
+    const rows = table.rows;
+    const totalCols = headerCells.length;
+    if (totalCols <= TABLE_COLUMN_HARD_CAP) {
+        return [buildTableElement(headerCells, rows, 0, totalCols, false)];
+    }
+    const out = [];
+    // First slice: columns [0, 50). Later slices repeat column 0 plus the next
+    // 49 columns, so every emitted table stays within the 50-column cap.
+    out.push(buildTableElement(headerCells, rows, 0, TABLE_COLUMN_HARD_CAP, false));
+    const chunkSize = TABLE_COLUMN_HARD_CAP - 1;
+    for (let start = TABLE_COLUMN_HARD_CAP; start < totalCols; start += chunkSize) {
+        const end = Math.min(totalCols, start + chunkSize);
+        out.push(buildTableElement(headerCells, rows, start, end, true));
+    }
+    return out;
+}
+/**
+ * Walk every cell of a parsed table and throw on the first one larger than
+ * `CELL_MAX_BYTES`. Run at render time so the error names the row and
+ * column position the author can locate in the source.
+ */
+function validateCellSizes(table) {
+    for (let rowIdx = 0; rowIdx < table.rows.length; rowIdx++) {
+        const row = table.rows[rowIdx];
+        if (!row)
+            continue;
+        for (let colIdx = 0; colIdx < row.length; colIdx++) {
+            const cell = row[colIdx];
+            const text = cell?.text ?? '';
+            const bytes = Buffer.byteLength(text, 'utf8');
+            if (bytes > CELL_MAX_BYTES) {
+                const header = table.header[colIdx]?.text ?? `column ${colIdx + 1}`;
+                throw new Error(`table cell at row ${rowIdx + 1}, column "${header}" is ${bytes} bytes; ` +
+                    `cells over ${CELL_MAX_BYTES} bytes do not render usefully in a card table. ` +
+                    'Move the content out of the table — a paragraph or fenced code block has no such cap.');
+            }
+        }
+    }
+}
+/**
+ * Build one `tag: table` element from the rows of an already-parsed GFM
+ * table. `start..end` selects which columns this element covers; when
+ * `includeIdentifier` is true, the original first column is prepended to
+ * the selection so a split table keeps an identifier column on every half.
+ *
+ * Column `data_type` is `text` unless any cell in that column carries
+ * inline markup, in which case it flips to `lark_md` so the markup renders.
+ */
+function buildTableElement(headerCells, rows, start, end, includeIdentifier) {
+    // Indices into the source table that this element covers. The identifier
+    // column is duplicated by index so each cell still resolves correctly.
+    const indices = [];
+    if (includeIdentifier && start > 0)
+        indices.push(0);
+    for (let i = start; i < end; i++)
+        indices.push(i);
+    // Stable, in-row-unique column names so a row object can be keyed by name
+    // without collisions even when display names repeat. `col_0`, `col_1`, ...
+    // are internal keys; the `display_name` is the visible label.
+    const columns = indices.map((srcIdx, outIdx) => {
+        const cell = headerCells[srcIdx];
+        const hasInline = rows.some((row) => cellHasInlineMarkup(row[srcIdx]));
+        return {
+            name: `col_${outIdx}`,
+            display_name: cell?.text ?? '',
+            data_type: hasInline ? 'lark_md' : 'text',
+            ...alignToHorizontal(cell?.align),
+        };
+    });
+    const builtRows = rows.map((row) => {
+        const record = {};
+        indices.forEach((srcIdx, outIdx) => {
+            const cell = row[srcIdx];
+            const colName = `col_${outIdx}`;
+            record[colName] = cell?.text ?? '';
+        });
+        return record;
+    });
+    return {
+        tag: 'table',
+        page_size: TABLE_DEFAULT_PAGE_SIZE,
+        row_height: 'low',
+        header_style: { bold: true, background_style: 'grey' },
+        columns,
+        rows: builtRows,
+    };
+}
+/**
+ * Translate a GFM alignment marker into the column field. `marked` reports
+ * `align` as `'left' | 'center' | 'right' | null`; an unaligned column gets
+ * no `horizontal_align`, so the API picks its default rather than this
+ * renderer forcing one.
+ */
+function alignToHorizontal(align) {
+    if (align === 'left' || align === 'center' || align === 'right') {
+        return { horizontal_align: align };
+    }
+    return {};
+}
+/**
+ * True when a table cell's parsed tokens include any non-text token —
+ * bold, italic, link, inline code, etc. The column whose cells trigger this
+ * needs `data_type: lark_md` so the markup renders instead of leaking
+ * through as literal characters.
+ */
+function cellHasInlineMarkup(cell) {
+    if (!cell || !cell.tokens)
+        return false;
+    for (const t of cell.tokens) {
+        if (t.type !== 'text')
+            return true;
+    }
+    return false;
+}
+/**
+ * Pack elements into cards by a dual budget: Feishu's 30 KB request cap AND
+ * the per-card element count cap. Both must be satisfied for an element to
+ * join the current card; either tripping flushes the card. The first card
+ * carries the header; later cards do not, so a long reply reads as a
+ * threaded continuation rather than repeated banners.
+ *
+ * A single element that itself would exceed either budget is split inline:
+ * a `tag: markdown` element by `splitMarkdownByBytes`, a `tag: table`
+ * element by reducing the rows it carries until it fits.
+ */
+function packIntoCards(elements, header) {
+    const cards = [];
+    let current = newCard(header);
+    let isFirstCard = true;
+    const flush = () => {
+        if (current.body.elements.length === 0 && current.header === undefined)
+            return;
+        cards.push(current);
+        isFirstCard = false;
+        current = newCard(undefined);
+    };
+    const tryAdd = (element) => {
+        if (current.body.elements.length + 1 > CARD_ELEMENT_SAFE_CAP)
+            return false;
+        const trial = {
+            ...current,
+            body: { elements: [...current.body.elements, element] },
+        };
+        return cardContentBytes(trial) <= CARD_CONTENT_SAFE_BYTES;
+    };
+    const addPiece = (piece) => {
+        if (!tryAdd(piece)) {
+            if (current.body.elements.length > 0)
+                flush();
+        }
+        current.body.elements.push(piece);
+    };
+    for (const element of elements) {
+        if (tryAdd(element)) {
+            current.body.elements.push(element);
+            continue;
+        }
+        // The element does not fit alongside what is already in the current
+        // card. Flush so the current card seals at its safe size, then retry.
+        if (current.body.elements.length > 0)
+            flush();
+        if (tryAdd(element)) {
+            current.body.elements.push(element);
+            continue;
+        }
+        // The element alone exceeds at least one budget on a fresh card. Split
+        // it into pieces that each fit on their own; each piece is then added
+        // through the normal packing path so adjacent small pieces can share a
+        // card.
+        const pieces = splitOversizedElement(element, isFirstCard ? header : undefined);
+        for (const piece of pieces)
+            addPiece(piece);
+    }
+    flush();
+    if (cards.length === 0)
+        cards.push(newCard(header));
+    return cards;
+}
+/** Build an empty card, optionally pre-populated with a header slot. */
+function newCard(header) {
+    const card = {
+        schema: '2.0',
+        config: { update_multi: true },
+        body: { elements: [] },
+    };
+    if (header)
+        card.header = header;
+    return card;
+}
+/**
+ * Split one too-big element into pieces that each individually fit under
+ * the per-card budgets. A markdown element is split by `splitMarkdownByBytes`;
+ * a table element is split by reducing its row count.
+ *
+ * `headerOnFirstCard` lets the splitter budget the first piece against the
+ * card with the header attached, so a piece that just fits next to the
+ * header doesn't get oversized for the very first card.
+ */
+function splitOversizedElement(element, headerOnFirstCard) {
+    if (element.tag === 'markdown') {
+        return splitMarkdownElement(element, headerOnFirstCard);
+    }
+    if (element.tag === 'table') {
+        return splitTableByRows(element, headerOnFirstCard);
+    }
+    return [element];
+}
+/**
+ * Split a too-big `tag: markdown` element into smaller ones, each whose
+ * serialised content fits the per-card byte budget. The body is split with
+ * `splitMarkdownByBytes`, which counts UTF-8 bytes — so a 12 K-character
+ * CJK paragraph (~36 KB) is correctly split, where a char-based budget
+ * would believe it fits and ship one oversized card.
+ */
+function splitMarkdownElement(element, headerOnFirstCard) {
+    // Reserve room for the JSON envelope of one card carrying one element:
+    // `{"schema":"2.0","config":{"update_multi":true},"body":{"elements":[{"tag":"markdown","content":"..."}]}}`
+    // plus the optional header. The envelope is measured with an empty
+    // content string; the 256-byte cushion covers JSON-escape expansion of
+    // body characters that need escaping (quotes, backslashes, control
+    // characters) versus their raw byte count.
+    const envelope = cardContentBytes(newCardWithEmpty(headerOnFirstCard));
+    const innerBudget = Math.max(256, CARD_CONTENT_SAFE_BYTES - envelope - 256);
+    const pieces = splitMarkdownByBytes(element.content, innerBudget);
+    return pieces.map((content) => ({ tag: 'markdown', content }));
+}
+/**
+ * Build an empty card carrying one empty markdown element, used to size the
+ * fixed envelope overhead when splitting an oversized markdown element. The
+ * cushion in `splitMarkdownElement` covers the difference between an empty
+ * content string and the brackets/quotes around real content plus any
+ * JSON escapes the content contributes on its own.
+ */
+function newCardWithEmpty(header) {
+    const card = newCard(header);
+    card.body.elements.push({ tag: 'markdown', content: '' });
+    return card;
+}
+/**
+ * Split a Markdown block's source into pieces whose UTF-8 byte length each
+ * stays at or under `byteBudget`. The input is one block's `raw` field from
+ * `marked.lexer`, so the block kind drives the split strategy:
+ *
+ *   - A fenced code block (opens with ``` or ~~~ and closes with the same
+ *     run) is split by line and the open / close lines are repeated on
+ *     every piece, so each piece is itself a well-formed fenced block.
+ *   - Any other block is split at line boundaries; a single line longer
+ *     than the budget is split by grapheme cluster, so a ZWJ-bound emoji
+ *     cluster or a Hangul syllable is not cut in half.
+ *
+ * Every returned piece is non-empty and fits the budget — the caller can
+ * use them directly as `tag: markdown` element bodies.
+ */
+export function splitMarkdownByBytes(text, byteBudget) {
+    if (Buffer.byteLength(text, 'utf8') <= byteBudget)
+        return [text];
+    const fenceLineMatch = /^([`~]{3,}[^\n]*)\n([\s\S]*?)\n([`~]{3,})\s*$/.exec(text);
+    if (fenceLineMatch) {
+        const open = fenceLineMatch[1];
+        const body = fenceLineMatch[2];
+        const close = fenceLineMatch[3];
+        const overhead = Buffer.byteLength(open, 'utf8') + Buffer.byteLength(close, 'utf8') + 2; // two \n separators
+        const inner = Math.max(64, byteBudget - overhead);
+        const bodyPieces = splitLinesByBytes(body.split('\n'), inner);
+        return bodyPieces.map((piece) => [open, piece, close].join('\n'));
+    }
+    return splitLinesByBytes(text.split('\n'), byteBudget);
+}
+/**
+ * Pack consecutive lines into pieces that each fit `byteBudget`. A line
+ * larger than the budget on its own is split by grapheme cluster — never
+ * by code unit, since that risks cutting a UTF-8 sequence or a ZWJ-bound
+ * emoji cluster in half.
+ */
+function splitLinesByBytes(lines, byteBudget) {
+    const pieces = [];
+    let current = [];
+    let currentBytes = 0;
+    const flush = () => {
+        if (current.length === 0)
+            return;
+        pieces.push(current.join('\n'));
+        current = [];
+        currentBytes = 0;
+    };
+    for (const line of lines) {
+        const lineBytes = Buffer.byteLength(line, 'utf8');
+        const sepBytes = current.length === 0 ? 0 : 1; // joining newline
+        if (lineBytes + sepBytes + currentBytes <= byteBudget) {
+            current.push(line);
+            currentBytes += lineBytes + sepBytes;
+            continue;
+        }
+        // Adding this line would overflow the current piece.
+        flush();
+        if (lineBytes <= byteBudget) {
+            current.push(line);
+            currentBytes = lineBytes;
+            continue;
+        }
+        // The single line is itself larger than the budget — split it inside.
+        for (const sub of splitByGraphemeBytes(line, byteBudget)) {
+            pieces.push(sub);
+        }
+    }
+    flush();
+    return pieces;
+}
+/**
+ * Split one string into UTF-8 byte chunks at grapheme cluster boundaries.
+ * Walks `Intl.Segmenter`'s grapheme segments, accumulating bytes until the
+ * next grapheme would exceed `byteBudget`. A line of CJK characters or
+ * ZWJ-bound emoji clusters therefore splits without ever cutting a
+ * code-point or an emoji-cluster in half.
+ */
+function splitByGraphemeBytes(text, byteBudget) {
+    // `und` (undetermined locale) gives the Unicode default grapheme rules,
+    // which is what we want — clusters formed by combining marks, ZWJ, etc.
+    const segmenter = new Intl.Segmenter('und', { granularity: 'grapheme' });
+    const pieces = [];
+    let current = '';
+    let currentBytes = 0;
+    for (const { segment } of segmenter.segment(text)) {
+        const segBytes = Buffer.byteLength(segment, 'utf8');
+        if (currentBytes + segBytes > byteBudget) {
+            if (current.length > 0)
+                pieces.push(current);
+            current = segment;
+            currentBytes = segBytes;
+            continue;
+        }
+        current += segment;
+        currentBytes += segBytes;
+    }
+    if (current.length > 0)
+        pieces.push(current);
+    return pieces;
+}
+/**
+ * Split a too-big `tag: table` element into smaller tables by row. The
+ * header columns are repeated on each split half so every emitted table is
+ * independently readable; cell-size validation has already rejected a row
+ * whose cells alone make it too big to fit, so the row-count window can
+ * always shrink to a piece that fits.
+ */
+function splitTableByRows(table, headerOnFirstCard) {
+    if (table.rows.length <= 1)
+        return [table];
+    const envelope = cardContentBytes(newCardWithEmpty(headerOnFirstCard));
+    const budget = Math.max(2048, CARD_CONTENT_SAFE_BYTES - envelope - 256);
+    const out = [];
+    let start = 0;
+    while (start < table.rows.length) {
+        let end = table.rows.length;
+        while (end > start + 1) {
+            const candidate = { ...table, rows: table.rows.slice(start, end) };
+            if (Buffer.byteLength(JSON.stringify(candidate), 'utf8') <= budget)
+                break;
+            end -= 1;
+        }
+        out.push({ ...table, rows: table.rows.slice(start, end) });
+        if (end === start)
+            break;
+        start = end;
+    }
+    return out;
+}
+//# sourceMappingURL=render.js.map

package/dist/render/render.js.map

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