fix exponential backtracking in regex

* fix placeholder check

* tiptap v3.29.2

* add s3 max socket env

.npmrc

@@ -1 +0,0 @@
-shamefully-hoist = true

Dockerfile

@@ -1,7 +1,7 @@
-FROM node:22-slim AS base
+FROM node:26-slim AS base
 LABEL org.opencontainers.image.source="https://github.com/docmost/docmost"
 
-RUN npm install -g pnpm@10.4.0
+RUN npm install -g pnpm@11.15.1
 
 FROM base AS builder
 
@@ -34,7 +34,6 @@ COPY --from=builder /app/packages/base-formula/package.json /app/packages/base-f
 # Copy root package files
 COPY --from=builder /app/package.json /app/package.json
 COPY --from=builder /app/pnpm*.yaml /app/
-COPY --from=builder /app/.npmrc /app/.npmrc
 
 # Copy patches
 COPY --from=builder /app/patches /app/patches

apps/client/package.json

@@ -36,7 +36,7 @@
     "@tanstack/react-table": "8.21.3",
     "@tanstack/react-virtual": "3.14.3",
     "alfaaz": "1.1.0",
-    "axios": "1.16.0",
+    "axios": "1.18.1",
     "blueimp-load-image": "5.16.0",
     "clsx": "2.1.1",
     "file-saver": "2.0.5",

apps/client/src/features/editor/collab-socket.ts

@@ -0,0 +1,46 @@
+import {
+  HocuspocusProviderWebsocket,
+  WebSocketStatus,
+} from "@hocuspocus/provider";
+import { getCollaborationUrl } from "@/lib/config.ts";
+
+const RELEASE_GRACE_MS = 5000;
+
+let socket: HocuspocusProviderWebsocket | null = null;
+let editorCount = 0;
+let releaseTimer: ReturnType<typeof setTimeout> | null = null;
+
+export function getCollabSocket(): HocuspocusProviderWebsocket {
+  if (!socket) {
+    socket = new HocuspocusProviderWebsocket({
+      url: getCollaborationUrl(),
+      autoConnect: false,
+    });
+  }
+  return socket;
+}
+
+export function acquireCollabSocket(): void {
+  editorCount++;
+  if (releaseTimer) {
+    clearTimeout(releaseTimer);
+    releaseTimer = null;
+  }
+  const collabSocket = getCollabSocket();
+  collabSocket.shouldConnect = true;
+  if (collabSocket.status === WebSocketStatus.Disconnected) {
+    collabSocket.connect();
+  }
+}
+
+export function releaseCollabSocket(): void {
+  editorCount--;
+  if (editorCount > 0) return;
+  if (releaseTimer) clearTimeout(releaseTimer);
+  releaseTimer = setTimeout(() => {
+    releaseTimer = null;
+    if (editorCount === 0) {
+      socket?.disconnect();
+    }
+  }, RELEASE_GRACE_MS);
+}

apps/client/src/features/editor/components/fixed-toolbar/fixed-toolbar.module.css

@@ -6,6 +6,7 @@
   z-index: 99;
   display: flex;
   align-items: center;
+  min-height: 45px;
   background: var(--mantine-color-body);
   border-bottom: 1px solid
     light-dark(var(--mantine-color-gray-2), var(--mantine-color-dark-4));

apps/client/src/features/editor/components/fixed-toolbar/fixed-toolbar.tsx

