chat 4.14.0 → 4.16.0

package/dist/index.js

@@ -1,7 +1,9 @@
 import {
   Actions,
+  BaseFormatConverter,
   Button,
   Card,
+  CardLink,
   CardText,
   Divider,
   Field,
@@ -13,16 +15,51 @@ import {
   Section,
   Select,
   SelectOption,
+  Table,
   TextInput,
+  blockquote,
+  cardChildToFallbackText,
   cardToFallbackText,
+  codeBlock,
+  emphasis,
   fromReactElement,
   fromReactModalElement,
+  getNodeChildren,
+  getNodeValue,
+  inlineCode,
+  isBlockquoteNode,
   isCardElement,
+  isCodeNode,
+  isDeleteNode,
+  isEmphasisNode,
+  isInlineCodeNode,
   isJSX,
+  isLinkNode,
+  isListItemNode,
+  isListNode,
   isModalElement,
+  isParagraphNode,
+  isStrongNode,
+  isTableCellNode,
+  isTableNode,
+  isTableRowNode,
+  isTextNode,
+  link,
+  markdownToPlainText,
+  paragraph,
+  parseMarkdown,
+  root,
+  strikethrough,
+  stringifyMarkdown,
+  strong,
+  tableElementToAscii,
+  tableToAscii,
+  text,
   toCardElement,
-  toModalElement
-} from "./chunk-THM4ACIE.js";
+  toModalElement,
+  toPlainText,
+  walkAst
+} from "./chunk-7S5DLTN2.js";
 
 // src/channel.ts
 import { WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2, WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2 } from "@workflow/serde";
@@ -44,217 +81,6 @@ function hasChatSingleton() {
   return _singleton !== null;
 }
 
