fix(client): keep space switcher dropdown inside its popover

* feat: page attachments endpoint

* feat: attachments modal

Dockerfile

@@ -42,7 +42,7 @@ RUN chown -R node:node /app
 
 USER node
 
-RUN pnpm install --frozen-lockfile --prod
+RUN pnpm install --frozen-lockfile --prod && rm -rf /home/node/.cache/pnpm
 
 RUN mkdir -p /app/data/storage
 

apps/client/public/locales/en-US/translation.json

@@ -387,6 +387,8 @@
   "Insert horizontal rule divider": "Insert horizontal rule divider",
   "Page break": "Page break",
   "Insert a page break for printing.": "Insert a page break for printing.",
+  "Footnote": "Footnote",
+  "Insert a footnote reference.": "Insert a footnote reference.",
   "Upload any image from your device.": "Upload any image from your device.",
   "Upload any video from your device.": "Upload any video from your device.",
   "Upload any audio from your device.": "Upload any audio from your device.",
@@ -508,11 +510,6 @@
   "Allow viewers to comment": "Allow viewers to comment",
   "Allow viewers to add comments on pages in this space.": "Allow viewers to add comments on pages in this space.",
   "Toggle viewer comments": "Toggle viewer comments",
-  "Hide comments from viewers": "Hide comments from viewers",
-  "Viewers cannot see or add comments on pages in this space.": "Viewers cannot see or add comments on pages in this space.",
-  "Toggle hide comments from viewers": "Toggle hide comments from viewers",
-  "Turn off 'Allow viewers to comment' first": "Turn off 'Allow viewers to comment' first",
-  "Turn off 'Hide comments from viewers' first": "Turn off 'Hide comments from viewers' first",
   "Public sharing is disabled at the workspace level": "Public sharing is disabled at the workspace level",
   "Prevent pages in this space from being shared publicly.": "Prevent pages in this space from being shared publicly.",
   "Page permissions": "Page permissions",
@@ -1294,5 +1291,16 @@
   "{{count}} rows deleted_one": "1 row deleted",
   "{{count}} rows deleted_other": "{{count}} rows deleted",
   "{{count}} selected_one": "1 selected",
-  "{{count}} selected_other": "{{count}} selected"
+  "{{count}} selected_other": "{{count}} selected",
+  "Compare": "Compare",
+  "Compare versions": "Compare versions",
+  "Select version from {{date}}": "Select version from {{date}}",
+  "Version actions for {{date}}": "Version actions for {{date}}",
+  "Comparing {{newer}} and {{older}}": "Comparing {{newer}} and {{older}}",
+  "Exit compare": "Exit compare",
+  "Search attachments...": "Search attachments...",
+  "Error loading attachments.": "Error loading attachments.",
+  "No attachments on this page yet.": "No attachments on this page yet.",
+  "Uploaded by {{name}}": "Uploaded by {{name}}",
+  "Download {{name}}": "Download {{name}}"
 }

apps/client/src/components/layouts/global/aside.tsx

@@ -11,13 +11,11 @@ import { pageEditorAtom } from "@/features/editor/atoms/editor-atoms.ts";
 import AsideChatPanel from "@/ee/ai-chat/components/aside-chat-panel";
 import { PageDetailsAside } from "@/features/page-details/components/page-details-aside.tsx";
 import { ASIDE_PANEL_ID } from "@/hooks/use-toggle-aside.tsx";
