@composer-app/mcp 0.0.4-beta.2 → 0.0.5

package/dist/{chunk-D62LPVSX.js → chunk-IDX65B2W.js}

@@ -33,6 +33,9 @@ function getActivityMap(doc) {
 function getActivityStateMap(doc) {
   return doc.getMap("activityState");
 }
+function stateKey(activityId, userId) {
+  return `${activityId}:${userId}`;
+}
 function emitActivity(doc, event, opts) {
   if (opts?.silent) return;
   const activity = getActivityMap(doc);
@@ -65,6 +68,20 @@ function pruneIfOverCap(doc) {
     });
   }
 }
+function markActivityReadForThread(doc, threadId, userId) {
+  const activity = getActivityMap(doc);
+  const stateMap = getActivityStateMap(doc);
+  activity.forEach((value) => {
+    const event = value;
+    if (event.threadId === threadId) {
+      const key = stateKey(event.id, userId);
+      const existing = stateMap.get(key);
+      if (!existing?.read) {
+        stateMap.set(key, { read: true, dismissed: existing?.dismissed ?? false });
+      }
+    }
+  });
+}
 function textPreview(text, maxLen = 80) {
   if (!text) return void 0;
   return text.length > maxLen ? text.slice(0, maxLen) + "\u2026" : text;
@@ -358,29 +375,1187 @@ var removeAwarenessStates = (awareness, clients, origin) => {
           /** @type {MetaClientState} */
           awareness.meta.get(clientID)
         );
-        awareness.meta.set(clientID, {
-          clock: curMeta.clock + 1,
-          lastUpdated: getUnixTime()
-        });
+        awareness.meta.set(clientID, {
+          clock: curMeta.clock + 1,
+          lastUpdated: getUnixTime()
+        });
+      }
+      removed.push(clientID);
+    }
+  }
+  if (removed.length > 0) {
+    awareness.emit("change", [{ added: [], updated: [], removed }, origin]);
+    awareness.emit("update", [{ added: [], updated: [], removed }, origin]);
+  }
+};
+
+// src/roomState.ts
+import WebSocket from "ws";
+
+// ../shared/src/editor-extensions.ts
+import StarterKit from "@tiptap/starter-kit";
+import { Code } from "@tiptap/extension-code";
+import CodeBlock from "@tiptap/extension-code-block";
+
+// ../node_modules/@tiptap/extension-blockquote/dist/index.js
+import { mergeAttributes, Node, wrappingInputRule } from "@tiptap/core";
+import { jsx } from "@tiptap/core/jsx-runtime";
+var inputRegex = /^\s*>\s$/;
+var Blockquote = Node.create({
+  name: "blockquote",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "block+",
+  group: "block",
+  defining: true,
+  parseHTML() {
+    return [{ tag: "blockquote" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return /* @__PURE__ */ jsx("blockquote", { ...mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), children: /* @__PURE__ */ jsx("slot", {}) });
+  },
+  parseMarkdown: (token, helpers) => {
+    var _a;
+    const parseBlockChildren = (_a = helpers.parseBlockChildren) != null ? _a : helpers.parseChildren;
+    return helpers.createNode("blockquote", void 0, parseBlockChildren(token.tokens || []));
+  },
+  renderMarkdown: (node, h) => {
+    if (!node.content) {
+      return "";
+    }
+    const prefix = ">";
+    const result = [];
+    node.content.forEach((child, index) => {
+      var _a, _b;
+      const childContent = (_b = (_a = h.renderChild) == null ? void 0 : _a.call(h, child, index)) != null ? _b : h.renderChildren([child]);
+      const lines = childContent.split("\n");
+      const linesWithPrefix = lines.map((line) => {
+        if (line.trim() === "") {
+          return prefix;
+        }
+        return `${prefix} ${line}`;
+      });
+      result.push(linesWithPrefix.join("\n"));
+    });
+    return result.join(`
+${prefix}
+`);
+  },
+  addCommands() {
+    return {
+      setBlockquote: () => ({ commands }) => {
+        return commands.wrapIn(this.name);
+      },
+      toggleBlockquote: () => ({ commands }) => {
+        return commands.toggleWrap(this.name);
+      },
+      unsetBlockquote: () => ({ commands }) => {
+        return commands.lift(this.name);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-b": () => this.editor.commands.toggleBlockquote()
+    };
+  },
+  addInputRules() {
+    return [
+      wrappingInputRule({
+        find: inputRegex,
+        type: this.type
+      })
+    ];
+  }
+});
+
+// ../node_modules/@tiptap/extension-list/dist/index.js
+import { mergeAttributes as mergeAttributes2, Node as Node2, wrappingInputRule as wrappingInputRule2 } from "@tiptap/core";
+import { mergeAttributes as mergeAttributes22, Node as Node22, renderNestedMarkdownContent } from "@tiptap/core";
+import { Extension } from "@tiptap/core";
+import { getNodeType } from "@tiptap/core";
+import { getNodeAtPosition } from "@tiptap/core";
+import { isAtStartOfNode, isNodeActive } from "@tiptap/core";
+import { getNodeType as getNodeType2 } from "@tiptap/core";
+import { isAtEndOfNode, isNodeActive as isNodeActive2 } from "@tiptap/core";
+import { Extension as Extension2 } from "@tiptap/core";
+import { mergeAttributes as mergeAttributes3, Node as Node3, wrappingInputRule as wrappingInputRule22 } from "@tiptap/core";
+import {
+  getRenderedAttributes,
+  mergeAttributes as mergeAttributes4,
+  Node as Node4,
+  renderNestedMarkdownContent as renderNestedMarkdownContent2,
+  wrappingInputRule as wrappingInputRule3
+} from "@tiptap/core";
+import { mergeAttributes as mergeAttributes5, Node as Node5, parseIndentedBlocks } from "@tiptap/core";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var ListItemName = "listItem";
+var TextStyleName = "textStyle";
+var bulletListInputRegex = /^\s*([-+*])\s$/;
+var BulletList = Node2.create({
+  name: "bulletList",
+  addOptions() {
+    return {
+      itemTypeName: "listItem",
+      HTMLAttributes: {},
+      keepMarks: false,
+      keepAttributes: false
+    };
+  },
+  group: "block list",
+  content() {
+    return `${this.options.itemTypeName}+`;
+  },
+  parseHTML() {
+    return [{ tag: "ul" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["ul", mergeAttributes2(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  markdownTokenName: "list",
+  parseMarkdown: (token, helpers) => {
+    if (token.type !== "list" || token.ordered) {
+      return [];
+    }
+    return {
+      type: "bulletList",
+      content: token.items ? helpers.parseChildren(token.items) : []
+    };
+  },
+  renderMarkdown: (node, h) => {
+    if (!node.content) {
+      return "";
+    }
+    return h.renderChildren(node.content, "\n");
+  },
+  markdownOptions: {
+    indentsContent: true
+  },
+  addCommands() {
+    return {
+      toggleBulletList: () => ({ commands, chain }) => {
+        if (this.options.keepAttributes) {
+          return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItemName, this.editor.getAttributes(TextStyleName)).run();
+        }
+        return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-8": () => this.editor.commands.toggleBulletList()
+    };
+  },
+  addInputRules() {
+    let inputRule = wrappingInputRule2({
+      find: bulletListInputRegex,
+      type: this.type
+    });
+    if (this.options.keepMarks || this.options.keepAttributes) {
+      inputRule = wrappingInputRule2({
+        find: bulletListInputRegex,
+        type: this.type,
+        keepMarks: this.options.keepMarks,
+        keepAttributes: this.options.keepAttributes,
+        getAttributes: () => {
+          return this.editor.getAttributes(TextStyleName);
+        },
+        editor: this.editor
+      });
+    }
+    return [inputRule];
+  }
+});
+var ListItem = Node22.create({
+  name: "listItem",
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      bulletListTypeName: "bulletList",
+      orderedListTypeName: "orderedList"
+    };
+  },
+  content: "paragraph block*",
+  defining: true,
+  parseHTML() {
+    return [
+      {
+        tag: "li"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["li", mergeAttributes22(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  markdownTokenName: "list_item",
+  parseMarkdown: (token, helpers) => {
+    var _a;
+    if (token.type !== "list_item") {
+      return [];
+    }
+    const parseBlockChildren = (_a = helpers.parseBlockChildren) != null ? _a : helpers.parseChildren;
+    let content = [];
+    if (token.tokens && token.tokens.length > 0) {
+      const hasParagraphTokens = token.tokens.some((t) => t.type === "paragraph");
+      if (hasParagraphTokens) {
+        content = parseBlockChildren(token.tokens);
+      } else {
+        const firstToken = token.tokens[0];
+        if (firstToken && firstToken.type === "text" && firstToken.tokens && firstToken.tokens.length > 0) {
+          const inlineContent = helpers.parseInline(firstToken.tokens);
+          content = [
+            {
+              type: "paragraph",
+              content: inlineContent
+            }
+          ];
+          if (token.tokens.length > 1) {
+            const remainingTokens = token.tokens.slice(1);
+            const additionalContent = parseBlockChildren(remainingTokens);
+            content.push(...additionalContent);
+          }
+        } else {
+          content = parseBlockChildren(token.tokens);
+        }
+      }
+    }
+    if (content.length === 0) {
+      content = [
+        {
+          type: "paragraph",
+          content: []
+        }
+      ];
+    }
+    return {
+      type: "listItem",
+      content
+    };
+  },
+  renderMarkdown: (node, h, ctx) => {
+    return renderNestedMarkdownContent(
+      node,
+      h,
+      (context) => {
+        var _a, _b;
+        if (context.parentType === "bulletList") {
+          return "- ";
+        }
+        if (context.parentType === "orderedList") {
+          const start = ((_b = (_a = context.meta) == null ? void 0 : _a.parentAttrs) == null ? void 0 : _b.start) || 1;
+          return `${start + context.index}. `;
+        }
+        return "- ";
+      },
+      ctx
+    );
+  },
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => this.editor.commands.splitListItem(this.name),
+      Tab: () => this.editor.commands.sinkListItem(this.name),
+      "Shift-Tab": () => this.editor.commands.liftListItem(this.name)
+    };
+  }
+});
+var listHelpers_exports = {};
+__export(listHelpers_exports, {
+  findListItemPos: () => findListItemPos,
+  getNextListDepth: () => getNextListDepth,
+  handleBackspace: () => handleBackspace,
+  handleDelete: () => handleDelete,
+  hasListBefore: () => hasListBefore,
+  hasListItemAfter: () => hasListItemAfter,
+  hasListItemBefore: () => hasListItemBefore,
+  listItemHasSubList: () => listItemHasSubList,
+  nextListIsDeeper: () => nextListIsDeeper,
+  nextListIsHigher: () => nextListIsHigher
+});
+var findListItemPos = (typeOrName, state) => {
+  const { $from } = state.selection;
+  const nodeType = getNodeType(typeOrName, state.schema);
+  let currentNode = null;
+  let currentDepth = $from.depth;
+  let currentPos = $from.pos;
+  let targetDepth = null;
+  while (currentDepth > 0 && targetDepth === null) {
+    currentNode = $from.node(currentDepth);
+    if (currentNode.type === nodeType) {
+      targetDepth = currentDepth;
+    } else {
+      currentDepth -= 1;
+      currentPos -= 1;
+    }
+  }
+  if (targetDepth === null) {
+    return null;
+  }
+  return { $pos: state.doc.resolve(currentPos), depth: targetDepth };
+};
+var getNextListDepth = (typeOrName, state) => {
+  const listItemPos = findListItemPos(typeOrName, state);
+  if (!listItemPos) {
+    return false;
+  }
+  const [, depth] = getNodeAtPosition(state, typeOrName, listItemPos.$pos.pos + 4);
+  return depth;
+};
+var hasListBefore = (editorState, name, parentListTypes) => {
+  const { $anchor } = editorState.selection;
+  const previousNodePos = Math.max(0, $anchor.pos - 2);
+  const previousNode = editorState.doc.resolve(previousNodePos).node();
+  if (!previousNode || !parentListTypes.includes(previousNode.type.name)) {
+    return false;
+  }
+  return true;
+};
+var hasListItemBefore = (typeOrName, state) => {
+  var _a;
+  const { $anchor } = state.selection;
+  const $targetPos = state.doc.resolve($anchor.pos - 2);
+  if ($targetPos.index() === 0) {
+    return false;
+  }
+  if (((_a = $targetPos.nodeBefore) == null ? void 0 : _a.type.name) !== typeOrName) {
+    return false;
+  }
+  return true;
+};
+var listItemHasSubList = (typeOrName, state, node) => {
+  if (!node) {
+    return false;
+  }
+  const nodeType = getNodeType2(typeOrName, state.schema);
+  let hasSubList = false;
+  node.descendants((child) => {
+    if (child.type === nodeType) {
+      hasSubList = true;
+    }
+  });
+  return hasSubList;
+};
+var handleBackspace = (editor, name, parentListTypes) => {
+  if (editor.commands.undoInputRule()) {
+    return true;
+  }
+  if (editor.state.selection.from !== editor.state.selection.to) {
+    return false;
+  }
+  if (!isNodeActive(editor.state, name) && hasListBefore(editor.state, name, parentListTypes)) {
+    const { $anchor } = editor.state.selection;
+    const $listPos = editor.state.doc.resolve($anchor.before() - 1);
+    const listDescendants = [];
+    $listPos.node().descendants((node, pos) => {
+      if (node.type.name === name) {
+        listDescendants.push({ node, pos });
+      }
+    });
+    const lastItem = listDescendants.at(-1);
+    if (!lastItem) {
+      return false;
+    }
+    const $lastItemPos = editor.state.doc.resolve($listPos.start() + lastItem.pos + 1);
+    return editor.chain().cut({ from: $anchor.start() - 1, to: $anchor.end() + 1 }, $lastItemPos.end()).joinForward().run();
+  }
+  if (!isNodeActive(editor.state, name)) {
+    return false;
+  }
+  if (!isAtStartOfNode(editor.state)) {
+    return false;
+  }
+  const listItemPos = findListItemPos(name, editor.state);
+  if (!listItemPos) {
+    return false;
+  }
+  const $prev = editor.state.doc.resolve(listItemPos.$pos.pos - 2);
+  const prevNode = $prev.node(listItemPos.depth);
+  const previousListItemHasSubList = listItemHasSubList(name, editor.state, prevNode);
+  if (hasListItemBefore(name, editor.state) && !previousListItemHasSubList) {
+    return editor.commands.joinItemBackward();
+  }
+  return editor.chain().liftListItem(name).run();
+};
+var nextListIsDeeper = (typeOrName, state) => {
+  const listDepth = getNextListDepth(typeOrName, state);
+  const listItemPos = findListItemPos(typeOrName, state);
+  if (!listItemPos || !listDepth) {
+    return false;
+  }
+  if (listDepth > listItemPos.depth) {
+    return true;
+  }
+  return false;
+};
+var nextListIsHigher = (typeOrName, state) => {
+  const listDepth = getNextListDepth(typeOrName, state);
+  const listItemPos = findListItemPos(typeOrName, state);
+  if (!listItemPos || !listDepth) {
+    return false;
+  }
+  if (listDepth < listItemPos.depth) {
+    return true;
+  }
+  return false;
+};
+var handleDelete = (editor, name) => {
+  if (!isNodeActive2(editor.state, name)) {
+    return false;
+  }
+  if (!isAtEndOfNode(editor.state, name)) {
+    return false;
+  }
+  const { selection } = editor.state;
+  const { $from, $to } = selection;
+  if (!selection.empty && $from.sameParent($to)) {
+    return false;
+  }
+  if (nextListIsDeeper(name, editor.state)) {
+    return editor.chain().focus(editor.state.selection.from + 4).lift(name).joinBackward().run();
+  }
+  if (nextListIsHigher(name, editor.state)) {
+    return editor.chain().joinForward().joinBackward().run();
+  }
+  return editor.commands.joinItemForward();
+};
+var hasListItemAfter = (typeOrName, state) => {
+  var _a;
+  const { $anchor } = state.selection;
+  const $targetPos = state.doc.resolve($anchor.pos - $anchor.parentOffset - 2);
+  if ($targetPos.index() === $targetPos.parent.childCount - 1) {
+    return false;
+  }
+  if (((_a = $targetPos.nodeAfter) == null ? void 0 : _a.type.name) !== typeOrName) {
+    return false;
+  }
+  return true;
+};
+var ListKeymap = Extension.create({
+  name: "listKeymap",
+  addOptions() {
+    return {
+      listTypes: [
+        {
+          itemName: "listItem",
+          wrapperNames: ["bulletList", "orderedList"]
+        },
+        {
+          itemName: "taskItem",
+          wrapperNames: ["taskList"]
+        }
+      ]
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      Delete: ({ editor }) => {
+        let handled = false;
+        this.options.listTypes.forEach(({ itemName }) => {
+          if (editor.state.schema.nodes[itemName] === void 0) {
+            return;
+          }
+          if (handleDelete(editor, itemName)) {
+            handled = true;
+          }
+        });
+        return handled;
+      },
+      "Mod-Delete": ({ editor }) => {
+        let handled = false;
+        this.options.listTypes.forEach(({ itemName }) => {
+          if (editor.state.schema.nodes[itemName] === void 0) {
+            return;
+          }
+          if (handleDelete(editor, itemName)) {
+            handled = true;
+          }
+        });
+        return handled;
+      },
+      Backspace: ({ editor }) => {
+        let handled = false;
+        this.options.listTypes.forEach(({ itemName, wrapperNames }) => {
+          if (editor.state.schema.nodes[itemName] === void 0) {
+            return;
+          }
+          if (handleBackspace(editor, itemName, wrapperNames)) {
+            handled = true;
+          }
+        });
+        return handled;
+      },
+      "Mod-Backspace": ({ editor }) => {
+        let handled = false;
+        this.options.listTypes.forEach(({ itemName, wrapperNames }) => {
+          if (editor.state.schema.nodes[itemName] === void 0) {
+            return;
+          }
+          if (handleBackspace(editor, itemName, wrapperNames)) {
+            handled = true;
+          }
+        });
+        return handled;
+      }
+    };
+  }
+});
+var ORDERED_LIST_ITEM_REGEX = /^(\s*)(\d+)\.\s+(.*)$/;
+var INDENTED_LINE_REGEX = /^\s/;
+function isBlockContentLine(line) {
+  const trimmedLine = line.trimStart();
+  return /^[-+*]\s+/.test(trimmedLine) || /^\d+\.\s+/.test(trimmedLine) || /^>\s?/.test(trimmedLine) || /^```/.test(trimmedLine) || /^~~~/.test(trimmedLine);
+}
+function splitItemContent(contentLines) {
+  const paragraphLines = [];
+  const blockLines = [];
+  let reachedBlockBoundary = false;
+  contentLines.forEach((line) => {
+    if (reachedBlockBoundary) {
+      blockLines.push(line);
+      return;
+    }
+    if (line.trim() === "") {
+      reachedBlockBoundary = true;
+      blockLines.push(line);
+      return;
+    }
+    if (paragraphLines.length > 0 && isBlockContentLine(line)) {
+      reachedBlockBoundary = true;
+      blockLines.push(line);
+      return;
+    }
+    paragraphLines.push(line);
+  });
+  return {
+    paragraphLines,
+    blockLines
+  };
+}
+function collectOrderedListItems(lines) {
+  const listItems = [];
+  let currentLineIndex = 0;
+  let consumed = 0;
+  while (currentLineIndex < lines.length) {
+    const line = lines[currentLineIndex];
+    const match = line.match(ORDERED_LIST_ITEM_REGEX);
+    if (!match) {
+      break;
+    }
+    const [, indent, number, content] = match;
+    const indentLevel = indent.length;
+    const itemContentLines = [content];
+    let nextLineIndex = currentLineIndex + 1;
+    const itemLines = [line];
+    let sawBlankLine = false;
+    while (nextLineIndex < lines.length) {
+      const nextLine = lines[nextLineIndex];
+      const nextMatch = nextLine.match(ORDERED_LIST_ITEM_REGEX);
+      if (nextMatch) {
+        break;
+      }
+      if (nextLine.trim() === "") {
+        itemLines.push(nextLine);
+        itemContentLines.push("");
+        sawBlankLine = true;
+        nextLineIndex += 1;
+      } else if (nextLine.match(INDENTED_LINE_REGEX)) {
+        itemLines.push(nextLine);
+        itemContentLines.push(nextLine.slice(indentLevel + 2));
+        nextLineIndex += 1;
+      } else {
+        if (sawBlankLine) {
+          break;
+        }
+        itemLines.push(nextLine);
+        itemContentLines.push(nextLine);
+        nextLineIndex += 1;
+      }
+    }
+    listItems.push({
+      indent: indentLevel,
+      number: parseInt(number, 10),
+      content: itemContentLines.join("\n").trim(),
+      contentLines: itemContentLines,
+      raw: itemLines.join("\n")
+    });
+    consumed = nextLineIndex;
+    currentLineIndex = nextLineIndex;
+  }
+  return [listItems, consumed];
+}
+function buildNestedStructure(items, baseIndent, lexer) {
+  const result = [];
+  let currentIndex = 0;
+  while (currentIndex < items.length) {
+    const item = items[currentIndex];
+    if (item.indent === baseIndent) {
+      const { paragraphLines, blockLines } = splitItemContent(item.contentLines);
+      const mainText = paragraphLines.join("\n").trim();
+      const tokens = [];
+      if (mainText) {
+        tokens.push({
+          type: "paragraph",
+          raw: mainText,
+          tokens: lexer.inlineTokens(mainText)
+        });
+      }
+      const additionalContent = blockLines.join("\n").trim();
+      if (additionalContent) {
+        const blockTokens = lexer.blockTokens(additionalContent);
+        tokens.push(...blockTokens);
+      }
+      let lookAheadIndex = currentIndex + 1;
+      const nestedItems = [];
+      while (lookAheadIndex < items.length && items[lookAheadIndex].indent > baseIndent) {
+        nestedItems.push(items[lookAheadIndex]);
+        lookAheadIndex += 1;
+      }
+      if (nestedItems.length > 0) {
+        const nextIndent = Math.min(...nestedItems.map((nestedItem) => nestedItem.indent));
+        const nestedListItems = buildNestedStructure(nestedItems, nextIndent, lexer);
+        tokens.push({
+          type: "list",
+          ordered: true,
+          start: nestedItems[0].number,
+          items: nestedListItems,
+          raw: nestedItems.map((nestedItem) => nestedItem.raw).join("\n")
+        });
+      }
+      result.push({
+        type: "list_item",
+        raw: item.raw,
+        tokens
+      });
+      currentIndex = lookAheadIndex;
+    } else {
+      currentIndex += 1;
+    }
+  }
+  return result;
+}
+function parseListItems(items, helpers) {
+  return items.map((item) => {
+    if (item.type !== "list_item") {
+      return helpers.parseChildren([item])[0];
+    }
+    const content = [];
+    if (item.tokens && item.tokens.length > 0) {
+      item.tokens.forEach((itemToken) => {
+        if (itemToken.type === "paragraph" || itemToken.type === "list" || itemToken.type === "blockquote" || itemToken.type === "code") {
+          content.push(...helpers.parseChildren([itemToken]));
+        } else if (itemToken.type === "text" && itemToken.tokens) {
+          const inlineContent = helpers.parseChildren([itemToken]);
+          content.push({
+            type: "paragraph",
+            content: inlineContent
+          });
+        } else {
+          const parsed = helpers.parseChildren([itemToken]);
+          if (parsed.length > 0) {
+            content.push(...parsed);
+          }
+        }
+      });
+    }
+    return {
+      type: "listItem",
+      content
+    };
+  });
+}
+var ListItemName2 = "listItem";
+var TextStyleName2 = "textStyle";
+var orderedListInputRegex = /^(\d+)\.\s$/;
+var OrderedList = Node3.create({
+  name: "orderedList",
+  addOptions() {
+    return {
+      itemTypeName: "listItem",
+      HTMLAttributes: {},
+      keepMarks: false,
+      keepAttributes: false
+    };
+  },
+  group: "block list",
+  content() {
+    return `${this.options.itemTypeName}+`;
+  },
+  addAttributes() {
+    return {
+      start: {
+        default: 1,
+        parseHTML: (element) => {
+          return element.hasAttribute("start") ? parseInt(element.getAttribute("start") || "", 10) : 1;
+        }
+      },
+      type: {
+        default: null,
+        parseHTML: (element) => element.getAttribute("type")
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "ol"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    const { start, ...attributesWithoutStart } = HTMLAttributes;
+    return start === 1 ? ["ol", mergeAttributes3(this.options.HTMLAttributes, attributesWithoutStart), 0] : ["ol", mergeAttributes3(this.options.HTMLAttributes, HTMLAttributes), 0];
+  },
+  markdownTokenName: "list",
+  parseMarkdown: (token, helpers) => {
+    if (token.type !== "list" || !token.ordered) {
+      return [];
+    }
+    const startValue = token.start || 1;
+    const content = token.items ? parseListItems(token.items, helpers) : [];
+    if (startValue !== 1) {
+      return {
+        type: "orderedList",
+        attrs: { start: startValue },
+        content
+      };
+    }
+    return {
+      type: "orderedList",
+      content
+    };
+  },
+  renderMarkdown: (node, h) => {
+    if (!node.content) {
+      return "";
+    }
+    return h.renderChildren(node.content, "\n");
+  },
+  markdownTokenizer: {
+    name: "orderedList",
+    level: "block",
+    start: (src) => {
+      const match = src.match(/^(\s*)(\d+)\.\s+/);
+      const index = match == null ? void 0 : match.index;
+      return index !== void 0 ? index : -1;
+    },
+    tokenize: (src, _tokens, lexer) => {
+      var _a;
+      const lines = src.split("\n");
+      const [listItems, consumed] = collectOrderedListItems(lines);
+      if (listItems.length === 0) {
+        return void 0;
+      }
+      const items = buildNestedStructure(listItems, 0, lexer);
+      if (items.length === 0) {
+        return void 0;
+      }
+      const startValue = ((_a = listItems[0]) == null ? void 0 : _a.number) || 1;
+      return {
+        type: "list",
+        ordered: true,
+        start: startValue,
+        items,
+        raw: lines.slice(0, consumed).join("\n")
+      };
+    }
+  },
+  markdownOptions: {
+    indentsContent: true
+  },
+  addCommands() {
+    return {
+      toggleOrderedList: () => ({ commands, chain }) => {
+        if (this.options.keepAttributes) {
+          return chain().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ListItemName2, this.editor.getAttributes(TextStyleName2)).run();
+        }
+        return commands.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-7": () => this.editor.commands.toggleOrderedList()
+    };
+  },
+  addInputRules() {
+    let inputRule = wrappingInputRule22({
+      find: orderedListInputRegex,
+      type: this.type,
+      getAttributes: (match) => ({ start: +match[1] }),
+      joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1]
+    });
+    if (this.options.keepMarks || this.options.keepAttributes) {
+      inputRule = wrappingInputRule22({
+        find: orderedListInputRegex,
+        type: this.type,
+        keepMarks: this.options.keepMarks,
+        keepAttributes: this.options.keepAttributes,
+        getAttributes: (match) => ({ start: +match[1], ...this.editor.getAttributes(TextStyleName2) }),
+        joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1],
+        editor: this.editor
+      });
+    }
+    return [inputRule];
+  }
+});
+var inputRegex2 = /^\s*(\[([( |x])?\])\s$/;
+var TaskItem = Node4.create({
+  name: "taskItem",
+  addOptions() {
+    return {
+      nested: false,
+      HTMLAttributes: {},
+      taskListTypeName: "taskList",
+      a11y: void 0
+    };
+  },
+  content() {
+    return this.options.nested ? "paragraph block*" : "paragraph+";
+  },
+  defining: true,
+  addAttributes() {
+    return {
+      checked: {
+        default: false,
+        keepOnSplit: false,
+        parseHTML: (element) => {
+          const dataChecked = element.getAttribute("data-checked");
+          return dataChecked === "" || dataChecked === "true";
+        },
+        renderHTML: (attributes) => ({
+          "data-checked": attributes.checked
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: `li[data-type="${this.name}"]`,
+        priority: 51
+      }
+    ];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    return [
+      "li",
+      mergeAttributes4(this.options.HTMLAttributes, HTMLAttributes, {
+        "data-type": this.name
+      }),
+      [
+        "label",
+        [
+          "input",
+          {
+            type: "checkbox",
+            checked: node.attrs.checked ? "checked" : null
+          }
+        ],
+        ["span"]
+      ],
+      ["div", 0]
+    ];
+  },
+  parseMarkdown: (token, h) => {
+    const content = [];
+    if (token.tokens && token.tokens.length > 0) {
+      content.push(h.createNode("paragraph", {}, h.parseInline(token.tokens)));
+    } else if (token.text) {
+      content.push(h.createNode("paragraph", {}, [h.createNode("text", { text: token.text })]));
+    } else {
+      content.push(h.createNode("paragraph", {}, []));
+    }
+    if (token.nestedTokens && token.nestedTokens.length > 0) {
+      const nestedContent = h.parseChildren(token.nestedTokens);
+      content.push(...nestedContent);
+    }
+    return h.createNode("taskItem", { checked: token.checked || false }, content);
+  },
+  renderMarkdown: (node, h) => {
+    var _a;
+    const checkedChar = ((_a = node.attrs) == null ? void 0 : _a.checked) ? "x" : " ";
+    const prefix = `- [${checkedChar}] `;
+    return renderNestedMarkdownContent2(node, h, prefix);
+  },
+  addKeyboardShortcuts() {
+    const shortcuts = {
+      Enter: () => this.editor.commands.splitListItem(this.name),
+      "Shift-Tab": () => this.editor.commands.liftListItem(this.name)
+    };
+    if (!this.options.nested) {
+      return shortcuts;
+    }
+    return {
+      ...shortcuts,
+      Tab: () => this.editor.commands.sinkListItem(this.name)
+    };
+  },
+  addNodeView() {
+    return ({ node, HTMLAttributes, getPos, editor }) => {
+      const listItem = document.createElement("li");
+      const checkboxWrapper = document.createElement("label");
+      const checkboxStyler = document.createElement("span");
+      const checkbox = document.createElement("input");
+      const content = document.createElement("div");
+      const updateA11Y = (currentNode) => {
+        var _a, _b;
+        checkbox.ariaLabel = ((_b = (_a = this.options.a11y) == null ? void 0 : _a.checkboxLabel) == null ? void 0 : _b.call(_a, currentNode, checkbox.checked)) || `Task item checkbox for ${currentNode.textContent || "empty task item"}`;
+      };
+      updateA11Y(node);
+      checkboxWrapper.contentEditable = "false";
+      checkbox.type = "checkbox";
+      checkbox.addEventListener("mousedown", (event) => event.preventDefault());
+      checkbox.addEventListener("change", (event) => {
+        if (!editor.isEditable && !this.options.onReadOnlyChecked) {
+          checkbox.checked = !checkbox.checked;
+          return;
+        }
+        const { checked } = event.target;
+        if (editor.isEditable && typeof getPos === "function") {
+          editor.chain().focus(void 0, { scrollIntoView: false }).command(({ tr }) => {
+            const position = getPos();
+            if (typeof position !== "number") {
+              return false;
+            }
+            const currentNode = tr.doc.nodeAt(position);
+            tr.setNodeMarkup(position, void 0, {
+              ...currentNode == null ? void 0 : currentNode.attrs,
+              checked
+            });
+            return true;
+          }).run();
+        }
+        if (!editor.isEditable && this.options.onReadOnlyChecked) {
+          if (!this.options.onReadOnlyChecked(node, checked)) {
+            checkbox.checked = !checkbox.checked;
+          }
+        }
+      });
+      Object.entries(this.options.HTMLAttributes).forEach(([key, value]) => {
+        listItem.setAttribute(key, value);
+      });
+      listItem.dataset.checked = node.attrs.checked;
+      checkbox.checked = node.attrs.checked;
+      checkboxWrapper.append(checkbox, checkboxStyler);
+      listItem.append(checkboxWrapper, content);
+      Object.entries(HTMLAttributes).forEach(([key, value]) => {
+        listItem.setAttribute(key, value);
+      });
+      let prevRenderedAttributeKeys = new Set(Object.keys(HTMLAttributes));
+      return {
+        dom: listItem,
+        contentDOM: content,
+        update: (updatedNode) => {
+          if (updatedNode.type !== this.type) {
+            return false;
+          }
+          listItem.dataset.checked = updatedNode.attrs.checked;
+          checkbox.checked = updatedNode.attrs.checked;
+          updateA11Y(updatedNode);
+          const extensionAttributes = editor.extensionManager.attributes;
+          const newHTMLAttributes = getRenderedAttributes(updatedNode, extensionAttributes);
+          const newKeys = new Set(Object.keys(newHTMLAttributes));
+          const staticAttrs = this.options.HTMLAttributes;
+          prevRenderedAttributeKeys.forEach((key) => {
+            if (!newKeys.has(key)) {
+              if (key in staticAttrs) {
+                listItem.setAttribute(key, staticAttrs[key]);
+              } else {
+                listItem.removeAttribute(key);
+              }
+            }
+          });
+          Object.entries(newHTMLAttributes).forEach(([key, value]) => {
+            if (value === null || value === void 0) {
+              if (key in staticAttrs) {
+                listItem.setAttribute(key, staticAttrs[key]);
+              } else {
+                listItem.removeAttribute(key);
+              }
+            } else {
+              listItem.setAttribute(key, value);
+            }
+          });
+          prevRenderedAttributeKeys = newKeys;
+          return true;
+        }
+      };
+    };
+  },
+  addInputRules() {
+    return [
+      wrappingInputRule3({
+        find: inputRegex2,
+        type: this.type,
+        getAttributes: (match) => ({
+          checked: match[match.length - 1] === "x"
+        })
+      })
+    ];
+  }
+});
+var TaskList = Node5.create({
+  name: "taskList",
+  addOptions() {
+    return {
+      itemTypeName: "taskItem",
+      HTMLAttributes: {}
+    };
+  },
+  group: "block list",
+  content() {
+    return `${this.options.itemTypeName}+`;
+  },
+  parseHTML() {
+    return [
+      {
+        tag: `ul[data-type="${this.name}"]`,
+        priority: 51
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["ul", mergeAttributes5(this.options.HTMLAttributes, HTMLAttributes, { "data-type": this.name }), 0];
+  },
+  parseMarkdown: (token, h) => {
+    return h.createNode("taskList", {}, h.parseChildren(token.items || []));
+  },
+  renderMarkdown: (node, h) => {
+    if (!node.content) {
+      return "";
+    }
+    return h.renderChildren(node.content, "\n");
+  },
+  markdownTokenizer: {
+    name: "taskList",
+    level: "block",
+    start(src) {
+      var _a;
+      const index = (_a = src.match(/^\s*[-+*]\s+\[([ xX])\]\s+/)) == null ? void 0 : _a.index;
+      return index !== void 0 ? index : -1;
+    },
+    tokenize(src, tokens, lexer) {
+      const parseTaskListContent = (content) => {
+        const nestedResult = parseIndentedBlocks(
+          content,
+          {
+            itemPattern: /^(\s*)([-+*])\s+\[([ xX])\]\s+(.*)$/,
+            extractItemData: (match) => ({
+              indentLevel: match[1].length,
+              mainContent: match[4],
+              checked: match[3].toLowerCase() === "x"
+            }),
+            createToken: (data, nestedTokens) => ({
+              type: "taskItem",
+              raw: "",
+              mainContent: data.mainContent,
+              indentLevel: data.indentLevel,
+              checked: data.checked,
+              text: data.mainContent,
+              tokens: lexer.inlineTokens(data.mainContent),
+              nestedTokens
+            }),
+            // Allow recursive nesting
+            customNestedParser: parseTaskListContent
+          },
+          lexer
+        );
+        if (nestedResult) {
+          return [
+            {
+              type: "taskList",
+              raw: nestedResult.raw,
+              items: nestedResult.items
+            }
+          ];
+        }
+        return lexer.blockTokens(content);
+      };
+      const result = parseIndentedBlocks(
+        src,
+        {
+          itemPattern: /^(\s*)([-+*])\s+\[([ xX])\]\s+(.*)$/,
+          extractItemData: (match) => ({
+            indentLevel: match[1].length,
+            mainContent: match[4],
+            checked: match[3].toLowerCase() === "x"
+          }),
+          createToken: (data, nestedTokens) => ({
+            type: "taskItem",
+            raw: "",
+            mainContent: data.mainContent,
+            indentLevel: data.indentLevel,
+            checked: data.checked,
+            text: data.mainContent,
+            tokens: lexer.inlineTokens(data.mainContent),
+            nestedTokens
+          }),
+          // Use the recursive parser for nested content
+          customNestedParser: parseTaskListContent
+        },
+        lexer
+      );
+      if (!result) {
+        return void 0;
       }
-      removed.push(clientID);
+      return {
+        type: "taskList",
+        raw: result.raw,
+        items: result.items
+      };
     }
+  },
+  markdownOptions: {
+    indentsContent: true
+  },
+  addCommands() {
+    return {
+      toggleTaskList: () => ({ commands }) => {
+        return commands.toggleList(this.name, this.options.itemTypeName);
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-9": () => this.editor.commands.toggleTaskList()
+    };
   }
-  if (removed.length > 0) {
-    awareness.emit("change", [{ added: [], updated: [], removed }, origin]);
-    awareness.emit("update", [{ added: [], updated: [], removed }, origin]);
+});
+var ListKit = Extension2.create({
+  name: "listKit",
+  addExtensions() {
+    const extensions = [];
+    if (this.options.bulletList !== false) {
+      extensions.push(BulletList.configure(this.options.bulletList));
+    }
+    if (this.options.listItem !== false) {
+      extensions.push(ListItem.configure(this.options.listItem));
+    }
+    if (this.options.listKeymap !== false) {
+      extensions.push(ListKeymap.configure(this.options.listKeymap));
+    }
+    if (this.options.orderedList !== false) {
+      extensions.push(OrderedList.configure(this.options.orderedList));
+    }
+    if (this.options.taskItem !== false) {
+      extensions.push(TaskItem.configure(this.options.taskItem));
+    }
+    if (this.options.taskList !== false) {
+      extensions.push(TaskList.configure(this.options.taskList));
+    }
+    return extensions;
   }
-};
-
-// src/roomState.ts
-import WebSocket from "ws";
+});
 
 // ../shared/src/editor-extensions.ts
-import StarterKit from "@tiptap/starter-kit";
-import { Code } from "@tiptap/extension-code";
-import CodeBlock from "@tiptap/extension-code-block";
-import TaskList from "@tiptap/extension-task-list";
-import TaskItem from "@tiptap/extension-task-item";
+import TaskList2 from "@tiptap/extension-task-list";
+import TaskItem2 from "@tiptap/extension-task-item";
 import Highlight from "@tiptap/extension-highlight";
 import Subscript from "@tiptap/extension-subscript";
 import Superscript from "@tiptap/extension-superscript";
@@ -479,7 +1654,7 @@ var ImageBlockExtension = Image.extend({
 var imageBlockExtensions_default = ImageBlockExtension;
 
 // ../shared/src/videoBlockNode.ts
-import { Node, mergeAttributes } from "@tiptap/core";
+import { Node as Node6, mergeAttributes as mergeAttributes6 } from "@tiptap/core";
 
 // ../shared/src/embedParser.ts
 var YOUTUBE_HOSTS = /* @__PURE__ */ new Set([
@@ -581,7 +1756,7 @@ function detectVideoProvider(url) {
   }
 }
 var IFRAME_SANDBOX = "allow-scripts allow-same-origin allow-presentation allow-popups";
-var VideoBlockNode = Node.create({
+var VideoBlockNode = Node6.create({
   name: "videoBlock",
   group: "block",
   addOptions() {
@@ -696,7 +1871,7 @@ var VideoBlockNode = Node.create({
   renderHTML({ node, HTMLAttributes }) {
     const attrs = node.attrs;
     if (attrs.src) {
-      const merged = mergeAttributes(HTMLAttributes, {
+      const merged = mergeAttributes6(HTMLAttributes, {
         src: attrs.src,
         controls: ""
       });
@@ -707,7 +1882,7 @@ var VideoBlockNode = Node.create({
       return ["video", merged];
     }
     if (attrs.embedUrl) {
-      const merged = mergeAttributes(HTMLAttributes, {
+      const merged = mergeAttributes6(HTMLAttributes, {
         src: attrs.embedUrl,
         sandbox: IFRAME_SANDBOX,
         frameborder: "0",
@@ -720,7 +1895,7 @@ var VideoBlockNode = Node.create({
       }
       return ["iframe", merged];
     }
-    return ["div", mergeAttributes(HTMLAttributes, { "data-video-error": "missing-src" })];
+    return ["div", mergeAttributes6(HTMLAttributes, { "data-video-error": "missing-src" })];
   },
   /**
    * Link-first markdown serialization (Phase 2 Unit 3):
@@ -771,7 +1946,7 @@ function filenameFromUrl(url) {
 var videoBlockNode_default = VideoBlockNode;
 
 // ../shared/src/mediaKeyboardNav.ts
-import { Extension } from "@tiptap/core";
+import { Extension as Extension3 } from "@tiptap/core";
 
 // ../node_modules/prosemirror-model/dist/index.js
 function findDiffStart(a, b, pos) {
@@ -1805,7 +2980,7 @@ var NodeRange = class {
   }
 };
 var emptyAttrs = /* @__PURE__ */ Object.create(null);
-var Node2 = class _Node {
+var Node7 = class _Node {
   /**
   @internal
   */
@@ -2206,7 +3381,7 @@ var Node2 = class _Node {
     return node;
   }
 };
-Node2.prototype.text = void 0;
+Node7.prototype.text = void 0;
 function wrapMarks(marks, str) {
   for (let i = marks.length - 1; i >= 0; i--)
     str = marks[i].type.name + "(" + str + ")";
@@ -3846,7 +5021,7 @@ var MEDIA_NODE_TYPES = /* @__PURE__ */ new Set(["image", "videoBlock"]);
 function isMediaNodeSelection(sel) {
   return sel instanceof NodeSelection && MEDIA_NODE_TYPES.has(sel.node.type.name);
 }
-var MediaKeyboardNav = Extension.create({
+var MediaKeyboardNav = Extension3.create({
   name: "mediaKeyboardNav",
   addProseMirrorPlugins() {
     return [
@@ -3890,8 +5065,251 @@ var MediaKeyboardNav = Extension.create({
 });
 var mediaKeyboardNav_default = MediaKeyboardNav;
 
+// ../shared/src/inlineIconNode.ts
+import { Node as Node8, mergeAttributes as mergeAttributes7 } from "@tiptap/core";
+var INLINE_ICON_ALLOWLIST = [
+  "message-square-plus",
+  "pen-line"
+];
+function isInlineIconName(value) {
+  return INLINE_ICON_ALLOWLIST.includes(value);
+}
+var INLINE_ICON_NODE_NAME = "inlineIcon";
+var InlineIconNode = Node8.create({
+  name: INLINE_ICON_NODE_NAME,
+  group: "inline",
+  inline: true,
+  atom: true,
+  selectable: false,
+  addAttributes() {
+    return {
+      name: {
+        default: null,
+        parseHTML: (el) => {
+          const raw = el.getAttribute("data-icon");
+          return raw && isInlineIconName(raw) ? raw : null;
+        },
+        renderHTML: (attrs) => attrs.name ? { "data-icon": attrs.name } : {}
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: "span[data-inline-icon]" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "span",
+      mergeAttributes7(HTMLAttributes, {
+        "data-inline-icon": "true",
+        class: "inline-icon"
+      })
+    ];
+  },
+  renderMarkdown(node) {
+    const name = node.attrs?.name;
+    return name && isInlineIconName(name) ? `:icon[${name}]` : "";
+  }
+});
+
+// ../shared/src/markdown.ts
+import { getSchema } from "@tiptap/core";
+import { MarkdownManager } from "@tiptap/markdown";
+import {
+  prosemirrorJSONToYXmlFragment,
+  yXmlFragmentToProsemirrorJSON
+} from "@tiptap/y-tiptap";
+
+// ../shared/src/frontmatter.ts
+function extractFrontmatter(text) {
+  const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) return null;
+  return { yaml: match[1].trim(), body: match[2] };
+}
+
+// ../shared/src/markdown.ts
+var EMPTY_LIST_ITEM_SENTINEL = "<!-- composer-empty-list-item -->";
+function markdownToDocJSON(markdown, extensions = editorExtensions) {
+  const manager = new MarkdownManager({ extensions });
+  const parsed = manager.parse(markdown);
+  const doc = parsed && parsed.type === "doc" ? parsed : { type: "doc", content: parsed?.content ?? [] };
+  repairListItemSchema(doc);
+  return doc;
+}
+function repairListItemSchema(node) {
+  if (node.type === "listItem" || node.type === "taskItem") {
+    if (!node.content || node.content.length === 0) {
+      node.content = [{ type: "paragraph" }];
+      return;
+    }
+    if (node.content[0]?.type !== "paragraph") {
+      node.content = [{ type: "paragraph" }, ...node.content];
+    }
+    const first = node.content[0];
+    if (first?.type === "paragraph" && paragraphIsEmptyListItemSentinel(first)) {
+      node.content = [{ type: "paragraph" }, ...node.content.slice(1)];
+    }
+  }
+  if (node.content) {
+    for (const child of node.content) repairListItemSchema(child);
+  }
+}
+function paragraphIsEmptyListItemSentinel(paragraph) {
+  if (!paragraph.content || paragraph.content.length === 0) return false;
+  let sawSentinel = false;
+  for (const child of paragraph.content) {
+    if (child.type === "paragraph" && (!child.content || child.content.length === 0)) {
+      sawSentinel = true;
+      continue;
+    }
+    if (child.type !== "text") return false;
+    if (child.text === EMPTY_LIST_ITEM_SENTINEL) {
+      sawSentinel = true;
+      continue;
+    }
+    if ((child.text ?? "").trim() !== "") return false;
+  }
+  return sawSentinel;
+}
+function writeMarkdownToYFragment(fragment, markdown, extensions = editorExtensions) {
+  const doc = fragment.doc;
+  if (!doc) throw new Error("fragment must be attached to a Y.Doc");
+  const fm = extractFrontmatter(markdown);
+  const body = fm ? fm.body : markdown;
+  const schema = getSchema(extensions);
+  const bodyDoc = markdownToDocJSON(body, extensions);
+  const children = [];
+  if (fm) {
+    children.push({
+      type: "frontmatter",
+      attrs: { language: "yaml" },
+      content: fm.yaml ? [{ type: "text", text: fm.yaml }] : void 0
+    });
+  }
+  if (bodyDoc.content) children.push(...bodyDoc.content);
+  const fullDoc = { type: "doc", content: children };
+  doc.transact(() => {
+    prosemirrorJSONToYXmlFragment(schema, fullDoc, fragment);
+  });
+}
+function markdownFromYFragment(fragment, extensions = editorExtensions) {
+  const json = yXmlFragmentToProsemirrorJSON(fragment);
+  if (!json || !json.content || json.content.length === 0) return "";
+  const manager = new MarkdownManager({ extensions });
+  return manager.serialize(json);
+}
+
 // ../shared/src/editor-extensions.ts
 var CodeWithCombinableMarks = Code.extend({ excludes: "" });
+var markText = (node) => node.content?.[0]?.text ?? "";
+var SubscriptWithMarkdown = Subscript.extend({
+  renderMarkdown: (node) => `<sub>${markText(node)}</sub>`
+});
+var SuperscriptWithMarkdown = Superscript.extend({
+  renderMarkdown: (node) => `<sup>${markText(node)}</sup>`
+});
+var BlockquoteWithStableEmptyMarkdown = Blockquote.extend({
+  renderMarkdown: (node, h) => {
+    if (!node.content) return "";
+    const rendered = node.content.map((child, index) => {
+      const childContent = h.renderChild?.(child, index) ?? h.renderChildren([child]);
+      return childContent.split("\n").map((line) => line.trim() === "" ? ">" : `> ${line}`).join("\n");
+    });
+    const nonEmpty = rendered.filter((part) => part.replace(/^>\s*/gm, "").trim() !== "");
+    if (nonEmpty.length === 0) return "";
+    return nonEmpty.join("\n>\n");
+  }
+});
+function renderStableListItemMarkdown(node, h, ctx = {}) {
+  if (!node.content) return "";
+  const prefix = ctx.itemPrefix ?? (ctx.parentType === "orderedList" ? `${(ctx.meta?.parentAttrs?.start ?? 1) + (ctx.index ?? 0)}. ` : "- ");
+  const [content, ...children] = node.content;
+  const renderedMain = content ? h.renderChildren([content]) : "";
+  const mainContent = renderedMain.trim() === "" ? EMPTY_LIST_ITEM_SENTINEL : renderedMain;
+  let output = `${prefix}${mainContent}`;
+  for (const [index, child] of children.entries()) {
+    const childContent = h.renderChild?.(child, index + 1) ?? h.renderChildren([child]);
+    const indentedChild = childContent.split("\n").map((line) => h.indent(line || "")).join("\n");
+    output += child.type === "paragraph" ? `
+
+${indentedChild}` : `
+${indentedChild}`;
+  }
+  return output;
+}
+var ListItemWithStableEmptyMarkdown = ListItem.extend({
+  renderMarkdown: renderStableListItemMarkdown
+});
+var TaskItemWithStableEmptyMarkdown = TaskItem2.extend({
+  renderMarkdown: (node, h) => renderStableListItemMarkdown(node, h, {
+    itemPrefix: `- [${node.attrs?.checked ? "x" : " "}] `
+  })
+});
+function normalizeAlign(value) {
+  return value === "left" || value === "right" || value === "center" ? value : null;
+}
+function sanitizeCellText(raw) {
+  return raw.replace(/\r?\n/g, "<br>").replace(/\s+/g, " ").trim().replace(/\|/g, "\\|");
+}
+function renderTableCellSafeMarkdown(node, h) {
+  if (!node?.content || node.content.length === 0) return "";
+  const rows = [];
+  for (const rowNode of node.content) {
+    const cells = [];
+    for (const cellNode of rowNode.content ?? []) {
+      const children = cellNode.content;
+      let raw = "";
+      if (Array.isArray(children) && children.length > 1) {
+        raw = children.map((c) => sanitizeCellText(h.renderChildren(c))).join("<br>");
+      } else {
+        raw = sanitizeCellText(children ? h.renderChildren(children) : "");
+      }
+      cells.push({
+        text: raw,
+        isHeader: cellNode.type === "tableHeader",
+        align: normalizeAlign(cellNode.attrs?.align)
+      });
+    }
+    rows.push(cells);
+  }
+  const columnCount = rows.reduce((max, r) => Math.max(max, r.length), 0);
+  if (columnCount === 0) return "";
+  const colWidths = new Array(columnCount).fill(0);
+  for (const r of rows) {
+    for (let i = 0; i < columnCount; i += 1) {
+      const len = (r[i]?.text || "").length;
+      if (len > colWidths[i]) colWidths[i] = len;
+      if (colWidths[i] < 3) colWidths[i] = 3;
+    }
+  }
+  const pad = (s, width) => s + " ".repeat(Math.max(0, width - s.length));
+  const headerRow = rows[0];
+  const hasHeader = headerRow.some((c) => c.isHeader);
+  const colAlignments = new Array(columnCount).fill(null);
+  for (const r of rows) {
+    for (let i = 0; i < columnCount; i += 1) {
+      if (!colAlignments[i] && r[i]?.align) colAlignments[i] = r[i].align;
+    }
+  }
+  let out = "\n";
+  const headerTexts = new Array(columnCount).fill(0).map((_, i) => hasHeader ? headerRow[i]?.text || "" : "");
+  out += `| ${headerTexts.map((t, i) => pad(t, colWidths[i])).join(" | ")} |
+`;
+  out += `| ${colWidths.map((w, index) => {
+    const dashCount = Math.max(3, w);
+    const a = colAlignments[index];
+    if (a === "left") return `:${"-".repeat(dashCount)}`;
+    if (a === "right") return `${"-".repeat(dashCount)}:`;
+    if (a === "center") return `:${"-".repeat(dashCount)}:`;
+    return "-".repeat(dashCount);
+  }).join(" | ")} |
+`;
+  const body = hasHeader ? rows.slice(1) : rows;
+  for (const r of body) {
+    out += `| ${new Array(columnCount).fill(0).map((_, i) => pad(r[i]?.text || "", colWidths[i])).join(" | ")} |
+`;
+  }
+  return out;
+}
 var TableWithId = Table.extend({
   addAttributes() {
     return {
@@ -3902,7 +5320,8 @@ var TableWithId = Table.extend({
         renderHTML: (attrs) => attrs.tableId ? { "data-table-id": attrs.tableId } : {}
       }
     };
-  }
+  },
+  renderMarkdown: renderTableCellSafeMarkdown
 });
 var FrontmatterSchema = CodeBlock.extend({
   name: "frontmatter",
@@ -3920,10 +5339,13 @@ ${text}
 function buildEditorExtensions(opts = {}) {
   const table = opts.table ?? TableWithId;
   const frontmatter = opts.frontmatter ?? FrontmatterSchema;
+  const inlineIcon = opts.inlineIcon ?? InlineIconNode;
   return [
     StarterKit.configure({
       undoRedo: false,
+      blockquote: false,
       code: false,
+      listItem: false,
       link: {
         openOnClick: true,
         HTMLAttributes: { target: "_blank", rel: "noopener noreferrer" },
@@ -3931,14 +5353,16 @@ function buildEditorExtensions(opts = {}) {
       }
     }),
     CodeWithCombinableMarks,
+    BlockquoteWithStableEmptyMarkdown,
+    ListItemWithStableEmptyMarkdown,
     imageBlockExtensions_default.configure({ roomId: opts.roomId, awareness: opts.awareness }),
     videoBlockNode_default.configure({ roomId: opts.roomId, awareness: opts.awareness }),
     mediaKeyboardNav_default,
-    TaskList,
-    TaskItem.configure({ nested: true }),
+    TaskList2,
+    TaskItemWithStableEmptyMarkdown.configure({ nested: true }),
     Highlight,
-    Subscript,
-    Superscript,
+    SubscriptWithMarkdown,
+    SuperscriptWithMarkdown,
     table.configure({
       resizable: true,
       handleWidth: 5,
@@ -3949,59 +5373,12 @@ function buildEditorExtensions(opts = {}) {
     TableRow,
     TableCell,
     TableHeader,
-    frontmatter
+    frontmatter,
+    inlineIcon
   ];
 }
 var editorExtensions = buildEditorExtensions();
 
-// ../shared/src/frontmatter.ts
-function extractFrontmatter(text) {
-  const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
-  if (!match) return null;
-  return { yaml: match[1].trim(), body: match[2] };
-}
-
-// ../shared/src/markdown.ts
-import { getSchema } from "@tiptap/core";
-import { MarkdownManager } from "@tiptap/markdown";
-import {
-  prosemirrorJSONToYXmlFragment,
-  yXmlFragmentToProsemirrorJSON
-} from "@tiptap/y-tiptap";
-function markdownToDocJSON(markdown, extensions = editorExtensions) {
-  const manager = new MarkdownManager({ extensions });
-  const parsed = manager.parse(markdown);
-  if (parsed && parsed.type === "doc") return parsed;
-  return { type: "doc", content: parsed?.content ?? [] };
-}
-function writeMarkdownToYFragment(fragment, markdown, extensions = editorExtensions) {
-  const doc = fragment.doc;
-  if (!doc) throw new Error("fragment must be attached to a Y.Doc");
-  const fm = extractFrontmatter(markdown);
-  const body = fm ? fm.body : markdown;
-  const schema = getSchema(extensions);
-  const bodyDoc = markdownToDocJSON(body, extensions);
-  const children = [];
-  if (fm) {
-    children.push({
-      type: "frontmatter",
-      attrs: { language: "yaml" },
-      content: fm.yaml ? [{ type: "text", text: fm.yaml }] : void 0
-    });
-  }
-  if (bodyDoc.content) children.push(...bodyDoc.content);
-  const fullDoc = { type: "doc", content: children };
-  doc.transact(() => {
-    prosemirrorJSONToYXmlFragment(schema, fullDoc, fragment);
-  });
-}
-function markdownFromYFragment(fragment, extensions = editorExtensions) {
-  const json = yXmlFragmentToProsemirrorJSON(fragment);
-  if (!json || !json.content || json.content.length === 0) return "";
-  const manager = new MarkdownManager({ extensions });
-  return manager.serialize(json);
-}
-
 // ../shared/src/insertMedia.ts
 import { nanoid as nanoid2 } from "nanoid";
 
@@ -5615,6 +6992,27 @@ var TOOL_DEFS = [
       required: ["roomId", "threadId"]
     }
   },
+  {
+    name: "composer_list_threads",
+    description: 'List comment and suggestion threads in the room, with full reply history. Same per-thread shape as `composer_get_thread` minus `sectionMarkdown` (omitted so the payload stays tractable across many threads \u2014 call `composer_get_full_doc` or `composer_get_thread` for surrounding context). Sorted by `createdAt` ascending so the agent reads them in the order they were posted. Use when you need to harvest discussion across the whole doc \u2014 e.g. "the user asked questions in the doc and other people answered in comment threads, summarize the answers". Optional `kind` filter narrows to one type when suggestion churn or comment chatter would be noise. Optional `status` filter drives the "which threads are still open" audit AND is the primary lever for shrinking the payload: `"open"` excludes resolved comments and accepted/rejected suggestions, which accumulate for the room\'s whole lifetime (they are never deleted), so on a long-lived doc the default `"all"` can be large.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        roomId: { type: "string" },
+        kind: {
+          type: "string",
+          enum: ["comment", "suggestion", "all"],
+          description: 'Which thread kind to return. `"comment"` = Q&A / discussion threads only; `"suggestion"` = text-replacement proposals only; `"all"` (default) = both, with the `kind` field on each entry as the discriminator.'
+        },
+        status: {
+          type: "string",
+          enum: ["open", "resolved", "all"],
+          description: 'Lifecycle filter. `"open"` = unresolved comments + pending suggestions (a thread with no terminal marker counts as open). `"resolved"` = resolved comments + accepted/rejected suggestions. `"all"` (default) = no filter. Use `"open"` for the unresolved-threads audit and to keep the response small on busy docs.'
+        }
+      },
+      required: ["roomId"]
+    }
+  },
   {
     name: "composer_add_comment",
     description: "Post a new top-level comment anchored to a text span anywhere in the doc. Anchor is { headingId, textToFind, occurrence? }. Use this to flag something the user didn't ask about \u2014 cross-referencing related sections, raising a concern elsewhere in the doc, or seeding a thread on a new span. Use `composer_reply_comment` instead when continuing an existing thread. Accepts optional `state` (ack-first flow: post with `state: \"thinking\"` to start the live indicator immediately) and `mentions` (array of target userIds \u2014 the invoker's userId from the mention event payload, for the `@invoker` backlink).\n**`textToFind` matches the doc's stored text, not the markdown source.** Inline marks (`**bold**`, `*italic*`, `` `code` ``, `_emphasis_`, `~~strike~~`) are stored as Y.Marks \u2014 write plain text, no markers. Top-level blocks join with `\\n\\n`; list items have NO separator (three bullets `- a / - b / - c` are stored as `abc`). Copy from `Section as the matcher sees it` in any `text_not_found` error if unsure. Returns { id } on success or an isError result if the anchor cannot be resolved.",
@@ -6130,23 +7528,8 @@ function handleGetFullDoc(args) {
   const state = getOrError(roomId);
   return okResult({ markdown: serializeDocAsMarkdown(state.doc) });
 }
-function handleGetThread(args) {
-  const a = asObject(args);
-  const roomId = asString(a.roomId, "roomId");
-  const threadId = asString(a.threadId, "threadId");
-  const state = getOrError(roomId);
-  const commentRaw = state.doc.getMap("comments").get(threadId);
-  const suggestionRaw = state.doc.getMap("suggestions").get(threadId);
-  const raw = commentRaw ?? suggestionRaw;
-  if (!raw) {
-    return errorResult(`thread not found: ${threadId}`);
-  }
-  const kind = commentRaw ? "comment" : "suggestion";
-  const anchoredContext = resolveAnchoredContext(
-    state.doc,
-    raw.anchorFrom,
-    raw.anchorTo
-  );
+function shapeThread(doc, threadId, raw, kind, opts) {
+  const anchoredContext = resolveAnchoredContext(doc, raw.anchorFrom, raw.anchorTo);
   const replies = Array.isArray(raw.replies) ? raw.replies : [];
   const shapedReplies = replies.filter(
     (r) => !!r && typeof r === "object" && typeof r.id === "string" && typeof r.text === "string"
@@ -6159,7 +7542,7 @@ function handleGetThread(args) {
     mentions: Array.isArray(r.mentions) ? r.mentions.filter((m) => typeof m === "string") : void 0,
     createdAt: typeof r.createdAt === "number" ? r.createdAt : void 0
   }));
-  return okResult({
+  return {
     threadId,
     kind,
     body: typeof raw.text === "string" ? raw.text : void 0,
@@ -6175,9 +7558,72 @@ function handleGetThread(args) {
     anchoredText: anchoredContext.anchoredText,
     headingId: anchoredContext.headingId,
     headingText: anchoredContext.headingText,
-    sectionMarkdown: anchoredContext.sectionMarkdown,
+    sectionMarkdown: opts.includeSectionMarkdown ? anchoredContext.sectionMarkdown : void 0,
     replies: shapedReplies
+  };
+}
+function handleGetThread(args) {
+  const a = asObject(args);
+  const roomId = asString(a.roomId, "roomId");
+  const threadId = asString(a.threadId, "threadId");
+  const state = getOrError(roomId);
+  const commentRaw = state.doc.getMap("comments").get(threadId);
+  const suggestionRaw = state.doc.getMap("suggestions").get(threadId);
+  const raw = commentRaw ?? suggestionRaw;
+  if (!raw) {
+    return errorResult(`thread not found: ${threadId}`);
+  }
+  const kind = commentRaw ? "comment" : "suggestion";
+  return okResult(
+    shapeThread(state.doc, threadId, raw, kind, { includeSectionMarkdown: true })
+  );
+}
+function handleListThreads(args) {
+  const a = asObject(args);
+  const roomId = asString(a.roomId, "roomId");
+  const state = getOrError(roomId);
+  const kindArg = asOptionalString(a.kind, "kind") ?? "all";
+  if (kindArg !== "all" && kindArg !== "comment" && kindArg !== "suggestion") {
+    return errorResult(`kind must be one of "all", "comment", "suggestion" (got "${kindArg}")`);
+  }
+  const statusArg = asOptionalString(a.status, "status") ?? "all";
+  if (statusArg !== "all" && statusArg !== "open" && statusArg !== "resolved") {
+    return errorResult(`status must be one of "all", "open", "resolved" (got "${statusArg}")`);
+  }
+  const out = [];
+  if (kindArg === "all" || kindArg === "comment") {
+    const comments = state.doc.getMap("comments");
+    comments.forEach((raw, id) => {
+      if (raw && typeof raw === "object") {
+        out.push(shapeThread(state.doc, id, raw, "comment", {
+          includeSectionMarkdown: false
+        }));
+      }
+    });
+  }
+  if (kindArg === "all" || kindArg === "suggestion") {
+    const suggestions = state.doc.getMap("suggestions");
+    suggestions.forEach((raw, id) => {
+      if (raw && typeof raw === "object") {
+        out.push(shapeThread(state.doc, id, raw, "suggestion", {
+          includeSectionMarkdown: false
+        }));
+      }
+    });
+  }
+  if (statusArg !== "all") {
+    const isOpen = (t) => t.kind === "comment" ? t.resolved !== true : t.status === void 0 || t.status === "pending";
+    const wantOpen = statusArg === "open";
+    for (let i = out.length - 1; i >= 0; i--) {
+      if (isOpen(out[i]) !== wantOpen) out.splice(i, 1);
+    }
+  }
+  out.sort((a2, b) => {
+    const aT = a2.createdAt ?? Number.POSITIVE_INFINITY;
+    const bT = b.createdAt ?? Number.POSITIVE_INFINITY;
+    return aT - bT;
   });
+  return okResult({ threads: out });
 }
 function performAddComment(state, a) {
   const anchor = asAnchor(a.anchor);
@@ -6452,6 +7898,7 @@ function performResolveThread(state, a) {
       participantUserIds: getParticipantUserIds(existing),
       createdAt
     });
+    markActivityReadForThread(state.doc, threadId, state.identity.userId);
   });
   return okResult({ threadId, resolved: true });
 }
@@ -6624,6 +8071,8 @@ async function dispatchTool(name, args, signal) {
           return handleGetFullDoc(args);
         case "composer_get_thread":
           return handleGetThread(args);
+        case "composer_list_threads":
+          return handleListThreads(args);
         case "composer_add_comment":
           return handleAddComment(args);
         case "composer_reply_comment":