-// src/markdown.ts
-import { toString as mdastToString } from "mdast-util-to-string";
-import remarkGfm from "remark-gfm";
-import remarkParse from "remark-parse";
-import remarkStringify from "remark-stringify";
-import { unified } from "unified";
-function isTextNode(node) {
-  return node.type === "text";
-}
-function isParagraphNode(node) {
-  return node.type === "paragraph";
-}
-function isStrongNode(node) {
-  return node.type === "strong";
-}
-function isEmphasisNode(node) {
-  return node.type === "emphasis";
-}
-function isDeleteNode(node) {
-  return node.type === "delete";
-}
-function isInlineCodeNode(node) {
-  return node.type === "inlineCode";
-}
-function isCodeNode(node) {
-  return node.type === "code";
-}
-function isLinkNode(node) {
-  return node.type === "link";
-}
-function isBlockquoteNode(node) {
-  return node.type === "blockquote";
-}
-function isListNode(node) {
-  return node.type === "list";
-}
-function isListItemNode(node) {
-  return node.type === "listItem";
-}
-function getNodeChildren(node) {
-  if ("children" in node && Array.isArray(node.children)) {
-    return node.children;
-  }
-  return [];
-}
-function getNodeValue(node) {
-  if ("value" in node && typeof node.value === "string") {
-    return node.value;
-  }
-  return "";
-}
-function parseMarkdown(markdown) {
-  const processor = unified().use(remarkParse).use(remarkGfm);
-  return processor.parse(markdown);
-}
-function stringifyMarkdown(ast) {
-  const processor = unified().use(remarkStringify).use(remarkGfm);
-  return processor.stringify(ast);
-}
-function toPlainText(ast) {
-  return mdastToString(ast);
-}
-function markdownToPlainText(markdown) {
-  const ast = parseMarkdown(markdown);
-  return mdastToString(ast);
-}
-function walkAst(node, visitor) {
-  if ("children" in node && Array.isArray(node.children)) {
-    node.children = node.children.map((child) => {
-      const result = visitor(child);
-      if (result === null) {
-        return null;
-      }
-      return walkAst(result, visitor);
-    }).filter((n) => n !== null);
-  }
-  return node;
-}
-function text(value) {
-  return { type: "text", value };
-}
-function strong(children) {
-  return { type: "strong", children };
-}
-function emphasis(children) {
-  return { type: "emphasis", children };
-}
-function strikethrough(children) {
-  return { type: "delete", children };
-}
-function inlineCode(value) {
-  return { type: "inlineCode", value };
-}
-function codeBlock(value, lang) {
-  return { type: "code", value, lang };
-}
-function link(url, children, title) {
-  return { type: "link", url, children, title };
-}
-function blockquote(children) {
-  return { type: "blockquote", children };
-}
-function paragraph(children) {
-  return { type: "paragraph", children };
-}
-function root(children) {
-  return { type: "root", children };
-}
-var BaseFormatConverter = class {
-  /**
-   * Template method for implementing fromAst with a node converter.
-   * Iterates through AST children and converts each using the provided function.
-   * Joins results with double newlines (standard paragraph separation).
-   *
-   * @param ast - The AST to convert
-   * @param nodeConverter - Function to convert each Content node to string
-   * @returns Platform-formatted string
-   */
-  fromAstWithNodeConverter(ast, nodeConverter) {
-    const parts = [];
-    for (const node of ast.children) {
-      parts.push(nodeConverter(node));
-    }
-    return parts.join("\n\n");
-  }
-  extractPlainText(platformText) {
-    return toPlainText(this.toAst(platformText));
-  }
-  // Convenience methods for markdown string I/O
-  fromMarkdown(markdown) {
-    return this.fromAst(parseMarkdown(markdown));
-  }
-  toMarkdown(platformText) {
-    return stringifyMarkdown(this.toAst(platformText));
-  }
-  /** @deprecated Use extractPlainText instead */
-  toPlainText(platformText) {
-    return this.extractPlainText(platformText);
-  }
-  /**
-   * Convert a PostableMessage to platform format (text only).
-   * - string: passed through as raw text (no conversion)
-   * - { raw: string }: passed through as raw text (no conversion)
-   * - { markdown: string }: converted from markdown to platform format
-   * - { ast: Root }: converted from AST to platform format
-   * - { card: CardElement }: returns fallback text (cards should be handled by adapter)
-   * - CardElement: returns fallback text (cards should be handled by adapter)
-   *
-   * Note: For cards, adapters should check for card content first and render
-   * them using platform-specific card APIs, using this method only for fallback.
-   */
-  renderPostable(message) {
-    if (typeof message === "string") {
-      return message;
-    }
-    if ("raw" in message) {
-      return message.raw;
-    }
-    if ("markdown" in message) {
-      return this.fromMarkdown(message.markdown);
-    }
-    if ("ast" in message) {
-      return this.fromAst(message.ast);
-    }
-    if ("card" in message) {
-      return message.fallbackText || this.cardToFallbackText(message.card);
-    }
-    if ("type" in message && message.type === "card") {
-      return this.cardToFallbackText(message);
-    }
-    throw new Error("Invalid PostableMessage format");
-  }
-  /**
-   * Generate fallback text from a card element.
-   * Override in subclasses for platform-specific formatting.
-   */
-  cardToFallbackText(card) {
-    const parts = [];
-    if (card.title) {
-      parts.push(`**${card.title}**`);
-    }
-    if (card.subtitle) {
-      parts.push(card.subtitle);
-    }
-    for (const child of card.children) {
-      const text2 = this.cardChildToFallbackText(child);
-      if (text2) {
-        parts.push(text2);
-      }
-    }
-    return parts.join("\n");
-  }
-  /**
-   * Convert card child element to fallback text.
-   */
-  cardChildToFallbackText(child) {
-    switch (child.type) {
-      case "text":
-        return child.content;
-      case "fields":
-        return child.children.map((f) => `**${f.label}**: ${f.value}`).join("\n");
-      case "actions":
-        return null;
-      case "section":
-        return child.children.map((c) => this.cardChildToFallbackText(c)).filter(Boolean).join("\n");
-      default:
-        return null;
-    }
-  }
-};
-
 // src/message.ts
 import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "@workflow/serde";
 var Message = class _Message {
@@ -786,6 +612,233 @@ function extractMessageContent(message) {
 
 // src/thread.ts
 import { WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3, WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3 } from "@workflow/serde";
+
+// src/streaming-markdown.ts
+import remend from "remend";
+var StreamingMarkdownRenderer = class {
+  accumulated = "";
+  dirty = true;
+  cachedRender = "";
+  finished = false;
+  /** Number of code fence toggles from completed lines (odd = inside). */
+  fenceToggles = 0;
+  /** Incomplete trailing line buffer for incremental fence tracking. */
+  incompleteLine = "";
+  /** Append a chunk from the LLM stream. */
+  push(chunk) {
+    this.accumulated += chunk;
+    this.dirty = true;
+    this.incompleteLine += chunk;
+    const parts = this.incompleteLine.split("\n");
+    this.incompleteLine = parts.pop() ?? "";
+    for (const line of parts) {
+      const trimmed = line.trimStart();
+      if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+        this.fenceToggles++;
+      }
+    }
+  }
+  /** O(1) check if accumulated text is inside an unclosed code fence. */
+  isAccumulatedInsideFence() {
+    let inside = this.fenceToggles % 2 === 1;
+    const trimmed = this.incompleteLine.trimStart();
+    if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+      inside = !inside;
+    }
+    return inside;
+  }
+  /**
+   * Get renderable markdown for an intermediate edit.
+   * - Holds back trailing lines that look like a table header (|...|)
+   *   until a separator line (|---|---|) confirms or the next line denies.
+   * - Applies remend() to close incomplete inline markers.
+   * - Idempotent: returns cached result if no push() since last call.
+   */
+  render() {
+    if (!this.dirty) {
+      return this.cachedRender;
+    }
+    this.dirty = false;
+    if (this.finished) {
+      this.cachedRender = remend(this.accumulated);
+      return this.cachedRender;
+    }
+    if (this.isAccumulatedInsideFence()) {
+      this.cachedRender = remend(this.accumulated);
+      return this.cachedRender;
+    }
+    const committable = getCommittablePrefix(this.accumulated);
+    this.cachedRender = remend(committable);
+    return this.cachedRender;
+  }
+  /**
+   * Get text safe for append-only streaming (e.g. Slack native streaming).
+   *
+   * - Holds back unconfirmed table headers until separator arrives.
+   * - Wraps confirmed tables in code fences so pipes render as literal
+   *   text (not broken mrkdwn). The code fence is left OPEN while
+   *   the table is still streaming, keeping output monotonic for deltas.
+   * - Holds back unclosed inline markers (**, *, ~~, `, [).
+   * - The final editMessage replaces everything with properly formatted text.
+   */
+  getCommittableText() {
+    if (this.finished) {
+      return wrapTablesForAppend(this.accumulated, true);
+    }
+    let text2 = this.accumulated;
+    if (text2.length > 0 && !text2.endsWith("\n")) {
+      const lastNewline = text2.lastIndexOf("\n");
+      const withoutIncompleteLine = lastNewline >= 0 ? text2.slice(0, lastNewline + 1) : "";
+      if (isInsideCodeFence(withoutIncompleteLine)) {
+        return wrapTablesForAppend(text2);
+      }
+      text2 = withoutIncompleteLine;
+    }
+    if (isInsideCodeFence(text2)) {
+      return wrapTablesForAppend(text2);
+    }
+    const committed = getCommittablePrefix(text2);
+    const wrapped = wrapTablesForAppend(committed);
+    if (isInsideCodeFence(wrapped)) {
+      return wrapped;
+    }
+    return findCleanPrefix(wrapped);
+  }
+  /** Raw accumulated text (no remend, no buffering). For the final edit. */
+  getText() {
+    return this.accumulated;
+  }
+  /** Signal stream end. Flushes held-back lines. Returns final render. */
+  finish() {
+    this.finished = true;
+    this.dirty = true;
+    return this.render();
+  }
+};
+var INLINE_MARKER_CHARS = /* @__PURE__ */ new Set(["*", "~", "`", "["]);
+function isClean(text2) {
+  return remend(text2).length <= text2.length;
+}
+function findCleanPrefix(text2) {
+  if (text2.length === 0 || isClean(text2)) {
+    return text2;
+  }
+  for (let i = text2.length - 1; i >= 0; i--) {
+    if (INLINE_MARKER_CHARS.has(text2[i])) {
+      while (i > 0 && text2[i - 1] === text2[i]) {
+        i--;
+      }
+      const candidate = text2.slice(0, i);
+      if (isClean(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return "";
+}
+var TABLE_ROW_RE = /^\|.*\|$/;
+var TABLE_SEPARATOR_RE = /^\|[\s:]*-{1,}[\s:]*(\|[\s:]*-{1,}[\s:]*)*\|$/;
+function isInsideCodeFence(text2) {
+  let inside = false;
+  for (const line of text2.split("\n")) {
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith("```") || trimmed.startsWith("~~~")) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}
+function getCommittablePrefix(text2) {
+  const endsWithNewline = text2.endsWith("\n");
+  const lines = text2.split("\n");
+  if (!endsWithNewline && lines.length > 0) {
+    lines.pop();
+  }
+  if (endsWithNewline && lines.length > 0 && lines.at(-1) === "") {
+    lines.pop();
+  }
+  let heldCount = 0;
+  let separatorFound = false;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const trimmed = lines[i].trim();
+    if (trimmed === "") {
+      break;
+    }
+    if (TABLE_SEPARATOR_RE.test(trimmed)) {
+      separatorFound = true;
+      break;
+    }
+    if (TABLE_ROW_RE.test(trimmed)) {
+      heldCount++;
+    } else {
+      break;
+    }
+  }
+  if (separatorFound || heldCount === 0) {
+    return text2;
+  }
+  const commitLineCount = lines.length - heldCount;
+  const committedLines = lines.slice(0, commitLineCount);
+  let result = committedLines.join("\n");
+  if (committedLines.length > 0) {
+    result += "\n";
+  }
+  return result;
+}
+function wrapTablesForAppend(text2, closeFences = false) {
+  const hadTrailingNewline = text2.endsWith("\n");
+  const lines = text2.split("\n");
+  if (hadTrailingNewline && lines.length > 0 && lines.at(-1) === "") {
+    lines.pop();
+  }
+  const result = [];
+  let inTable = false;
+  let inUserCodeFence = false;
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!inTable && (trimmed.startsWith("```") || trimmed.startsWith("~~~"))) {
+      inUserCodeFence = !inUserCodeFence;
+      result.push(lines[i]);
+      continue;
+    }
+    if (inUserCodeFence) {
+      result.push(lines[i]);
+      continue;
+    }
+    const isTableLine = trimmed !== "" && (TABLE_ROW_RE.test(trimmed) || TABLE_SEPARATOR_RE.test(trimmed));
+    if (isTableLine && !inTable) {
+      let hasSeparator = false;
+      for (let j = i; j < lines.length; j++) {
+        const t = lines[j].trim();
+        if (TABLE_SEPARATOR_RE.test(t)) {
+          hasSeparator = true;
+          break;
+        }
+        if (t === "" || !TABLE_ROW_RE.test(t)) {
+          break;
+        }
+      }
+      if (hasSeparator) {
+        result.push("```");
+        inTable = true;
+      }
+    } else if (!isTableLine && inTable) {
+      result.push("```");
+      inTable = false;
+    }
+    result.push(lines[i]);
+  }
+  if (inTable && closeFences) {
+    result.push("```");
+  }
+  let output = result.join("\n");
+  if (hadTrailingNewline) {
+    output += "\n";
+  }
+  return output;
+}
+
+// src/thread.ts
 function isLazyConfig2(config) {
   return "adapterName" in config && !("adapter" in config);
 }
@@ -809,6 +862,8 @@ var ThreadImpl = class _ThreadImpl {
   _currentMessage;
   /** Update interval for fallback streaming */
   _streamingUpdateIntervalMs;
+  /** Placeholder text for fallback streaming (post + edit) */
+  _fallbackStreamingPlaceholderText;
   /** Cached channel instance */
   _channel;
   constructor(config) {
@@ -818,6 +873,7 @@ var ThreadImpl = class _ThreadImpl {
     this._isSubscribedContext = config.isSubscribedContext ?? false;
     this._currentMessage = config.currentMessage;
     this._streamingUpdateIntervalMs = config.streamingUpdateIntervalMs ?? 500;
+    this._fallbackStreamingPlaceholderText = config.fallbackStreamingPlaceholderText !== void 0 ? config.fallbackStreamingPlaceholderText : "...";
     if (isLazyConfig2(config)) {
       this._adapterName = config.adapterName;
     } else {
@@ -1050,7 +1106,11 @@ var ThreadImpl = class _ThreadImpl {
         }
       };
       const raw = await this.adapter.stream(this.id, wrappedStream, options);
-      return this.createSentMessage(raw.id, accumulated, raw.threadId);
+      return this.createSentMessage(
+        raw.id,
+        { markdown: accumulated },
+        raw.threadId
+      );
     }
     return this.fallbackStream(textStream, options);
   }
@@ -1065,37 +1125,56 @@ var ThreadImpl = class _ThreadImpl {
    */
   async fallbackStream(textStream, options) {
     const intervalMs = options?.updateIntervalMs ?? this._streamingUpdateIntervalMs;
-    const msg = await this.adapter.postMessage(this.id, "...");
-    const threadIdForEdits = msg.threadId || this.id;
-    let accumulated = "";
-    let lastEditContent = "...";
+    const placeholderText = this._fallbackStreamingPlaceholderText;
+    let msg = placeholderText === null ? null : await this.adapter.postMessage(this.id, placeholderText);
+    let threadIdForEdits = this.id;
+    const renderer = new StreamingMarkdownRenderer();
+    let lastEditContent = "";
     let stopped = false;
     let pendingEdit = null;
     let timerId = null;
+    if (msg) {
+      threadIdForEdits = msg.threadId || this.id;
+      lastEditContent = placeholderText ?? "";
+    }
+    const scheduleNextEdit = () => {
+      timerId = setTimeout(() => {
+        pendingEdit = doEditAndReschedule();
+      }, intervalMs);
+    };
     const doEditAndReschedule = async () => {
-      if (stopped) {
+      if (stopped || !msg) {
         return;
       }
-      if (accumulated !== lastEditContent) {
-        const content = accumulated;
+      const content = renderer.render();
+      if (content !== lastEditContent) {
         try {
-          await this.adapter.editMessage(threadIdForEdits, msg.id, content);
+          await this.adapter.editMessage(threadIdForEdits, msg.id, {
+            markdown: content
+          });
           lastEditContent = content;
         } catch {
         }
       }
       if (!stopped) {
-        timerId = setTimeout(() => {
-          pendingEdit = doEditAndReschedule();
-        }, intervalMs);
+        scheduleNextEdit();
       }
     };
-    timerId = setTimeout(() => {
-      pendingEdit = doEditAndReschedule();
-    }, intervalMs);
+    if (msg) {
+      scheduleNextEdit();
+    }
     try {
       for await (const chunk of textStream) {
-        accumulated += chunk;
+        renderer.push(chunk);
+        if (!msg) {
+          const content = renderer.render();
+          msg = await this.adapter.postMessage(this.id, {
+            markdown: content
+          });
+          threadIdForEdits = msg.threadId || this.id;
+          lastEditContent = content;
+          scheduleNextEdit();
+        }
       }
     } finally {
       stopped = true;
@@ -1107,10 +1186,25 @@ var ThreadImpl = class _ThreadImpl {
     if (pendingEdit) {
       await pendingEdit;
     }
-    if (accumulated !== lastEditContent) {
-      await this.adapter.editMessage(threadIdForEdits, msg.id, accumulated);
+    const accumulated = renderer.getText();
+    const finalContent = renderer.finish();
+    if (!msg) {
+      msg = await this.adapter.postMessage(this.id, {
+        markdown: accumulated
+      });
+      threadIdForEdits = msg.threadId || this.id;
+      lastEditContent = accumulated;
     }
-    return this.createSentMessage(msg.id, accumulated, threadIdForEdits);
+    if (finalContent !== lastEditContent) {
+      await this.adapter.editMessage(threadIdForEdits, msg.id, {
+        markdown: accumulated
+      });
+    }
+    return this.createSentMessage(
+      msg.id,
+      { markdown: accumulated },
+      threadIdForEdits
+    );
   }
   async refresh() {
     const result = await this.adapter.fetchMessages(this.id, { limit: 50 });
@@ -1330,7 +1424,7 @@ function extractMessageContent2(message) {
 var DEFAULT_LOCK_TTL_MS = 3e4;
 var SLACK_USER_ID_REGEX = /^U[A-Z0-9]+$/i;
 var DISCORD_SNOWFLAKE_REGEX = /^\d{17,19}$/;
-var DEDUPE_TTL_MS = 6e4;
+var DEDUPE_TTL_MS = 5 * 60 * 1e3;
 var MODAL_CONTEXT_TTL_MS = 24 * 60 * 60 * 1e3;
 var Chat = class {
   /**
@@ -1368,6 +1462,8 @@ var Chat = class {
   userName;
   logger;
   _streamingUpdateIntervalMs;
+  _fallbackStreamingPlaceholderText;
+  _dedupeTtlMs;
   mentionHandlers = [];
   messagePatterns = [];
   subscribedMessageHandlers = [];
@@ -1379,6 +1475,7 @@ var Chat = class {
   assistantThreadStartedHandlers = [];
   assistantContextChangedHandlers = [];
   appHomeOpenedHandlers = [];
+  memberJoinedChannelHandlers = [];
   /** Initialization state */
   initPromise = null;
   initialized = false;
@@ -1393,6 +1490,8 @@ var Chat = class {
     this._stateAdapter = config.state;
     this.adapters = /* @__PURE__ */ new Map();
     this._streamingUpdateIntervalMs = config.streamingUpdateIntervalMs ?? 500;
+    this._fallbackStreamingPlaceholderText = config.fallbackStreamingPlaceholderText !== void 0 ? config.fallbackStreamingPlaceholderText : "...";
+    this._dedupeTtlMs = config.dedupeTtlMs ?? DEDUPE_TTL_MS;
     if (typeof config.logger === "string") {
       this.logger = new ConsoleLogger(config.logger);
     } else {
@@ -1623,6 +1722,10 @@ var Chat = class {
     this.appHomeOpenedHandlers.push(handler);
     this.logger.debug("Registered app home opened handler");
   }
+  onMemberJoinedChannel(handler) {
+    this.memberJoinedChannelHandlers.push(handler);
+    this.logger.debug("Registered member joined channel handler");
+  }
   /**
    * Get an adapter by name with type safety.
    */
@@ -1824,6 +1927,22 @@ var Chat = class {
       options.waitUntil(task);
     }
   }
+  processMemberJoinedChannel(event, options) {
+    const task = (async () => {
+      for (const handler of this.memberJoinedChannelHandlers) {
+        await handler(event);
+      }
+    })().catch((err) => {
+      this.logger.error("Member joined channel handler error", {
+        error: err,
+        channelId: event.channelId,
+        userId: event.userId
+      });
+    });
+    if (options?.waitUntil) {
+      options.waitUntil(task);
+    }
+  }
   /**
    * Handle a slash command event internally.
    */
@@ -2299,7 +2418,7 @@ var Chat = class {
       });
       return;
     }
-    await this._stateAdapter.set(dedupeKey, true, DEDUPE_TTL_MS);
+    await this._stateAdapter.set(dedupeKey, true, this._dedupeTtlMs);
     const lock = await this._stateAdapter.acquireLock(
       threadId,
       DEFAULT_LOCK_TTL_MS
@@ -2386,7 +2505,8 @@ var Chat = class {
       isSubscribedContext,
       isDM,
       currentMessage: initialMessage,
-      streamingUpdateIntervalMs: this._streamingUpdateIntervalMs
+      streamingUpdateIntervalMs: this._streamingUpdateIntervalMs,
+      fallbackStreamingPlaceholderText: this._fallbackStreamingPlaceholderText
     });
   }
   /**
@@ -2822,6 +2942,8 @@ var emoji = createEmoji();
 var Actions2 = Actions;
 var Button2 = Button;
 var Card2 = Card;
+var cardChildToFallbackText2 = cardChildToFallbackText;
+var CardLink2 = CardLink;
 var CardText2 = CardText;
 var Divider2 = Divider;
 var Field2 = Field;
@@ -2832,6 +2954,7 @@ var isCardElement2 = isCardElement;
 var isJSX2 = isJSX;
 var LinkButton2 = LinkButton;
 var Section2 = Section;
+var Table2 = Table;
 var toCardElement2 = toCardElement;
 var toModalElement2 = toModalElement;
 var fromReactModalElement2 = fromReactModalElement;
@@ -2846,6 +2969,7 @@ export {
   BaseFormatConverter,
   Button2 as Button,
   Card2 as Card,
+  CardLink2 as CardLink,
   CardText2 as CardText,
   ChannelImpl,
   Chat,
@@ -2867,10 +2991,13 @@ export {
   Section2 as Section,
   Select2 as Select,
   SelectOption2 as SelectOption,
+  StreamingMarkdownRenderer,
   THREAD_STATE_TTL_MS,
+  Table2 as Table,
   TextInput2 as TextInput,
   ThreadImpl,
   blockquote,
+  cardChildToFallbackText2 as cardChildToFallbackText,
   codeBlock,
   convertEmojiPlaceholders,
   createEmoji,
@@ -2897,6 +3024,9 @@ export {
   isModalElement2 as isModalElement,
   isParagraphNode,
   isStrongNode,
+  isTableCellNode,
+  isTableNode,
+  isTableRowNode,
   isTextNode,
   link,
   markdownToPlainText,
@@ -2906,6 +3036,8 @@ export {
   strikethrough,
   stringifyMarkdown,
   strong,
+  tableElementToAscii,
+  tableToAscii,
   text,
   toCardElement2 as toCardElement,
   toModalElement2 as toModalElement,