-import { useCanViewComments } from "@/features/comment/hooks/use-can-view-comments.ts";
 
 export default function Aside() {
   const [{ tab, isAsideOpen }, setAsideState] = useAtom(asideStateAtom);
   const { t } = useTranslation();
   const pageEditor = useAtomValue(pageEditorAtom);
-  const canViewComments = useCanViewComments();
   const closeAside = () => setAsideState((s) => ({ ...s, isAsideOpen: false }));
 
   useEffect(() => {
@@ -25,18 +23,12 @@ export default function Aside() {
     document.getElementById(ASIDE_PANEL_ID)?.focus();
   }, [isAsideOpen, tab]);
 
-  useEffect(() => {
-    if (isAsideOpen && tab === "comments" && !canViewComments) {
-      setAsideState({ tab: "", isAsideOpen: false });
-    }
-  }, [isAsideOpen, tab, canViewComments, setAsideState]);
-
   let title: string;
   let component: ReactNode;
 
   switch (tab) {
     case "comments":
-      component = canViewComments ? <CommentListWithTabs /> : null;
+      component = <CommentListWithTabs />;
       title = "Comments";
       break;
     case "toc":

apps/client/src/ee/ai-chat/components/chat-input.tsx

@@ -255,6 +255,7 @@ export default function ChatInput({
     },
     content: "",
     editable: true,
+    textDirection: "auto",
     immediatelyRender: true,
     shouldRerenderOnTransaction: false,
     autofocus: autofocus ? "end" : false,

apps/client/src/ee/features.ts

@@ -19,7 +19,6 @@ export const Feature = {
   SHARING_CONTROLS: 'sharing:controls',
   TEMPLATES: 'templates',
   VIEWER_COMMENTS: 'comment:viewer',
-  HIDE_COMMENTS: 'comment:hide',
   PERSONAL_SPACES: 'spaces:personal',
   DOCX_EXPORT: 'export:docx',
   BASES: 'bases',

apps/client/src/ee/security/components/space-hide-comments-toggle.tsx

@@ -1,62 +0,0 @@
-import { Group, Text, Switch, Tooltip } from "@mantine/core";
-import React, { useState } from "react";
-import { useTranslation } from "react-i18next";
-import { ISpace } from "@/features/space/types/space.types.ts";
-import { useUpdateSpaceMutation } from "@/features/space/queries/space-query.ts";
-import { useHasFeature } from "@/ee/hooks/use-feature.ts";
-import { Feature } from "@/ee/features.ts";
-import { useUpgradeLabel } from "@/ee/hooks/use-upgrade-label.ts";
-
-type SpaceHideCommentsToggleProps = {
-  space: ISpace;
-};
-
-export default function SpaceHideCommentsToggle({
-  space,
-}: SpaceHideCommentsToggleProps) {
-  const { t } = useTranslation();
-  const hasHideComments = useHasFeature(Feature.HIDE_COMMENTS);
-  const upgradeLabel = useUpgradeLabel();
-  const allowViewerCommentsEnabled =
-    space.settings?.comments?.allowViewerComments === true;
-  const isDisabled = !hasHideComments || allowViewerCommentsEnabled;
-  const tooltipLabel = !hasHideComments
-    ? upgradeLabel
-    : t("Turn off 'Allow viewers to comment' first");
-  const [checked, setChecked] = useState(
-    space.settings?.comments?.hideCommentsFromViewers === true,
-  );
-  const updateSpaceMutation = useUpdateSpaceMutation();
-
-  const handleChange = async (event: React.ChangeEvent<HTMLInputElement>) => {
-    const value = event.currentTarget.checked;
-    try {
-      await updateSpaceMutation.mutateAsync({
-        spaceId: space.id,
-        hideCommentsFromViewers: value,
-      });
-      setChecked(value);
-    } catch {
-      // error handled by mutation
-    }
-  };
-
-  return (
-    <Group justify="space-between" wrap="nowrap" gap="xl">
-      <div>
-        <Text size="md">{t("Hide comments from viewers")}</Text>
-        <Text size="sm" c="dimmed">
-          {t("Viewers cannot see or add comments on pages in this space.")}
-        </Text>
-      </div>
-      <Tooltip label={tooltipLabel} disabled={!isDisabled} refProp="rootRef">
-        <Switch
-          checked={checked}
-          onChange={handleChange}
-          disabled={isDisabled}
-          aria-label={t("Toggle hide comments from viewers")}
-        />
-      </Tooltip>
-    </Group>
-  );
-}

apps/client/src/ee/security/components/space-viewer-comments-toggle.tsx

@@ -17,12 +17,7 @@ export default function SpaceViewerCommentsToggle({
   const { t } = useTranslation();
   const hasViewerComments = useHasFeature(Feature.VIEWER_COMMENTS);
   const upgradeLabel = useUpgradeLabel();
-  const hideCommentsEnabled =
+  const isDisabled = !hasViewerComments;
-    space.settings?.comments?.hideCommentsFromViewers === true;
-  const isDisabled = !hasViewerComments || hideCommentsEnabled;
-  const tooltipLabel = !hasViewerComments
-    ? upgradeLabel
-    : t("Turn off 'Hide comments from viewers' first");
   const [checked, setChecked] = useState(
     space.settings?.comments?.allowViewerComments === true,
   );
@@ -50,7 +45,7 @@ export default function SpaceViewerCommentsToggle({
         </Text>
       </div>
       <Tooltip
-        label={tooltipLabel}
+        label={upgradeLabel}
         disabled={!isDisabled}
         refProp="rootRef"
       >

apps/client/src/ee/template/components/readonly-template-editor.tsx

@@ -41,6 +41,7 @@ export default function ReadonlyTemplateEditor({
       <EditorProvider
         editable={false}
         immediatelyRender={true}
+        textDirection="auto"
         extensions={extensions}
         content={template.content}
       />

apps/client/src/ee/template/pages/template-editor.tsx

@@ -87,6 +87,7 @@ export default function TemplateEditor() {
   const editor = useEditor({
     extensions: templateExtensions,
     content: "",
+    textDirection: "auto",
     editorProps: {
       scrollThreshold: 80,
       scrollMargin: 80,

apps/client/src/features/attachments/components/attachment-file-icon.tsx

@@ -0,0 +1,59 @@
+import { ThemeIcon } from "@mantine/core";
+import {
+  IconFile,
+  IconFileTypeCsv,
+  IconFileTypeDocx,
+  IconFileTypePdf,
+  IconFileTypePpt,
+  IconFileTypeXls,
+  IconFileZip,
+  IconMovie,
+  IconMusic,
+  IconPhoto,
+  type Icon,
+} from "@tabler/icons-react";
+
+const EXT_ICONS: Record<string, { icon: Icon; color: string }> = {
+  ".pdf": { icon: IconFileTypePdf, color: "red" },
+  ".doc": { icon: IconFileTypeDocx, color: "blue" },
+  ".docx": { icon: IconFileTypeDocx, color: "blue" },
+  ".xls": { icon: IconFileTypeXls, color: "teal" },
+  ".xlsx": { icon: IconFileTypeXls, color: "teal" },
+  ".csv": { icon: IconFileTypeCsv, color: "teal" },
+  ".ppt": { icon: IconFileTypePpt, color: "orange" },
+  ".pptx": { icon: IconFileTypePpt, color: "orange" },
+  ".zip": { icon: IconFileZip, color: "gray" },
+  ".rar": { icon: IconFileZip, color: "gray" },
+  ".7z": { icon: IconFileZip, color: "gray" },
+  ".tar": { icon: IconFileZip, color: "gray" },
+  ".gz": { icon: IconFileZip, color: "gray" },
+};
+
+const MIME_ICONS: Array<{ prefix: string; icon: Icon; color: string }> = [
+  { prefix: "image/", icon: IconPhoto, color: "grape" },
+  { prefix: "video/", icon: IconMovie, color: "violet" },
+  { prefix: "audio/", icon: IconMusic, color: "pink" },
+];
+
+interface AttachmentFileIconProps {
+  fileExt?: string;
+  mimeType?: string;
+}
+
+export function AttachmentFileIcon({
+  fileExt,
+  mimeType,
+}: AttachmentFileIconProps) {
+  const byExt = fileExt ? EXT_ICONS[fileExt.toLowerCase()] : undefined;
+  const byMime = mimeType
+    ? MIME_ICONS.find((entry) => mimeType.startsWith(entry.prefix))
+    : undefined;
+  const { icon: FileIcon, color } = byExt ??
+    byMime ?? { icon: IconFile, color: "gray" };
+
+  return (
+    <ThemeIcon variant="light" color={color} size={40} radius="md">
+      <FileIcon size={22} stroke={1.5} />
+    </ThemeIcon>
+  );
+}

apps/client/src/features/attachments/components/page-attachments-modal.tsx

@@ -0,0 +1,191 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+  ActionIcon,
+  Anchor,
+  Center,
+  Group,
+  Loader,
+  Modal,
+  ScrollArea,
+  Text,
+  Tooltip,
+} from "@mantine/core";
+import { IconDownload } from "@tabler/icons-react";
+import { useTranslation } from "react-i18next";
+import { SearchInput } from "@/components/common/search-input.tsx";
+import { CustomAvatar } from "@/components/ui/custom-avatar.tsx";
+import { usePageAttachmentsQuery } from "@/features/attachments/queries/attachment-query.ts";
+import { IPageAttachment } from "@/features/attachments/types/attachment.types.ts";
+import { AttachmentFileIcon } from "@/features/attachments/components/attachment-file-icon.tsx";
+import { formatBytes } from "@/lib";
+import { getFileUrl } from "@/lib/config.ts";
+import { formattedDate } from "@/lib/time.ts";
+
+interface PageAttachmentsModalProps {
+  pageId: string;
+  open: boolean;
+  onClose: () => void;
+}
+
+export default function PageAttachmentsModal({
+  pageId,
+  open,
+  onClose,
+}: PageAttachmentsModalProps) {
+  const { t } = useTranslation();
+
+  return (
+    <Modal
+      opened={open}
+      onClose={onClose}
+      title={t("Attachments")}
+      size={800}
+      closeButtonProps={{ "aria-label": t("Close") }}
+    >
+      <PageAttachmentsList pageId={pageId} />
+    </Modal>
+  );
+}
+
+function PageAttachmentsList({ pageId }: { pageId: string }) {
+  const { t } = useTranslation();
+  const [search, setSearch] = useState("");
+  const {
+    data,
+    isLoading,
+    isError,
+    isFetching,
+    fetchNextPage,
+    hasNextPage,
+    isFetchingNextPage,
+  } = usePageAttachmentsQuery(pageId, search);
+
+  const attachments = useMemo(
+    () => data?.pages.flatMap((page) => page.items) ?? [],
+    [data],
+  );
+
+  const loadMoreRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    const sentinel = loadMoreRef.current;
+    if (!sentinel || !hasNextPage) return;
+
+    const observer = new IntersectionObserver(
+      (entries) => {
+        if (entries[0].isIntersecting && !isFetching) {
+          fetchNextPage();
+        }
+      },
+      { threshold: 0.1 },
+    );
+
+    observer.observe(sentinel);
+    return () => observer.disconnect();
+  }, [fetchNextPage, hasNextPage, isFetching]);
+
+  const handleSearch = useCallback((value: string) => setSearch(value), []);
+
+  return (
+    <>
+      <SearchInput
+        onSearch={handleSearch}
+        placeholder={t("Search attachments...")}
+      />
+
+      {isLoading ? (
+        <Center py="xl">
+          <Loader size="sm" />
+        </Center>
+      ) : isError ? (
+        <Center py="xl">
+          <Text size="sm" c="dimmed">
+            {t("Error loading attachments.")}
+          </Text>
+        </Center>
+      ) : attachments.length === 0 ? (
+        <Center py="xl">
+          <Text size="sm" c="dimmed">
+            {search
+              ? t("No results found")
+              : t("No attachments on this page yet.")}
+          </Text>
+        </Center>
+      ) : (
+        <ScrollArea.Autosize mah={480} type="scroll" scrollbarSize={5}>
+          {attachments.map((attachment) => (
+            <AttachmentRow key={attachment.id} attachment={attachment} />
+          ))}
+          {hasNextPage && <div ref={loadMoreRef} style={{ height: 1 }} />}
+          {isFetchingNextPage && (
+            <Center py="sm">
+              <Loader size="sm" />
+            </Center>
+          )}
+        </ScrollArea.Autosize>
+      )}
+    </>
+  );
+}
+
+function AttachmentRow({ attachment }: { attachment: IPageAttachment }) {
+  const { t } = useTranslation();
+  const fileUrl = getFileUrl(attachment.url);
+
+  return (
+    <Group wrap="nowrap" gap="md" py="sm" pr="xs">
+      <AttachmentFileIcon
+        fileExt={attachment.fileExt}
+        mimeType={attachment.mimeType}
+      />
+
+      <div style={{ flex: 1, minWidth: 0 }}>
+        <Anchor
+          href={fileUrl}
+          target="_blank"
+          rel="noopener noreferrer"
+          size="sm"
+          fw={500}
+          c="inherit"
+          truncate="end"
+          style={{ display: "block" }}
+        >
+          {attachment.fileName}
+        </Anchor>
+        <Text size="xs" c="dimmed" mt={2} truncate="end">
+          {formatBytes(Number(attachment.fileSize))}
+          {" · "}
+          {formattedDate(new Date(attachment.createdAt))}
+        </Text>
+      </div>
+
+      {attachment.creator && (
+        <Tooltip
+          label={t("Uploaded by {{name}}", { name: attachment.creator.name })}
+          withArrow
+        >
+          <CustomAvatar
+            avatarUrl={attachment.creator.avatarUrl}
+            name={attachment.creator.name}
+            size="sm"
+          />
+        </Tooltip>
+      )}
+
+      <Tooltip label={t("Download attachment")} withArrow>
+        <ActionIcon
+          component="a"
+          href={fileUrl}
+          download={attachment.fileName}
+          target="_blank"
+          rel="noopener noreferrer"
+          variant="subtle"
+          color="gray"
+          aria-label={t("Download {{name}}", { name: attachment.fileName })}
+        >
+          <IconDownload size={18} />
+        </ActionIcon>
+      </Tooltip>
+    </Group>
+  );
+}

apps/client/src/features/attachments/queries/attachment-query.ts

@@ -0,0 +1,25 @@
+import {
+  InfiniteData,
+  keepPreviousData,
+  useInfiniteQuery,
+  UseInfiniteQueryResult,
+} from "@tanstack/react-query";
+import { getPageAttachments } from "@/features/attachments/services/attachment-service.ts";
+import { IPageAttachment } from "@/features/attachments/types/attachment.types.ts";
+import { IPagination } from "@/lib/types.ts";
+
+export function usePageAttachmentsQuery(
+  pageId: string,
+  search?: string,
+): UseInfiniteQueryResult<InfiniteData<IPagination<IPageAttachment>, unknown>> {
+  return useInfiniteQuery({
+    queryKey: ["page-attachments", pageId, search],
+    queryFn: ({ pageParam }) =>
+      getPageAttachments(pageId, { cursor: pageParam, query: search }),
+    enabled: !!pageId,
+    gcTime: 0,
+    placeholderData: keepPreviousData,
+    initialPageParam: undefined,
+    getNextPageParam: (lastPage) => lastPage.meta?.nextCursor ?? undefined,
+  });
+}

apps/client/src/features/attachments/services/attachment-service.ts

@@ -3,7 +3,17 @@ import loadImage from "blueimp-load-image";
 import {
   AvatarIconType,
   IAttachment,
+  IPageAttachment,
 } from "@/features/attachments/types/attachment.types.ts";
+import { IPagination, QueryParams } from "@/lib/types.ts";
+
+export async function getPageAttachments(
+  pageId: string,
+  params?: QueryParams,
+): Promise<IPagination<IPageAttachment>> {
+  const req = await api.post("/pages/attachments", { pageId, ...params });
+  return req.data;
+}
 
 async function compressAndResizeIcon(
   file: File,

apps/client/src/features/attachments/services/index.ts

@@ -1,4 +1,5 @@
 export {
+  getPageAttachments,
   uploadIcon,
   uploadUserAvatar,
   uploadSpaceIcon,

apps/client/src/features/attachments/types/attachment.types.ts

@@ -15,6 +15,15 @@ export interface IAttachment {
   deletedAt: string | null;
 }
 
+export interface IPageAttachment extends IAttachment {
+  url: string;
+  creator: {
+    id: string;
+    name: string;
+    avatarUrl: string | null;
+  } | null;
+}
+
 export enum AvatarIconType {
   AVATAR = "avatar",
   SPACE_ICON = "space-icon",

apps/client/src/features/comment/components/comment-editor.tsx

@@ -103,6 +103,7 @@ const CommentEditor = forwardRef(
       },
       content: defaultContent,
       editable,
+      textDirection: "auto",
       immediatelyRender: true,
       shouldRerenderOnTransaction: false,
       autofocus: (autofocus && "end") || false,

apps/client/src/features/comment/hooks/use-can-view-comments.ts

@@ -1,15 +0,0 @@
-import { useParams } from "react-router-dom";
-import { usePageQuery } from "@/features/page/queries/page-query.ts";
-import { useGetSpaceBySlugQuery } from "@/features/space/queries/space-query.ts";
-import { extractPageSlugId } from "@/lib";
-
-export function useCanViewComments(): boolean {
-  const { pageSlug } = useParams();
-  const { data: page } = usePageQuery({ pageId: extractPageSlugId(pageSlug) });
-  const { data: space } = useGetSpaceBySlugQuery(page?.space?.slug);
-
-  const canEdit = !page?.deletedAt && (page?.permissions?.canEdit ?? false);
-  return (
-    canEdit || space?.settings?.comments?.hideCommentsFromViewers !== true
-  );
-}

apps/client/src/features/editor/components/fixed-toolbar/groups/more-inserts-group.tsx

@@ -12,6 +12,7 @@ import {
   IconMathFunction,
   IconRotate2,
   IconSitemap,
+  IconSuperscript,
   IconTable,
   IconTag,
 } from "@tabler/icons-react";
@@ -270,6 +271,12 @@ export const MoreInsertsGroup: FC<Props> = ({ editor, templateMode }) => {
         >
           {t("Math block")}
         </Menu.Item>
+        <Menu.Item
+          leftSection={<IconSuperscript size={16} />}
+          onClick={() => editor.chain().focus().addFootnote().run()}
+        >
+          {t("Footnote")}
+        </Menu.Item>
       </Menu.Dropdown>
     </Menu>
   );

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

@@ -30,6 +30,7 @@ import {
   IconTag,
   IconMoodSmile,
   IconRotate2,
+  IconSuperscript,
 } from "@tabler/icons-react";
 import {
   CommandProps,
@@ -177,6 +178,16 @@ const CommandGroups: SlashMenuGroupedItemsType = {
       command: ({ editor, range }: CommandProps) =>
         editor.chain().focus().deleteRange(range).setPageBreak().run(),
     },
+    {
+      title: "Footnote",
+      description: "Insert a footnote reference.",
+      searchTerms: ["footnote", "reference", "citation", "note"],
+      icon: IconSuperscript,
+      command: ({ editor, range }: CommandProps) => {
+        editor.chain().focus().deleteRange(range).run();
+        editor.commands.addFootnote();
+      },
+    },
     {
       title: "Image",
       description: "Upload any image from your device.",

apps/client/src/features/editor/components/transclusion/transclusion-content.tsx

@@ -40,6 +40,7 @@ export default function TransclusionContent({ content }: Props) {
       <EditorProvider
         editable={false}
         immediatelyRender={true}
+        textDirection="auto"
         extensions={extensions}
         content={content as any}
       />

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

@@ -1,5 +1,6 @@
 import { markInputRule } from "@tiptap/core";
 import { StarterKit } from "@tiptap/starter-kit";
+import { Document } from "@tiptap/extension-document";
 import { Code } from "@tiptap/extension-code";
 import { TextAlign } from "@tiptap/extension-text-align";
 import { TaskList, TaskItem } from "@tiptap/extension-list";
@@ -63,6 +64,9 @@ import {
   TransclusionReference,
   TableView,
   BaseEmbed as BaseEmbedNode,
+  Footnotes,
+  Footnote,
+  FootnoteReference,
 } from "@docmost/editor-ext";
 import {
   randomElement,
@@ -132,6 +136,7 @@ lowlight.register("scala", scala);
 // @ts-ignore
 export const mainExtensions = [
   StarterKit.configure({
+    document: false,
     heading: false,
     undoRedo: false,
     link: false,
@@ -143,6 +148,9 @@ export const mainExtensions = [
     codeBlock: false,
     code: false,
   }),
+  Document.extend({
+    content: "block+ footnotes?",
+  }),
   // Override TipTap's Code extension to fix the inline code input rule.
   // The upstream regex /(^|[^`])`([^`]+)`(?!`)$/ captures the character
   // before the opening backtick as part of the match, causing markInputRule
@@ -203,7 +211,8 @@ export const mainExtensions = [
             parentName === "tableCell" ||
             parentName === "tableHeader" ||
             parentName === "callout" ||
-            parentName === "blockquote"
+            parentName === "blockquote" ||
+            parentName === "footnote"
           ) {
             return i18n.t("Write...");
           }
@@ -417,6 +426,9 @@ export const mainExtensions = [
   }).configure(),
   Columns,
   Column,
+  Footnotes,
+  Footnote,
+  FootnoteReference,
   AutoJoiner.configure({
     elementsToJoin: [],
   }),

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

@@ -82,8 +82,6 @@ import {
   getCollabSocket,
   releaseCollabSocket,
 } from "@/features/editor/collab-socket";
-import clsx from "clsx";
-import { useCanViewComments } from "@/features/comment/hooks/use-can-view-comments.ts";
 
 interface PageEditorProps {
   pageId: string;
@@ -198,7 +196,6 @@ function CollabPageEditor({
   const { pageSlug } = useParams();
   const slugId = extractPageSlugId(pageSlug);
   const currentPageEditMode = useAtomValue(currentPageEditModeAtom);
-  const canViewComments = useCanViewComments();
   const canScroll = useCallback(
     () => Boolean(isComponentMounted.current && editorRef.current),
     [isComponentMounted],
@@ -252,6 +249,7 @@ function CollabPageEditor({
     {
       extensions,
       editable,
+      textDirection: "auto",
       immediatelyRender: true,
       shouldRerenderOnTransaction: false,
       editorProps: {
@@ -375,7 +373,6 @@ function CollabPageEditor({
   };
 
   useEffect(() => {
-    if (!canViewComments) return;
     document.addEventListener("ACTIVE_COMMENT_EVENT", handleActiveCommentEvent);
     return () => {
       document.removeEventListener(
@@ -383,7 +380,7 @@ function CollabPageEditor({
         handleActiveCommentEvent,
       );
     };
-  }, [canViewComments]);
+  }, []);
 
   useEffect(() => {
     setActiveCommentId(null);
@@ -434,13 +431,7 @@ function CollabPageEditor({
   }
 
   return (
-    <div
+    <div className="editor-container" style={{ position: "relative" }}>
-      className={clsx(
-        "editor-container",
-        !canViewComments && "comments-hidden",
-      )}
-      style={{ position: "relative" }}
-    >
       <div ref={menuContainerRef}>
         <EditorContent editor={editor} />
 
@@ -490,21 +481,18 @@ function StaticPageEditor({
   content: any;
   ariaLabel: string;
 }) {
-  const canViewComments = useCanViewComments();
-
   return (
-    <div className={clsx(!canViewComments && "comments-hidden")}>
+    <EditorProvider
-      <EditorProvider
+      editable={false}
-        editable={false}
+      immediatelyRender={true}
-        immediatelyRender={true}
+      textDirection="auto"
-        extensions={mainExtensions}
+      extensions={mainExtensions}
-        content={content}
+      content={content}
-        editorProps={{
+      editorProps={{
-          attributes: {
+        attributes: {
-            "aria-label": ariaLabel,
+          "aria-label": ariaLabel,
-          },
+        },
-        }}
+      }}
-      />
+    />
-    </div>
   );
 }

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

@@ -85,6 +85,7 @@ export default function ReadonlyPageEditor({
         <EditorProvider
           editable={false}
           immediatelyRender={true}
+          textDirection="auto"
           extensions={titleExtensions}
           content={title}
         ></EditorProvider>
@@ -93,6 +94,7 @@ export default function ReadonlyPageEditor({
       <EditorProvider
         editable={false}
         immediatelyRender={true}
+        textDirection="auto"
         extensions={extensions}
         content={content}
         onCreate={({ editor }) => {

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

@@ -315,8 +315,3 @@
     height: 100%;
   }
 }
-
-.comments-hidden .ProseMirror .comment-mark {
-  background: none;
-  border-bottom: none;
-}

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

@@ -0,0 +1,26 @@
+.ProseMirror sup a.footnote-ref {
+  color: var(--mantine-primary-color-filled);
+  text-decoration: none;
+  cursor: pointer;
+  font-weight: 600;
+}
+
+.ProseMirror sup:has(a.footnote-ref) {
+  padding: 0 1px;
+}
+
+.ProseMirror ol.footnotes {
+  margin-top: 2rem;
+  padding-top: 0.75rem;
+  font-size: 0.875rem;
+  color: var(--mantine-color-dimmed);
+  list-style-type: decimal;
+}
+
+.ProseMirror ol.footnotes:has(li) {
+  border-top: 1px solid var(--mantine-color-default-border);
+}
+
+.ProseMirror ol.footnotes li p {
+  margin: 0.15rem 0;
+}

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

@@ -18,3 +18,4 @@
 @import "./columns.css";
 @import "./status.css";
 @import "./base-embed.css";
+@import "./footnotes.css";

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

@@ -54,7 +54,7 @@
         var(--mantine-color-dark-5)
       );
       font-weight: bold;
-      text-align: left;
+      text-align: start;
     }
 
     .column-resize-handle {

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

@@ -86,6 +86,7 @@ export function TitleEditor({
     },
     editable: editable,
     content: title,
+    textDirection: "auto",
     immediatelyRender: true,
     shouldRerenderOnTransaction: false,
     editorProps: {

apps/client/src/features/page-history/atoms/history-atoms.ts

@@ -6,4 +6,13 @@ export const activeHistoryPrevIdAtom = atom<string>("");
 export const highlightChangesAtom = atom<boolean>(true);
 
 export type DiffCounts = { added: number; deleted: number; total: number };
-export const diffCountsAtom = atom<DiffCounts | null>(null);
+export const diffCountsAtom = atom<DiffCounts | null>(
+  null as DiffCounts | null,
+);
+
+export type ComparePair = { newerId: string; olderId: string };
+export const compareModeAtom = atom<boolean>(false);
+export const compareSelectionAtom = atom<string[]>([]);
+export const comparePairAtom = atom<ComparePair | null>(
+  null as ComparePair | null,
+);

apps/client/src/features/page-history/components/css/history.module.css

@@ -1,7 +1,7 @@
 .history {
-  display: block;
+  display: flex;
+  align-items: center;
   width: 100%;
-  padding: var(--mantine-spacing-md);
   color: light-dark(var(--mantine-color-black), var(--mantine-color-dark-0));
 
   @mixin hover {
@@ -12,6 +12,28 @@
   }
 }
 
+.historyButton {
+  flex: 1;
+  min-width: 0;
+  color: inherit;
+}
+
+.compareCheckbox {
+  padding-left: var(--mantine-spacing-xs);
+}
+
+.itemMenu {
+  opacity: 0;
+  margin-right: var(--mantine-spacing-xs);
+}
+
+.history:hover .itemMenu,
+.history:focus-within .itemMenu,
+.history.active .itemMenu,
+.itemMenu[aria-expanded="true"] {
+  opacity: 1;
+}
+
 .historyEditor {
   :global(.ProseMirror) {
     padding: 0 !important;
@@ -77,3 +99,8 @@
   flex: 1;
   padding: rem(16px) rem(40px);
 }
+
+.compareBanner {
+  border-bottom: rem(1px) solid
+    light-dark(var(--mantine-color-gray-3), var(--mantine-color-dark-4));
+}

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

@@ -31,6 +31,7 @@ export function HistoryEditor({
   const editor = useEditor({
     extensions: mainExtensions,
     editable: false,
+    textDirection: "auto",
   });
 
   useEffect(() => {
@@ -170,7 +171,6 @@ export function HistoryEditor({
     }
 
     const total = addedCount + deletedCount;
-    // @ts-ignore
     setDiffCounts({ added: addedCount, deleted: deletedCount, total });
 
     editor.setOptions({

apps/client/src/features/page-history/components/history-item.tsx

@@ -1,10 +1,21 @@
-import { Text, Group, UnstyledButton, Avatar, Tooltip } from "@mantine/core";
+import {
+  Text,
+  Group,
+  UnstyledButton,
+  Avatar,
+  Tooltip,
+  ActionIcon,
+  Checkbox,
+  Menu,
+} from "@mantine/core";
+import { IconDots } from "@tabler/icons-react";
 import { CustomAvatar } from "@/components/ui/custom-avatar.tsx";
 import { formattedDate } from "@/lib/time";
 import classes from "./css/history.module.css";
 import clsx from "clsx";
 import { IPageHistory } from "@/features/page-history/types/page.types";
 import { memo, useCallback } from "react";
+import { useTranslation } from "react-i18next";
 
 const MAX_VISIBLE_AVATARS = 5;
 
@@ -15,6 +26,13 @@ interface HistoryItemProps {
   onHover?: (id: string, index: number) => void;
   onHoverEnd?: () => void;
   isActive: boolean;
+  compareMode: boolean;
+  isChecked: boolean;
+  isCheckboxDisabled: boolean;
+  canCompare: boolean;
+  onToggleCompare: (id: string) => void;
+  onStartCompare: (id: string) => void;
+  onRestore?: (id: string, index: number) => void;
 }
 
 const HistoryItem = memo(function HistoryItem({
@@ -24,10 +42,24 @@ const HistoryItem = memo(function HistoryItem({
   onHover,
   onHoverEnd,
   isActive,
+  compareMode,
+  isChecked,
+  isCheckboxDisabled,
+  canCompare,
+  onToggleCompare,
+  onStartCompare,
+  onRestore,
 }: HistoryItemProps) {
+  const { t } = useTranslation();
+  const date = formattedDate(new Date(historyItem.createdAt));
+
   const handleClick = useCallback(() => {
-    onSelect(historyItem.id, index);
+    if (compareMode) {
-  }, [onSelect, historyItem.id, index]);
+      onToggleCompare(historyItem.id);
+    } else {
+      onSelect(historyItem.id, index);
+    }
+  }, [compareMode, onToggleCompare, onSelect, historyItem.id, index]);
 
   const handleMouseEnter = useCallback(() => {
     onHover?.(historyItem.id, index);
@@ -37,63 +69,115 @@ const HistoryItem = memo(function HistoryItem({
   const hasContributors = contributors && contributors.length > 0;
 
   return (
-    <UnstyledButton
+    <div
-      p="xs"
+      className={clsx(classes.history, { [classes.active]: isActive })}
-      onClick={handleClick}
       onMouseEnter={handleMouseEnter}
       onMouseLeave={onHoverEnd}
-      className={clsx(classes.history, { [classes.active]: isActive })}
     >
-      <Text size="sm">{formattedDate(new Date(historyItem.createdAt))}</Text>
+      {compareMode && (
+        <Checkbox
+          size="xs"
+          className={classes.compareCheckbox}
+          checked={isChecked}
+          disabled={isCheckboxDisabled}
+          onChange={() => onToggleCompare(historyItem.id)}
+          aria-label={t("Select version from {{date}}", { date })}
+        />
+      )}
 
-      <Group gap={6} wrap="nowrap" mt={4}>
+      <UnstyledButton
-        {hasContributors ? (
+        p="xs"
-          <>
+        onClick={handleClick}
-            <Tooltip.Group openDelay={300} closeDelay={100}>
+        className={classes.historyButton}
-              <Avatar.Group spacing={8}>
+      >
-                {contributors.slice(0, MAX_VISIBLE_AVATARS).map((contributor) => (
+        <Text size="sm">{date}</Text>
-                  <Tooltip key={contributor.id} label={contributor.name} withArrow>
+
-                    <CustomAvatar
+        <Group gap={6} wrap="nowrap" mt={4}>
-                      size="sm"
+          {hasContributors ? (
-                      avatarUrl={contributor.avatarUrl}
+            <>
-                      name={contributor.name}
+              <Tooltip.Group openDelay={300} closeDelay={100}>
-                    />
+                <Avatar.Group spacing={8}>
-                  </Tooltip>
+                  {contributors
-                ))}
+                    .slice(0, MAX_VISIBLE_AVATARS)
-                {contributors.length > MAX_VISIBLE_AVATARS && (
+                    .map((contributor) => (
-                  <Tooltip
+                      <Tooltip
-                    withArrow
+                        key={contributor.id}
-                    label={contributors.slice(MAX_VISIBLE_AVATARS).map((c) => (
+                        label={contributor.name}
-                      <div key={c.id}>{c.name}</div>
+                        withArrow
+                      >
+                        <CustomAvatar
+                          size="sm"
+                          avatarUrl={contributor.avatarUrl}
+                          name={contributor.name}
+                        />
+                      </Tooltip>
                     ))}
-                  >
+                  {contributors.length > MAX_VISIBLE_AVATARS && (
-                    <Avatar size="sm" color="gray">
+                    <Tooltip
-                      +{contributors.length - MAX_VISIBLE_AVATARS}
+                      withArrow
-                    </Avatar>
+                      label={contributors
-                  </Tooltip>
+                        .slice(MAX_VISIBLE_AVATARS)
-                )}
+                        .map((c) => (
-              </Avatar.Group>
+                          <div key={c.id}>{c.name}</div>
-            </Tooltip.Group>
+                        ))}
-            {contributors.length === 1 && (
+                    >
+                      <Avatar size="sm" color="gray">
+                        +{contributors.length - MAX_VISIBLE_AVATARS}
+                      </Avatar>
+                    </Tooltip>
+                  )}
+                </Avatar.Group>
+              </Tooltip.Group>
+              {contributors.length === 1 && (
+                <Text size="sm" c="dimmed" lineClamp={1}>
+                  {contributors[0].name}
+                </Text>
+              )}
+            </>
+          ) : (
+            <>
+              <CustomAvatar
+                size="sm"
+                avatarUrl={historyItem.lastUpdatedBy?.avatarUrl}
+                name={historyItem.lastUpdatedBy?.name}
+              />
               <Text size="sm" c="dimmed" lineClamp={1}>
-                {contributors[0].name}
+                {historyItem.lastUpdatedBy?.name}
               </Text>
+            </>
+          )}
+        </Group>
+      </UnstyledButton>
+
+      {!compareMode && (
+        <Menu shadow="md" width={180} position="bottom-end">
+          <Menu.Target>
+            <ActionIcon
+              variant="subtle"
+              color="gray"
+              className={classes.itemMenu}
+              aria-label={t("Version actions for {{date}}", { date })}
+              onClick={(e) => e.stopPropagation()}
+            >
+              <IconDots size={18} />
+            </ActionIcon>
+          </Menu.Target>
+          <Menu.Dropdown>
+            <Menu.Item
+              disabled={!canCompare}
+              onClick={() => onStartCompare(historyItem.id)}
+            >
+              {t("Compare")}
+            </Menu.Item>
+            {onRestore && (
+              <Menu.Item onClick={() => onRestore(historyItem.id, index)}>
+                {t("Restore")}
+              </Menu.Item>
             )}
-          </>
+          </Menu.Dropdown>
-        ) : (
+        </Menu>
-          <>
+      )}
-            <CustomAvatar
+    </div>
-              size="sm"
-              avatarUrl={historyItem.lastUpdatedBy?.avatarUrl}
-              name={historyItem.lastUpdatedBy?.name}
-            />
-            <Text size="sm" c="dimmed" lineClamp={1}>
-              {historyItem.lastUpdatedBy?.name}
-            </Text>
-          </>
-        )}
-      </Group>
-    </UnstyledButton>
   );
 });
 

apps/client/src/features/page-history/components/history-list.tsx

@@ -6,8 +6,12 @@ import HistoryItem from "@/features/page-history/components/history-item";
 import {
   activeHistoryIdAtom,
   activeHistoryPrevIdAtom,
+  compareModeAtom,
+  comparePairAtom,
+  compareSelectionAtom,
   historyAtoms,
 } from "@/features/page-history/atoms/history-atoms";
+import { resolveComparePair } from "@/features/page-history/utils/resolve-compare-pair";
 import { useAtom, useSetAtom } from "jotai";
 import { useCallback, useEffect, useMemo, useRef } from "react";
 import {
@@ -32,6 +36,9 @@ function HistoryList({ pageId }: Props) {
   const [activeHistoryId, setActiveHistoryId] = useAtom(activeHistoryIdAtom);
   const setActiveHistoryPrevId = useSetAtom(activeHistoryPrevIdAtom);
   const setHistoryModalOpen = useSetAtom(historyAtoms);
+  const [compareMode, setCompareMode] = useAtom(compareModeAtom);
+  const [compareSelection, setCompareSelection] = useAtom(compareSelectionAtom);
+  const setComparePair = useSetAtom(comparePairAtom);
 
   const {
     data: pageHistoryData,
@@ -79,10 +86,58 @@ function HistoryList({ pageId }: Props) {
 
   const handleSelect = useCallback(
     (id: string, index: number) => {
+      setComparePair(null);
       setActiveHistoryId(id);
       setActiveHistoryPrevId(historyItems[index + 1]?.id ?? "");
     },
-    [historyItems, setActiveHistoryId, setActiveHistoryPrevId],
+    [historyItems, setActiveHistoryId, setActiveHistoryPrevId, setComparePair],
+  );
+
+  const handleToggleCompare = useCallback(
+    (id: string) => {
+      setCompareSelection((prev) => {
+        if (prev.includes(id)) return prev.filter((item) => item !== id);
+        if (prev.length >= 2) return prev;
+        return [...prev, id];
+      });
+    },
+    [setCompareSelection],
+  );
+
+  const handleStartCompare = useCallback(
+    (id: string) => {
+      setComparePair(null);
+      setCompareMode(true);
+      setCompareSelection([id]);
+    },
+    [setComparePair, setCompareMode, setCompareSelection],
+  );
+
+  const handleCancelCompare = useCallback(() => {
+    setCompareMode(false);
+    setCompareSelection([]);
+  }, [setCompareMode, setCompareSelection]);
+
+  const handleConfirmCompare = useCallback(() => {
+    const pair = resolveComparePair(historyItems, compareSelection);
+    if (!pair) return;
+    setComparePair(pair);
+    setCompareMode(false);
+    setCompareSelection([]);
+  }, [
+    historyItems,
+    compareSelection,
+    setComparePair,
+    setCompareMode,
+    setCompareSelection,
+  ]);
+
+  const handleRestoreItem = useCallback(
+    (id: string, index: number) => {
+      handleSelect(id, index);
+      confirmRestore(id);
+    },
+    [handleSelect, confirmRestore],
   );
 
   useEffect(() => {
@@ -138,6 +193,16 @@ function HistoryList({ pageId }: Props) {
             onHover={handleHover}
             onHoverEnd={clearPrefetchTimeout}
             isActive={historyItem.id === activeHistoryId}
+            compareMode={compareMode}
+            isChecked={compareSelection.includes(historyItem.id)}
+            isCheckboxDisabled={
+              !compareSelection.includes(historyItem.id) &&
+              compareSelection.length >= 2
+            }
+            canCompare={historyItems.length >= 2}
+            onToggleCompare={handleToggleCompare}
+            onStartCompare={handleStartCompare}
+            onRestore={canRestore ? handleRestoreItem : undefined}
           />
         ))}
         {hasNextPage && <div ref={loadMoreRef} style={{ height: 1 }} />}
@@ -148,22 +213,44 @@ function HistoryList({ pageId }: Props) {
         )}
       </ScrollArea>
 
-      {canRestore && (
+      {compareMode ? (
         <>
           <Divider />
           <Group p="xs" wrap="nowrap">
             <Button
               variant="default"
               size="compact-md"
-              onClick={() => setHistoryModalOpen(false)}
+              onClick={handleCancelCompare}
             >
               {t("Cancel")}
             </Button>
-            <Button size="compact-md" onClick={confirmRestore}>
+            <Button
-              {t("Restore")}
+              size="compact-md"
+              disabled={compareSelection.length !== 2}
+              onClick={handleConfirmCompare}
+            >
+              {t("Compare")}
             </Button>
           </Group>
         </>
+      ) : (
+        canRestore && (
+          <>
+            <Divider />
+            <Group p="xs" wrap="nowrap">
+              <Button
+                variant="default"
+                size="compact-md"
+                onClick={() => setHistoryModalOpen(false)}
+              >
+                {t("Cancel")}
+              </Button>
+              <Button size="compact-md" onClick={() => confirmRestore()}>
+                {t("Restore")}
+              </Button>
+            </Group>
+          </>
+        )
       )}
     </div>
   );

apps/client/src/features/page-history/components/history-modal-body.tsx

@@ -1,5 +1,6 @@
 import {
   ActionIcon,
+  CloseButton,
   Group,
   Paper,
   ScrollArea,
@@ -12,17 +13,20 @@ import { useAtom, useAtomValue } from "jotai";
 import {
   activeHistoryIdAtom,
   activeHistoryPrevIdAtom,
+  comparePairAtom,
   diffCountsAtom,
   highlightChangesAtom,
 } from "@/features/page-history/atoms/history-atoms";
 import HistoryView from "@/features/page-history/components/history-view";
-import { useRef } from "react";
+import { useMemo, useRef } from "react";
 import { IconChevronUp, IconChevronDown } from "@tabler/icons-react";
 import { useTranslation } from "react-i18next";
 import {
   useDiffNavigation,
   useHistoryReset,
 } from "@/features/page-history/hooks";
+import { usePageHistoryListQuery } from "@/features/page-history/queries/page-history-query";
+import { formattedDate } from "@/lib/time";
 
 interface Props {
   pageId: string;
@@ -36,6 +40,28 @@ export default function HistoryModalBody({ pageId }: Props) {
   const activeHistoryPrevId = useAtomValue(activeHistoryPrevIdAtom);
   const [highlightChanges, setHighlightChanges] = useAtom(highlightChangesAtom);
   const diffCounts = useAtomValue(diffCountsAtom);
+  const [comparePair, setComparePair] = useAtom(comparePairAtom);
+
+  const { data: pageHistoryData } = usePageHistoryListQuery(pageId);
+  const historyItems = useMemo(
+    () => pageHistoryData?.pages.flatMap((page) => page.items) ?? [],
+    [pageHistoryData],
+  );
+
+  const compareLabel = useMemo(() => {
+    if (!comparePair) return null;
+    const newerItem = historyItems.find(
+      (item) => item.id === comparePair.newerId,
+    );
+    const olderItem = historyItems.find(
+      (item) => item.id === comparePair.olderId,
+    );
+    if (!newerItem || !olderItem) return null;
+    return t("Comparing {{newer}} and {{older}}", {
+      newer: formattedDate(new Date(newerItem.createdAt)),
+      older: formattedDate(new Date(olderItem.createdAt)),
+    });
+  }, [comparePair, historyItems, t]);
 
   useHistoryReset(pageId);
   const { currentChangeIndex, handlePrevChange, handleNextChange } =
@@ -50,6 +76,25 @@ export default function HistoryModalBody({ pageId }: Props) {
       </nav>
 
       <div style={{ position: "relative", flex: 1 }}>
+        {comparePair && (
+          <Group
+            justify="space-between"
+            wrap="nowrap"
+            px="md"
+            py={4}
+            className={classes.compareBanner}
+          >
+            <Text size="sm" fw={500} lineClamp={1}>
+              {compareLabel ?? t("Compare versions")}
+            </Text>
+            <CloseButton
+              size="sm"
+              aria-label={t("Exit compare")}
+              onClick={() => setComparePair(null)}
+            />
+          </Group>
+        )}
+
         <ScrollArea
           h={650}
           w="100%"
@@ -57,11 +102,18 @@ export default function HistoryModalBody({ pageId }: Props) {
           viewportRef={scrollViewportRef}
         >
           <div className={classes.sidebarRightSection}>
-            {activeHistoryId && <HistoryView />}
+            {comparePair ? (
+              <HistoryView
+                historyId={comparePair.newerId}
+                prevHistoryId={comparePair.olderId}
+              />
+            ) : (
+              activeHistoryId && <HistoryView />
+            )}
           </div>
         </ScrollArea>
 
-        {activeHistoryId && activeHistoryPrevId && (
+        {(comparePair || (activeHistoryId && activeHistoryPrevId)) && (
           <Paper
             shadow="md"
             radius="xl"

apps/client/src/features/page-history/components/history-modal-mobile.tsx

@@ -166,7 +166,7 @@ export default function HistoryModalMobile({ pageId, pageTitle }: Props) {
           <Button variant="default" onClick={() => setHistoryModalOpen(false)}>
             {t("Cancel")}
           </Button>
-          <Button onClick={confirmRestore}>{t("Restore")}</Button>
+          <Button onClick={() => confirmRestore()}>{t("Restore")}</Button>
         </Group>
       )}
 

apps/client/src/features/page-history/components/history-view.tsx

@@ -7,21 +7,29 @@ import {
   activeHistoryPrevIdAtom,
 } from "@/features/page-history/atoms/history-atoms";
 
-function HistoryView() {
+interface Props {
+  historyId?: string;
+  prevHistoryId?: string;
+}
+
+function HistoryView({ historyId, prevHistoryId }: Props) {
   const { t } = useTranslation();
-  const historyId = useAtomValue(activeHistoryIdAtom);
+  const activeId = useAtomValue(activeHistoryIdAtom);
-  const prevHistoryId = useAtomValue(activeHistoryPrevIdAtom);
+  const activePrevId = useAtomValue(activeHistoryPrevIdAtom);
+
+  const resolvedId = historyId ?? activeId;
+  const resolvedPrevId = prevHistoryId ?? activePrevId;
 
   const {
     data,
     isLoading: isLoadingCurrent,
     isError: isErrorCurrent,
-  } = usePageHistoryQuery(historyId);
+  } = usePageHistoryQuery(resolvedId);
   const {
     data: prevData,
     isLoading: isLoadingPrev,
     isError: isErrorPrev,
-  } = usePageHistoryQuery(prevHistoryId);
+  } = usePageHistoryQuery(resolvedPrevId);
 
   if (isLoadingCurrent || isLoadingPrev) {
     return <></>;

apps/client/src/features/page-history/hooks/use-history-reset.ts

@@ -3,22 +3,45 @@ import { useEffect } from "react";
 import {
   activeHistoryIdAtom,
   activeHistoryPrevIdAtom,
+  compareModeAtom,
+  comparePairAtom,
+  compareSelectionAtom,
   diffCountsAtom,
 } from "@/features/page-history/atoms/history-atoms";
 
 /**
  * Resets history state when pageId changes.
- * Clears active selection and diff counts.
+ * Clears active selection, diff counts, and compare state.
+ * Compare state also resets on unmount so reopening the modal starts clean.
  */
 export function useHistoryReset(pageId: string) {
   const [, setActiveHistoryId] = useAtom(activeHistoryIdAtom);
   const [, setActiveHistoryPrevId] = useAtom(activeHistoryPrevIdAtom);
   const [, setDiffCounts] = useAtom(diffCountsAtom);
+  const [, setCompareMode] = useAtom(compareModeAtom);
+  const [, setCompareSelection] = useAtom(compareSelectionAtom);
+  const [, setComparePair] = useAtom(comparePairAtom);
 
   useEffect(() => {
+    const resetCompare = () => {
+      setCompareMode(false);
+      setCompareSelection([]);
+      setComparePair(null);
+    };
+
     setActiveHistoryId("");
     setActiveHistoryPrevId("");
-    // @ts-ignore
     setDiffCounts(null);
-  }, [pageId, setActiveHistoryId, setActiveHistoryPrevId, setDiffCounts]);
+    resetCompare();
+
+    return resetCompare;
+  }, [
+    pageId,
+    setActiveHistoryId,
+    setActiveHistoryPrevId,
+    setDiffCounts,
+    setCompareMode,
+    setCompareSelection,
+    setComparePair,
+  ]);
 }

apps/client/src/features/page-history/hooks/use-history-restore.tsx

@@ -1,4 +1,4 @@
-import { useAtom, useAtomValue, useSetAtom } from "jotai";
+import { useAtomValue, useSetAtom } from "jotai";
 import { useCallback } from "react";
 import { useTranslation } from "react-i18next";
 import { Text } from "@mantine/core";
@@ -9,7 +9,8 @@ import {
   activeHistoryIdAtom,
   historyAtoms,
 } from "@/features/page-history/atoms/history-atoms";
-import { usePageHistoryQuery } from "@/features/page-history/queries/page-history-query";
+import { fetchPageHistory } from "@/features/page-history/queries/page-history-query";
+import { IPageHistory } from "@/features/page-history/types/page.types";
 import {
   pageEditorAtom,
   titleEditorAtom,
@@ -25,8 +26,6 @@ export function useHistoryRestore() {
   const { t } = useTranslation();
 
   const activeHistoryId = useAtomValue(activeHistoryIdAtom);
-  const { data: activeHistoryData } = usePageHistoryQuery(activeHistoryId);
-
   const mainEditor = useAtomValue(pageEditorAtom);
   const mainEditorTitle = useAtomValue(titleEditorAtom);
   const setHistoryModalOpen = useSetAtom(historyAtoms);
@@ -40,47 +39,66 @@ export function useHistoryRestore() {
     SpaceCaslSubject.Page,
   );
 
-  const handleRestore = useCallback(() => {
+  const handleRestore = useCallback(
-    if (!activeHistoryData) return;
+    async (historyId: string) => {
-    if (
+      let historyData: IPageHistory;
-      !mainEditor ||
+      try {
-      mainEditor.isDestroyed ||
+        historyData = await fetchPageHistory(historyId);
-      !mainEditorTitle ||
+      } catch {
-      mainEditorTitle.isDestroyed
+        notifications.show({
-    ) {
+          message: t("Error fetching page data."),
-      return;
+          color: "red",
-    }
+        });
+        return;
+      }
 
-    mainEditorTitle
+      if (
-      .chain()
+        !mainEditor ||
-      .clearContent()
+        mainEditor.isDestroyed ||
-      .setContent(activeHistoryData.title, { emitUpdate: true })
+        !mainEditorTitle ||
-      .run();
+        mainEditorTitle.isDestroyed
+      ) {
+        return;
+      }
 
-    mainEditor
+      mainEditorTitle
-      .chain()
+        .chain()
-      .clearContent()
+        .clearContent()
-      .setContent(activeHistoryData.content)
+        .setContent(historyData.title, { emitUpdate: true })
-      .run();
+        .run();
 
-    setHistoryModalOpen(false);
+      mainEditor
-    notifications.show({ message: t("Successfully restored") });
+        .chain()
-  }, [activeHistoryData, mainEditor, mainEditorTitle, setHistoryModalOpen, t]);
+        .clearContent()
+        .setContent(historyData.content)
+        .run();
 
-  const confirmRestore = useCallback(() => {
+      setHistoryModalOpen(false);
-    modals.openConfirmModal({
+      notifications.show({ message: t("Successfully restored") });
-      title: t("Please confirm your action"),
+    },
-      children: (
+    [mainEditor, mainEditorTitle, setHistoryModalOpen, t],
-        <Text size="sm">
+  );
-          {t(
+
-            "Are you sure you want to restore this version? Any changes not versioned will be lost.",
+  const confirmRestore = useCallback(
-          )}
+    (historyId?: string) => {
-        </Text>
+      const targetId = historyId ?? activeHistoryId;
-      ),
+      if (!targetId) return;
-      labels: { confirm: t("Confirm"), cancel: t("Cancel") },
+
-      onConfirm: handleRestore,
+      modals.openConfirmModal({
-    });
+        title: t("Please confirm your action"),
-  }, [t, handleRestore]);
+        children: (
+          <Text size="sm">
+            {t(
+              "Are you sure you want to restore this version? Any changes not versioned will be lost.",
+            )}
+          </Text>
+        ),
+        labels: { confirm: t("Confirm"), cancel: t("Cancel") },
+        onConfirm: () => handleRestore(targetId),
+      });
+    },
+    [t, handleRestore, activeHistoryId],
+  );
 
   return { canRestore, confirmRestore };
 }

apps/client/src/features/page-history/queries/page-history-query.ts

@@ -23,6 +23,14 @@ export function prefetchPageHistory(historyId: string) {
   });
 }
 
+export function fetchPageHistory(historyId: string): Promise<IPageHistory> {
+  return queryClient.fetchQuery({
+    queryKey: ["page-history", historyId],
+    queryFn: () => getPageHistoryById(historyId),
+    staleTime: HISTORY_STALE_TIME,
+  });
+}
+
 export function usePageHistoryListQuery(
   pageId: string,
 ): UseInfiniteQueryResult<InfiniteData<IPagination<IPageHistory>, unknown>> {

apps/client/src/features/page-history/utils/resolve-compare-pair.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { resolveComparePair } from "./resolve-compare-pair";
+
+// list is newest-first, matching usePageHistoryListQuery order
+const items = [{ id: "v3" }, { id: "v2" }, { id: "v1" }];
+
+describe("resolveComparePair", () => {
+  it("orders newer before older regardless of selection order", () => {
+    expect(resolveComparePair(items, ["v1", "v3"])).toEqual({
+      newerId: "v3",
+      olderId: "v1",
+    });
+    expect(resolveComparePair(items, ["v3", "v1"])).toEqual({
+      newerId: "v3",
+      olderId: "v1",
+    });
+  });
+
+  it("returns null unless exactly two versions are selected", () => {
+    expect(resolveComparePair(items, [])).toBeNull();
+    expect(resolveComparePair(items, ["v1"])).toBeNull();
+    expect(resolveComparePair(items, ["v1", "v2", "v3"])).toBeNull();
+  });
+
+  it("returns null when a selected id is not in the list", () => {
+    expect(resolveComparePair(items, ["v1", "missing"])).toBeNull();
+  });
+
+  it("returns null when the same id is selected twice", () => {
+    expect(resolveComparePair(items, ["v2", "v2"])).toBeNull();
+  });
+});

apps/client/src/features/page-history/utils/resolve-compare-pair.ts

@@ -0,0 +1,18 @@
+import { ComparePair } from "@/features/page-history/atoms/history-atoms";
+
+/**
+ * Resolves which of the two selected versions is newer using their position
+ * in the history list (list is newest-first: lower index = newer).
+ */
+export function resolveComparePair(
+  historyItems: { id: string }[],
+  selection: string[],
+): ComparePair | null {
+  if (selection.length !== 2) return null;
+  const indexA = historyItems.findIndex((item) => item.id === selection[0]);
+  const indexB = historyItems.findIndex((item) => item.id === selection[1]);
+  if (indexA === -1 || indexB === -1 || indexA === indexB) return null;
+  return indexA < indexB
+    ? { newerId: selection[0], olderId: selection[1] }
+    : { newerId: selection[1], olderId: selection[0] };
+}

apps/client/src/features/page/components/header/page-header-menu.tsx

@@ -11,6 +11,7 @@ import {
   IconList,
   IconMarkdown,
   IconMessage,
+  IconPaperclip,
   IconPrinter,
   IconStar,
   IconStarFilled,
@@ -42,6 +43,7 @@ import {
 import { formattedDate } from "@/lib/time.ts";
 import { PageEditModeToggle } from "@/features/user/components/page-state-pref.tsx";
 import MovePageModal from "@/features/page/components/move-page-modal.tsx";
+import PageAttachmentsModal from "@/features/attachments/components/page-attachments-modal.tsx";
 import { useTimeAgo } from "@/hooks/use-time-ago.tsx";
 import { PageShareModal } from "@/ee/page-permission";
 import {
@@ -58,7 +60,6 @@ import {
   useWatchPageMutation,
   useUnwatchPageMutation,
 } from "@/features/page/queries/watcher-query";
-import { useCanViewComments } from "@/features/comment/hooks/use-can-view-comments.ts";
 
 interface PageHeaderMenuProps {
   readOnly?: boolean;
@@ -66,7 +67,6 @@ interface PageHeaderMenuProps {
 export default function PageHeaderMenu({ readOnly }: PageHeaderMenuProps) {
   const { t } = useTranslation();
   const commentsTriggerProps = useAsideTriggerProps("comments");
-  const canViewComments = useCanViewComments();
   const tocTriggerProps = useAsideTriggerProps("toc");
   const { pageSlug } = useParams();
   const { data: page } = usePageQuery({
@@ -107,18 +107,16 @@ export default function PageHeaderMenu({ readOnly }: PageHeaderMenuProps) {
 
       <PageShareModal readOnly={readOnly} />
 
-      {canViewComments && (
+      <Tooltip label={t("Comments")} openDelay={250} withArrow>
-        <Tooltip label={t("Comments")} openDelay={250} withArrow>
+        <ActionIcon
-          <ActionIcon
+          variant="subtle"
-            variant="subtle"
+          color="dark"
-            color="dark"
+          aria-label={t("Comments")}
-            aria-label={t("Comments")}
+          {...commentsTriggerProps}
-            {...commentsTriggerProps}
+        >
-          >
+          <IconMessage size={20} stroke={2} />
-            <IconMessage size={20} stroke={2} />
+        </ActionIcon>
-          </ActionIcon>
+      </Tooltip>
-        </Tooltip>
-      )}
 
       {!page?.isBase && (
         <Tooltip label={t("Table of contents")} openDelay={250} withArrow>
@@ -161,6 +159,10 @@ function PageActionMenu({ readOnly }: PageActionMenuProps) {
     verificationOpened,
     { open: openVerificationModal, close: closeVerificationModal },
   ] = useDisclosure(false);
+  const [
+    attachmentsOpened,
+    { open: openAttachmentsModal, close: closeAttachmentsModal },
+  ] = useDisclosure(false);
   const [pageEditor] = useAtom(pageEditorAtom);
   const pageUpdatedAt = useTimeAgo(page?.updatedAt);
   const favoriteIds = useFavoriteIds("page", page?.spaceId);
@@ -297,6 +299,15 @@ function PageActionMenu({ readOnly }: PageActionMenuProps) {
             </Menu.Item>
           )}
 
+          {!page?.isBase && (
+            <Menu.Item
+              leftSection={<IconPaperclip size={16} />}
+              onClick={openAttachmentsModal}
+            >
+              {t("Attachments")}
+            </Menu.Item>
+          )}
+
           {!readOnly && !page?.isBase && (
             <PageVerificationMenuItem
               pageId={page?.id}
@@ -399,6 +410,12 @@ function PageActionMenu({ readOnly }: PageActionMenuProps) {
         opened={verificationOpened}
         onClose={closeVerificationModal}
       />
+
+      <PageAttachmentsModal
+        pageId={page.id}
+        open={attachmentsOpened}
+        onClose={closeAttachmentsModal}
+      />
     </>
   );
 }

apps/client/src/features/space/components/sidebar/space-select.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useState } from "react";
+import React, { useEffect, useRef, useState } from "react";
 import { useDebouncedValue } from "@mantine/hooks";
 import { Group, Select, SelectProps, Text } from "@mantine/core";
 import { useGetSpacesQuery } from "@/features/space/queries/space-query.ts";
@@ -14,6 +14,7 @@ interface SpaceSelectProps {
   width?: number;
   opened?: boolean;
   clearable?: boolean;
+  withinPortal?: boolean;
 }
 
 const renderSelectOption: SelectProps["renderOption"] = ({ option }) => (
@@ -41,6 +42,7 @@ export function SpaceSelect({
   width,
   opened,
   clearable,
+  withinPortal = true,
 }: SpaceSelectProps) {
   const { t } = useTranslation();
   const [searchValue, setSearchValue] = useState("");
@@ -50,9 +52,13 @@ export function SpaceSelect({
     limit: 50,
   });
   const [data, setData] = useState([]);
+  const fetchedSpaces = useRef(new Map<string, ISpace>());
 
   useEffect(() => {
     if (spaces) {
+      spaces.items.forEach((space: ISpace) =>
+        fetchedSpaces.current.set(space.slug, space),
+      );
       const spaceData = spaces?.items
         .filter((space: ISpace) => space.slug !== value)
         .map((space: ISpace) => {
@@ -83,14 +89,19 @@ export function SpaceSelect({
       onSearchChange={setSearchValue}
       clearable={clearable}
       variant="filled"
-      onChange={(slug) =>
+      onChange={(slug) => {
-        onChange(spaces.items?.find((item) => item.slug === slug))
+        // options accumulate across fetches; resolve against everything
-      }
+        // fetched, not just the latest query result
+        const space = slug && fetchedSpaces.current.get(slug);
+        if (space) {
+          onChange(space);
+        }
+      }}
       onClick={(e) => e.stopPropagation()}
       nothingFoundMessage={t("No space found")}
       limit={50}
       checkIconPosition="right"
-      comboboxProps={{ width, withinPortal: true, position: "bottom", keepMounted: false, dropdownPadding: 0 }}
+      comboboxProps={{ width, withinPortal, position: "bottom", keepMounted: false, dropdownPadding: 0 }}
       dropdownOpened={opened}
     />
   );

apps/client/src/features/space/components/sidebar/switch-space.test.tsx

@@ -0,0 +1,118 @@
+import { beforeAll, describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { MantineProvider } from "@mantine/core";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { MemoryRouter, useLocation } from "react-router-dom";
+import { SwitchSpace } from "./switch-space.tsx";
+
+vi.mock("@/main.tsx", async () => {
+  const { QueryClient } = await import("@tanstack/react-query");
+  return { queryClient: new QueryClient() };
+});
+
+const SPACES = [
+  { id: "1", name: "General", slug: "general", logo: null },
+  { id: "2", name: "Engineering", slug: "engineering", logo: null },
+  { id: "3", name: "Marketing", slug: "marketing", logo: null },
+];
+
+vi.mock("@/features/space/services/space-service.ts", () => ({
+  getSpaces: vi.fn(async () => ({ items: SPACES, meta: {} })),
+  getSpaceById: vi.fn(),
+  getSpaceMembers: vi.fn(),
+  addSpaceMember: vi.fn(),
+  changeMemberRole: vi.fn(),
+  removeSpaceMember: vi.fn(),
+  createSpace: vi.fn(),
+  updateSpace: vi.fn(),
+  deleteSpace: vi.fn(),
+}));
+
+beforeAll(() => {
+  window.matchMedia = ((query: string) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: () => {},
+    removeListener: () => {},
+    addEventListener: () => {},
+    removeEventListener: () => {},
+    dispatchEvent: () => false,
+  })) as unknown as typeof window.matchMedia;
+  window.ResizeObserver = class {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+  } as unknown as typeof window.ResizeObserver;
+  Element.prototype.scrollIntoView = () => {};
+});
+
+function LocationProbe() {
+  const location = useLocation();
+  return <div data-testid="location">{location.pathname}</div>;
+}
+
+function renderSwitcher() {
+  const client = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+  return render(
+    <MantineProvider>
+      <QueryClientProvider client={client}>
+        <MemoryRouter initialEntries={["/s/general"]}>
+          <SwitchSpace spaceName="General" spaceSlug="general" />
+          <LocationProbe />
+        </MemoryRouter>
+      </QueryClientProvider>
+    </MantineProvider>,
+  );
+}
+
+function getOption(name: string) {
+  const options = screen.getAllByRole("option", { hidden: true });
+  const match = options.find((option) => option.textContent?.includes(name));
+  if (!match) {
+    throw new Error(`option ${name} not found`);
+  }
+  return match;
+}
+
+async function openSwitcher() {
+  fireEvent.click(screen.getByRole("button", { name: /general/i }));
+  const dialog = await screen.findByRole("dialog", { hidden: true });
+  await screen.findAllByRole("option", { hidden: true });
+  return dialog;
+}
+
+describe("SwitchSpace", () => {
+  it("renders the space options inside the popover so option clicks are not outside clicks", async () => {
+    renderSwitcher();
+    const dialog = await openSwitcher();
+    const listbox = screen.getByRole("listbox", { hidden: true });
+    expect(dialog.contains(listbox)).toBe(true);
+  });
+
+  it("keeps the popover open when an option is pressed with the mouse", async () => {
+    renderSwitcher();
+    const dialog = await openSwitcher();
+    fireEvent.mouseDown(getOption("Marketing"));
+    await new Promise((resolve) => setTimeout(resolve, 400));
+    expect(document.body.contains(dialog)).toBe(true);
+  });
+
+  it("navigates to the space picked from search results", async () => {
+    renderSwitcher();
+    await openSwitcher();
+    fireEvent.change(screen.getByPlaceholderText("Search for spaces"), {
+      target: { value: "mark" },
+    });
+    await waitFor(() => getOption("Marketing"));
+    const option = getOption("Marketing");
+    fireEvent.mouseDown(option);
+    fireEvent.mouseUp(option);
+    fireEvent.click(option);
+    await waitFor(() =>
+      expect(screen.getByTestId("location").textContent).toBe("/s/marketing"),
+    );
+  });
+});

apps/client/src/features/space/components/sidebar/switch-space.tsx

@@ -64,12 +64,15 @@ export function SwitchSpace({
         </Button>
       </Popover.Target>
       <Popover.Dropdown>
+        {/* keep the options dropdown inside the popover; a portaled dropdown
+            registers as an outside click and closes the popover mid-selection */}
         <SpaceSelect
           label={spaceName}
           value={spaceSlug}
           onChange={(space) => handleSelect(space.slug)}
           width={300}
           opened={true}
+          withinPortal={false}
         />
       </Popover.Dropdown>
     </Popover>

apps/client/src/features/space/components/space-security-settings.tsx

@@ -4,7 +4,6 @@ import { useTranslation } from "react-i18next";
 import { ISpace } from "@/features/space/types/space.types.ts";
 import SpacePublicSharingToggle from "@/ee/security/components/space-public-sharing-toggle.tsx";
 import SpaceViewerCommentsToggle from "@/ee/security/components/space-viewer-comments-toggle.tsx";
-import SpaceHideCommentsToggle from "@/ee/security/components/space-hide-comments-toggle.tsx";
 
 type SpaceSecuritySettingsProps = {
   space: ISpace;
@@ -30,10 +29,6 @@ export default function SpaceSecuritySettings({
       <Divider my="lg" />
 
       <SpaceViewerCommentsToggle space={space} />
-
-      <Divider my="lg" />
-
-      <SpaceHideCommentsToggle space={space} />
     </div>
   );
 }

apps/client/src/features/space/types/space.types.ts

@@ -11,7 +11,6 @@ export interface ISpaceSharingSettings {
 
 export interface ISpaceCommentsSettings {
   allowViewerComments?: boolean;
-  hideCommentsFromViewers?: boolean;
 }
 
 export interface ISpaceSettings {
@@ -37,7 +36,6 @@ export interface ISpace {
   // for updates
   disablePublicSharing?: boolean;
   allowViewerComments?: boolean;
-  hideCommentsFromViewers?: boolean;
 }
 
 interface IMembership {

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

@@ -1,4 +1,5 @@
 import { StarterKit } from '@tiptap/starter-kit';
+import { Document } from '@tiptap/extension-document';
 import { TextAlign } from '@tiptap/extension-text-align';
 import { Superscript } from '@tiptap/extension-superscript';
 import SubScript from '@tiptap/extension-subscript';
@@ -45,8 +46,16 @@ import {
   TransclusionSource,
   TransclusionReference,
   BaseEmbed,
+  Footnotes,
+  Footnote,
+  FootnoteReference,
 } from '@docmost/editor-ext';
-import { generateText, getSchema, JSONContent } from '@tiptap/core';
+import {
+  extensions as coreExtensions,
+  generateText,
+  getSchema,
+  JSONContent,
+} from '@tiptap/core';
 import { generateHTML, generateJSON } from '../common/helpers/prosemirror/html';
 // @tiptap/html library works best for generating prosemirror json state but not HTML
 // see: https://github.com/ueberdosis/tiptap/issues/5352
@@ -57,12 +66,17 @@ import * as Y from 'yjs';
 import { Logger } from '@nestjs/common';
 
 export const tiptapExtensions = [
+  coreExtensions.TextDirection.configure({ direction: 'auto' }),
   StarterKit.configure({
+    document: false,
     codeBlock: false,
     link: false,
     trailingNode: false,
     heading: false,
   }),
+  Document.extend({
+    content: 'block+ footnotes?',
+  }),
   Heading,
   UniqueID.configure({
     types: ['heading', 'paragraph', 'transclusionSource'],
@@ -110,7 +124,10 @@ export const tiptapExtensions = [
   Status,
   TransclusionSource,
   TransclusionReference,
-  BaseEmbed
+  BaseEmbed,
+  Footnotes,
+  Footnote,
+  FootnoteReference,
 ] as any;
 
 export function jsonToHtml(tiptapJson: any) {

apps/server/src/common/features.ts

@@ -18,7 +18,6 @@ export const Feature = {
   RETENTION: 'retention',
   SHARING_CONTROLS: 'sharing:controls',
   VIEWER_COMMENTS: 'comment:viewer',
-  HIDE_COMMENTS: 'comment:hide',
   TEMPLATES: 'templates',
   PDF_EXPORT: 'export:pdf',
   PERSONAL_SPACES: 'spaces:personal',

apps/server/src/core/attachment/attachment.controller.ts

@@ -53,8 +53,14 @@ import { EnvironmentService } from '../../integrations/environment/environment.s
 import { TokenService } from '../auth/services/token.service';
 import { JwtAttachmentPayload, JwtType } from '../auth/dto/jwt-payload';
 import * as path from 'path';
-import { AttachmentInfoDto, RemoveIconDto } from './dto/attachment.dto';
+import {
+  AttachmentInfoDto,
+  PageIdDto,
+  RemoveIconDto,
+} from './dto/attachment.dto';
+import { PaginationOptions } from '@docmost/db/pagination/pagination-options';
 import { PageAccessService } from '../page/page-access/page-access.service';
+import { DomainService } from '../../integrations/environment/domain.service';
 import { AuditEvent, AuditResource } from '../../common/events/audit-events';
 import {
   AUDIT_SERVICE,
@@ -75,6 +81,7 @@ export class AttachmentController {
     private readonly environmentService: EnvironmentService,
     private readonly tokenService: TokenService,
     private readonly pageAccessService: PageAccessService,
+    private readonly domainService: DomainService,
     @Inject(AUDIT_SERVICE) private readonly auditService: IAuditService,
   ) {}
 
@@ -151,7 +158,10 @@ export class AttachmentController {
         },
       });
 
-      return res.send(fileResponse);
+      return res.send({
+        ...fileResponse,
+        url: this.buildFileUrl(workspace, fileResponse),
+      });
     } catch (err: any) {
       if (err?.statusCode === 413) {
         const errMessage = `File too large. Exceeds the ${this.environmentService.getFileUploadSizeLimit()} limit`;
@@ -411,7 +421,37 @@ export class AttachmentController {
 
     await this.pageAccessService.validateCanView(page, user);
 
-    return attachment;
+    return { ...attachment, url: this.buildFileUrl(workspace, attachment) };
+  }
+
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  @Post('pages/attachments')
+  async getPageAttachments(
+    @Body() dto: PageIdDto,
+    @Body() pagination: PaginationOptions,
+    @AuthUser() user: User,
+    @AuthWorkspace() workspace: Workspace,
+  ) {
+    const page = await this.pageRepo.findById(dto.pageId);
+    if (!page || page.workspaceId !== workspace.id) {
+      throw new NotFoundException('Page not found');
+    }
+
+    await this.pageAccessService.validateCanView(page, user);
+
+    const result = await this.attachmentRepo.findPageAttachments(
+      page.id,
+      pagination,
+    );
+
+    return {
+      ...result,
+      items: result.items.map((attachment) => ({
+        ...attachment,
+        url: this.buildFileUrl(workspace, attachment),
+      })),
+    };
   }
 
   @UseGuards(JwtAuthGuard)
@@ -465,6 +505,10 @@ export class AttachmentController {
     }
   }
 
+  private buildFileUrl(workspace: Workspace, attachment: Attachment): string {
+    return `${this.domainService.getUrl(workspace.hostname)}/api/files/${attachment.id}/${encodeURIComponent(attachment.fileName)}`;
+  }
+
   private async sendFileResponse(
     req: FastifyRequest,
     res: FastifyReply,

apps/server/src/core/attachment/dto/attachment.dto.ts

@@ -1,4 +1,11 @@
-import { IsEnum, IsIn, IsNotEmpty, IsOptional, IsUUID } from 'class-validator';
+import {
+  IsEnum,
+  IsIn,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  IsUUID,
+} from 'class-validator';
 import { AttachmentType } from '../attachment.constants';
 
 export class AttachmentInfoDto {
@@ -7,6 +14,12 @@ export class AttachmentInfoDto {
   attachmentId: string;
 }
 
+export class PageIdDto {
+  @IsString()
+  @IsNotEmpty()
+  pageId: string;
+}
+
 export class RemoveIconDto {
   @IsEnum(AttachmentType)
   @IsIn([

apps/server/src/core/comment/comment.controller.ts

@@ -89,29 +89,20 @@ export class CommentController {
     @Body()
     pagination: PaginationOptions,
     @AuthUser() user: User,
-    @AuthWorkspace() workspace: Workspace,
   ) {
     const page = await this.pageRepo.findById(input.pageId);
     if (!page) {
       throw new NotFoundException('Page not found');
     }
 
-    await this.pageAccessService.validateCanViewComments(
+    await this.pageAccessService.validateCanView(page, user);
-      page,
-      user,
-      workspace.id,
-    );
 
     return this.commentService.findByPageId(page.id, pagination);
   }
 
   @HttpCode(HttpStatus.OK)
   @Post('info')
-  async findOne(
+  async findOne(@Body() input: CommentIdDto, @AuthUser() user: User) {
-    @Body() input: CommentIdDto,
-    @AuthUser() user: User,
-    @AuthWorkspace() workspace: Workspace,
-  ) {
     const comment = await this.commentRepo.findById(input.commentId);
     if (!comment) {
       throw new NotFoundException('Comment not found');
@@ -122,11 +113,7 @@ export class CommentController {
       throw new NotFoundException('Page not found');
     }
 
-    await this.pageAccessService.validateCanViewComments(
+    await this.pageAccessService.validateCanView(page, user);
-      page,
-      user,
-      workspace.id,
-    );
 
     return comment;
   }

apps/server/src/core/notification/services/comment.notification.ts

@@ -14,7 +14,6 @@ import { CommentMentionEmail } from '@docmost/transactional/emails/comment-menti
 import { CommentCreateEmail } from '@docmost/transactional/emails/comment-created-email';
 import { CommentResolvedEmail } from '@docmost/transactional/emails/comment-resolved-email';
 import { getPageTitle } from '../../../common/helpers';
-import { PageAccessService } from '../../page/page-access/page-access.service';
 
 @Injectable()
 export class CommentNotificationService {
@@ -26,7 +25,6 @@ export class CommentNotificationService {
     private readonly spaceMemberRepo: SpaceMemberRepo,
     private readonly pagePermissionRepo: PagePermissionRepo,
     private readonly watcherRepo: WatcherRepo,
-    private readonly pageAccessService: PageAccessService,
   ) {}
 
   async processComment(data: ICommentNotificationJob, appUrl: string) {
@@ -50,7 +48,7 @@ export class CommentNotificationService {
     );
     if (!context) return;
 
-    const { actor, pageTitle, pageUrl, spaceSettings } = context;
+    const { actor, pageTitle, pageUrl } = context;
     const notifiedUserIds = new Set<string>();
     notifiedUserIds.add(actorId);
 
@@ -74,16 +72,7 @@ export class CommentNotificationService {
         pageId,
         [...usersWithSpaceAccess],
       );
-    let accessibleUserIds = usersWithPageAccess;
+    const usersWithAccess = new Set(usersWithPageAccess);
-    if (spaceSettings?.comments?.hideCommentsFromViewers === true) {
-      accessibleUserIds =
-        await this.pageAccessService.filterUserIdsWithPageEditAccess(
-          spaceId,
-          pageId,
-          accessibleUserIds,
-        );
-    }
-    const usersWithAccess = new Set(accessibleUserIds);
 
     for (const userId of mentionedUserIds) {
       if (!usersWithAccess.has(userId)) continue;
@@ -156,7 +145,7 @@ export class CommentNotificationService {
     );
     if (!context) return;
 
-    const { actor, pageTitle, pageUrl, spaceSettings } = context;
+    const { actor, pageTitle, pageUrl } = context;
 
     const roles = await this.spaceMemberRepo.getUserSpaceRoles(
       commentCreatorId,
@@ -177,16 +166,6 @@ export class CommentNotificationService {
       );
     if (hasPageAccess.length === 0) return;
 
-    if (spaceSettings?.comments?.hideCommentsFromViewers === true) {
-      const editCapable =
-        await this.pageAccessService.filterUserIdsWithPageEditAccess(
-          spaceId,
-          pageId,
-          [commentCreatorId],
-        );
-      if (editCapable.length === 0) return;
-    }
-
     const notification = await this.notificationService.create({
       userId: commentCreatorId,
       workspaceId,
@@ -246,7 +225,7 @@ export class CommentNotificationService {
         .executeTakeFirst(),
       this.db
         .selectFrom('spaces')
-        .select(['id', 'slug', 'settings'])
+        .select(['id', 'slug'])
         .where('id', '=', spaceId)
         .executeTakeFirst(),
     ]);
@@ -257,11 +236,6 @@ export class CommentNotificationService {
 
     const pageUrl = `${appUrl}/s/${space.slug}/p/${page.slugId}`;
 
-    return {
+    return { actor, pageTitle: getPageTitle(page.title), pageUrl };
-      actor,
-      pageTitle: getPageTitle(page.title),
-      pageUrl,
-      spaceSettings: (space.settings ?? null) as Record<string, any> | null,
-    };
   }
 }

apps/server/src/core/page/page-access/page-access.service.ts

@@ -7,7 +7,6 @@ import {
   SpaceCaslSubject,
 } from '../../casl/interfaces/space-ability.type';
 import { SpaceRepo } from '@docmost/db/repos/space/space.repo';
-import { SpaceMemberRepo } from '@docmost/db/repos/space/space-member.repo';
 
 @Injectable()
 export class PageAccessService {
@@ -15,7 +14,6 @@ export class PageAccessService {
     private readonly pagePermissionRepo: PagePermissionRepo,
     private readonly spaceAbility: SpaceAbilityFactory,
     private readonly spaceRepo: SpaceRepo,
-    private readonly spaceMemberRepo: SpaceMemberRepo,
   ) {}
 
   /**
@@ -120,68 +118,8 @@ export class PageAccessService {
 
     const space = await this.spaceRepo.findById(page.spaceId, workspaceId);
     const settings = space?.settings as Record<string, any> | null;
-    if (
+    if (!settings?.comments?.allowViewerComments) {
-      !settings?.comments?.allowViewerComments ||
-      settings?.comments?.hideCommentsFromViewers
-    ) {
       throw new ForbiddenException();
     }
   }
-
-  async validateCanViewComments(
-    page: Page,
-    user: User,
-    workspaceId: string,
-  ): Promise<void> {
-    const { canEdit } = await this.validateCanViewWithPermissions(page, user);
-    if (canEdit) {
-      return;
-    }
-
-    const space = await this.spaceRepo.findById(page.spaceId, workspaceId);
-    const settings = space?.settings as Record<string, any> | null;
-    if (settings?.comments?.hideCommentsFromViewers) {
-      throw new ForbiddenException();
-    }
-  }
-
-  /**
-   * Callers must pass userIds that already have space access (WS room members / pre-filtered notification recipients).
-   */
-  async filterUserIdsWithPageEditAccess(
-    spaceId: string,
-    pageId: string,
-    userIds: string[],
-  ): Promise<string[]> {
-    if (userIds.length === 0) {
-      return [];
-    }
-
-    const spaceHasRestrictedPages =
-      await this.pagePermissionRepo.hasRestrictedPagesInSpace(spaceId);
-    const hasRestriction =
-      spaceHasRestrictedPages &&
-      (await this.pagePermissionRepo.hasRestrictedAncestor(pageId));
-
-    if (!hasRestriction) {
-      const editCapableIds =
-        await this.spaceMemberRepo.getUserIdsWithSpaceEditAccess(
-          userIds,
-          spaceId,
-        );
-      return userIds.filter((id) => editCapableIds.has(id));
-    }
-
-    const results = await Promise.all(
-      userIds.map(async (userId) => {
-        const { canEdit } = await this.pagePermissionRepo.canUserEditPage(
-          userId,
-          pageId,
-        );
-        return canEdit ? userId : null;
-      }),
-    );
-
-    return results.filter((id): id is string => id !== null);
-  }
 }

apps/server/src/core/space/dto/update-space.dto.ts

@@ -15,8 +15,4 @@ export class UpdateSpaceDto extends PartialType(CreateSpaceDto) {
   @IsOptional()
   @IsBoolean()
   allowViewerComments: boolean;
-
-  @IsOptional()
-  @IsBoolean()
-  hideCommentsFromViewers: boolean;
 }

apps/server/src/core/space/services/space.service.ts

@@ -30,35 +30,6 @@ import {
   IAuditService,
 } from '../../../integrations/audit/audit.service';
 
-export function validateExclusiveCommentSettings(
-  dto: Partial<
-    Pick<UpdateSpaceDto, 'allowViewerComments' | 'hideCommentsFromViewers'>
-  >,
-  settingsBefore: Record<string, any>,
-): void {
-  if (
-    dto.allowViewerComments === undefined &&
-    dto.hideCommentsFromViewers === undefined
-  ) {
-    return;
-  }
-
-  const allowViewerComments =
-    dto.allowViewerComments ??
-    settingsBefore.comments?.allowViewerComments ??
-    false;
-  const hideCommentsFromViewers =
-    dto.hideCommentsFromViewers ??
-    settingsBefore.comments?.hideCommentsFromViewers ??
-    false;
-
-  if (allowViewerComments && hideCommentsFromViewers) {
-    throw new BadRequestException(
-      "'Allow viewers to comment' and 'Hide comments from viewers' cannot both be enabled",
-    );
-  }
-}
-
 @Injectable()
 export class SpaceService {
   constructor(
@@ -170,8 +141,7 @@ export class SpaceService {
 
     if (
       typeof updateSpaceDto.disablePublicSharing !== 'undefined' ||
-      typeof updateSpaceDto.allowViewerComments !== 'undefined' ||
+      typeof updateSpaceDto.allowViewerComments !== 'undefined'
-      typeof updateSpaceDto.hideCommentsFromViewers !== 'undefined'
     ) {
       const workspace = await this.workspaceRepo.findById(workspaceId, {
         withLicenseKey: true,
@@ -198,17 +168,6 @@ export class SpaceService {
       ) {
         throw new ForbiddenException('This feature requires a valid license');
       }
-
-      if (
-        updateSpaceDto.hideCommentsFromViewers === true &&
-        !this.licenseCheckService.hasFeature(
-          workspace.licenseKey,
-          Feature.HIDE_COMMENTS,
-          workspace.plan,
-        )
-      ) {
-        throw new ForbiddenException('This feature requires a valid license');
-      }
     }
 
     const spaceBefore = await this.spaceRepo.findById(
@@ -217,8 +176,6 @@ export class SpaceService {
     );
     const settingsBefore = (spaceBefore?.settings ?? {}) as Record<string, any>;
 
-    validateExclusiveCommentSettings(updateSpaceDto, settingsBefore);
-
     const before: Record<string, any> = {};
     const after: Record<string, any> = {};
 
@@ -261,23 +218,6 @@ export class SpaceService {
         );
       }
 
-      if (typeof updateSpaceDto.hideCommentsFromViewers !== 'undefined') {
-        const prev = settingsBefore?.comments?.hideCommentsFromViewers ?? false;
-        if (prev !== updateSpaceDto.hideCommentsFromViewers) {
-          before.hideCommentsFromViewers = prev;
-          after.hideCommentsFromViewers =
-            updateSpaceDto.hideCommentsFromViewers;
-        }
-
-        await this.spaceRepo.updateCommentSettings(
-          updateSpaceDto.spaceId,
-          workspaceId,
-          'hideCommentsFromViewers',
-          updateSpaceDto.hideCommentsFromViewers,
-          trx,
-        );
-      }
-
       updatedSpace = await this.spaceRepo.updateSpace(
         {
           name: updateSpaceDto.name,

apps/server/src/database/repos/attachment/attachment.repo.ts

@@ -1,5 +1,8 @@
 import { Injectable } from '@nestjs/common';
 import { InjectKysely } from 'nestjs-kysely';
+import { ExpressionBuilder, sql } from 'kysely';
+import { jsonObjectFrom } from 'kysely/helpers/postgres';
+import { DB } from '@docmost/db/types/db';
 import { KyselyDB, KyselyTransaction } from '@docmost/db/types/kysely.types';
 import { dbOrTx } from '@docmost/db/utils';
 import {
@@ -8,6 +11,8 @@ import {
   UpdatableAttachment,
 } from '@docmost/db/types/entity.types';
 import { AttachmentType } from '../../../core/attachment/attachment.constants';
+import { PaginationOptions } from '@docmost/db/pagination/pagination-options';
+import { executeWithCursorPagination } from '@docmost/db/pagination/cursor-pagination';
 
 @Injectable()
 export class AttachmentRepo {
@@ -89,6 +94,41 @@ export class AttachmentRepo {
       .execute();
   }
 
+  async findPageAttachments(pageId: string, pagination: PaginationOptions) {
+    let query = this.db
+      .selectFrom('attachments')
+      .select(this.baseFields)
+      .select((eb) => this.withCreator(eb))
+      .where('pageId', '=', pageId)
+      .where('type', '=', AttachmentType.File)
+      .where('deletedAt', 'is', null);
+
+    if (pagination.query) {
+      query = query.where(
+        sql`f_unaccent(file_name)`,
+        'ilike',
+        sql`f_unaccent(${'%' + pagination.query + '%'})`,
+      );
+    }
+
+    return executeWithCursorPagination(query, {
+      perPage: pagination.limit,
+      cursor: pagination.cursor,
+      beforeCursor: pagination.beforeCursor,
+      fields: [{ expression: 'id', direction: 'desc' }],
+      parseCursor: (cursor) => ({ id: cursor.id }),
+    });
+  }
+
+  withCreator(eb: ExpressionBuilder<DB, 'attachments'>) {
+    return jsonObjectFrom(
+      eb
+        .selectFrom('users')
+        .select(['users.id', 'users.name', 'users.avatarUrl'])
+        .whereRef('users.id', '=', 'attachments.creatorId'),
+    ).as('creator');
+  }
+
   async findByIds(
     ids: string[],
     opts?: {

apps/server/src/database/repos/space/space-member.repo.ts

@@ -20,7 +20,6 @@ import {
   CacheKey,
   PERMISSION_CACHE_TTL_MS,
 } from '../../../common/helpers/cache-keys';
-import { SpaceRole } from '../../../common/helpers/types/permission';
 
 @Injectable()
 export class SpaceMemberRepo {
@@ -279,32 +278,6 @@ export class SpaceMemberRepo {
     return new Set(rows.map((r) => r.userId));
   }
 
-  async getUserIdsWithSpaceEditAccess(
-    userIds: string[],
-    spaceId: string,
-  ): Promise<Set<string>> {
-    if (userIds.length === 0) return new Set();
-
-    const rows = await this.db
-      .selectFrom('spaceMembers')
-      .select('userId')
-      .where('userId', 'in', userIds)
-      .where('spaceId', '=', spaceId)
-      .where('spaceMembers.role', 'in', [SpaceRole.ADMIN, SpaceRole.WRITER])
-      .unionAll(
-        this.db
-          .selectFrom('spaceMembers')
-          .innerJoin('groupUsers', 'groupUsers.groupId', 'spaceMembers.groupId')
-          .select('groupUsers.userId')
-          .where('groupUsers.userId', 'in', userIds)
-          .where('spaceMembers.spaceId', '=', spaceId)
-          .where('spaceMembers.role', 'in', [SpaceRole.ADMIN, SpaceRole.WRITER]),
-      )
-      .execute();
-
-    return new Set(rows.map((r) => r.userId));
-  }
-
   async getSpaceIdsByGroupId(groupId: string): Promise<string[]> {
     const rows = await this.db
       .selectFrom('spaceMembers')

apps/server/src/database/repos/space/space.repo.ts

@@ -149,17 +149,6 @@ export class SpaceRepo {
       .executeTakeFirst();
   }
 
-  async getSpaceSettings(
-    spaceId: string,
-  ): Promise<Record<string, any> | null> {
-    const row = await this.db
-      .selectFrom('spaces')
-      .select('settings')
-      .where('id', '=', spaceId)
-      .executeTakeFirst();
-    return (row?.settings as Record<string, any> | undefined) ?? null;
-  }
-
   async insertSpace(
     insertableSpace: InsertableSpace,
     trx?: KyselyTransaction,

apps/server/src/ws/ws.service.ts

@@ -3,8 +3,6 @@ import { CACHE_MANAGER } from '@nestjs/cache-manager';
 import { Cache } from 'cache-manager';
 import { Server, Socket } from 'socket.io';
 import { PagePermissionRepo } from '@docmost/db/repos/page/page-permission.repo';
-import { SpaceRepo } from '@docmost/db/repos/space/space.repo';
-import { PageAccessService } from '../core/page/page-access/page-access.service';
 import {
   TREE_EVENTS,
   WS_SPACE_RESTRICTION_CACHE_PREFIX,
@@ -19,8 +17,6 @@ export class WsService {
 
   constructor(
     private readonly pagePermissionRepo: PagePermissionRepo,
-    private readonly spaceRepo: SpaceRepo,
-    private readonly pageAccessService: PageAccessService,
     @Inject(CACHE_MANAGER) private readonly cacheManager: Cache,
   ) {}
 
@@ -71,24 +67,9 @@ export class WsService {
     spaceId: string,
     pageId: string,
     data: any,
-    opts?: { bypassVisibilityCheck?: boolean },
   ): Promise<void> {
     const room = getSpaceRoomName(spaceId);
 
-    if (
-      !opts?.bypassVisibilityCheck &&
-      (await this.spaceHidesCommentsFromViewers(spaceId))
-    ) {
-      await this.broadcastToUsersMatching(room, null, data, (candidateIds) =>
-        this.pageAccessService.filterUserIdsWithPageEditAccess(
-          spaceId,
-          pageId,
-          candidateIds,
-        ),
-      );
-      return;
-    }
-
     const hasRestrictions = await this.spaceHasRestrictions(spaceId);
     if (!hasRestrictions) {
       this.server.to(room).emit('message', data);
@@ -137,17 +118,6 @@ export class WsService {
     excludeSocketId: string | null,
     pageId: string,
     data: any,
-  ): Promise<void> {
-    await this.broadcastToUsersMatching(room, excludeSocketId, data, (ids) =>
-      this.pagePermissionRepo.getUserIdsWithPageAccess(pageId, ids),
-    );
-  }
-
-  private async broadcastToUsersMatching(
-    room: string,
-    excludeSocketId: string | null,
-    data: any,
-    filterUserIds: (candidateUserIds: string[]) => Promise<string[]>,
   ): Promise<void> {
     const sockets = await this.server.in(room).fetchSockets();
 
@@ -174,9 +144,15 @@ export class WsService {
     const candidateUserIds = Array.from(userSocketMap.keys());
     if (candidateUserIds.length === 0) return;
 
-    const allowedSet = new Set(await filterUserIds(candidateUserIds));
+    const authorizedUserIds =
+      await this.pagePermissionRepo.getUserIdsWithPageAccess(
+        pageId,
+        candidateUserIds,
+      );
+
+    const authorizedSet = new Set(authorizedUserIds);
     for (const [userId, userSockets] of userSocketMap) {
-      if (allowedSet.has(userId)) {
+      if (authorizedSet.has(userId)) {
         for (const socket of userSockets) {
           socket.emit('message', data);
         }
@@ -200,13 +176,6 @@ export class WsService {
     return hasRestrictions;
   }
 
-  private async spaceHidesCommentsFromViewers(
-    spaceId: string,
-  ): Promise<boolean> {
-    const settings = await this.spaceRepo.getSpaceSettings(spaceId);
-    return settings?.comments?.hideCommentsFromViewers === true;
-  }
-
   private extractPageId(data: any): string | null {
     switch (data.operation) {
       case 'addTreeNode':

packages/editor-ext/src/index.ts

@@ -32,6 +32,7 @@ export * from "./lib/columns";
 export * from "./lib/status";
 export * from "./lib/pdf";
 export * from "./lib/page-break";
+export * from "./lib/footnotes";
 export * from "./lib/resizable-nodeview";
 export {
   pageNodeToDocxBuffer,

packages/editor-ext/src/lib/footnotes/footnote.ts

@@ -0,0 +1,189 @@
+//Source MIT - https://github.com/buttondown/tiptap-footnotes
+import { mergeAttributes } from "@tiptap/core";
+import ListItem, { ListItemOptions } from "@tiptap/extension-list-item";
+
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    footnote: {
+      /**
+       * scrolls to & sets the text selection at the end of the footnote with the given id
+       * @param id the id of the footote (i.e. the `data-id` attribute value of the footnote)
+       * @example editor.commands.focusFootnote("a43956c1-1ab8-462f-96e4-be3a4b27fd50")
+       */
+      focusFootnote: (id: string) => ReturnType;
+    };
+  }
+}
+
+export interface FootnoteOptions extends ListItemOptions {
+  /**
+   * Content expression for this node
+   * @default "paragraph+"
+   */
+  content: string;
+}
+
+const Footnote = ListItem.extend<FootnoteOptions>({
+  name: "footnote",
+  content() {
+    return this.options.content;
+  },
+  isolating: true,
+  defining: true,
+  draggable: false,
+
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      bulletListTypeName: 'bulletList',
+      orderedListTypeName: 'orderedList',
+      ...this.parent?.(),
+      content: "paragraph+",
+    };
+  },
+
+  addAttributes() {
+    return {
+      id: {
+        isRequired: true,
+      },
+      // the data-id field should match the data-id field of a footnote reference.
+      // it's used to link footnotes and references together.
+      "data-id": {
+        isRequired: true,
+      },
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "li",
+        getAttrs(node) {
+          const id = node.getAttribute("data-id");
+          if (id) {
+            return {
+              "data-id": node.getAttribute("data-id"),
+            };
+          }
+          return false;
+        },
+        priority: 1000,
+      },
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "li",
+      mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
+      0,
+    ];
+  },
+
+  addCommands() {
+    return {
+      focusFootnote:
+        (id: string) =>
+        ({ editor, chain }) => {
+          const matchedFootnote = editor.$node("footnote", {
+            "data-id": id,
+          });
+          if (matchedFootnote) {
+            // sets the text selection to the end of the footnote definition and scroll to it.
+            chain()
+              .focus()
+              .setTextSelection(
+                matchedFootnote.from + matchedFootnote.content.size
+              )
+              .run();
+
+            matchedFootnote.element.scrollIntoView();
+            return true;
+          }
+          return false;
+        },
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      // when inside a footnote, Mod-a should select only the footnote content
+      "Mod-a": ({ editor }) => {
+        try {
+          const { selection } = editor.state;
+          const { $from } = selection;
+
+          for (let depth = $from.depth; depth >= 0; depth--) {
+            const node = $from.node(depth);
+            if (node.type.name === "footnote") {
+              const start = $from.start(depth);
+              const end = $from.end(depth);
+
+              editor.commands.setTextSelection({
+                from: start + 1,
+                to: end - 1,
+              });
+              return true;
+            }
+          }
+
+          return false;
+        } catch (e) {
+          return false;
+        }
+      },
+      // when the user presses tab, adjust the text selection to be at the end of the next footnote
+      Tab: ({ editor }) => {
+        try {
+          const { selection } = editor.state;
+          const pos = editor.$pos(selection.anchor);
+          if (!pos.after) return false;
+          // if the next node  is "footnotes", place the text selection at the end of the first footnote
+          if (pos.after.node.type.name == "footnotes") {
+            const firstChild = pos.after.node.child(0);
+            editor
+              .chain()
+              .setTextSelection(pos.after.from + firstChild.content.size)
+              .scrollIntoView()
+              .run();
+            return true;
+          } else {
+            const startPos = selection.$from.start(2);
+            if (Number.isNaN(startPos)) return false;
+            const parent = editor.$pos(startPos);
+            if (parent.node.type.name != "footnote" || !parent.after) {
+              return false;
+            }
+            // if the next node is a footnote, place the text selection at the end of it
+            editor
+              .chain()
+              .setTextSelection(parent.after.to - 1)
+              .scrollIntoView()
+              .run();
+            return true;
+          }
+        } catch {
+          return false;
+        }
+      },
+      // inverse of the tab command - place the text selection at the end of the previous footnote
+      "Shift-Tab": ({ editor }) => {
+        const { selection } = editor.state;
+        const startPos = selection.$from.start(2);
+        if (Number.isNaN(startPos)) return false;
+        const parent = editor.$pos(startPos);
+        if (parent.node.type.name != "footnote" || !parent.before) {
+          return false;
+        }
+
+        editor
+          .chain()
+          .setTextSelection(parent.before.to - 1)
+          .scrollIntoView()
+          .run();
+        return true;
+      },
+    };
+  },
+
+});
+
+export default Footnote;

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

@@ -0,0 +1,46 @@
+//Source MIT - https://github.com/buttondown/tiptap-footnotes
+import OrderedList from "@tiptap/extension-ordered-list";
+import FootnoteRules from "./rules";
+
+const Footnotes = OrderedList.extend({
+  name: "footnotes",
+  group: "", // removed the default group of the ordered list extension
+  isolating: true,
+  defining: true,
+  draggable: false,
+
+  content() {
+    return "footnote*";
+  },
+  addAttributes() {
+    return {
+      class: {
+        default: "footnotes",
+      },
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "ol.footnotes",
+        priority: 1000,
+      },
+    ];
+  },
+
+  addKeyboardShortcuts() {
+    return {};
+  },
+  addCommands() {
+    return {};
+  },
+  addInputRules() {
+    return [];
+  },
+
+  addExtensions() {
+    return [FootnoteRules];
+  },
+});
+
+export default Footnotes;

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

@@ -0,0 +1,4 @@
+export { default as Footnotes } from "./footnotes";
+export { default as Footnote } from "./footnote";
+export type { FootnoteOptions } from "./footnote";
+export { default as FootnoteReference } from "./reference";

packages/editor-ext/src/lib/footnotes/reference.ts

@@ -0,0 +1,221 @@
+//Source MIT - https://github.com/buttondown/tiptap-footnotes
+import { mergeAttributes, Node } from "@tiptap/core";
+import {
+  Fragment as PMFragment,
+  Node as PMNode,
+  Slice,
+} from "@tiptap/pm/model";
+import { NodeSelection, Plugin, PluginKey } from "@tiptap/pm/state";
+import { generateNodeId } from "../utils";
+
+
+const REFNUM_ATTR = "data-reference-number";
+const REF_CLASS = "footnote-ref";
+
+declare module "@tiptap/core" {
+  interface Commands<ReturnType> {
+    footnoteReference: {
+      /**
+       * add a new footnote reference
+       * @example editor.commands.addFootnote()
+       */
+      addFootnote: () => ReturnType;
+    };
+  }
+}
+
+const FootnoteReference = Node.create({
+  name: "footnoteReference",
+  inline: true,
+  content: "text*",
+  group: "inline",
+  atom: true,
+  draggable: true,
+
+  parseHTML() {
+    return [
+      {
+        tag: `sup`,
+        priority: 1000,
+        getAttrs(node) {
+          const anchor = node.querySelector<HTMLAnchorElement>(
+            `a.${REF_CLASS}:first-child`
+          );
+
+          if (!anchor) {
+            return false;
+          }
+
+          const id = anchor.getAttribute("data-id");
+          const ref = anchor.getAttribute(REFNUM_ATTR);
+
+          return {
+            "data-id": id ?? generateNodeId(),
+            referenceNumber: ref ?? anchor.innerText,
+          };
+        },
+        contentElement(node) {
+          return node.firstChild as HTMLElement;
+        },
+      },
+    ];
+  },
+
+  addAttributes() {
+    return {
+      class: {
+        default: REF_CLASS,
+      },
+      "data-id": {
+        renderHTML(attributes) {
+          return {
+            "data-id": attributes["data-id"] || generateNodeId(),
+          };
+        },
+      },
+      referenceNumber: {},
+
+      href: {
+        renderHTML(attributes) {
+          return {
+            href: `#fn:${attributes["referenceNumber"]}`,
+          };
+        },
+      },
+    };
+  },
+
+  renderHTML({ HTMLAttributes }) {
+    const { referenceNumber, ...attributes } = HTMLAttributes;
+    const attrs = mergeAttributes(this.options.HTMLAttributes, attributes);
+    attrs[REFNUM_ATTR] = referenceNumber;
+
+    return [
+      "sup",
+      { id: `fnref:${referenceNumber}` },
+      ["a", attrs, HTMLAttributes.referenceNumber],
+    ];
+  },
+
+  addProseMirrorPlugins() {
+    const { editor } = this;
+
+    // Ensures pasted footnote references get unique IDs.
+    const mapNode = (node: PMNode): PMNode => {
+      if (node.type.name === this.name) {
+        const newAttrs = { ...node.attrs, "data-id": generateNodeId() };
+        return node.type.create(newAttrs, node.content, node.marks);
+      }
+
+      if (node.content && node.content.size > 0) {
+        const newChildren: PMNode[] = [];
+        let changed = false;
+
+        node.content.forEach((child) => {
+          const mapped = mapNode(child);
+          if (mapped !== child) {
+            changed = true;
+          }
+
+          newChildren.push(mapped);
+        });
+
+        if (changed) {
+          return node.copy(PMFragment.from(newChildren));
+        }
+      }
+
+      return node;
+    };
+
+    return [
+      new Plugin({
+        key: new PluginKey("footnotePasteHandler"),
+        props: {
+          transformPasted(slice) {
+            const mappedNodes: PMNode[] = [];
+            let changed = false;
+
+            slice.content.forEach((node) => {
+              const mapped = mapNode(node);
+              if (mapped !== node) {
+                changed = true;
+              }
+              mappedNodes.push(mapped);
+            });
+
+            if (!changed) {
+              return slice;
+            }
+
+            return new Slice(
+              PMFragment.from(mappedNodes),
+              slice.openStart,
+              slice.openEnd
+            );
+          },
+        },
+      }),
+      new Plugin({
+        key: new PluginKey("footnoteRefClick"),
+
+        props: {
+          // on double-click, focus on the footnote
+          handleDoubleClickOn(view, pos, node, nodePos, event) {
+            if (node.type.name != "footnoteReference") return false;
+            event.preventDefault();
+            const id = node.attrs["data-id"];
+            return editor.commands.focusFootnote(id);
+          },
+          // click the footnote reference once to get focus, click twice to scroll to the footnote
+          handleClickOn(view, pos, node, nodePos, event) {
+            if (node.type.name != "footnoteReference") return false;
+            event.preventDefault();
+            const { selection } = editor.state.tr;
+            if (selection instanceof NodeSelection && selection.node.eq(node)) {
+              const id = node.attrs["data-id"];
+              return editor.commands.focusFootnote(id);
+            } else {
+              editor.chain().setNodeSelection(nodePos).run();
+              return true;
+            }
+          },
+        },
+      }),
+    ];
+  },
+
+  addCommands() {
+    return {
+      addFootnote:
+        () =>
+        ({ state, tr }) => {
+          const node = this.type.create({
+            "data-id": generateNodeId(),
+          });
+          tr.insert(state.selection.anchor, node);
+          return true;
+        },
+    };
+  },
+
+  addInputRules() {
+    // when a user types [^text], add a new footnote
+    return [
+      {
+        find: /\[\^(.*?)\]/,
+        type: this.type,
+        undoable: true,
+        handler({ range, match, chain }) {
+          const start = range.from;
+          let end = range.to;
+          if (match[1]) {
+            chain().deleteRange({ from: start, to: end }).addFootnote().run();
+          }
+        },
+      },
+    ];
+  },
+});
+
+export default FootnoteReference;

packages/editor-ext/src/lib/footnotes/rules.ts

@@ -0,0 +1,90 @@
+//Source MIT - https://github.com/buttondown/tiptap-footnotes
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { ReplaceStep } from "@tiptap/pm/transform";
+import { Extension } from "@tiptap/core";
+import { updateFootnotesList } from "./utils";
+
+const FootnoteRules = Extension.create({
+  name: "footnoteRules",
+  priority: 1000,
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey("footnoteRules"),
+        filterTransaction(tr) {
+          const { from, to } = tr.selection;
+
+          // Allow full document selections (Mod-a/Ctrl-a)
+          if (from === 0 && to === tr.doc.content.size) return true;
+
+          let selectedFootnotes = false;
+          let selectedContent = false;
+          let footnoteCount = 0;
+          tr.doc.nodesBetween(from, to, (node, _, parent) => {
+            if (parent?.type.name == "doc" && node.type.name != "footnotes") {
+              selectedContent = true;
+            } else if (node.type.name == "footnote") {
+              footnoteCount += 1;
+            } else if (node.type.name == "footnotes") {
+              selectedFootnotes = true;
+            }
+          });
+          const overSelected = selectedContent && selectedFootnotes;
+          /*
+           * Here, we don't allow any transaction that spans between the "content" nodes and the "footnotes" node. This also rejects any transaction that spans between more than 1 footnote.
+           */
+          return !overSelected && footnoteCount <= 1;
+        },
+
+        // if there are some to the footnote references (added/deleted/dragged), append a transaction that updates the footnotes list accordingly
+        appendTransaction(transactions, oldState, newState) {
+          let newTr = newState.tr;
+          let refsChanged = false; // true if the footnote references have been changed, false otherwise
+          for (let tr of transactions) {
+            if (!tr.docChanged) continue;
+            if (refsChanged) break;
+
+            for (let step of tr.steps) {
+              if (!(step instanceof ReplaceStep)) continue;
+              if (refsChanged) break;
+
+              const isDelete = step.from != step.to; // the user deleted items from the document (from != to & the step is a replace step)
+              const isInsert = step.slice.size > 0;
+
+              // check if any footnote references have been inserted
+              if (isInsert) {
+                step.slice.content.descendants((node) => {
+                  if (node?.type.name == "footnoteReference") {
+                    refsChanged = true;
+                    return false;
+                  }
+                });
+              }
+              if (isDelete && !refsChanged) {
+                // check if any footnote references have been deleted
+                tr.before.nodesBetween(
+                  step.from,
+                  Math.min(tr.before.content.size, step.to), // make sure to not go over the old document's limit
+                  (node) => {
+                    if (node.type.name == "footnoteReference") {
+                      refsChanged = true;
+                      return false;
+                    }
+                  },
+                );
+              }
+            }
+          }
+
+          if (refsChanged) {
+            updateFootnotesList(newTr, newState);
+            return newTr;
+          }
+
+          return null;
+        },
+      }),
+    ];
+  },
+});
+export default FootnoteRules;

packages/editor-ext/src/lib/footnotes/utils.ts

@@ -0,0 +1,123 @@
+//Source MIT - https://github.com/buttondown/tiptap-footnotes
+import { EditorState, Transaction } from "@tiptap/pm/state";
+import { Fragment, Node } from "@tiptap/pm/model";
+
+// update the reference number of all the footnote references in the document
+export function updateFootnoteReferences(tr: Transaction) {
+  let count = 1;
+
+  const nodes: any[] = [];
+
+  tr.doc.descendants((node, pos) => {
+    if (node.type.name == "footnoteReference") {
+      tr.setNodeAttribute(pos, "referenceNumber", `${count}`);
+
+      nodes.push(node);
+      count += 1;
+    }
+  });
+  // return the updated footnote references (in the order that they appear in the document)
+  return nodes;
+}
+
+function getFootnotes(tr: Transaction) {
+  let footnotesRange: { from: number; to: number } | undefined;
+  const footnotes: Node[] = [];
+  tr.doc.descendants((node, pos) => {
+    if (node.type.name == "footnote") {
+      footnotes.push(node);
+    } else if (node.type.name == "footnotes") {
+      footnotesRange = { from: pos, to: pos + node.nodeSize };
+    } else {
+      return false;
+    }
+  });
+  return { footnotesRange, footnotes };
+}
+
+// update the "footnotes" ordered list based on the footnote references in the document
+export function updateFootnotesList(tr: Transaction, state: EditorState) {
+  const footnoteReferences = updateFootnoteReferences(tr);
+
+  const footnoteType = state.schema.nodes.footnote;
+  const footnotesType = state.schema.nodes.footnotes;
+
+  const emptyParagraph = state.schema.nodeFromJSON({
+    type: "paragraph",
+    content: [],
+  });
+
+  const { footnotesRange, footnotes } = getFootnotes(tr);
+
+  // a mapping of footnote id -> footnote node
+  const footnoteIds: { [key: string]: Node } = footnotes.reduce(
+    (obj, footnote) => {
+      obj[footnote.attrs["data-id"]] = footnote;
+      return obj;
+    },
+    {} as any,
+  );
+
+  const newFootnotes: Node[] = [];
+
+  let footnoteRefIds = new Set(
+    footnoteReferences.map((ref) => ref.attrs["data-id"]),
+  );
+  const deleteFootnoteIds: Set<string> = new Set();
+  for (let footnote of footnotes) {
+    const id = footnote.attrs["data-id"];
+    if (!footnoteRefIds.has(id) || deleteFootnoteIds.has(id)) {
+      deleteFootnoteIds.add(id);
+      // we traverse through this footnote's content because it may contain footnote references.
+      // we want to delete the footnotes associated with these references, so we add them to the delete set.
+      footnote.content.descendants((node) => {
+        if (node.type.name == "footnoteReference")
+          deleteFootnoteIds.add(node.attrs["data-id"]);
+      });
+    }
+  }
+
+  for (let i = 0; i < footnoteReferences.length; i++) {
+    let refId = footnoteReferences[i].attrs["data-id"];
+
+    if (deleteFootnoteIds.has(refId)) continue;
+    // if there is a footnote w/ the same id as this `ref`, we preserve its content and update its id attribute
+    if (refId in footnoteIds) {
+      let footnote = footnoteIds[refId];
+      newFootnotes.push(
+        footnoteType.create(
+          { ...footnote.attrs, id: `fn:${i + 1}` },
+          footnote.content,
+        ),
+      );
+    } else {
+      let newNode = footnoteType.create(
+        {
+          "data-id": refId,
+          id: `fn:${i + 1}`,
+        },
+        [emptyParagraph],
+      );
+      newFootnotes.push(newNode);
+    }
+  }
+
+  if (newFootnotes.length == 0) {
+    // no footnotes in the doc, delete the "footnotes" node
+    if (footnotesRange) {
+      tr.delete(footnotesRange.from, footnotesRange.to);
+    }
+  } else if (!footnotesRange) {
+    // there is no footnotes node present in the doc, add it
+    tr.insert(
+      tr.doc.content.size,
+      footnotesType.create(undefined, Fragment.from(newFootnotes)),
+    );
+  } else {
+    tr.replaceWith(
+      footnotesRange!.from + 1, // add 1 to point at the position after the opening ol tag
+      footnotesRange!.to - 1, // substract 1 to point to the position before the closing ol tag
+      Fragment.from(newFootnotes),
+    );
+  }
+}

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

@@ -0,0 +1,110 @@
+import { Token, marked } from 'marked';
+import { generateNodeId } from '../../utils';
+
+interface FootnoteRefToken {
+  type: 'footnoteRef';
+  label: string;
+  raw: string;
+}
+
+interface FootnoteDefToken {
+  type: 'footnoteDef';
+  label: string;
+  text: string;
+  raw: string;
+}
+
+// Parse-scoped state: markdownToHtml resets before the top-level parse and
+// appends the collected list after it. Nested marked.parse calls (callout,
+// footnote definitions) share this state, so hooks cannot be used here.
+let footnoteRefs: { label: string; id: string; number: number }[] = [];
+let footnoteDefs = new Map<string, string>();
+
+export function resetFootnotes() {
+  footnoteRefs = [];
+  footnoteDefs = new Map();
+}
+
+export function renderFootnotesList(): string {
+  if (!footnoteRefs.length) return '';
+  const items = footnoteRefs.map(({ label, id, number }) => {
+    const body = footnoteDefs.get(label) || '<p></p>';
+    return `<li id="fn:${number}" data-id="${id}">${body}</li>`;
+  });
+  return `<ol class="footnotes">\n${items.join('\n')}\n</ol>\n`;
+}
+
+export const footnoteRefExtension = {
+  name: 'footnoteRef',
+  level: 'inline',
+  start(src: string) {
+    return src.indexOf('[^');
+  },
+  tokenizer(src: string): FootnoteRefToken | undefined {
+    const match = /^\[\^([^\]\s]+)\]/.exec(src);
+    if (match) {
+      return {
+        type: 'footnoteRef',
+        raw: match[0],
+        label: match[1].toLowerCase(),
+      };
+    }
+  },
+  renderer(token: Token) {
+    const refToken = token as FootnoteRefToken;
+    const number = footnoteRefs.length + 1;
+    const id = generateNodeId();
+    footnoteRefs.push({ label: refToken.label, id, number });
+    return `<sup id="fnref:${number}"><a class="footnote-ref" data-id="${id}" data-reference-number="${number}" href="#fn:${number}">${number}</a></sup>`;
+  },
+};
+
+export const footnoteDefExtension = {
+  name: 'footnoteDef',
+  level: 'block',
+  start(src: string) {
+    return src.match(/^\[\^[^\]\s]+\]:/m)?.index ?? -1;
+  },
+  tokenizer(src: string): FootnoteDefToken | undefined {
+    const firstLine = /^\[\^([^\]\s]+)\]:[ \t]*/.exec(src);
+    if (!firstLine) return undefined;
+
+    const lines = src.split('\n');
+    const contentLines = [lines[0].slice(firstLine[0].length)];
+    let consumed = 1;
+    while (consumed < lines.length) {
+      const line = lines[consumed];
+      if (/^[ \t]{2,}\S/.test(line)) {
+        contentLines.push(line.replace(/^[ \t]{1,4}/, ''));
+        consumed += 1;
+      } else if (
+        /^[ \t]*$/.test(line) &&
+        consumed + 1 < lines.length &&
+        /^[ \t]{2,}\S/.test(lines[consumed + 1])
+      ) {
+        contentLines.push('');
+        consumed += 1;
+      } else {
+        break;
+      }
+    }
+
+    const raw =
+      lines.slice(0, consumed).join('\n') +
+      (consumed < lines.length ? '\n' : '');
+    return {
+      type: 'footnoteDef',
+      raw,
+      label: firstLine[1].toLowerCase(),
+      text: contentLines.join('\n').trim(),
+    };
+  },
+  renderer(token: Token) {
+    const defToken = token as FootnoteDefToken;
+    const body = defToken.text
+      ? marked.parse(defToken.text).toString()
+      : '<p></p>';
+    footnoteDefs.set(defToken.label, body);
+    return '';
+  },
+};

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

@@ -2,6 +2,12 @@ import { marked } from "marked";
 import { calloutExtension } from "./callout.marked";
 import { mathBlockExtension } from "./math-block.marked";
 import { mathInlineExtension } from "./math-inline.marked";
+import {
+  footnoteDefExtension,
+  footnoteRefExtension,
+  renderFootnotesList,
+  resetFootnotes,
+} from "./footnotes.marked";
 
 marked.use({
   renderer: {
@@ -34,7 +40,13 @@ marked.use({
 });
 
 marked.use({
-  extensions: [calloutExtension, mathBlockExtension, mathInlineExtension],
+  extensions: [
+    calloutExtension,
+    mathBlockExtension,
+    mathInlineExtension,
+    footnoteDefExtension,
+    footnoteRefExtension,
+  ],
 });
 
 marked.setOptions({ breaks: true });
@@ -48,5 +60,7 @@ export function markdownToHtml(
     .replace(YAML_FONT_MATTER_REGEX, "")
     .trimStart();
 
-  return marked.parse(markdown).toString();
+  resetFootnotes();
+  const html = marked.parse(markdown).toString();
+  return html + renderFootnotesList();
 }

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

@@ -34,6 +34,8 @@ export function htmlToMarkdown(html: string): string {
     iframeEmbed,
     image,
     video,
+    footnoteRef,
+    footnotesList,
   ]);
   return turndownService.turndown(html).replaceAll('<br>', ' ');
 }
@@ -203,6 +205,56 @@ function image(turndownService: _TurndownService) {
   });
 }
 
+function getFootnoteAnchor(node: HTMLElement): HTMLElement | null {
+  const child = node.firstElementChild as HTMLElement | null;
+  return child?.nodeName === 'A' && child.classList.contains('footnote-ref')
+    ? child
+    : null;
+}
+
+function footnoteRef(turndownService: _TurndownService) {
+  turndownService.addRule('footnoteRef', {
+    filter: function (node: HTMLInputElement) {
+      return node.nodeName === 'SUP' && !!getFootnoteAnchor(node);
+    },
+    replacement: function (_content: string, node: HTMLInputElement) {
+      const anchor = getFootnoteAnchor(node);
+      const number =
+        anchor.getAttribute('data-reference-number') || anchor.textContent;
+      return `[^${number}]`;
+    },
+  });
+}
+
+function footnotesList(turndownService: _TurndownService) {
+  turndownService.addRule('footnotesList', {
+    filter: function (node: HTMLInputElement) {
+      return node.nodeName === 'OL' && node.classList.contains('footnotes');
+    },
+    replacement: function (_content: string, node: HTMLInputElement) {
+      const items = Array.from(node.children).filter(
+        (child) => child.nodeName === 'LI',
+      );
+      const definitions = items.map((li, index) => {
+        const number =
+          (li.getAttribute('id') || '').replace('fn:', '') ||
+          String(index + 1);
+        const markdown = turndownService
+          .turndown((li as HTMLElement).innerHTML)
+          .trim();
+        // continuation lines need a 4-space indent to stay in the footnote
+        const [first, ...rest] = markdown.split('\n');
+        const body = [
+          first,
+          ...rest.map((line: string) => (line.trim() ? `    ${line}` : line)),
+        ].join('\n');
+        return `[^${number}]: ${body}`;
+      });
+      return `\n\n${definitions.join('\n')}\n\n`;
+    },
+  });
+}
+
 function video(turndownService: _TurndownService) {
   turndownService.addRule('video', {
     filter: function (node: HTMLInputElement) {

packages/editor-ext/src/lib/prosemirror-docx/schema.ts

@@ -1,4 +1,4 @@
-import { HeadingLevel, ShadingType } from 'docx';
+import { FootnoteReferenceRun, HeadingLevel, Paragraph, ShadingType } from 'docx';
 import { Node } from 'prosemirror-model';
 import {
   DocxSerializerAsync,
@@ -168,9 +168,31 @@ export const defaultAsyncNodes: NodeSerializerAsync = {
   pageBreak(state, node) {
     state.closeBlock(node, { pageBreakBefore: true });
   },
+  footnoteReference(state, node) {
+    const number =
+      Number(node.attrs?.referenceNumber) || state.$footnoteCounter + 1;
+    state.$footnoteCounter = Math.max(state.$footnoteCounter, number);
+    // seed an empty body so the reference stays valid even if the trailing
+    // footnotes list is missing; the footnotes node overwrites it with content
+    if (!state.footnotes[number]) {
+      state.footnotes[number] = { children: [new Paragraph('')] };
+    }
+    state.current.push(new FootnoteReferenceRun(number));
+  },
+  async footnotes(state, node) {
+    for (let i = 0; i < node.childCount; i += 1) {
+      const item = node.child(i);
+      const number =
+        Number(String(item.attrs?.id ?? '').replace('fn:', '')) || i + 1;
+      await state.footnoteDefinition(item, number);
+    }
+  },
+  // items are consumed by the footnotes handler above
+  footnote() {},
   // No usable static export representation: skip without failing.
   subpages() {},
   transclusionReference() {},
+  base() {},
 };
 
 export const defaultMarks: MarkSerializer = {

packages/editor-ext/src/lib/prosemirror-docx/serializer.ts

@@ -824,6 +824,29 @@ export class DocxSerializerStateAsync {
     this.current.push(new FootnoteReferenceRun(this.$footnoteCounter));
   }
 
+  // Fills the footnote body for an already-referenced footnote number from a
+  // node holding block content (Docmost keeps footnote text in a trailing
+  // list, separate from the inline reference).
+  async footnoteDefinition(node: Node, number: number) {
+    const { current, children, nextRunOpts, nextParentParagraphOpts } = this;
+    this.current = [];
+    this.children = [];
+    delete this.nextRunOpts;
+    delete this.nextParentParagraphOpts;
+
+    await this.renderContent(node);
+    this.footnotes[number] = {
+      children: this.children.filter(
+        (child): child is Paragraph => child instanceof Paragraph,
+      ),
+    };
+
+    this.current = current;
+    this.children = children;
+    this.nextRunOpts = nextRunOpts;
+    this.nextParentParagraphOpts = nextParentParagraphOpts;
+  }
+
   closeBlock(node: Node, props?: IParagraphOptions) {
     const paragraph = new Paragraph({
       children: this.current,

packages/editor-ext/src/lib/trailing-node.ts

@@ -7,9 +7,19 @@ export interface TrailingNodeExtensionOptions {
 }
 
 function nodeEqualsType({ types, node }: { types: any, node: any }) {
+  if (!node) return false
   return (Array.isArray(types) && types.includes(node.type)) || node.type === types
 }
 
+// footnotes must stay the last doc child, so the trailing node goes before it
+function lastNodeBeforeFootnotes(doc: any) {
+  const lastChild = doc.lastChild
+  if (lastChild?.type.name === 'footnotes') {
+    return doc.childCount > 1 ? doc.child(doc.childCount - 2) : null
+  }
+  return lastChild
+}
+
 // @ts-ignore
 /**
  * Extension based on:
@@ -40,19 +50,23 @@ export const TrailingNode = Extension.create<TrailingNodeExtensionOptions>({
         appendTransaction: (_, __, state) => {
           const { doc, tr, schema } = state;
           const shouldInsertNodeAtEnd = plugin.getState(state);
-          const endPosition = doc.content.size;
           const type = schema.nodes[this.options.node]
 
           if (!shouldInsertNodeAtEnd) {
             return;
           }
 
+          const lastChild = doc.lastChild
+          const endPosition = lastChild?.type.name === 'footnotes'
+            ? doc.content.size - lastChild.nodeSize
+            : doc.content.size
+
           return tr.insert(endPosition, type.create());
         },
         state: {
           init: (_, state) => {
             try {
-              const lastNode = state.tr.doc.lastChild
+              const lastNode = lastNodeBeforeFootnotes(state.tr.doc)
               return !nodeEqualsType({ node: lastNode, types: disabledNodes })
             } catch (err){
               console.log(err)
@@ -70,7 +84,7 @@ export const TrailingNode = Extension.create<TrailingNodeExtensionOptions>({
               return value
             }
 
-            const lastNode = tr.doc.lastChild
+            const lastNode = lastNodeBeforeFootnotes(tr.doc)
             return !nodeEqualsType({ node: lastNode, types: disabledNodes })
           },
         },