@@ -31,8 +31,6 @@ export const FixedToolbar: FC<FixedToolbarProps> = ({
   const workspace = useAtomValue(workspaceAtom);
   const isGenerativeAiEnabled = workspace?.settings?.ai?.generative === true;
 
-  if (!editor || !state) return null;
-
   return (
     <>
       <div
@@ -49,22 +47,26 @@ export const FixedToolbar: FC<FixedToolbarProps> = ({
               <div className={classes.divider} />
             </>
           )} */}
-          <BlockTypeGroup editor={editor} />
-          <div className={classes.divider} />
-          <InlineMarksGroup editor={editor} state={state} />
-          <div className={classes.divider} />
-          <ColorGroup editor={editor} />
-          <div className={classes.divider} />
-          <ListsGroup editor={editor} state={state} />
-          <div className={classes.divider} />
-          <AlignmentGroup editor={editor} />
-          <div className={classes.divider} />
-          <MediaGroup editor={editor} templateMode={templateMode} />
-          <div className={classes.divider} />
-          <QuickInsertsGroup editor={editor} />
-          <MoreInsertsGroup editor={editor} templateMode={templateMode} />
-          <div className={classes.divider} />
-          <HistoryGroup editor={editor} state={state} />
+          {editor && state && (
+            <>
+              <BlockTypeGroup editor={editor} />
+              <div className={classes.divider} />
+              <InlineMarksGroup editor={editor} state={state} />
+              <div className={classes.divider} />
+              <ColorGroup editor={editor} />
+              <div className={classes.divider} />
+              <ListsGroup editor={editor} state={state} />
+              <div className={classes.divider} />
+              <AlignmentGroup editor={editor} />
+              <div className={classes.divider} />
+              <MediaGroup editor={editor} templateMode={templateMode} />
+              <div className={classes.divider} />
+              <QuickInsertsGroup editor={editor} />
+              <MoreInsertsGroup editor={editor} templateMode={templateMode} />
+              <div className={classes.divider} />
+              <HistoryGroup editor={editor} state={state} />
+            </>
+          )}
         </div>
       </div>
       <div className={classes.spacer} aria-hidden />

apps/client/src/features/editor/components/slash-menu/menu-items.ts

@@ -389,6 +389,14 @@ const CommandGroups: SlashMenuGroupedItemsType = {
       command: ({ editor, range }: CommandProps) =>
         editor.chain().focus().deleteRange(range).setDetails().run(),
     },
+    {
+      title: "Tabs",
+      description: "Insert a multi-tab content block.",
+      searchTerms: ["tabs", "tabbed", "multi", "panel"],
+      icon: IconSitemap,
+      command: ({ editor, range }: CommandProps) =>
+        editor.chain().focus().deleteRange(range).insertTabs().run(),
+    },
     {
       title: "Callout",
       description: "Insert callout notice.",

apps/client/src/features/editor/components/tabs/tabs-menu.tsx

@@ -0,0 +1,167 @@
+import { BubbleMenu } from "@tiptap/react/menus";
+import React, { useCallback } from "react";
+import { EditorMenuProps, ShouldShowProps } from "../table/types/types";
+import { isEditorReady, isTextSelected } from "@docmost/editor-ext";
+import { Node as PMNode } from "@tiptap/pm/model";
+import { findParentNode, posToDOMRect } from "@tiptap/core";
+import classes from "../common/toolbar-menu.module.css";
+import { ActionIcon, Tooltip } from "@mantine/core";
+import { useTranslation } from "react-i18next";
+import {
+  IconChevronLeft,
+  IconChevronRight,
+  IconColumnInsertLeft,
+  IconColumnInsertRight,
+  IconColumnRemove,
+  IconTrashX,
+} from "@tabler/icons-react";
+
+const TabsMenu = React.memo(({ editor }: EditorMenuProps) => {
+  const { t } = useTranslation();
+
+  const shouldShow = useCallback(
+    ({ state }: ShouldShowProps) => {
+      if (!state) {
+        return false;
+      }
+
+      if (isTextSelected(editor)) return false;
+
+      return editor.isActive("tabs");
+    },
+    [editor]
+  );
+
+  const getReferencedVirtualElement = useCallback(() => {
+    if (!isEditorReady(editor)) return;
+    const { selection } = editor.state;
+    const predicate = (node: PMNode) => node.type.name === "tabs";
+    const parent = findParentNode(predicate)(selection);
+
+    if (parent) {
+      const dom = editor.view.nodeDOM(parent?.pos) as HTMLElement;
+      const domRect = dom.getBoundingClientRect();
+      return {
+        getBoundingClientRect: () => domRect,
+        getClientRects: () => [domRect],
+      };
+    }
+
+    const domRect = posToDOMRect(editor.view, selection.from, selection.to);
+    return {
+      getBoundingClientRect: () => domRect,
+      getClientRects: () => [domRect],
+    };
+  }, [editor]);
+
+  const handleAddTabLeft = useCallback(() => {
+    editor.chain().focus().insertTab("left").run();
+  }, [editor]);
+
+  const handleAddTabRight = useCallback(() => {
+    editor.chain().focus().insertTab("right").run();
+  }, [editor]);
+
+  const handleMoveTabRight = useCallback(() => {
+    editor.chain().focus().moveTab("right").run();
+  }, [editor]);
+
+  const handleMoveTabLeft = useCallback(() => {
+    editor.chain().focus().moveTab("left").run();
+  }, [editor]);
+
+  const handleDeleteTab = useCallback(() => {
+    editor.chain().focus().deleteTab().run();
+  }, [editor]);
+
+  const handleDelete = useCallback(() => {
+    editor.chain().focus().deleteTabs().run();
+  }, [editor]);
+
+  return (
+    <BubbleMenu
+      style={{ zIndex: 99 }}
+      editor={editor}
+      pluginKey="tabs-menu"
+      resizeDelay={0}
+      getReferencedVirtualElement={getReferencedVirtualElement}
+      shouldShow={shouldShow}
+      options={{
+        placement: "top",
+        offset: false,
+        flip: false,
+      }}
+    >
+      <div className={classes.toolbar}>
+        <Tooltip position="top" label={t("Add left tab")} withinPortal={false}>
+          <ActionIcon
+            onClick={handleAddTabLeft}
+            variant="subtle"
+            size="lg"
+            aria-label={t("Add left tab")}
+          >
+            <IconColumnInsertLeft size={18} />
+          </ActionIcon>
+        </Tooltip>
+        <Tooltip position="top" label={t("Add right tab")} withinPortal={false}>
+          <ActionIcon
+            onClick={handleAddTabRight}
+            variant="subtle"
+            size="lg"
+            aria-label={t("Add right tab")}
+          >
+            <IconColumnInsertRight size={18} />
+          </ActionIcon>
+        </Tooltip>
+        <Tooltip position="top" label={t("Delete tab")} withinPortal={false}>
+          <ActionIcon
+            onClick={handleDeleteTab}
+            variant="subtle"
+            size="lg"
+            aria-label={t("Delete tab")}
+          >
+            <IconColumnRemove size={18} />
+          </ActionIcon>
+        </Tooltip>
+
+        <div className={classes.divider} />
+
+        <Tooltip position="top" label={t("Move tab left")} withinPortal={false}>
+          <ActionIcon
+            onClick={handleMoveTabLeft}
+            variant="subtle"
+            size="lg"
+            aria-label={t("Move tab left")}
+          >
+            <IconChevronLeft size={18} />
+          </ActionIcon>
+        </Tooltip>
+
+        <Tooltip position="top" label={t("Move tab right")} withinPortal={false}>
+          <ActionIcon
+            onClick={handleMoveTabRight}
+            variant="subtle"
+            size="lg"
+            aria-label={t("Move tab right")}
+          >
+            <IconChevronRight size={18} />
+          </ActionIcon>
+        </Tooltip>
+        <div className={classes.divider} />
+
+        <Tooltip position="top" label={t("Delete")} withinPortal={false}>
+          <ActionIcon
+            onClick={handleDelete}
+            variant="subtle"
+            size="lg"
+            aria-label={t("Delete")}
+          >
+            <IconTrashX size={18} />
+          </ActionIcon>
+        </Tooltip>
+      </div>
+    </BubbleMenu>
+  );
+});
+
+export default TabsMenu;

apps/client/src/features/editor/components/tabs/tabs-view.tsx

@@ -0,0 +1,140 @@
+import React, {
+  ChangeEvent,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type KeyboardEvent,
+} from "react";
+import { NodeViewContent, NodeViewWrapper, type NodeViewProps } from "@tiptap/react";
+import { Tabs, TextInput } from "@mantine/core";
+
+export default function TabsView(props: NodeViewProps) {
+  const { node, editor, getPos } = props;
+  const isEditable = editor.isEditable;
+  const allowFocusRef = useRef(false);
+
+  const tabs = useMemo(() => {
+    return Array.from({ length: node.childCount }, (_, index) => {
+      const labelNode = node.child(index)?.child(0);
+      const labelText = labelNode?.textContent;
+      const labelId = node.child(index)?.attrs?.id;
+
+      return {
+        label: labelText ?? "",
+        id: labelId ?? index,
+      };
+    });
+  }, [node]);
+
+  const activeTab = clampIndex(node.attrs.activeTab);
+  const [activeLabel, setActiveLabel] = useState(tabs[activeTab].label ?? "");
+
+  useEffect(() => {
+    setActiveLabel(tabs[activeTab].label);
+  }, [activeTab, tabs]);
+
+  const handleMouseDown = useCallback((event: React.MouseEvent) => {
+    const previous = document.activeElement as HTMLElement | null;
+    const input = event.currentTarget;
+
+    if (!previous?.contains(input)) {
+      allowFocusRef.current = true;
+      return;
+    }
+
+    allowFocusRef.current = true;
+  }, []);
+
+  const handleFocus = useCallback(
+    (event: React.FocusEvent<HTMLInputElement>) => {
+      if (!allowFocusRef.current || !isEditable) {
+        event.preventDefault();
+        event.target.blur();
+      }
+    },
+    [isEditable]
+  );
+
+  const handleBlur = useCallback(() => {
+    allowFocusRef.current = false;
+  }, []);
+
+  const commitLabel = useCallback(
+    (event: ChangeEvent<HTMLInputElement>) => {
+      const label = event.currentTarget.value;
+      setActiveLabel(label);
+
+      if (label === tabs[activeTab].label) return;
+      if (typeof getPos === "function") {
+        editor.commands.updateTabLabel?.(activeTab, label, getPos());
+      }
+    },
+    [activeTab, editor, getPos, tabs]
+  );
+
+  const handleLabelKeyDown = useCallback(
+    (event: KeyboardEvent<HTMLInputElement>) => {
+      event.stopPropagation();
+      if (event.key === "Escape") {
+        event.preventDefault();
+        event.currentTarget.blur();
+      }
+    },
+    []
+  );
+
+  return (
+    <NodeViewWrapper data-type="tabs">
+      <Tabs value={String(activeTab)}>
+        <Tabs.List style={{ marginBottom: 10 }}>
+          {tabs.map(({ label, id }, index) => (
+            <Tabs.Tab
+              key={id}
+              value={index.toString()}
+              onFocus={(event) => event.currentTarget.blur()}
+              onClick={(e) => {
+                e.preventDefault();
+                if (typeof getPos === "function") {
+                  editor.commands.setActiveTab?.(index, getPos());
+                }
+              }}
+            >
+              <TextInput
+                aria-label="Edit tab label"
+                onMouseDown={handleMouseDown}
+                onFocus={handleFocus}
+                onBlur={handleBlur}
+                onChange={commitLabel}
+                onKeyDown={handleLabelKeyDown}
+                variant="unstyled"
+                size="xs"
+                value={
+                  index === activeTab && allowFocusRef.current ? activeLabel : label
+                }
+                styles={{
+                  input: {
+                    minWidth: 80,
+                    padding: 0,
+                    cursor: "pointer",
+                  },
+                }}
+              />
+            </Tabs.Tab>
+          ))}
+        </Tabs.List>
+      </Tabs>
+
+      <div className="dm-tabs__content">
+        <NodeViewContent as="div" />
+      </div>
+    </NodeViewWrapper>
+  );
+}
+
+const clampIndex = (value: unknown, length = Number.MAX_SAFE_INTEGER) => {
+  const parsed = Number(value ?? 0);
+  if (!Number.isFinite(parsed) || length <= 0) return 0;
+  return Math.max(0, Math.min(Math.trunc(parsed), length - 1));
+};

apps/client/src/features/editor/extensions/drag-handle.ts

@@ -5,8 +5,9 @@ import {
   PluginKey,
   TextSelection,
 } from "@tiptap/pm/state";
-import { Fragment, Slice, Node } from "@tiptap/pm/model";
-import { EditorView } from "@tiptap/pm/view";
+import { Fragment, Slice } from "@tiptap/pm/model";
+import type { Node, ResolvedPos } from "@tiptap/pm/model";
+import type { EditorView } from "@tiptap/pm/view";
 
 export interface GlobalDragHandleOptions {
   /**
@@ -150,9 +151,126 @@ function isCustomNodeDOM(
   return false;
 }
 
+function getDirectTarget($pos: ResolvedPos, ancestorDepth: number) {
+  const ancestor = $pos.node(ancestorDepth);
+
+  if (ancestor.childCount === 0) return null;
+
+  if ($pos.depth > ancestorDepth) {
+    const childDepth = ancestorDepth + 1;
+    return {
+      pos: $pos.before(childDepth),
+      node: $pos.node(childDepth),
+    };
+  }
+
+  const index = $pos.index(ancestorDepth);
+  const childIndex = Math.min(index, ancestor.childCount - 1);
+  if (childIndex < 0) return null;
+
+  return {
+    pos: $pos.posAtIndex(childIndex, ancestorDepth),
+    node: ancestor.child(childIndex),
+  };
+}
+
+type DragSource = { from: number; to: number; node: Node };
+
+function dragSourceFromDOM(view: EditorView, dom: Element): DragSource | null {
+  let pos: number;
+  try {
+    pos = view.posAtDOM(dom, 0);
+  } catch {
+    return null;
+  }
+
+  const $pos = view.state.doc.resolve(pos);
+  if ($pos.depth === 0) return null;
+
+  const from = $pos.before($pos.depth);
+  const node = $pos.node($pos.depth);
+  return { from, to: from + node.nodeSize, node };
+}
+
+function resolveMoveSource(
+  view: EditorView,
+  hint: DragSource | null,
+): DragSource | null {
+  const { state } = view;
+
+  if (hint) {
+    const current = state.doc.nodeAt(hint.from);
+    if (current?.eq(hint.node)) return hint;
+  }
+
+  if (state.selection instanceof NodeSelection) {
+    return {
+      from: state.selection.from,
+      to: state.selection.from + state.selection.node.nodeSize,
+      node: state.selection.node,
+    };
+  }
+
+  return null;
+}
+
+function moveNodeWithinTabPanel(
+  view: EditorView,
+  dropPos: number,
+  source: DragSource,
+): boolean {
+  const { state } = view;
+  const { from: sourceFrom, to: sourceTo, node: sourceNode } = source;
+
+  const $drop = state.doc.resolve(dropPos);
+  const panelDepth = view.state.doc.resolve(dropPos).depth
+  if (panelDepth < 0) return false;
+
+  if (dropPos > sourceFrom && dropPos < sourceTo) return false;
+
+  let insertPos: number;
+  const target = getDirectTarget($drop, panelDepth);
+  if (!target) {
+    insertPos = $drop.start(panelDepth);
+  } else {
+    const targetStart = target.pos;
+    const targetEnd = targetStart + target.node.nodeSize;
+    const midpoint = (targetStart + targetEnd) / 2;
+    insertPos = dropPos >= midpoint ? targetEnd : targetStart;
+  }
+
+  // Already in place.
+  if (insertPos === sourceFrom || insertPos === sourceTo) return false;
+
+  const tr = state.tr;
+  tr.delete(sourceFrom, sourceTo);
+
+  const insertAt = tr.mapping.map(insertPos, -1);
+  const $insert = tr.doc.resolve(insertAt);
+  const index = $insert.index();
+
+  if (!$insert.parent.canReplace(index, index, Fragment.from(sourceNode))) {
+    return false;
+  }
+
+  tr.insert(insertAt, sourceNode);
+
+  const $placed = tr.doc.resolve(
+    Math.min(insertAt, tr.doc.content.size),
+  );
+  tr.setSelection(NodeSelection.near($placed));
+  tr.scrollIntoView();
+
+  view.dispatch(tr);
+  return true;
+}
+
+const NON_PROMOTABLE_PARENTS = new Set(["tabs", "tab", "tabPanel"]);
+
 function calcNodePos(pos: number, view: EditorView) {
   const $pos = view.state.doc.resolve(pos);
-  if ($pos.depth > 1) return $pos.before($pos.depth);
+  if ($pos.depth > 1 && !NON_PROMOTABLE_PARENTS.has($pos.node($pos.depth).type.name))
+    return $pos.before($pos.depth);
   return pos;
 }
 
@@ -160,6 +278,8 @@ export function DragHandlePlugin(
   options: GlobalDragHandleOptions & { pluginKey: string },
 ) {
   let listType = "";
+  let dragSource: DragSource | null = null;
+
   function handleDragStart(event: DragEvent, view: EditorView) {
     view.focus();
 
@@ -176,6 +296,8 @@ export function DragHandlePlugin(
 
     if (!(node instanceof Element)) return;
 
+    dragSource = dragSourceFromDOM(view, node);
+
     let draggedNodePos = nodePosAtDOM(node, view, options);
     if (draggedNodePos == null || draggedNodePos < 0) return;
     draggedNodePos = calcNodePos(draggedNodePos, view);
@@ -401,6 +523,7 @@ export function DragHandlePlugin(
           );
 
           const notDragging = node?.closest(".not-draggable");
+          const notDraggingMatch = node?.matches(".not-draggable-match")
           const excludedTagList = options.excludedTags
             .concat(["ol", "ul"])
             .join(", ");
@@ -408,7 +531,8 @@ export function DragHandlePlugin(
           if (
             !(node instanceof Element) ||
             node.matches(excludedTagList) ||
-            notDragging
+            notDragging ||
+            notDraggingMatch
           ) {
             hideDragHandle();
             return;
@@ -496,6 +620,22 @@ export function DragHandlePlugin(
           const isDroppedInsideList =
             resolvedPos.parent.type.name === "listItem";
 
+          const isDroppedInsideTabPanel =
+            resolvedPos.parent.type.name === "tabPanel";
+
+          if (isDroppedInsideTabPanel) {
+            const source = resolveMoveSource(view, dragSource);
+            const moved = source
+              ? moveNodeWithinTabPanel(view, dropPos.pos, source)
+              : false;
+   
+            // even when not moved swallow the drop so ProseMirror doesn't insert a copy.
+            event.preventDefault();
+            view.dragging = null;
+            dragSource = null;
+            return moved;
+          }
+
           // If the selected node is a list item and is not dropped inside a list, we need to wrap it inside <ol> tag otherwise ol list items will be transformed into ul list item when dropped
           if (
             view.state.selection instanceof NodeSelection &&
@@ -513,6 +653,7 @@ export function DragHandlePlugin(
         },
         dragend: (view) => {
           view.dom.classList.remove("dragging");
+          dragSource = null;
         },
       },
     },
@@ -526,6 +667,7 @@ const GlobalDragHandle = Extension.create({
     return {
       dragHandleWidth: 20,
       scrollThreshold: 100,
+      dragHandleSelector: undefined,
       excludedTags: [],
       customNodes: [],
       atomNodes: [],

apps/client/src/features/editor/extensions/extensions.ts

@@ -62,6 +62,10 @@ import {
   TransclusionReference,
   TableView,
   BaseEmbed as BaseEmbedNode,
+  Tabs,
+  Tab,
+  TabLabel,
+  TabPanel,
 } from "@docmost/editor-ext";
 import {
   randomElement,
@@ -90,6 +94,7 @@ import ExcalidrawView from "@/features/editor/components/excalidraw/excalidraw-v
 import EmbedView from "@/features/editor/components/embed/embed-view.tsx";
 import PdfView from "@/features/editor/components/pdf/pdf-view.tsx";
 import SubpagesView from "@/features/editor/components/subpages/subpages-view.tsx";
+import TabsView from "@/features/editor/components/tabs/tabs-view.tsx";
 import TransclusionView from "@/features/editor/components/transclusion/transclusion-view.tsx";
 import TransclusionReferenceView from "@/features/editor/components/transclusion/transclusion-reference-view.tsx";
 import { BaseEmbedView } from "@/features/editor/components/base-embed/base-embed-view.tsx";
@@ -194,16 +199,18 @@ export const mainExtensions = [
         return i18n.t("Toggle title");
       }
       if (node.type.name === "paragraph") {
-        const $pos = editor.state.doc.resolve(pos);
-        const parentName = $pos.parent.type.name;
-        if (
-          parentName === "column" ||
-          parentName === "tableCell" ||
-          parentName === "tableHeader" ||
-          parentName === "callout" ||
-          parentName === "blockquote"
-        ) {
-          return i18n.t("Write...");
+        const doc = editor.state.doc;
+        if (pos >= 0 && pos <= doc.content.size) {
+          const parentName = doc.resolve(pos).parent.type.name;
+          if (
+            parentName === "column" ||
+            parentName === "tableCell" ||
+            parentName === "tableHeader" ||
+            parentName === "callout" ||
+            parentName === "blockquote"
+          ) {
+            return i18n.t("Write...");
+          }
         }
         return i18n.t('Write anything. Enter "/" for commands');
       }
@@ -232,7 +239,7 @@ export const mainExtensions = [
   Typography,
   TrailingNode,
   GlobalDragHandle.configure({
-    customNodes: ["transclusionSource", "transclusionReference"],
+    customNodes: ["transclusionSource", "transclusionReference", "tabPanel"],
     atomNodes: ["base"],
   }),
   TextStyle,
@@ -287,6 +294,12 @@ export const mainExtensions = [
   Details,
   DetailsSummary,
   DetailsContent,
+  Tabs.configure({
+    view: TabsView,
+  }),
+  Tab,
+  TabLabel,
+  TabPanel,
   Youtube.configure({
     addPasteHandler: false,
     controls: true,

apps/client/src/features/editor/hooks/use-collaboration-url.ts

@@ -1,7 +0,0 @@
-import { getCollaborationUrl } from "@/lib/config.ts";
-
-const useCollaborationURL = (): string => {
-  return getCollaborationUrl();
-};
-
-export default useCollaborationURL;

apps/client/src/features/editor/page-editor.tsx

@@ -2,20 +2,22 @@ import "@/features/editor/styles/index.css";
 import React, {
   useCallback,
   useEffect,
+  useLayoutEffect,
   useMemo,
   useRef,
   useState,
 } from "react";
 import { IndexeddbPersistence } from "y-indexeddb";
-import * as Y from "yjs";
 import {
-  HocuspocusProvider,
-  onStatusParameters,
   WebSocketStatus,
-  HocuspocusProviderWebsocket,
-  onSyncedParameters,
   onStatelessParameters,
 } from "@hocuspocus/provider";
+import {
+  HocuspocusProviderWebsocketComponent,
+  HocuspocusRoom,
+  useHocuspocusEvent,
+  useHocuspocusProvider,
+} from "@hocuspocus/provider-react";
 import {
   Editor,
   EditorContent,
@@ -28,7 +30,6 @@ import {
   mainExtensions,
 } from "@/features/editor/extensions/extensions";
 import { useAtom, useAtomValue } from "jotai";
-import useCollaborationUrl from "@/features/editor/hooks/use-collaboration-url";
 import { currentUserAtom } from "@/features/user/atoms/current-user-atom";
 import {
   currentPageEditModeAtom,
@@ -76,6 +77,12 @@ import { EditorLinkMenu } from "@/features/editor/components/link/link-menu";
 import ColumnsMenu from "@/features/editor/components/columns/columns-menu.tsx";
 import { TransclusionLookupProvider } from "@/features/editor/components/transclusion/transclusion-lookup-context";
 import { useTranslation } from "react-i18next";
+import {
+  acquireCollabSocket,
+  getCollabSocket,
+  releaseCollabSocket,
+} from "@/features/editor/collab-socket";
+import TabsMenu from "./components/tabs/tabs-menu";
 
 interface PageEditorProps {
   pageId: string;
@@ -91,7 +98,80 @@ export default function PageEditor({
   canComment,
 }: PageEditorProps) {
   const { t } = useTranslation();
-  const collaborationURL = useCollaborationUrl();
+  const { data: collabQuery, refetch: refetchCollabToken } = useCollabToken();
+  const { pageSlug } = useParams();
+  const slugId = extractPageSlugId(pageSlug);
+  const [socket] = useState(getCollabSocket);
+  const hasCollabToken = !!collabQuery?.token;
+
+  useEffect(() => {
+    if (!hasCollabToken) return;
+    acquireCollabSocket();
+    return () => releaseCollabSocket();
+  }, [hasCollabToken]);
+
+  const handleStateless = ({ payload }: onStatelessParameters) => {
+    try {
+      const message = JSON.parse(payload);
+      if (message?.type !== "page.updated" || !message.updatedAt) return;
+      const pageData = queryClient.getQueryData<IPage>(["pages", slugId]);
+      if (pageData) {
+        queryClient.setQueryData(["pages", slugId], {
+          ...pageData,
+          updatedAt: message.updatedAt,
+          ...(message.lastUpdatedBy && {
+            lastUpdatedBy: message.lastUpdatedBy,
+          }),
+        });
+      }
+    } catch {
+      // ignore unrelated stateless messages
+    }
+  };
+
+  const handleAuthenticationFailed = () => {
+    const payload = jwtDecode(collabQuery?.token);
+    const now = Date.now().valueOf() / 1000;
+    const isTokenExpired = now >= payload.exp;
+    if (isTokenExpired) {
+      refetchCollabToken();
+    }
+  };
+
+  return (
+    <TransclusionLookupProvider>
+      {collabQuery?.token ? (
+        <HocuspocusProviderWebsocketComponent websocketProvider={socket}>
+          <HocuspocusRoom
+            name={`page.${pageId}`}
+            token={collabQuery.token}
+            flushDelay={500}
+            onStateless={handleStateless}
+            onAuthenticationFailed={handleAuthenticationFailed}
+          >
+            <CollabPageEditor
+              pageId={pageId}
+              editable={editable}
+              content={content}
+              canComment={canComment}
+            />
+          </HocuspocusRoom>
+        </HocuspocusProviderWebsocketComponent>
+      ) : (
+        <StaticPageEditor content={content} ariaLabel={t("Page content")} />
+      )}
+    </TransclusionLookupProvider>
+  );
+}
+
+function CollabPageEditor({
+  pageId,
+  editable,
+  content,
+  canComment,
+}: PageEditorProps) {
+  const { t } = useTranslation();
+  const provider = useHocuspocusProvider();
   const isComponentMounted = useRef(false);
   const editorRef = useRef<Editor | null>(null);
 
@@ -112,7 +192,6 @@ export default function PageEditor({
   );
   const [, setYjsSynced] = useAtom(yjsSyncedAtom);
   const menuContainerRef = useRef(null);
-  const { data: collabQuery, refetch: refetchCollabToken } = useCollabToken();
   const { isIdle, resetIdle } = useIdle(FIVE_MINUTES, { initialState: false });
   const documentState = useDocumentVisibility();
   const { pageSlug } = useParams();
@@ -123,95 +202,24 @@ export default function PageEditor({
     [isComponentMounted],
   );
   const { handleScrollTo } = useEditorScroll({ canScroll });
-  // Providers only created once per pageId
-  const providersRef = useRef<{
-    local: IndexeddbPersistence;
-    remote: HocuspocusProvider;
-    socket: HocuspocusProviderWebsocket;
-  } | null>(null);
-  const [providersReady, setProvidersReady] = useState(false);
 
   useEffect(() => {
-    if (!providersRef.current) {
-      const documentName = `page.${pageId}`;
-      const ydoc = new Y.Doc();
-      const local = new IndexeddbPersistence(documentName, ydoc);
-      const socket = new HocuspocusProviderWebsocket({
-        url: collaborationURL,
-      });
-      const onLocalSyncedHandler = () => {
-        setIsLocalSynced(true);
-      };
-      const onStatusHandler = (event: onStatusParameters) => {
-        setYjsConnectionStatus(event.status);
-      };
-      const onSyncedHandler = (event: onSyncedParameters) => {
-        setIsRemoteSynced(event.state);
-      };
-      const onStatelessHandler = ({ payload }: onStatelessParameters) => {
-        try {
-          const message = JSON.parse(payload);
-          if (message?.type !== "page.updated" || !message.updatedAt) return;
-          const pageData = queryClient.getQueryData<IPage>(["pages", slugId]);
-          if (pageData) {
-            queryClient.setQueryData(["pages", slugId], {
-              ...pageData,
-              updatedAt: message.updatedAt,
-              ...(message.lastUpdatedBy && {
-                lastUpdatedBy: message.lastUpdatedBy,
-              }),
-            });
-          }
-        } catch {
-          // ignore unrelated stateless messages
-        }
-      };
-      const onAuthenticationFailedHandler = () => {
-        const payload = jwtDecode(collabQuery?.token);
-        const now = Date.now().valueOf() / 1000;
-        const isTokenExpired = now >= payload.exp;
-        if (isTokenExpired) {
-          refetchCollabToken().then((result) => {
-            if (result.data?.token) {
-              socket.disconnect();
-              setTimeout(() => {
-                remote.configuration.token = result.data.token;
-                socket.connect();
-              }, 100);
-            }
-          });
-        }
-      };
-      const remote = new HocuspocusProvider({
-        websocketProvider: socket,
-        name: documentName,
-        document: ydoc,
-        token: collabQuery?.token,
-        onAuthenticationFailed: onAuthenticationFailedHandler,
-        onStatus: onStatusHandler,
-        onSynced: onSyncedHandler,
-        onStateless: onStatelessHandler,
-      });
-
-      local.on("synced", onLocalSyncedHandler);
-      providersRef.current = { socket, local, remote };
-      setProvidersReady(true);
-    } else {
-      setProvidersReady(true);
-    }
-    // Only destroy on final unmount
+    const local = new IndexeddbPersistence(
+      provider.configuration.name,
+      provider.document,
+    );
+    local.on("synced", () => setIsLocalSynced(true));
     return () => {
-      providersRef.current?.socket.destroy();
-      providersRef.current?.remote.destroy();
-      providersRef.current?.local.destroy();
-      providersRef.current = null;
+      local.destroy();
     };
-  }, [pageId]);
+  }, [provider]);
+
+  useHocuspocusEvent("synced", ({ state }) => setIsRemoteSynced(state));
+  useHocuspocusEvent("status", ({ status }) => setYjsConnectionStatus(status));
 
   // Only connect/disconnect on tab/idle, not destroy
   useEffect(() => {
-    if (!providersReady || !providersRef.current) return;
-    const socket = providersRef.current.socket;
+    const socket = provider.configuration.websocketProvider;
 
     if (
       isIdle &&
@@ -228,23 +236,15 @@ export default function PageEditor({
       resetIdle();
       socket.connect();
     }
-  }, [isIdle, documentState, providersReady, resetIdle]);
-
-  // Attach here, to make sure the connection gets properly established
-  providersRef.current?.remote.attach();
+  }, [isIdle, documentState, provider, resetIdle]);
 
   const extensions = useMemo(() => {
-    if (!providersReady || !providersRef.current || !currentUser?.user) {
+    if (!currentUser?.user) {
       return mainExtensions;
     }
 
-    const remoteProvider = providersRef.current.remote;
-
-    return [
-      ...mainExtensions,
-      ...collabExtensions(remoteProvider, currentUser?.user),
-    ];
-  }, [providersReady, currentUser?.user]);
+    return [...mainExtensions, ...collabExtensions(provider, currentUser.user)];
+  }, [provider, currentUser?.user]);
 
   const editor = useEditor(
     {
@@ -326,6 +326,16 @@ export default function PageEditor({
     [pageId, editable, extensions],
   );
 
+  useLayoutEffect(() => {
+    if (editor && !editor.isDestroyed) {
+      // @ts-ignore
+      setEditor(editor);
+      // @ts-ignore
+      editor.storage.pageId = pageId;
+      editorRef.current = editor;
+    }
+  }, [editor, pageId, setEditor]);
+
   const editorIsEditable = useEditorState({
     editor,
     selector: (ctx) => {
@@ -416,65 +426,73 @@ export default function PageEditor({
     }
   }, [yjsConnectionStatus, isSynced]);
 
+  if (showStatic) {
+    return <StaticPageEditor content={content} ariaLabel={t("Page content")} />;
+  }
+
   return (
-    <TransclusionLookupProvider>
-      {showStatic ? (
-        <EditorProvider
-          editable={false}
-          immediatelyRender={true}
-          extensions={mainExtensions}
-          content={content}
-          editorProps={{
-            attributes: {
-              "aria-label": t("Page content"),
-            },
-          }}
-        />
-      ) : (
-        <div className="editor-container" style={{ position: "relative" }}>
-          <div ref={menuContainerRef}>
-            <EditorContent editor={editor} />
+    <div className="editor-container" style={{ position: "relative" }}>
+      <div ref={menuContainerRef}>
+        <EditorContent editor={editor} />
 
-            {editor && (
-              <SearchAndReplaceDialog editor={editor} editable={editable} />
-            )}
+        {editor && (
+          <SearchAndReplaceDialog editor={editor} editable={editable} />
+        )}
 
-            {editor && editorIsEditable && (
-              <div>
-                <EditorAiMenu editor={editor} />
-                <EditorLinkMenu editor={editor} />
-                <EditorBubbleMenu editor={editor} />
-                <TableMenu editor={editor} />
-                <TableHandlesLayer editor={editor} />
-                <ImageMenu editor={editor} />
-                <VideoMenu editor={editor} />
-                <PdfMenu editor={editor} />
-                <CalloutMenu editor={editor} />
-                <SubpagesMenu editor={editor} />
-                <ExcalidrawMenu editor={editor} />
-                <DrawioMenu editor={editor} />
-                <ColumnsMenu editor={editor} />
-              </div>
-            )}
-            {editor &&
-              !editorIsEditable &&
-              (editable || canComment) &&
-              providersRef.current && <ReadonlyBubbleMenu editor={editor} />}
-            {showCommentPopup && (
-              <CommentDialog editor={editor} pageId={pageId} />
-            )}
-            {showReadOnlyCommentPopup && (
-              <CommentDialog editor={editor} pageId={pageId} readOnly />
-            )}
+        {editor && editorIsEditable && (
+          <div>
+            <EditorAiMenu editor={editor} />
+            <EditorLinkMenu editor={editor} />
+            <EditorBubbleMenu editor={editor} />
+            <TableMenu editor={editor} />
+            <TableHandlesLayer editor={editor} />
+            <ImageMenu editor={editor} />
+            <VideoMenu editor={editor} />
+            <PdfMenu editor={editor} />
+            <CalloutMenu editor={editor} />
+            <SubpagesMenu editor={editor} />
+            <ExcalidrawMenu editor={editor} />
+            <DrawioMenu editor={editor} />
+            <ColumnsMenu editor={editor} />
+            <TabsMenu editor={editor} />
           </div>
-          <div
-            onClick={() => {
-              if (editor && !editor.isDestroyed) editor.commands.focus("end");
-            }}
-            style={{ paddingBottom: "20vh" }}
-          ></div>
-        </div>
-      )}
-    </TransclusionLookupProvider>
+        )}
+        {editor && !editorIsEditable && (editable || canComment) && (
+          <ReadonlyBubbleMenu editor={editor} />
+        )}
+        {showCommentPopup && <CommentDialog editor={editor} pageId={pageId} />}
+        {showReadOnlyCommentPopup && (
+          <CommentDialog editor={editor} pageId={pageId} readOnly />
+        )}
+      </div>
+      <div
+        onClick={() => {
+          if (editor && !editor.isDestroyed) editor.commands.focus("end");
+        }}
+        style={{ paddingBottom: "20vh" }}
+      ></div>
+    </div>
+  );
+}
+
+function StaticPageEditor({
+  content,
+  ariaLabel,
+}: {
+  content: any;
+  ariaLabel: string;
+}) {
+  return (
+    <EditorProvider
+      editable={false}
+      immediatelyRender={true}
+      extensions={mainExtensions}
+      content={content}
+      editorProps={{
+        attributes: {
+          "aria-label": ariaLabel,
+        },
+      }}
+    />
   );
 }

apps/client/src/features/editor/styles/index.css

@@ -17,4 +17,5 @@
 @import "./indent.css";
 @import "./columns.css";
 @import "./status.css";
+@import "./tabs.css";
 @import "./base-embed.css";

apps/client/src/features/editor/styles/tabs.css

@@ -0,0 +1,15 @@
+.ProseMirror {
+  [data-type="tabs"] {
+    button {
+      outline: none;
+    }
+  }
+  
+  [data-type="tabLabel"] {
+    display: none;
+  }
+
+  [data-type="tabPanel"] {
+    outline: none;
+  }
+}

apps/server/package.json

@@ -88,7 +88,6 @@
     "kysely-migration-cli": "0.4.2",
     "kysely-postgres-js": "3.0.0",
     "ldapts": "8.1.7",
-    "lib0": "0.2.117",
     "mammoth": "1.12.0",
     "mime-types": "3.0.2",
     "msgpackr": "^1.11.9",
@@ -118,7 +117,6 @@
     "stripe": "^17.7.0",
     "tlds": "1.261.0",
     "tmp-promise": "3.0.3",
-    "tseep": "1.3.1",
     "typesense": "3.0.5",
     "undici": "7.28.0",
     "ws": "8.21.0",

apps/server/src/collaboration/collaboration.gateway.ts

@@ -15,6 +15,7 @@ import {
   RedisSyncExtension,
   SerializedHTTPRequest,
 } from './extensions/redis-sync';
+import { toWebRequest } from './extensions/redis-sync/redis-sync.types';
 import { WsSocketWrapper } from './extensions/redis-sync/ws-socket-wrapper';
 import RedisClient from 'ioredis';
 import { pack, unpack } from 'msgpackr';
@@ -98,34 +99,36 @@ export class CollaborationGateway {
       const serializedHTTPRequest = this.serializeRequest(request);
       const socketId = serializedHTTPRequest.headers['sec-websocket-key'];
 
-      // Create wrapper socket that only receives events via emit()
-      // This prevents double-handling since Hocuspocus won't listen to raw WebSocket events
       const wrappedSocket = new WsSocketWrapper(client);
 
       // Route through RedisSync extension (this calls handleConnection internally)
-      this.redisSync.onSocketOpen(wrappedSocket as any, serializedHTTPRequest);
+      this.redisSync.onSocketOpen(wrappedSocket, serializedHTTPRequest);
 
-      // Forward raw WebSocket messages to the extension
       client.on('message', (data: ArrayBuffer) => {
-        this.redisSync!.onSocketMessage(
-          wrappedSocket as any,
-          serializedHTTPRequest,
-          data,
-        );
+        this.redisSync!.onSocketMessage(serializedHTTPRequest, data);
       });
 
-      // Forward close events
       client.on('close', (code: number, reason: Buffer) => {
-        this.redisSync!.onSocketClose(socketId, code, reason.buffer as ArrayBuffer);
-      });
-
-      // Forward pong events for keepalive
-      client.on('pong', (data: Buffer) => {
-        wrappedSocket.emit('pong', data);
+        this.redisSync!.onSocketClose(
+          socketId,
+          code,
+          new Uint8Array(reason).buffer,
+        );
       });
     } else {
       // Fallback to direct Hocuspocus connection
-      this.hocuspocus.handleConnection(client, request);
+      const clientConnection = this.hocuspocus.handleConnection(
+        client,
+        toWebRequest(this.serializeRequest(request)),
+      );
+
+      client.on('message', (data: Buffer) => {
+        clientConnection.handleMessage(new Uint8Array(data));
+      });
+
+      client.on('close', (code: number, reason: Buffer) => {
+        clientConnection.handleClose({ code, reason: reason.toString() });
+      });
     }
   }
 
@@ -178,6 +181,7 @@ export class CollaborationGateway {
 
         if (this.hocuspocus.getDocumentsCount() === 0) resolve('');
         this.hocuspocus.closeConnections();
+        this.hocuspocus.flushPendingStores();
       } catch (error) {
         console.error(error);
       }

apps/server/src/collaboration/collaboration.util.ts

@@ -45,6 +45,10 @@ import {
   TransclusionSource,
   TransclusionReference,
   BaseEmbed,
+  Tabs,
+  Tab,
+  TabLabel,
+  TabPanel,
 } from '@docmost/editor-ext';
 import { generateText, getSchema, JSONContent } from '@tiptap/core';
 import { generateHTML, generateJSON } from '../common/helpers/prosemirror/html';
@@ -87,6 +91,10 @@ export const tiptapExtensions = [
   Details,
   DetailsContent,
   DetailsSummary,
+  Tabs,
+  Tab,
+  TabLabel,
+  TabPanel,
   CustomTable,
   TableCell,
   TableRow,

apps/server/src/collaboration/extensions/persistence.extension.ts

@@ -96,7 +96,7 @@ export class PersistenceExtension implements Extension {
   }
 
   async onStoreDocument(data: onStoreDocumentPayload) {
-    const { documentName, document, context } = data;
+    const { documentName, document, lastContext } = data;
 
     const pageId = getPageId(documentName);
 
@@ -151,7 +151,7 @@ export class PersistenceExtension implements Extension {
             content: tiptapJson,
             textContent: textContent,
             ydoc: ydocState,
-            lastUpdatedById: context.user.id,
+            lastUpdatedById: lastContext.user.id,
             contributorIds: contributorIds,
           },
           pageId,
@@ -169,12 +169,12 @@ export class PersistenceExtension implements Extension {
         JSON.stringify({
           type: 'page.updated',
           updatedAt: new Date().toISOString(),
-          lastUpdatedById: context?.user?.id,
-          lastUpdatedBy: context?.user
+          lastUpdatedById: lastContext?.user?.id,
+          lastUpdatedBy: lastContext?.user
             ? {
-                id: context.user?.id,
-                name: context.user?.name,
-                avatarUrl: context.user?.avatarUrl,
+                id: lastContext.user?.id,
+                name: lastContext.user?.name,
+                avatarUrl: lastContext.user?.avatarUrl,
               }
             : undefined,
         }),

apps/server/src/collaboration/extensions/redis-sync/collab-proxy-socket.ts

@@ -1,61 +1,37 @@
 import type RedisClient from 'ioredis';
-import { EventEmitter } from 'tseep';
-import type {
-  Pack,
-  RSAMessageClose,
-  RSAMessagePing,
-  RSAMessageSend,
-} from './redis-sync.types';
+import type { WebSocketLike } from '@hocuspocus/server';
+import type { Pack, RSAMessageClose, RSAMessageSend } from './redis-sync.types';
 
-export class CollabProxySocket extends EventEmitter {
+// Stands in for the client WebSocket on the server that owns the document.
+// Outgoing traffic is relayed over redis to the origin server, which holds the real socket.
+export class CollabProxySocket implements WebSocketLike {
   private readonly replyTo: string;
-  private readonly serverChannel: string;
   private readonly socketId: string;
   private pub: RedisClient;
   private readonly pack: Pack;
   readyState = 1;
+  onClose?: (code?: number, reason?: string) => void;
 
-  constructor(
-    pub: RedisClient,
-    pack: Pack,
-    replyTo: string,
-    serverChannel: string,
-    socketId: string,
-  ) {
-    super();
+  constructor(pub: RedisClient, pack: Pack, replyTo: string, socketId: string) {
     this.replyTo = replyTo;
     this.socketId = socketId;
-    this.serverChannel = serverChannel;
     this.pub = pub;
     this.pack = pack;
-    this.once('close', () => {
-      this.readyState = 3;
-    });
   }
 
-  private publish(msg: RSAMessageClose | RSAMessagePing | RSAMessageSend) {
+  private publish(msg: RSAMessageClose | RSAMessageSend) {
     this.pub.publish(this.replyTo, this.pack(msg));
   }
 
+  // The origin server already closed the real socket; stop relaying without echoing a close back
+  markClosed() {
+    this.readyState = 3;
+  }
+
   close(code?: number, reason?: string) {
     if (this.readyState !== 1) return;
-    const msg: RSAMessageClose = {
-      type: 'close',
-      code,
-      reason,
-      socketId: this.socketId,
-    };
-    this.publish(msg);
-  }
-
-  ping() {
-    if (this.readyState !== 1) return;
-    const msg: RSAMessagePing = {
-      type: 'ping',
-      socketId: this.socketId,
-      replyTo: this.serverChannel,
-    };
-    this.publish(msg);
+    this.readyState = 3;
+    this.onClose?.(code, reason);
   }
 
   send(message: Uint8Array) {

apps/server/src/collaboration/extensions/redis-sync/redis-sync.extension.ts

@@ -3,27 +3,30 @@ import {
   Extension,
   Hocuspocus,
   IncomingMessage,
-  afterUnloadDocumentPayload,
   onConfigurePayload,
   onLoadDocumentPayload,
+  afterUnloadDocumentPayload,
+  WebSocketLike,
 } from '@hocuspocus/server';
+import { ConnectionTimeout, Unauthorized } from '@hocuspocus/common';
 import RedisClient from 'ioredis';
-import { readVarString } from 'lib0/decoding.js';
 import { CollabProxySocket } from './collab-proxy-socket';
 import {
-  BaseWebSocket,
   Configuration,
   CustomEvents,
   Pack,
   RSAMessage,
+  RSAMessageClose,
   RSAMessageCloseProxy,
   RSAMessageCustomEventComplete,
   RSAMessageCustomEventStart,
-  RSAMessagePong,
   RSAMessageProxy,
   RSAMessageUnload,
   SerializedHTTPRequest,
   Unpack,
+  OriginConnection,
+  ProxyConnection,
+  toWebRequest,
 } from './redis-sync.types';
 
 export type { Pack, SerializedHTTPRequest } from './redis-sync.types';
@@ -38,10 +41,10 @@ export class RedisSyncExtension<TCE extends CustomEvents> implements Extension {
   private sub: RedisClient;
   private readonly pack: Pack;
   private readonly unpack: Unpack;
-  private originSockets: Record<SocketId, BaseWebSocket> = {};
+  private originConnections: Record<SocketId, OriginConnection> = {};
   private locks: Record<DocumentName, NodeJS.Timeout> = {};
   private lockPromises: Record<DocumentName, Promise<ServerId | null>> = {};
-  private proxySockets: Record<SocketId, CollabProxySocket> = {};
+  private proxyConnections: Record<SocketId, ProxyConnection> = {};
   private readonly prefix: string;
   private readonly lockPrefix: string;
   private readonly msgChannel: string;
@@ -54,6 +57,9 @@ export class RedisSyncExtension<TCE extends CustomEvents> implements Extension {
   // @ts-ignore
   private pendingReplies: Record<number, PromiseWithResolvers<any>['resolve']> =
     {};
+  private deriveContext: (
+    serializedHTTPRequest: SerializedHTTPRequest,
+  ) => Record<string, any>;
 
   constructor(configuration: Configuration<TCE>) {
     const {
@@ -65,6 +71,7 @@ export class RedisSyncExtension<TCE extends CustomEvents> implements Extension {
       prefix,
       customEvents,
       customEventTTL,
+      deriveContext,
     } = configuration;
     this.pub = redis.duplicate();
     this.sub = redis.duplicate();
@@ -77,6 +84,7 @@ export class RedisSyncExtension<TCE extends CustomEvents> implements Extension {
     this.lockPrefix = `${this.prefix}Lock`;
     this.msgChannel = `${this.prefix}Msg`;
     this.customEvents = (customEvents as any) ?? ({} as any as CustomEvents);
+    this.deriveContext = deriveContext ?? (() => ({}));
     this.sub.subscribe(this.msgChannel, `${this.msgChannel}:${this.serverId}`);
     this.sub.on('messageBuffer', this.handleRedisMessage);
     this.pub.on('error', () => {});
@@ -87,44 +95,63 @@ export class RedisSyncExtension<TCE extends CustomEvents> implements Extension {
   }
 
   private closeProxy(socketId: string) {
-    const proxySocket = this.proxySockets[socketId];
-    if (proxySocket) {
-      proxySocket.emit(
-        'close',
-        1000,
-        Buffer.from('provider_initiated', 'utf-8'),
-      );
-      delete this.proxySockets[socketId];
+    const entry = this.proxyConnections[socketId];
+    if (entry) {
+      delete this.proxyConnections[socketId];
+      const { socket, clientConnection } = entry;
+      // The origin socket is already gone; don't echo a close message back
+      socket.markClosed();
+      clientConnection.handleClose({
+        code: 1000,
+        reason: 'provider_initiated',
+      });
     }
   }
 
-  private pongProxy(socketId: string) {
-    this.proxySockets[socketId]?.emit('pong');
-  }
-
   private handleProxyMessage(
     msg: Pick<RSAMessageProxy, 'replyTo' | 'message' | 'serializedHTTPRequest'>,
   ) {
     const { replyTo, message, serializedHTTPRequest } = msg;
     const { headers } = serializedHTTPRequest;
-    const socketId = headers['sec-websocket-key']!;
-    let socket = this.proxySockets[socketId];
-    if (!socket) {
-      socket = new CollabProxySocket(
+    const socketId = headers['sec-websocket-key'];
+    let entry = this.proxyConnections[socketId];
+    if (!entry) {
+      const socket = new CollabProxySocket(
         this.pub,
         this.pack,
         replyTo,
-        `${this.msgChannel}:${this.serverId}`,
         socketId,
       );
-      this.proxySockets[socketId] = socket;
-      this.instance.handleConnection(
-        socket as any,
-        serializedHTTPRequest as any,
-        {},
+      // A proxy connection with no live documents (client left the page, auth
+      // failed, or the origin server crashed) is reaped by hocuspocus' message
+      // timeout. Dispose it silently in that case: relaying the timeout close
+      // to the origin would kill the client's real socket, which may be busy
+      // serving other documents. Genuine protocol closes are still relayed.
+      socket.onClose = (code, reason) => {
+        delete this.proxyConnections[socketId];
+        if (code !== ConnectionTimeout.code) {
+          const msg: RSAMessageClose = {
+            type: 'close',
+            code,
+            reason,
+            socketId,
+          };
+          this.pub.publish(replyTo, this.pack(msg));
+        }
+      };
+      const clientConnection = this.instance.handleConnection(
+        socket,
+        toWebRequest(serializedHTTPRequest),
+        this.deriveContext(serializedHTTPRequest),
       );
+      entry = { clientConnection, socket };
+      this.proxyConnections[socketId] = entry;
     }
-    socket.emit('message', message);
+    entry.clientConnection.handleMessage(message);
+  }
+
+  private getLock(documentName: string) {
+    return this.pub.get(this.getKey(documentName));
   }
 
   private getOrClaimLock(documentName: string) {
@@ -166,10 +193,6 @@ export class RedisSyncExtension<TCE extends CustomEvents> implements Extension {
       this.closeProxy(msg.socketId);
       return;
     }
-    if (type === 'pong') {
-      this.pongProxy(msg.socketId);
-      return;
-    }
     if (type === 'unload') {
       delete this.lockPromises[msg.documentName];
       return;
@@ -198,22 +221,14 @@ export class RedisSyncExtension<TCE extends CustomEvents> implements Extension {
       return;
     }
     const { socketId } = msg;
-    const socket = this.originSockets[socketId];
-    if (!socket) {
+    const entry = this.originConnections[socketId];
+    if (!entry) {
       // origin socket already cleaned up
       return;
     }
+    const { socket } = entry;
     if (type === 'close') {
       socket.close(msg.code, msg.reason);
-    } else if (type === 'ping') {
-      // Reply instantly to the proxy socket, without forwarding to client
-      // The origin socket handles heartbeat for itself
-      const { replyTo, socketId } = msg;
-      const reply: RSAMessagePong = {
-        type: 'pong',
-        socketId,
-      };
-      this.pub.publish(`${replyTo}`, this.pack(reply));
     } else if (type === 'send') {
       socket.send(msg.message);
     }
@@ -251,6 +266,8 @@ export class RedisSyncExtension<TCE extends CustomEvents> implements Extension {
     eventName: TName,
     documentName: string,
     payload: any,
+    // if true, don't claim the lock. Useful for targeting pages that are currently open
+    onlyIfOpen = false,
   ) {
     const isDocLoadedOnInstance = this.instance.documents.has(documentName);
 
@@ -258,7 +275,14 @@ export class RedisSyncExtension<TCE extends CustomEvents> implements Extension {
       return this.handleEventLocally(eventName, documentName, payload);
     }
 
-    const proxyTo = await this.getOrClaimLockThrottled(documentName);
+    const proxyTo = await (onlyIfOpen
+      ? this.getLock(documentName)
+      : this.getOrClaimLockThrottled(documentName));
+
+    if (!proxyTo && onlyIfOpen) {
+      return;
+    }
+
     if (proxyTo && proxyTo !== this.serverId) {
       ++this.replyIdCounter; // bug in biome thinks this.replyIdCounter is not used if written on the line below
       const replyId = this.replyIdCounter;
@@ -277,7 +301,8 @@ export class RedisSyncExtension<TCE extends CustomEvents> implements Extension {
       const { promise, resolve, reject } = Promise.withResolvers();
       this.pendingReplies[replyId] = resolve;
       setTimeout(() => {
-        reject('TIMEOUT');
+        delete this.pendingReplies[replyId];
+        reject(new Error('TIMEOUT'));
       }, this.customEventTTL);
       return promise as Promise<ReturnType<TCE[TName]>>;
     }
@@ -296,36 +321,59 @@ export class RedisSyncExtension<TCE extends CustomEvents> implements Extension {
 
   /* WebSocket Server Hooks */
   onSocketOpen(
-    ws: BaseWebSocket,
+    ws: WebSocketLike,
     serializedHTTPRequest: SerializedHTTPRequest,
-    context = {},
   ) {
-    const socketId = serializedHTTPRequest.headers['sec-websocket-key']!;
-    this.originSockets[socketId] = ws;
-    this.instance.handleConnection(
-      ws as any,
-      serializedHTTPRequest as any,
-      context,
+    const socketId = serializedHTTPRequest.headers['sec-websocket-key'];
+    const clientConnection = this.instance.handleConnection(
+      ws,
+      toWebRequest(serializedHTTPRequest),
+      this.deriveContext(serializedHTTPRequest),
     );
+    this.originConnections[socketId] = { clientConnection, socket: ws };
   }
 
   async onSocketMessage(
-    ws: BaseWebSocket,
     serializedHTTPRequest: SerializedHTTPRequest,
     detachableMsg: ArrayBuffer,
   ) {
-    const message = new Uint8Array(detachableMsg.slice());
-    const tmpMsg = new IncomingMessage(detachableMsg);
-    const documentName = readVarString(tmpMsg.decoder);
+    const socketId = serializedHTTPRequest.headers['sec-websocket-key'];
+    const entry = this.originConnections[socketId];
+    if (!entry) return;
+    const { clientConnection } = entry;
+
+    let message: Uint8Array;
+    let documentName: string;
+    try {
+      message = new Uint8Array(detachableMsg.slice());
+      const tmpMsg = new IncomingMessage(detachableMsg);
+      const documentNameAndSessionId = tmpMsg.readVarString();
+      // session-aware providers suffix the documentName with \0sessionId
+      const sepIdx = documentNameAndSessionId.indexOf('\0');
+      documentName =
+        sepIdx === -1
+          ? documentNameAndSessionId
+          : documentNameAndSessionId.slice(0, sepIdx);
+    } catch (error) {
+      entry.socket.close(Unauthorized.code, Unauthorized.reason);
+      return;
+    }
     const isDocLoadedOnInstance = this.instance.documents.has(documentName);
 
     if (isDocLoadedOnInstance) {
-      ws.emit('message', message);
+      clientConnection.handleMessage(message);
       return;
     }
 
     const proxyTo = await this.getOrClaimLockThrottled(documentName);
     if (proxyTo && proxyTo !== this.serverId) {
+      // Proxied messages bypass handleMessage, so refresh the connection's
+      // liveness fields manually or hocuspocus' message timeout would reap the
+      // real socket every `timeout` ms. connectionEstablishedAt is the
+      // reference while unauthenticated (auth for remote docs is proxied too)
+      // and is private upstream.
+      clientConnection.lastMessageReceivedAt = Date.now();
+      (clientConnection as any).connectionEstablishedAt = Date.now();
       // another server owns the doc
       const proxyMessage: RSAMessageProxy = {
         serializedHTTPRequest: serializedHTTPRequest,
@@ -338,16 +386,17 @@ export class RedisSyncExtension<TCE extends CustomEvents> implements Extension {
       return;
     }
     // This server owns the document, but hocuspocus hasn't loaded it yet
-    ws.emit('message', message);
+    clientConnection.handleMessage(message);
   }
 
   onSocketClose(socketId: string, code?: number, reason?: ArrayBuffer) {
-    const socket = this.originSockets[socketId];
-    if (!socket) return;
-    // at this point the socket is considered GC'd and we cannot call close
-    // The origin socket did not set up any connections for the proxy, so none of the hooks will work if we just emit
-    socket?.emit('close', code, reason);
-    delete this.originSockets[socketId];
+    const entry = this.originConnections[socketId];
+    if (!entry) return;
+    delete this.originConnections[socketId];
+    entry.clientConnection.handleClose({
+      code: code ?? 1000,
+      reason: reason ? Buffer.from(reason).toString() : '',
+    });
     const msg: RSAMessageCloseProxy = { type: 'closeProxy', socketId };
     this.pub.publish(this.msgChannel, this.pack(msg)).catch(() => {});
   }
@@ -372,6 +421,7 @@ export class RedisSyncExtension<TCE extends CustomEvents> implements Extension {
   }
 
   async onDestroy() {
+    this.pendingReplies = {};
     this.pub.disconnect(false);
     this.sub.disconnect(false);
   }

apps/server/src/collaboration/extensions/redis-sync/redis-sync.types.ts

@@ -1,12 +1,13 @@
-import EventEmitter from 'node:events';
 import { IncomingHttpHeaders } from 'node:http2';
 import RedisClient from 'ioredis';
+import { CollabProxySocket } from './collab-proxy-socket';
+import { type Hocuspocus, type WebSocketLike } from '@hocuspocus/server';
 
 export type SecondParam<T> = T extends (
-  arg1: unknown,
+  arg1: any,
   arg2: infer A,
-  ...args: unknown[]
-) => unknown
+  ...args: any[]
+) => any
   ? A
   : never;
 
@@ -41,17 +42,6 @@ export type RSAMessageClose = {
   socketId: string;
 };
 
-export type RSAMessagePing = {
-  type: 'ping';
-  socketId: string;
-  replyTo: string;
-};
-
-export type RSAMessagePong = {
-  type: 'pong';
-  socketId: string;
-};
-
 export type RSAMessageSend = {
   type: 'send';
   // @ts-ignore
@@ -59,7 +49,7 @@ export type RSAMessageSend = {
   socketId: string;
 };
 
-export type RSAMessageCustomEventStart<TName = string, TPayload = unknown> = {
+export type RSAMessageCustomEventStart<TName = string, TPayload = any> = {
   type: 'customEventStart';
   documentName: string;
   eventName: TName;
@@ -71,7 +61,7 @@ export type RSAMessageCustomEventStart<TName = string, TPayload = unknown> = {
 export type RSAMessageCustomEventComplete = {
   type: 'customEventComplete';
   replyId: number;
-  payload: unknown;
+  payload: any;
 };
 
 export type RSAMessage =
@@ -79,8 +69,6 @@ export type RSAMessage =
   | RSAMessageCloseProxy
   | RSAMessageUnload
   | RSAMessageClose
-  | RSAMessagePing
-  | RSAMessagePong
   | RSAMessageSend
   | RSAMessageCustomEventStart
   | RSAMessageCustomEventComplete;
@@ -99,9 +87,20 @@ type CustomEventName = string;
 
 export type CustomEvents = Record<
   CustomEventName,
-  (documentName: string, payload: unknown) => Promise<unknown>
+  (documentName: string, payload: any) => Promise<any>
 >;
 
+// Not exported by @hocuspocus/server
+export type ClientConnection = ReturnType<Hocuspocus['handleConnection']>;
+export type OriginConnection = {
+  clientConnection: ClientConnection;
+  socket: WebSocketLike;
+};
+export type ProxyConnection = {
+  clientConnection: ClientConnection;
+  socket: CollabProxySocket;
+};
+
 export interface Configuration<TCE> {
   redis: RedisClient;
   pack: Pack;
@@ -111,11 +110,29 @@ export interface Configuration<TCE> {
   customEventTTL?: number;
   prefix?: string;
   customEvents?: TCE;
+  // Derive the hocuspocus context once per socket instead of re-deriving it in a
+  // per-document hook like onConnect/onAuthenticate. Runs on the origin server when
+  // the socket opens and on the doc owner when the first proxied message arrives.
+  deriveContext?: (
+    serializedHTTPRequest: SerializedHTTPRequest,
+  ) => Record<string, any>;
 }
 
-export type BaseWebSocket = EventEmitter & {
-  readyState: number;
-  close(code?: number, reason?: string): void;
-  ping(): void;
-  send(message: Uint8Array): void;
+// Hocuspocus expects a web-standard Request, so rehydrate one from what crossed the wire
+export const toWebRequest = (serializedHTTPRequest: SerializedHTTPRequest) => {
+  const { method, url, headers } = serializedHTTPRequest;
+  const webHeaders = new Headers();
+  Object.entries(headers).forEach(([name, value]) => {
+    if (Array.isArray(value)) {
+      value.forEach((v) => {
+        webHeaders.append(name, v);
+      });
+    } else if (value !== undefined) {
+      webHeaders.set(name, value);
+    }
+  });
+  return new Request(new URL(url, 'http://localhost'), {
+    method,
+    headers: webHeaders,
+  });
 };

apps/server/src/collaboration/extensions/redis-sync/ws-socket-wrapper.ts

@@ -1,20 +1,17 @@
-import { EventEmitter } from 'events';
 import type WebSocket from 'ws';
+import type { WebSocketLike } from '@hocuspocus/server';
 
 /**
- * Wrapper around ws WebSocket that only receives events via emit().
- * This prevents double-handling when used with RedisSyncExtension.
+ * Wrapper around ws WebSocket that Hocuspocus only writes to.
+ * Incoming socket events are forwarded separately by the gateway,
+ * which prevents double-handling with RedisSyncExtension.
  */
-export class WsSocketWrapper extends EventEmitter {
+export class WsSocketWrapper implements WebSocketLike {
   private ws: WebSocket;
   readyState = 1;
 
   constructor(ws: WebSocket) {
-    super();
     this.ws = ws;
-    this.once('close', () => {
-      this.readyState = 3;
-    });
   }
 
   close(code?: number, reason?: string) {
@@ -27,15 +24,6 @@ export class WsSocketWrapper extends EventEmitter {
     }
   }
 
-  ping() {
-    if (this.readyState !== 1) return;
-    try {
-      this.ws.ping();
-    } catch (e) {
-      // Socket already closed
-    }
-  }
-
   send(message: Uint8Array) {
     if (this.readyState !== 1) return;
     try {

apps/server/src/integrations/storage/drivers/s3.driver.ts

@@ -15,13 +15,21 @@ import { getMimeType } from '../../../common/helpers';
 import { Upload } from '@aws-sdk/lib-storage';
 import { Logger } from '@nestjs/common';
 
+const S3_MAX_SOCKETS = parseInt(process.env.AWS_S3_MAX_SOCKETS) || 200;
+
 export class S3Driver implements StorageDriver {
   private readonly s3Client: S3Client;
   private readonly config: S3StorageConfig;
 
   constructor(config: S3StorageConfig) {
-    this.config = config;
-    this.s3Client = new S3Client(config as any);
+    this.config = {
+      ...config,
+      requestHandler: {
+        httpAgent: { maxSockets: S3_MAX_SOCKETS },
+        httpsAgent: { maxSockets: S3_MAX_SOCKETS },
+      },
+    };
+    this.s3Client = new S3Client(this.config as any);
   }
 
   async upload(filePath: string, file: Buffer | Readable): Promise<void> {

package.json

@@ -23,41 +23,43 @@
     "@casl/ability": "6.8.0",
     "@docmost/editor-ext": "workspace:*",
     "@floating-ui/dom": "1.7.3",
-    "@hocuspocus/provider": "3.4.4",
-    "@hocuspocus/server": "3.4.4",
-    "@hocuspocus/transformer": "3.4.4",
+    "@hocuspocus/common": "4.4.0",
+    "@hocuspocus/provider": "4.4.0",
+    "@hocuspocus/provider-react": "4.4.0",
+    "@hocuspocus/server": "4.4.0",
+    "@hocuspocus/transformer": "4.4.0",
     "@joplin/turndown": "4.0.82",
     "@joplin/turndown-plugin-gfm": "1.0.64",
     "@sindresorhus/slugify": "3.0.0",
-    "@tiptap/core": "3.27.1",
-    "@tiptap/extension-audio": "3.27.1",
-    "@tiptap/extension-code-block": "3.27.1",
-    "@tiptap/extension-collaboration": "3.27.1",
-    "@tiptap/extension-collaboration-caret": "3.27.1",
-    "@tiptap/extension-color": "3.27.1",
-    "@tiptap/extension-document": "3.27.1",
-    "@tiptap/extension-heading": "3.27.1",
-    "@tiptap/extension-highlight": "3.27.1",
-    "@tiptap/extension-history": "3.27.1",
-    "@tiptap/extension-image": "3.27.1",
-    "@tiptap/extension-link": "3.27.1",
-    "@tiptap/extension-list": "3.27.1",
-    "@tiptap/extension-placeholder": "3.27.1",
-    "@tiptap/extension-subscript": "3.27.1",
-    "@tiptap/extension-superscript": "3.27.1",
-    "@tiptap/extension-table": "3.27.1",
-    "@tiptap/extension-text": "3.27.1",
-    "@tiptap/extension-text-align": "3.27.1",
-    "@tiptap/extension-text-style": "3.27.1",
-    "@tiptap/extension-typography": "3.27.1",
-    "@tiptap/extension-unique-id": "3.27.1",
-    "@tiptap/extension-youtube": "3.27.1",
-    "@tiptap/html": "3.27.1",
-    "@tiptap/pm": "3.27.1",
-    "@tiptap/react": "3.27.1",
-    "@tiptap/starter-kit": "3.27.1",
-    "@tiptap/suggestion": "3.27.1",
-    "@tiptap/y-tiptap": "3.0.5",
+    "@tiptap/core": "3.29.2",
+    "@tiptap/extension-audio": "3.29.2",
+    "@tiptap/extension-code-block": "3.29.2",
+    "@tiptap/extension-collaboration": "3.29.2",
+    "@tiptap/extension-collaboration-caret": "3.29.2",
+    "@tiptap/extension-color": "3.29.2",
+    "@tiptap/extension-document": "3.29.2",
+    "@tiptap/extension-heading": "3.29.2",
+    "@tiptap/extension-highlight": "3.29.2",
+    "@tiptap/extension-history": "3.29.2",
+    "@tiptap/extension-image": "3.29.2",
+    "@tiptap/extension-link": "3.29.2",
+    "@tiptap/extension-list": "3.29.2",
+    "@tiptap/extension-placeholder": "3.29.2",
+    "@tiptap/extension-subscript": "3.29.2",
+    "@tiptap/extension-superscript": "3.29.2",
+    "@tiptap/extension-table": "3.29.2",
+    "@tiptap/extension-text": "3.29.2",
+    "@tiptap/extension-text-align": "3.29.2",
+    "@tiptap/extension-text-style": "3.29.2",
+    "@tiptap/extension-typography": "3.29.2",
+    "@tiptap/extension-unique-id": "3.29.2",
+    "@tiptap/extension-youtube": "3.29.2",
+    "@tiptap/html": "3.29.2",
+    "@tiptap/pm": "3.29.2",
+    "@tiptap/react": "3.29.2",
+    "@tiptap/starter-kit": "3.29.2",
+    "@tiptap/suggestion": "3.29.2",
+    "@tiptap/y-tiptap": "3.0.7",
     "bytes": "3.1.2",
     "cross-env": "10.1.0",
     "date-fns": "4.1.0",
@@ -93,50 +95,5 @@
       "packages/*"
     ]
   },
-  "packageManager": "pnpm@10.4.0",
-  "pnpm": {
-    "patchedDependencies": {
-      "scimmy@1.3.5": "patches/scimmy@1.3.5.patch"
-    },
-    "overrides": {
-      "prosemirror-changeset": "2.4.0",
-      "y-prosemirror": "1.3.7",
-      "glob": "13.0.6",
-      "ws": "8.21.0",
-      "dompurify": "3.4.11",
-      "tmp": "0.2.7",
-      "hono": "4.12.25",
-      "mermaid": "11.15.0",
-      "nanoid@^3": "3.3.8",
-      "socket.io-parser": "4.2.6",
-      "serialize-javascript": "7.0.3",
-      "lodash-es": "4.18.1",
-      "lodash": "4.18.1",
-      "@hono/node-server": "1.19.13",
-      "undici": "7.28.0",
-      "ajv@^6": "6.14.0",
-      "ajv@^8": "8.18.0",
-      "underscore": "1.13.8",
-      "immutable": "4.3.8",
-      "express-rate-limit": "8.2.2",
-      "minimatch@^3": "3.1.5",
-      "minimatch@^5": "5.1.8",
-      "flatted": "3.4.2",
-      "picomatch@<2.3.2": "2.3.2",
-      "picomatch@>=4.0.0 <4.0.4": "4.0.4",
-      "fastify": "5.8.5",
-      "yaml@>=1.0.0 <1.10.3": "1.10.3",
-      "yaml@>=2.0.0 <2.8.3": "2.8.3",
-      "path-to-regexp@^8": "8.4.0",
-      "brace-expansion@^5": "5.0.6",
-      "@xmldom/xmldom": "0.8.13",
-      "handlebars": "4.7.9",
-      "axios": "1.16.0",
-      "langsmith": "0.7.0",
-      "follow-redirects": "1.16.0",
-      "protobufjs": "7.5.8",
-      "ip-address": "10.1.1"
-    },
-    "neverBuiltDependencies": []
-  }
+  "packageManager": "pnpm@11.15.1"
 }

packages/editor-ext/src/index.ts

@@ -30,6 +30,7 @@ export * from "./lib/shared-storage";
 export * from "./lib/recreate-transform";
 export * from "./lib/columns";
 export * from "./lib/status";
+export * from "./lib/tabs";
 export * from "./lib/pdf";
 export * from "./lib/page-break";
 export * from "./lib/resizable-nodeview";

packages/editor-ext/src/lib/markdown/utils/marked.utils.ts

@@ -2,6 +2,7 @@ import { marked } from "marked";
 import { calloutExtension } from "./callout.marked";
 import { mathBlockExtension } from "./math-block.marked";
 import { mathInlineExtension } from "./math-inline.marked";
+import { tabsExtension } from "./tabs.marked";
 
 marked.use({
   renderer: {
@@ -34,7 +35,12 @@ marked.use({
 });
 
 marked.use({
-  extensions: [calloutExtension, mathBlockExtension, mathInlineExtension],
+  extensions: [
+    calloutExtension,
+    mathBlockExtension,
+    mathInlineExtension,
+    tabsExtension,
+  ],
 });
 
 marked.setOptions({ breaks: true });

packages/editor-ext/src/lib/markdown/utils/tabs.marked.ts

@@ -0,0 +1,152 @@
+import { marked, type Token } from 'marked';
+
+interface MarkdownTab {
+  label: string;
+  text: string;
+  forceActive: boolean;
+}
+
+interface TabbedToken {
+  type: 'tabbed';
+  raw: string;
+  tabs: MarkdownTab[];
+  activeTabIndex: number;
+}
+
+const HEADER_RE =
+  /^===([!+])?\s*["'“”‘’]((?:\\["\\]|[^\\"'“”‘’\n])+?)["'“”‘’]\s*$/gm;
+
+export const tabsExtension = {
+  name: 'tabbed',
+  level: 'block',
+  start(src: string) {
+    return src.search(/^===(?:[!+])?\s*["'“”‘’]/m);
+  },
+  tokenizer(src: string): TabbedToken | undefined {
+    if (src.indexOf('===') === -1) return;
+
+    const headers: Array<{
+      index: number;
+      raw: string;
+      marker: string;
+      label: string;
+    }> = [];
+
+    HEADER_RE.lastIndex = 0;
+
+    for (let m = HEADER_RE.exec(src); m !== null; m = HEADER_RE.exec(src)) {
+      headers.push({
+        index: m.index,
+        raw: m[0],
+        marker: m[1] ?? '',
+        label: unescapeTabLabel(m[2].trim()),
+      });
+    }
+
+    if (headers.length < 1 || headers[0].index !== 0) return;
+
+    const tabs: MarkdownTab[] = [];
+    let consumed = 0;
+    let breakOutOfTabSet = false;
+
+    for (let i = 0; i < headers.length; i++) {
+      const h = headers[i];
+
+      if (i > 0 && h.marker === '!') break;
+
+      const headerEnd = h.index + h.raw.length;
+      const bodyStart =
+        src.charCodeAt(headerEnd) === 10 ? headerEnd + 1 : headerEnd;
+
+      const next = headers[i + 1];
+      const bodyLimit = next ? next.index : src.length;
+      let bodyEnd = bodyLimit;
+      let lineStart = bodyStart;
+      
+      while (lineStart < bodyLimit) {
+        const newlineIndex = src.indexOf('\n', lineStart);
+        const lineEnd =
+          newlineIndex === -1 || newlineIndex > bodyLimit
+            ? bodyLimit
+            : newlineIndex;
+
+        const line = src.slice(lineStart, lineEnd);
+        const isBlank = line.trim() === '';
+        const isIndented = /^( {2,4}|\t)/.test(line);
+
+        if (!isBlank && !isIndented) {
+          bodyEnd = lineStart;
+          breakOutOfTabSet = true;
+          break;
+        }
+
+        lineStart = lineEnd < bodyLimit ? lineEnd + 1 : bodyLimit;
+      }
+
+      let body = src.slice(bodyStart, bodyEnd).replace(/\n+$/, '');
+
+      if (body.length > 0) {
+        body = body
+          .split('\n')
+          .map((line) => line.replace(/^(?:\t| {2,4})/, ''))
+          .join('\n');
+      }
+
+      tabs.push({
+        label: h.label,
+        text: body,
+        forceActive: h.marker === '+',
+      });
+
+      consumed = bodyEnd;
+
+      if (breakOutOfTabSet) break;
+    }
+
+    if (tabs.length < 1) return;
+
+    const forcedActiveIndex = tabs.findIndex((t) => t.forceActive);
+
+    return {
+      type: 'tabbed',
+      raw: src.slice(0, consumed),
+      tabs,
+      activeTabIndex: Math.max(forcedActiveIndex, 0),
+    };
+  },
+  renderer(token: Token) {
+    const tabbedToken = token as TabbedToken;
+
+    const activeTabIndex = Math.max(
+      0,
+      Math.min(tabbedToken.activeTabIndex ?? 0, tabbedToken.tabs.length - 1),
+    );
+
+    const sections = tabbedToken.tabs.map((tab, index) => {
+      const label = escapeHtml(tab.label);
+      const panel = marked.parse(tab.text || '').toString();
+      const isActive = index === activeTabIndex;
+
+      const activeAttrs = isActive
+        ? 'data-tab-active="true"'
+        : 'data-tab-active="false"';
+
+      return `<div data-type="tab" aria-hidden="true" ${activeAttrs}><div data-type="tabLabel">${label}</div><div data-type="tabPanel" >${panel}</div></div>`;
+    });
+
+    return `<div data-type="tabs" data-active-tab="${activeTabIndex}">${sections.join('')}</div>`;
+  },
+};
+
+function unescapeTabLabel(value: string): string {
+  return value.replace(/\\(["\\])/g, '$1');
+}
+
+function escapeHtml(value: string): string {
+  return value
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}

packages/editor-ext/src/lib/markdown/utils/turndown.utils.ts

@@ -24,6 +24,7 @@ export function htmlToMarkdown(html: string): string {
     TurndownPluginGfm.tables,
     TurndownPluginGfm.strikethrough,
     TurndownPluginGfm.highlightedCodeBlock,
+    tabs,
     taskList,
     callout,
     preserveDetail,
@@ -38,6 +39,64 @@ export function htmlToMarkdown(html: string): string {
   return turndownService.turndown(html).replaceAll('<br>', ' ');
 }
 
+const hasPreviousTabs = (node: HTMLElement) => {
+  // we want to make this as cheap as reasonable since it
+  // would be preferable to return a false positive
+  // than to make the editor noticably slower
+  let el = node.previousElementSibling;
+  let checks = 0;
+
+  while (el) {
+    if (el.getAttribute('data-type') === 'tabs') return true;
+    el = el.previousElementSibling;
+    checks += 1;
+
+    if (checks === 100) return true;
+  }
+
+  return false;
+};
+
+function tabs(turndownService: _TurndownService) {
+  turndownService.addRule('tabs', {
+    filter: (node: HTMLInputElement) =>
+      node.nodeName === 'DIV' && node.getAttribute('data-type') === 'tabs',
+    replacement: (content: string, node: HTMLInputElement) => {
+      const tabNodes = Array.from(
+        node.querySelectorAll(':scope > div[data-type="tab"]'),
+      );
+      if (tabNodes.length === 0) return content;
+
+      const isNestedTabsNode =
+        node.parentElement?.closest('div[data-type="tabs"]') !== null;
+
+      const tabBlocks = tabNodes.map((tabNode, index) => {
+        const labelNode = tabNode.querySelector(
+          ':scope > div[data-type="tabLabel"]',
+        );
+        const panelNode = tabNode.querySelector(
+          ':scope > div[data-type="tabPanel"]',
+        );
+
+        const label = sanitizeTabLabel(labelNode?.textContent || 'Tab');
+        const panelMarkdown = panelNode
+          ? turndownService.turndown(panelNode.innerHTML).trim()
+          : '';
+
+        const isFirstTabInSet = index === 0;
+        const marker =
+          isFirstTabInSet && !isNestedTabsNode && hasPreviousTabs(node)
+            ? '!'
+            : '';
+
+        return `===${marker} "${label}"\n${indentMarkdownBlock(panelMarkdown)}`;
+      });
+
+      return `\n\n${tabBlocks.join('\n\n')}\n\n`;
+    },
+  });
+}
+
 function listParagraph(turndownService: _TurndownService) {
   turndownService.addRule('paragraph', {
     filter: ['p'],
@@ -53,7 +112,9 @@ function listParagraph(turndownService: _TurndownService) {
 function orderedListItem(turndownService: _TurndownService) {
   turndownService.addRule('orderedListItem', {
     filter: function (node: HTMLInputElement) {
-      return node.nodeName === 'LI' && node.getAttribute('data-type') !== 'taskItem';
+      return (
+        node.nodeName === 'LI' && node.getAttribute('data-type') !== 'taskItem'
+      );
     },
     replacement: (content: string, node: HTMLInputElement, options: any) => {
       const parent = node.parentNode as HTMLElement;
@@ -114,9 +175,7 @@ function taskList(turndownService: _TurndownService) {
       const prefix = `- ${isChecked ? '[x]' : '[ ]'} `;
 
       return (
-        prefix +
-        text +
-        (node.nextSibling && !/\n$/.test(text) ? '\n' : '')
+        prefix + text + (node.nextSibling && !/\n$/.test(text) ? '\n' : '')
       );
     },
   });
@@ -211,10 +270,25 @@ function video(turndownService: _TurndownService) {
     replacement: function (_content: string, node: HTMLInputElement) {
       const src = node.getAttribute('src') || '';
       const ariaLabel = node.getAttribute('aria-label');
-      const name = sanitizeMdLinkText(
-        ariaLabel || getBasename(src) || src,
-      );
+      const name = sanitizeMdLinkText(ariaLabel || getBasename(src) || src);
       return '[' + name + '](' + src + ')';
     },
   });
 }
+
+function sanitizeTabLabel(value: string): string {
+  return value
+    .replace(/[\r\n]+/g, ' ')
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .trim();
+}
+
+function indentMarkdownBlock(content: string): string {
+  if (!content) return '\t';
+
+  return content
+    .split('\n')
+    .map((line) => (line.trim() ? `\t${line}` : ''))
+    .join('\n');
+}

packages/editor-ext/src/lib/search-and-replace/search-and-replace.ts

@@ -422,6 +422,8 @@ export const SearchAndReplace = Extension.create<
         state: {
           init: () => DecorationSet.empty,
           apply({ doc, docChanged }, oldState) {
+            const storage = editor.storage.searchAndReplace;
+            if (!storage) return oldState;
             const {
               searchTerm,
               lastSearchTerm,
@@ -429,7 +431,7 @@ export const SearchAndReplace = Extension.create<
               lastCaseSensitive,
               resultIndex,
               lastResultIndex,
-            } = editor.storage.searchAndReplace;
+            } = storage;
 
             if (
               !docChanged &&

packages/editor-ext/src/lib/tabs/index.ts

@@ -0,0 +1,8 @@
+export { Tabs } from "./tabs";
+export { Tab } from "./tab";
+export { TabLabel } from "./tab-label";
+export { TabPanel } from "./tab-panel";
+export type { TabsOptions } from "./tabs";
+export type { TabOptions } from "./tab";
+export type { TabLabelOptions } from "./tab-label";
+export type { TabPanelOptions } from "./tab-panel";

packages/editor-ext/src/lib/tabs/tab-label.ts

@@ -0,0 +1,42 @@
+import { mergeAttributes, Node } from "@tiptap/core";
+
+export interface TabLabelOptions {
+  HTMLAttributes: Record<string, unknown>;
+}
+
+export const TabLabel = Node.create<TabLabelOptions>({
+  name: "tabLabel",
+  content: "inline*",
+  defining: true,
+  selectable: false,
+
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+    };
+  },
+
+  parseHTML() {
+    return [
+      {
+        tag: `div[data-type="${this.name}"]`,
+      },
+    ];
+  },
+
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "div",
+      mergeAttributes(
+        {
+          "data-type": this.name,
+          "aria-hidden": "true",
+          class: "not-draggable-match"
+        },
+        this.options.HTMLAttributes,
+        HTMLAttributes,
+      ),
+      0,
+    ];
+  },
+});

packages/editor-ext/src/lib/tabs/tab-panel.ts

@@ -0,0 +1,37 @@
+import { mergeAttributes, Node } from "@tiptap/core";
+
+export interface TabPanelOptions {
+  HTMLAttributes: Record<string, unknown>;
+}
+
+export const TabPanel = Node.create<TabPanelOptions>({
+  name: "tabPanel",
+  content: "block+",
+  defining: true,
+
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+    };
+  },
+
+  parseHTML() {
+    return [
+      {
+        tag: `div[data-type="${this.name}"]`,
+      },
+    ];
+  },
+
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "div",
+      mergeAttributes(
+        { "data-type": this.name, role: "tabpanel", class: "not-draggable-match" },
+        this.options.HTMLAttributes,
+        HTMLAttributes,
+      ),
+      0,
+    ];
+  },
+});

packages/editor-ext/src/lib/tabs/tab.ts

@@ -0,0 +1,72 @@
+import { mergeAttributes, Node } from '@tiptap/core';
+import { generateNodeId } from "../utils";
+
+export interface TabOptions {
+  HTMLAttributes: Record<string, unknown>;
+}
+
+export const Tab = Node.create<TabOptions>({
+  name: 'tab',
+  content: 'tabLabel tabPanel',
+  defining: true,
+  isolating: true,
+
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+    };
+  },
+
+  addAttributes() {
+    return {
+      id: {
+        default: '',
+        parseHTML: (element: HTMLElement) =>
+          element.getAttribute('data-tab-id') ?? generateNodeId(),
+        renderHTML: (attributes: { id?: string }) => ({
+          'data-tab-id': attributes.id ?? '',
+        }),
+      },
+      active: {
+        default: true,
+        parseHTML: (element: HTMLElement) => {
+          const rawValue = element.getAttribute('data-tab-active');
+          if (rawValue === null) {
+            return !element.hasAttribute('hidden');
+          }
+
+          return rawValue === 'true';
+        },
+        renderHTML: (attributes: { active?: boolean }) => {
+          const isActive = attributes.active !== false;
+
+          return {
+            'data-tab-active': isActive ? 'true' : 'false',
+            'aria-hidden': isActive ? 'false' : 'true',
+            ...(isActive ? {} : { hidden: 'hidden' }),
+          };
+        },
+      },
+    };
+  },
+
+  parseHTML() {
+    return [
+      {
+        tag: `div[data-type="${this.name}"]`,
+      },
+    ];
+  },
+
+  renderHTML({ HTMLAttributes }) {
+    return [
+      'div',
+      mergeAttributes(
+        { 'data-type': this.name },
+        this.options.HTMLAttributes,
+        HTMLAttributes,
+      ),
+      0,
+    ];
+  },
+});

packages/editor-ext/src/lib/tabs/tabs.ts

@@ -0,0 +1,463 @@
+import { InputRule, Node, Range, mergeAttributes } from '@tiptap/core';
+import { Fragment, type Node as PMNode } from '@tiptap/pm/model';
+import {
+  TextSelection,
+  type Transaction,
+  type EditorState,
+} from '@tiptap/pm/state';
+import { ReactNodeViewRenderer, type ReactNodeViewProps } from '@tiptap/react';
+import type { ComponentType } from 'react';
+import { generateNodeId } from '../utils';
+import { findParentNode } from '../table/utils';
+
+export interface TabsOptions {
+  HTMLAttributes: Record<string, unknown>;
+  view: ComponentType<ReactNodeViewProps<HTMLElement>> | null;
+}
+
+const TAB_INPUT_REGEX =
+  /^\s*===\s*["'“”‘’]((?:\\["\\]|[^\\"'“”‘’\n])+?)["'“”‘’]\s+$/;
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    tabs: {
+      insertTabs: (tabName?: string, range?: Range) => ReturnType;
+      insertTab: (pos: 'right' | 'left') => ReturnType;
+      moveTab: (pos: 'right' | 'left') => ReturnType;
+      setActiveTab: (index: number, tabsPos: number) => ReturnType;
+      deleteTabs: () => ReturnType;
+      updateTabLabel: (
+        index: number,
+        label: string,
+        tabsPos: number,
+      ) => ReturnType;
+    };
+  }
+}
+
+export const Tabs = Node.create<TabsOptions>({
+  name: 'tabs',
+  group: 'block',
+  content: 'tab+',
+  defining: true,
+  isolating: true,
+
+  addOptions() {
+    return { HTMLAttributes: {}, view: null };
+  },
+
+  addAttributes() {
+    return {
+      activeTab: {
+        default: 0,
+        parseHTML: (element) =>
+          Number(element.getAttribute('data-active-tab')) || 0,
+        renderHTML: (attributes) => ({
+          'data-active-tab': clampIndex(attributes.activeTab),
+        }),
+      },
+    };
+  },
+
+  parseHTML() {
+    return [{ tag: `div[data-type="${this.name}"]` }];
+  },
+
+  renderHTML({ HTMLAttributes }) {
+    return [
+      'div',
+      mergeAttributes(
+        { 'data-type': this.name },
+        this.options.HTMLAttributes,
+        HTMLAttributes,
+      ),
+      0,
+    ];
+  },
+
+  addNodeView() {
+    if (!this.options.view) return undefined;
+    this.editor.isInitialized = true;
+    return ReactNodeViewRenderer(this.options.view);
+  },
+
+  addInputRules() {
+    return [
+      new InputRule({
+        find: TAB_INPUT_REGEX,
+        handler: ({ range, match }) => {
+          const rawLabel = typeof match[1] === 'string' ? match[1] : 'Tab 1';
+          const label = rawLabel.replace(/\\(["\\])/g, '$1').trim();
+
+          this.editor.commands.insertTabs(label, range);
+        },
+      }),
+    ];
+  },
+
+  addCommands() {
+    const createTab = (
+      schema: EditorState['schema'],
+      label: string,
+      active: boolean,
+    ) => {
+      const { tab, tabLabel, tabPanel, paragraph } = schema.nodes;
+      if (!tab || !tabLabel || !tabPanel || !paragraph) return null;
+
+      return tab.create({ id: generateNodeId(), active }, [
+        tabLabel.create(null, schema.text(label || ' ')),
+        tabPanel.create(null, paragraph.create()),
+      ]);
+    };
+
+    const getTabPos = (doc: PMNode, tabsPos: number, tabIndex: number) => {
+      const pos = doc.resolve(tabsPos + 1);
+      return pos.posAtIndex(tabIndex, pos.depth);
+    };
+
+    const applyActiveTabState = (
+      tr: Transaction,
+      tabsPos: number,
+      previousIndex: number,
+      nextIndex: number,
+    ) => {
+      const tabsNode = tr.doc.nodeAt(tabsPos);
+      if (tabsNode?.type.name !== 'tabs' || tabsNode.childCount <= 0) {
+        return null;
+      }
+
+      const prev = clampIndex(previousIndex, tabsNode.childCount);
+      const next = clampIndex(nextIndex, tabsNode.childCount);
+
+      tr.setNodeMarkup(tabsPos, undefined, {
+        ...tabsNode.attrs,
+        activeTab: next,
+      });
+
+      const prevTabPos = getTabPos(tr.doc, tabsPos, prev);
+      const nextTabPos = getTabPos(tr.doc, tabsPos, next);
+
+      if (prev !== next) {
+        const prevTabNode = tr.doc.nodeAt(prevTabPos);
+        if (prevTabNode) {
+          tr.setNodeMarkup(prevTabPos, undefined, {
+            ...prevTabNode.attrs,
+            active: false,
+          });
+        }
+      }
+
+      const nextTabNode = tr.doc.nodeAt(nextTabPos);
+      if (nextTabNode) {
+        tr.setNodeMarkup(nextTabPos, undefined, {
+          ...nextTabNode.attrs,
+          active: true,
+        });
+      }
+
+      return nextTabPos;
+    };
+
+    const selectTabPanel = (
+      tr: Transaction,
+      tabsPos: number,
+      tabPos: number,
+    ) => {
+      const tabsNode = tr.doc.nodeAt(tabsPos);
+      if (tabsNode?.type.name !== 'tabs' || tabsNode.childCount <= 0) {
+        return null;
+      }
+
+      const tabNode = tr.doc.nodeAt(tabPos);
+      const labelSize = tabNode?.child(0).nodeSize ?? 0;
+      const panelContentPos = tabPos + 1 + labelSize + 1;
+
+      tr.setSelection(TextSelection.near(tr.doc.resolve(panelContentPos), 1));
+    };
+
+    return {
+      insertTabs:
+        (tabName?: string, range?: Range) =>
+        ({ tr, state, dispatch }) => {
+          const firstTab = createTab(state.schema, tabName ?? 'Tab 1', true);
+          if (!firstTab) return false;
+
+          const tabsNode = this.type.create(
+            {
+              activeTab: 0,
+            },
+            Fragment.fromArray([firstTab]),
+          );
+
+          const insertionPos = tr.selection.from;
+
+          if (range) {
+            tr.replaceRangeWith(
+              range.from,
+              range.to,
+              tabsNode,
+            ).scrollIntoView();
+          } else {
+            tr.replaceSelectionWith(tabsNode).scrollIntoView();
+          }
+
+          const firstTabPos = getTabPos(tr.doc, insertionPos, 0);
+          const firstTabNode = tr.doc.nodeAt(firstTabPos);
+          if (!firstTabNode) return false;
+
+          if (!range) {
+            const labelSize = firstTabNode.child(0)?.nodeSize ?? 0;
+            const panelContentPos = firstTabPos + 2 + labelSize + 2;
+
+            tr.setSelection(
+              TextSelection.near(tr.doc.resolve(panelContentPos), 1),
+            );
+          }
+
+          if (dispatch) dispatch(tr);
+          return true;
+        },
+
+      insertTab:
+        (pos: 'left' | 'right') =>
+        ({ state, tr, dispatch }) => {
+          const { $from } = state.selection;
+          const tabs = findParentNode(
+            (node) => node.type.name === this.name,
+            $from,
+          );
+          if (!tabs || tabs.node.childCount <= 0) return false;
+
+          const currentTabIndex = clampIndex(
+            tabs.node.attrs.activeTab,
+            tabs.node.childCount,
+          );
+
+          const insertIndex =
+            pos === 'right' ? currentTabIndex + 1 : currentTabIndex;
+
+          const newTab = createTab(state.schema, 'Tab', false);
+          if (!newTab) return false;
+
+          const insertPos = getTabPos(state.doc, tabs.pos, insertIndex);
+          tr.insert(insertPos, newTab);
+
+          const insertedTabPos = getTabPos(tr.doc, tabs.pos, insertIndex);
+          tr.setNodeMarkup(insertedTabPos, undefined, {
+            ...newTab.attrs,
+            active: true,
+          });
+
+          const previousActiveIndex =
+            pos === 'left' ? currentTabIndex + 1 : currentTabIndex;
+
+          const activeTabPos = applyActiveTabState(
+            tr,
+            tabs.pos,
+            previousActiveIndex,
+            insertIndex,
+          );
+          if (activeTabPos == null) return false;
+
+          selectTabPanel(tr, tabs.pos, insertedTabPos);
+          if (dispatch) dispatch(tr);
+          return true;
+        },
+
+      moveTab:
+        (pos: 'left' | 'right') =>
+        ({ state, tr, dispatch }) => {
+          const { $from } = state.selection;
+          const tabs = findParentNode(
+            (node) => node.type.name === this.name,
+            $from,
+          );
+          if (!tabs || tabs.node.childCount <= 1) return false;
+
+          const currentTabIndex = clampIndex(
+            tabs.node.attrs.activeTab,
+            tabs.node.childCount,
+          );
+
+          const targetIndex =
+            pos === 'left' ? currentTabIndex - 1 : currentTabIndex + 1;
+
+          if (targetIndex < 0 || targetIndex >= tabs.node.childCount)
+            return false;
+
+          const currentTabPos = getTabPos(state.doc, tabs.pos, currentTabIndex);
+          const currentTabNode = state.doc.nodeAt(currentTabPos);
+          if (!currentTabNode) return false;
+
+          const mappedCurrentTabPos = tr.mapping.map(currentTabPos);
+          tr.delete(
+            mappedCurrentTabPos,
+            mappedCurrentTabPos + currentTabNode.nodeSize,
+          );
+
+          const insertPos = getTabPos(tr.doc, tabs.pos, targetIndex);
+          tr.insert(insertPos, currentTabNode);
+
+          const movedTabPos = applyActiveTabState(
+            tr,
+            tabs.pos,
+            targetIndex,
+            targetIndex,
+          );
+          selectTabPanel(tr, tabs.pos, movedTabPos);
+
+          if (dispatch) dispatch(tr.scrollIntoView());
+          return true;
+        },
+
+      setActiveTab:
+        (index, tabsPos) =>
+        ({ state, tr, dispatch }) => {
+          const tabsNode = state.doc.nodeAt(tabsPos);
+          if (tabsNode?.childCount <= 0) return false;
+
+          const nextIndex = clampIndex(index, tabsNode.childCount);
+          const prevIndex = clampIndex(
+            tabsNode.attrs.activeTab,
+            tabsNode.childCount,
+          );
+
+          const activeTabPos = applyActiveTabState(
+            tr,
+            tabsPos,
+            prevIndex,
+            nextIndex,
+          );
+          if (activeTabPos == null) return false;
+
+          selectTabPanel(tr, tabsPos, activeTabPos);
+          if (dispatch) dispatch(tr.scrollIntoView());
+          return true;
+        },
+
+      updateTabLabel:
+        (index, label, tabsPos) =>
+        ({ state, tr, dispatch }) => {
+          const tabsNode = state.doc.nodeAt(tabsPos);
+          if (!tabsNode) return false;
+
+          const labelIndex = clampIndex(index, tabsNode.childCount);
+          const $tabs = state.doc.resolve(tabsPos + 1);
+          const tabPos = $tabs.posAtIndex(labelIndex, $tabs.depth);
+
+          const labelNode = state.doc.nodeAt(tabPos + 1);
+          const labelContentPos = tabPos + 2;
+
+          tr.replaceWith(
+            labelContentPos,
+            labelContentPos + labelNode.content.size,
+            state.schema.text(label || ' '),
+          );
+
+          if (dispatch) dispatch(tr);
+          return true;
+        },
+
+      deleteTab:
+        () =>
+        ({ state, tr, dispatch }) => {
+          const { $from } = state.selection;
+          const tabs = findParentNode(
+            (node) => node.type.name === this.name,
+            $from,
+          );
+          if (!tabs) return false;
+
+          if (tabs.node.childCount < 2) {
+            this.editor.commands.deleteTabs();
+            return true;
+          }
+
+          const currentTabIndex = clampIndex(
+            tabs.node.attrs.activeTab,
+            tabs.node.childCount,
+          );
+
+          const currentTabPos = getTabPos(state.doc, tabs.pos, currentTabIndex);
+          const currentTabNode = state.doc.nodeAt(currentTabPos);
+          if (!currentTabNode) return false;
+
+          const nextTabIndex =
+            currentTabIndex < tabs.node.childCount - 1
+              ? currentTabIndex
+              : currentTabIndex - 1;
+
+          tr.delete(currentTabPos, currentTabPos + currentTabNode.nodeSize);
+
+          const activeTabPos = applyActiveTabState(
+            tr,
+            tabs.pos,
+            nextTabIndex,
+            nextTabIndex,
+          );
+          if (activeTabPos == null) return false;
+
+          selectTabPanel(tr, tabs.pos, activeTabPos);
+
+          if (dispatch) dispatch(tr);
+          return true;
+        },
+
+      deleteTabs:
+        () =>
+        ({ state, tr, dispatch }) => {
+          const { $from } = state.selection;
+          const tabs = findParentNode(
+            (node) => node.type.name === this.name,
+            $from,
+          );
+          if (tabs?.node.childCount <= 0) return false;
+
+          tr.delete(tabs.pos, tabs.pos + tabs.node.nodeSize);
+
+          if (dispatch) dispatch(tr);
+          return true;
+        },
+    };
+  },
+
+  addKeyboardShortcuts() {
+    return {
+      Enter: ({ editor }) => {
+        const { state } = editor;
+        const { $from, empty } = state.selection;
+
+        if (!empty) return false;
+        if ($from.parent.content.size > 0) return false;
+
+        const tabsNode = findParentNode(
+          (node) => node.type.name === this.name,
+          $from,
+        );
+
+        if (!tabsNode) return false;
+        return editor
+          .chain()
+          .command(({ tr, state }) => {
+            const posAfter = $from.after(tabsNode.depth);
+            tr.delete($from.before(), $from.after());
+
+            const targetPos = tr.mapping.map(posAfter);
+            const paragraph = state.schema.nodes.paragraph.create();
+
+            tr.insert(targetPos, paragraph);
+            tr.setSelection(TextSelection.create(tr.doc, targetPos + 1));
+            return true;
+          })
+          .scrollIntoView()
+          .run();
+      },
+    };
+  },
+});
+
+const clampIndex = (value: unknown, length = Number.MAX_SAFE_INTEGER) => {
+  const parsed = Number(value ?? 0);
+  if (!Number.isFinite(parsed) || length <= 0) return 0;
+  return Math.max(0, Math.min(Math.trunc(parsed), length - 1));
+};

pnpm-workspace.yaml

@@ -1,3 +1,65 @@
 packages:
   - 'apps/*'
   - 'packages/*'
+patchedDependencies:
+  scimmy@1.3.5: patches/scimmy@1.3.5.patch
+overrides:
+  prosemirror-changeset: 2.4.0
+  y-prosemirror: 1.3.7
+  glob: 13.0.6
+  ws: 8.21.0
+  dompurify: 3.4.11
+  tmp: 0.2.7
+  hono: 4.12.25
+  mermaid: 11.15.0
+  nanoid@^3: 3.3.8
+  socket.io-parser: 4.2.6
+  serialize-javascript: 7.0.3
+  lodash-es: 4.18.1
+  lodash: 4.18.1
+  '@hono/node-server': 1.19.13
+  undici: 7.28.0
+  ajv@^6: 6.14.0
+  ajv@^8: 8.18.0
+  underscore: 1.13.8
+  immutable: 4.3.8
+  express-rate-limit: 8.2.2
+  minimatch@^3: 3.1.5
+  minimatch@^5: 5.1.8
+  flatted: 3.4.2
+  picomatch@<2.3.2: 2.3.2
+  picomatch@>=4.0.0 <4.0.4: 4.0.4
+  fastify: 5.8.5
+  yaml@>=1.0.0 <1.10.3: 1.10.3
+  yaml@>=2.0.0 <2.8.3: 2.8.3
+  path-to-regexp@^8: 8.4.0
+  brace-expansion@^5: 5.0.6
+  '@xmldom/xmldom': 0.8.13
+  handlebars: 4.7.9
+  axios: 1.18.1
+  langsmith: 0.7.0
+  follow-redirects: 1.16.0
+  protobufjs: 7.5.8
+  ip-address: 10.1.1
+  fast-uri: 3.1.3
+  form-data@>=4.0.0 <4.0.6: 4.0.6
+  nanoid@>=4.0.0 <5.0.9: 5.1.16
+  qs: 6.15.3
+  esbuild@>=0.27.3 <0.28.1: 0.28.1
+  '@babel/core@<=7.29.0': 7.29.7
+  '@opentelemetry/core@>=2.0.0 <2.8.0': 2.9.0
+  '@babel/plugin-transform-modules-systemjs@<=7.29.3': 7.29.7
+  brace-expansion@<1.1.13: 1.1.15
+  brace-expansion@>=2.0.0 <2.0.3: 2.0.3
+  js-yaml@>=3.0.0 <3.15.0: 3.15.0
+  js-yaml@>=4.0.0 <=4.1.1: 4.3.0
+shamefullyHoist: true
+minimumReleaseAge: 4320
+allowBuilds:
+  '@swc/core': true
+  bcrypt: true
+  core-js: true
+  esbuild: true
+  msgpackr-extract: true
+  nx: true
+  unrs-resolver: true