scheduled cleanup

* chore: package updates

* remove stale overrides

Dockerfile

@@ -1,7 +1,7 @@
 FROM node:26-slim AS base
 LABEL org.opencontainers.image.source="https://github.com/docmost/docmost"
 
-RUN npm install -g pnpm@11.13.0
+RUN npm install -g pnpm@11.15.1
 
 FROM base AS builder
 

apps/client/package.json

@@ -36,7 +36,7 @@
     "@tanstack/react-table": "8.21.3",
     "@tanstack/react-virtual": "3.14.3",
     "alfaaz": "1.1.0",
-    "axios": "1.16.0",
+    "axios": "1.18.1",
     "blueimp-load-image": "5.16.0",
     "clsx": "2.1.1",
     "file-saver": "2.0.5",
@@ -61,7 +61,7 @@
     "react-error-boundary": "6.1.1",
     "react-helmet-async": "3.0.0",
     "react-i18next": "16.5.8",
-    "react-router-dom": "7.18.0",
+    "react-router-dom": "7.18.2",
     "semver": "7.7.4",
     "socket.io-client": "4.8.3",
     "zod": "4.3.6"
@@ -86,7 +86,7 @@
     "globals": "15.13.0",
     "jsdom": "25.0.0",
     "optics-ts": "2.4.1",
-    "postcss": "8.5.14",
+    "postcss": "8.5.25",
     "postcss-preset-mantine": "1.18.0",
     "postcss-simple-vars": "7.0.1",
     "prettier": "3.8.1",

apps/client/src/App.tsx

@@ -40,6 +40,7 @@ import WorkspaceApiKeys from "@/ee/api-key/pages/workspace-api-keys";
 import AiSettings from "@/ee/ai/pages/ai-settings.tsx";
 import BasePage from "@/ee/base/pages/base-page.tsx";
 import AuditLogs from "@/ee/audit/pages/audit-logs.tsx";
+import PageAnalytics from "@/ee/page-analytics/pages/page-analytics.tsx";
 import VerifiedPages from "@/ee/page-verification/pages/verified-pages.tsx";
 import TemplateList from "@/ee/template/pages/template-list";
 import TemplateEditor from "@/ee/template/pages/template-editor";
@@ -127,6 +128,7 @@ export default function App() {
             <Route path={"ai"} element={<AiSettings />} />
             <Route path={"ai/mcp"} element={<AiSettings />} />
             <Route path={"audit"} element={<AuditLogs />} />
+            <Route path={"analytics"} element={<PageAnalytics />} />
             <Route path={"verifications"} element={<VerifiedPages />} />
             {!isCloud() && <Route path={"license"} element={<License />} />}
             {isCloud() && <Route path={"billing"} element={<Billing />} />}

apps/client/src/components/settings/settings-queries.tsx

@@ -5,7 +5,7 @@ import {
 } from "@/ee/billing/services/billing-service.ts";
 import { getSpaces } from "@/features/space/services/space-service.ts";
 import { getGroups } from "@/features/group/services/group-service.ts";
-import { QueryParams } from "@/lib/types.ts";
+import type { QueryParams } from "@/lib/types.ts";
 import { getWorkspaceMembers } from "@/features/workspace/services/workspace-service.ts";
 import { getLicenseInfo } from "@/ee/licence/services/license-service.ts";
 import { getSsoProviders } from "@/ee/security/services/security-service.ts";
@@ -14,6 +14,11 @@ import { getApiKeys } from "@/ee/api-key";
 import { getAuditLogs } from "@/ee/audit/services/audit-service";
 import { getVerificationList } from "@/ee/page-verification/services/page-verification-service";
 import { getScimTokens } from "@/ee/scim/services/scim-token-service";
+import {
+  getWorkspacePageAnalyticsDailyStats,
+  getWorkspacePageAnalyticsTopPages,
+  getWorkspacePageAnalyticsTotals,
+} from "@/ee/page-analytics/services/page-analytics-service";
 
 export const prefetchWorkspaceMembers = () => {
   const params: QueryParams = { limit: 100, query: "" };
@@ -100,6 +105,31 @@ export const prefetchVerifiedPages = () => {
   });
 };
 
+export const prefetchPageAnalytics = () => {
+  const dateRange = {
+    startDate: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
+      .toISOString()
+      .slice(0, 10),
+    endDate: new Date().toISOString().slice(0, 10),
+  };
+  const listParams = { ...dateRange, cursor: undefined, limit: 10 };
+
+  queryClient.prefetchQuery({
+    queryKey: ["workspace-page-analytics-totals", dateRange],
+    queryFn: () => getWorkspacePageAnalyticsTotals(dateRange),
+  });
+
+  queryClient.prefetchQuery({
+    queryKey: ["workspace-page-analytics-top-pages", listParams],
+    queryFn: () => getWorkspacePageAnalyticsTopPages(listParams),
+  });
+
+  queryClient.prefetchQuery({
+    queryKey: ["workspace-page-analytics-daily-stats", listParams],
+    queryFn: () => getWorkspacePageAnalyticsDailyStats(listParams),
+  });
+};
+
 export const prefetchScimTokens = () => {
   queryClient.prefetchQuery({
     queryKey: ["scim-token-list", { cursor: undefined }],

apps/client/src/components/settings/settings-sidebar.tsx

@@ -15,6 +15,7 @@ import {
   IconSparkles,
   IconHistory,
   IconShieldCheck,
+  IconChartBar,
 } from "@tabler/icons-react";
 import { Link, useLocation } from "react-router-dom";
 import classes from "./settings.module.css";
@@ -38,6 +39,7 @@ import {
   prefetchWorkspaceMembers,
   prefetchAuditLogs,
   prefetchVerifiedPages,
+  prefetchPageAnalytics,
 } from "@/components/settings/settings-queries.tsx";
 import AppVersion from "@/components/settings/app-version.tsx";
 import { mobileSidebarAtom } from "@/components/layouts/global/hooks/atoms/sidebar-atom.ts";
@@ -125,6 +127,13 @@ const groupedData: DataGroup[] = [
         role: "owner",
         env: "selfhosted",
       },
+      {
+        label: "Page analytics",
+        icon: IconChartBar,
+        path: "/settings/analytics",
+        feature: Feature.PAGE_ANALYTICS,
+        role: "owner",
+      },
     ],
   },
   {
@@ -225,6 +234,9 @@ export default function SettingsSidebar() {
             case "Verified pages":
               prefetchHandler = prefetchVerifiedPages;
               break;
+            case "Page analytics":
+              prefetchHandler = prefetchPageAnalytics;
+              break;
             default:
               break;
           }

apps/client/src/ee/audit/pages/audit-logs.tsx

@@ -26,24 +26,8 @@ import { IAuditLogParams } from "@/ee/audit/types/audit.types";
 import { eventFilterOptions } from "@/ee/audit/lib/audit-event-labels";
 import AuditLogsTable from "@/ee/audit/components/audit-logs-table";
 import useUserRole from "@/hooks/use-user-role";
+import { daysToRetention, retentionToDays, RetentionUnit } from "@/ee/utils";
 
-type RetentionUnit = "days" | "months" | "years";
-
-function daysToRetention(days: number): { amount: number; unit: RetentionUnit } {
-  if (days >= 365 && days % 365 === 0) {
-    return { amount: days / 365, unit: "years" };
-  }
-  if (days >= 30 && days % 30 === 0) {
-    return { amount: days / 30, unit: "months" };
-  }
-  return { amount: days, unit: "days" };
-}
-
-function retentionToDays(amount: number, unit: RetentionUnit): number {
-  if (unit === "years") return amount * 365;
-  if (unit === "months") return amount * 30;
-  return amount;
-}
 
 export default function AuditLogs() {
   const { t } = useTranslation();

apps/client/src/ee/features.ts

@@ -15,6 +15,7 @@ export const Feature = {
   SCIM: 'scim',
   PAGE_VERIFICATION: 'page:verification',
   AUDIT_LOGS: 'audit:logs',
+  PAGE_ANALYTICS: 'analytics:page-analytics',
   RETENTION: 'retention',
   SHARING_CONTROLS: 'sharing:controls',
   TEMPLATES: 'templates',

apps/client/src/ee/page-analytics/pages/page-analytics.tsx

@@ -0,0 +1,421 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import {
+  ActionIcon,
+  Badge,
+  Button,
+  Card,
+  Group,
+  NumberInput,
+  Popover,
+  Select,
+  SimpleGrid,
+  Stack,
+  Table,
+  Text,
+  Tooltip,
+} from "@mantine/core";
+import { Helmet } from "react-helmet-async";
+import { useTranslation } from "react-i18next";
+import SettingsTitle from "@/components/settings/settings-title";
+import { getAppName } from "@/lib/config";
+import Paginate from "@/components/common/paginate";
+import { useCursorPaginate } from "@/hooks/use-cursor-paginate";
+import {
+  usePageAnalyticsRetentionQuery,
+  useUpdatePageAnalyticsRetentionMutation,
+  useWorkspacePageAnalyticsDailyStatsQuery,
+  useWorkspacePageAnalyticsTopPagesQuery,
+  useWorkspacePageAnalyticsTotalsQuery,
+} from "@/ee/page-analytics/queries/page-analytics-query";
+import { Link } from "react-router-dom";
+import { formatLocalized, useDateFnsLocale } from "@/lib/date-locale";
+import { IconSettings } from "@tabler/icons-react";
+import {
+  daysToRetention,
+  formatNumber,
+  retentionToDays,
+  RetentionUnit,
+  toISODate,
+} from "@/ee/utils";
+
+type RangePreset = "7" | "30" | "90";
+
+const DAILY_PAGE_SIZE = 10;
+
+export default function PageAnalytics() {
+  const { t } = useTranslation();
+  const locale = useDateFnsLocale();
+  const [rangePreset, setRangePreset] = useState<RangePreset>("30");
+  const [topPagesLimit, setTopPagesLimit] = useState("10");
+  const [settingsOpen, setSettingsOpen] = useState(false);
+
+  const { data: retentionData } = usePageAnalyticsRetentionQuery();
+  const updateRetention = useUpdatePageAnalyticsRetentionMutation();
+
+  const parsed = useMemo(
+    () => daysToRetention(retentionData?.retentionDays ?? 365),
+    [retentionData]
+  );
+
+  useEffect(() => {
+    if (settingsOpen) return;
+
+    setRetentionAmount(parsed.amount);
+    setRetentionUnit(parsed.unit);
+  }, [parsed]);
+
+  const [retentionAmount, setRetentionAmount] = useState<number | string>(
+    parsed.amount
+  );
+  const [retentionUnit, setRetentionUnit] = useState<RetentionUnit>(parsed.unit);
+
+  const resetRetentionForm = useCallback(() => {
+    const { amount, unit } = daysToRetention(retentionData?.retentionDays ?? 365);
+    setRetentionAmount(amount);
+    setRetentionUnit(unit);
+  }, [setRetentionAmount, setRetentionUnit, retentionData]);
+
+  const {
+    cursor: topPagesCursor,
+    goNext: goNextTopPages,
+    goPrev: goPrevTopPages,
+    resetCursor: resetTopPagesCursor,
+  } = useCursorPaginate();
+
+  const {
+    cursor: dailyCursor,
+    goNext: goNextDaily,
+    goPrev: goPrevDaily,
+    resetCursor: resetDailyCursor,
+  } = useCursorPaginate();
+
+  const dateRange = useMemo(
+    () => ({
+      startDate: toISODate(rangePreset),
+      endDate: new Date().toISOString().slice(0, 10),
+    }),
+    [rangePreset]
+  );
+
+  const topPagesParams = useMemo(
+    () => ({
+      ...dateRange,
+      cursor: topPagesCursor,
+      limit: Number(topPagesLimit),
+    }),
+    [dateRange, topPagesCursor, topPagesLimit]
+  );
+
+  const formatDate = useCallback(
+    (value?: Date | string | null) => {
+      if (!value) return "-";
+
+      const date = new Date(value);
+      if (Number.isNaN(date.getTime())) return "-";
+
+      return formatLocalized(date, "MMM dd, yyyy", "PP", locale);
+    },
+    [locale]
+  );
+
+  const dailyParams = useMemo(
+    () => ({
+      ...dateRange,
+      cursor: dailyCursor,
+      limit: DAILY_PAGE_SIZE,
+    }),
+    [dateRange, dailyCursor]
+  );
+
+  const { data: totalsData } = useWorkspacePageAnalyticsTotalsQuery(dateRange);
+  const { data: topPagesData, isLoading: isTopPagesLoading } =
+    useWorkspacePageAnalyticsTopPagesQuery(topPagesParams);
+  const { data: dailyData, isLoading: isDailyLoading } =
+    useWorkspacePageAnalyticsDailyStatsQuery(dailyParams);
+
+  const handleRangeChange = (value: RangePreset) => {
+    if (value) {
+      setRangePreset(value);
+      resetTopPagesCursor();
+      resetDailyCursor();
+    }
+  };
+
+  const handleTopPagesLimitChange = (value: string | null) => {
+    if (value) {
+      setTopPagesLimit(value);
+      resetTopPagesCursor();
+    }
+  };
+
+  return (
+    <>
+      <Helmet>
+        <title>
+          {t("Page analytics")} - {getAppName()}
+        </title>
+      </Helmet>
+
+      <SettingsTitle title={t("Page analytics")} />
+
+      <Group justify="space-between" mb="md">
+        <Select
+          value={rangePreset}
+          onChange={handleRangeChange}
+          data={[
+            { value: "7", label: t("Last 7 days") },
+            { value: "30", label: t("Last 30 days") },
+            { value: "90", label: t("Last 90 days") },
+          ]}
+          w={160}
+          size="sm"
+          allowDeselect={false}
+        />
+        <Popover
+          position="bottom-end"
+          shadow="md"
+          width={260}
+          withArrow
+          opened={settingsOpen}
+          onChange={(opened) => {
+            if (!opened) resetRetentionForm();
+            setSettingsOpen(opened);
+          }}
+        >
+          <Popover.Target>
+            <Tooltip label={t("Audit settings")}>
+              <ActionIcon
+                variant="default"
+                size="input-sm"
+                ml="auto"
+                onClick={() => setSettingsOpen((o) => !o)}
+              >
+                <IconSettings size={16} />
+              </ActionIcon>
+            </Tooltip>
+          </Popover.Target>
+          <Popover.Dropdown>
+            <Text fz="sm" fw={500} mb={4}>
+              {t("Retention")}
+            </Text>
+            <Text fz="xs" c="dimmed" mb="sm">
+              {t("Logs older than this period are automatically deleted.")}
+            </Text>
+            <Group gap="xs" wrap="nowrap" mb="sm">
+              <NumberInput
+                value={retentionAmount}
+                onChange={(val) => setRetentionAmount(val)}
+                min={1}
+                hideControls
+                size="sm"
+                w={60}
+              />
+              <Select
+                data={[
+                  { value: "days", label: t("days") },
+                  { value: "months", label: t("months") },
+                  { value: "years", label: t("years") },
+                ]}
+                value={retentionUnit}
+                onChange={(value) => {
+                  if (value === "days" || value === "months" || value === "years") {
+                    setRetentionUnit(value);
+                  }
+                }}
+                size="sm"
+                style={{ flex: 1 }}
+                comboboxProps={{ withinPortal: false }}
+              />
+            </Group>
+            <Group gap="xs" grow>
+              <Button
+                size="xs"
+                variant="default"
+                onClick={() => {
+                  resetRetentionForm();
+                  setSettingsOpen(false);
+                }}
+              >
+                {t("Cancel")}
+              </Button>
+              <Button
+                size="xs"
+                onClick={() => {
+                  const num =
+                    typeof retentionAmount === "number" ? retentionAmount : 1;
+                  const clamped = Math.max(1, num);
+                  setRetentionAmount(clamped);
+                  const days = retentionToDays(clamped, retentionUnit);
+
+                  if (days !== (retentionData?.retentionDays ?? 365)) {
+                    updateRetention.mutate({
+                      pageAnalyticsRetentionDays: Number(days),
+                    });
+                  }
+                  setSettingsOpen(false);
+                }}
+                loading={updateRetention.isPending}
+              >
+                {t("Save")}
+              </Button>
+            </Group>
+          </Popover.Dropdown>
+        </Popover>
+      </Group>
+
+      <SimpleGrid cols={{ base: 1, sm: 2, lg: 4 }} mb="md">
+        <Card withBorder radius="md" p="md">
+          <Text size="xs" c="dimmed">
+            {t("Total views")}
+          </Text>
+          <Text fw={700} fz="xl">
+            {formatNumber(totalsData?.totals.totalViews)}
+          </Text>
+        </Card>
+        <Card withBorder radius="md" p="md">
+          <Text size="xs" c="dimmed">
+            {t("Unique visitors")}
+          </Text>
+          <Text fw={700} fz="xl">
+            {formatNumber(totalsData?.totals.uniqueVisitors)}
+          </Text>
+        </Card>
+        <Card withBorder radius="md" p="md">
+          <Text size="xs" c="dimmed">
+            {t("Authenticated visitors")}
+          </Text>
+          <Text fw={700} fz="xl">
+            {formatNumber(totalsData?.totals.authenticatedVisitors)}
+          </Text>
+        </Card>
+        <Card withBorder radius="md" p="md">
+          <Text size="xs" c="dimmed">
+            {t("Shared-link views")}
+          </Text>
+          <Text fw={700} fz="xl">
+            {formatNumber(totalsData?.totals.sharedViews)}
+          </Text>
+        </Card>
+      </SimpleGrid>
+
+      <SimpleGrid cols={{ base: 1, lg: 2 }} spacing="md">
+        <Card withBorder radius="md" p="md">
+          <Group justify="space-between" mb="sm">
+            <Text fw={600}>{t("Top pages")}</Text>
+            <Group gap="xs">
+              {isTopPagesLoading && <Badge variant="light">{t("Loading")}</Badge>}
+              <Select
+                aria-label={t("Number of top pages")}
+                data={[
+                  { value: "10", label: t("Top 10") },
+                  { value: "20", label: t("Top 20") },
+                  { value: "50", label: t("Top 50") },
+                  { value: "100", label: t("Top 100") },
+                ]}
+                value={topPagesLimit}
+                onChange={handleTopPagesLimitChange}
+                w={100}
+                size="xs"
+                allowDeselect={false}
+              />
+            </Group>
+          </Group>
+          <Table striped highlightOnHover withTableBorder withColumnBorders>
+            <Table.Thead>
+              <Table.Tr>
+                <Table.Th>{t("Page")}</Table.Th>
+                <Table.Th>{t("Views")}</Table.Th>
+                <Table.Th>{t("Visitors")}</Table.Th>
+                <Table.Th>{t("Last viewed")}</Table.Th>
+              </Table.Tr>
+            </Table.Thead>
+            <Table.Tbody>
+              {(topPagesData?.items ?? []).map((item) => (
+                <Table.Tr key={item.pageId}>
+                  <Table.Td>
+                    {item.pageSlugId ? (
+                      <Link to={`/p/${item.pageSlugId}`}>
+                        {item.pageTitle || t("Untitled")}
+                      </Link>
+                    ) : (
+                      item.pageTitle || t("Untitled")
+                    )}
+                  </Table.Td>
+                  <Table.Td>{formatNumber(item.totalViews)}</Table.Td>
+                  <Table.Td>{formatNumber(item.uniqueVisitors)}</Table.Td>
+                  <Table.Td>{formatDate(item.lastViewedAt)}</Table.Td>
+                </Table.Tr>
+              ))}
+              {!isTopPagesLoading && (topPagesData?.items.length ?? 0) === 0 && (
+                <Table.Tr>
+                  <Table.Td colSpan={4}>
+                    <Text c="dimmed" size="sm">
+                      {t("No analytics data for this range.")}
+                    </Text>
+                  </Table.Td>
+                </Table.Tr>
+              )}
+            </Table.Tbody>
+          </Table>
+          {topPagesData?.items &&
+            topPagesData.items.length > 0 &&
+            (topPagesData.meta.hasPrevPage || topPagesData.meta.hasNextPage) && (
+              <Paginate
+                hasPrevPage={topPagesData.meta.hasPrevPage}
+                hasNextPage={topPagesData.meta.hasNextPage}
+                onPrev={goPrevTopPages}
+                onNext={() => goNextTopPages(topPagesData.meta.nextCursor)}
+              />
+            )}
+        </Card>
+
+        <Card withBorder radius="md" p="md">
+          <Group justify="space-between" mb="sm">
+            <Text fw={600}>{t("Daily breakdown")}</Text>
+            {isDailyLoading && <Badge variant="light">{t("Loading")}</Badge>}
+          </Group>
+          <Stack gap="xs">
+            <Table striped highlightOnHover withTableBorder withColumnBorders>
+              <Table.Thead>
+                <Table.Tr>
+                  <Table.Th>{t("Date")}</Table.Th>
+                  <Table.Th>{t("Views")}</Table.Th>
+                  <Table.Th>{t("Visitors")}</Table.Th>
+                </Table.Tr>
+              </Table.Thead>
+              <Table.Tbody>
+                {(dailyData?.items ?? []).map((item) => (
+                  <Table.Tr key={item.viewDate}>
+                    <Table.Td>{item.viewDate}</Table.Td>
+                    <Table.Td>{formatNumber(item.totalViews)}</Table.Td>
+                    <Table.Td>{formatNumber(item.uniqueVisitors)}</Table.Td>
+                  </Table.Tr>
+                ))}
+                {!isDailyLoading && (dailyData?.items.length ?? 0) === 0 && (
+                  <Table.Tr>
+                    <Table.Td colSpan={3}>
+                      <Text c="dimmed" size="sm">
+                        {t("No analytics data for this range.")}
+                      </Text>
+                    </Table.Td>
+                  </Table.Tr>
+                )}
+              </Table.Tbody>
+            </Table>
+
+            {dailyData?.items &&
+              dailyData.items.length > 0 &&
+              (dailyData.meta.hasPrevPage || dailyData.meta.hasNextPage) && (
+                <Paginate
+                  hasPrevPage={dailyData.meta.hasPrevPage}
+                  hasNextPage={dailyData.meta.hasNextPage}
+                  onPrev={goPrevDaily}
+                  onNext={() => goNextDaily(dailyData.meta.nextCursor)}
+                />
+              )}
+          </Stack>
+        </Card>
+      </SimpleGrid>
+    </>
+  );
+}

apps/client/src/ee/page-analytics/queries/page-analytics-query.ts

@@ -0,0 +1,73 @@
+import { keepPreviousData, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  getPageAnalyticsRetention,
+  getWorkspacePageAnalyticsDailyStats,
+  getWorkspacePageAnalyticsTopPages,
+  getWorkspacePageAnalyticsTotals,
+  updatePageAnalyticsRetention,
+} from "@/ee/page-analytics/services/page-analytics-service";
+import type { IPagination } from "@/lib/types";
+import type {
+  WorkspaceAnalyticsDailyStat,
+  WorkspaceAnalyticsListParams,
+  WorkspaceAnalyticsParams,
+  WorkspaceAnalyticsTopPage,
+  WorkspaceAnalyticsTotals,
+} from "@/ee/page-analytics/types/page-analytics.types";
+import { useTranslation } from "react-i18next";
+import { notifications } from "@mantine/notifications";
+
+export function useWorkspacePageAnalyticsTotalsQuery(
+  params?: WorkspaceAnalyticsParams,
+) {
+  return useQuery<WorkspaceAnalyticsTotals, Error>({
+    queryKey: ["workspace-page-analytics-totals", params],
+    queryFn: () => getWorkspacePageAnalyticsTotals(params),
+    placeholderData: keepPreviousData,
+  });
+}
+
+export function useWorkspacePageAnalyticsDailyStatsQuery(
+  params?: WorkspaceAnalyticsListParams,
+) {
+  return useQuery<IPagination<WorkspaceAnalyticsDailyStat>, Error>({
+    queryKey: ["workspace-page-analytics-daily-stats", params],
+    queryFn: () => getWorkspacePageAnalyticsDailyStats(params),
+    placeholderData: keepPreviousData,
+  });
+}
+
+export function useWorkspacePageAnalyticsTopPagesQuery(
+  params?: WorkspaceAnalyticsListParams,
+) {
+  return useQuery<IPagination<WorkspaceAnalyticsTopPage>, Error>({
+    queryKey: ["workspace-page-analytics-top-pages", params],
+    queryFn: () => getWorkspacePageAnalyticsTopPages(params),
+    placeholderData: keepPreviousData,
+  });
+}
+
+export function usePageAnalyticsRetentionQuery() {
+  return useQuery({
+    queryKey: ["page-analytics-retention"],
+    queryFn: () => getPageAnalyticsRetention(),
+  });
+}
+
+export function useUpdatePageAnalyticsRetentionMutation() {
+  const queryClient = useQueryClient();
+  const { t } = useTranslation();
+
+  return useMutation({
+    mutationFn: (data: { pageAnalyticsRetentionDays: number }) =>
+      updatePageAnalyticsRetention(data),
+    onSuccess: () => {
+      notifications.show({ message: t("Page analytics retention updated") });
+      queryClient.invalidateQueries({ queryKey: ["page-analytics-retention"] });
+    },
+    onError: (error) => {
+      const errorMessage = error["response"]?.data?.message;
+      notifications.show({ message: errorMessage, color: "red" });
+    },
+  });
+}

apps/client/src/ee/page-analytics/services/page-analytics-service.ts

@@ -0,0 +1,43 @@
+import api from "@/lib/api-client";
+import type { IPagination } from "@/lib/types";
+import type {
+  WorkspaceAnalyticsDailyStat,
+  WorkspaceAnalyticsListParams,
+  WorkspaceAnalyticsParams,
+  WorkspaceAnalyticsTopPage,
+  WorkspaceAnalyticsTotals,
+} from "@/ee/page-analytics/types/page-analytics.types";
+
+export async function getWorkspacePageAnalyticsTotals(
+  params?: WorkspaceAnalyticsParams,
+): Promise<WorkspaceAnalyticsTotals> {
+  const req = await api.post("/page-analytics/workspace-stats", params);
+  return req.data;
+}
+
+export async function getWorkspacePageAnalyticsDailyStats(
+  params?: WorkspaceAnalyticsListParams,
+): Promise<IPagination<WorkspaceAnalyticsDailyStat>> {
+  const req = await api.post("/page-analytics/workspace-daily-stats", params);
+  return req.data;
+}
+
+export async function getWorkspacePageAnalyticsTopPages(
+  params?: WorkspaceAnalyticsListParams,
+): Promise<IPagination<WorkspaceAnalyticsTopPage>> {
+  const req = await api.post("/page-analytics/workspace-top-pages", params);
+  return req.data;
+}
+
+export async function getPageAnalyticsRetention(): Promise<{ retentionDays: number }> {
+  const req = await api.post("/page-analytics/retention");
+  return req.data;
+}
+
+export async function updatePageAnalyticsRetention(data: {
+  pageAnalyticsRetentionDays: number;
+}): Promise<{ retentionDays: number }> {
+
+  const req = await api.post("/page-analytics/retention/update", data);
+  return req.data;
+}

apps/client/src/ee/page-analytics/types/page-analytics.types.ts

@@ -0,0 +1,32 @@
+import { QueryParams } from "@/lib/types";
+
+export type WorkspaceAnalyticsParams = {
+  startDate?: string;
+  endDate?: string;
+};
+
+export type WorkspaceAnalyticsListParams = WorkspaceAnalyticsParams &
+  QueryParams;
+
+export type BasicStats = {
+  totalViews: number;
+  uniqueVisitors: number;
+  authenticatedVisitors: number;
+  sharedViews: number;
+};
+
+export type WorkspaceAnalyticsDailyStat = BasicStats & {
+  viewDate: string;
+};
+
+export type WorkspaceAnalyticsTopPage = BasicStats & {
+  pageId: string;
+  pageTitle: string | null;
+  pageSlugId: string | null;
+  lastViewedAt: string | null;
+};
+
+export type WorkspaceAnalyticsTotals = {
+  range: { startDate: string; endDate: string };
+  totals: BasicStats;
+};

apps/client/src/ee/utils.ts

@@ -14,3 +14,33 @@ export function exchangeTokenRedirectUrl(
 ) {
   return getHostnameUrl(hostname) + "/api/auth/exchange?token=" + exchangeToken;
 }
+
+export type RetentionUnit = "days" | "months" | "years";
+
+export function daysToRetention(days: number): { amount: number; unit: RetentionUnit } {
+  if (days >= 365 && days % 365 === 0) {
+    return { amount: days / 365, unit: "years" };
+  }
+  if (days >= 30 && days % 30 === 0) {
+    return { amount: days / 30, unit: "months" };
+  }
+  return { amount: days, unit: "days" };
+}
+
+export function retentionToDays(amount: number, unit: RetentionUnit): number {
+  if (unit === "years") return amount * 365;
+  if (unit === "months") return amount * 30;
+  return amount;
+}
+
+export function toISODate(daysAgo: number | string): string {
+  const daysNum = Number(daysAgo);
+
+  return new Date(Date.now() - daysNum * 24 * 60 * 60 * 1000)
+    .toISOString()
+    .slice(0, 10);
+}
+
+export function formatNumber(value: number | null | undefined): string {
+  return Number(value ?? 0).toLocaleString();
+}

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

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

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

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

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

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

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

@@ -3,7 +3,8 @@ import { StarterKit } from "@tiptap/starter-kit";
 import { Code } from "@tiptap/extension-code";
 import { TextAlign } from "@tiptap/extension-text-align";
 import { TaskList, TaskItem } from "@tiptap/extension-list";
-import { Placeholder, CharacterCount, UndoRedo } from "@tiptap/extensions";
+import { CharacterCount, UndoRedo } from "@tiptap/extensions";
+import { Placeholder } from "@/features/editor/extensions/placeholder";
 import { Superscript } from "@tiptap/extension-superscript";
 import SubScript from "@tiptap/extension-subscript";
 import { Typography } from "@tiptap/extension-typography";
@@ -194,16 +195,18 @@ export const mainExtensions = [
         return i18n.t("Toggle title");
       }
       if (node.type.name === "paragraph") {
-        const $pos = editor.state.doc.resolve(pos);
-        const parentName = $pos.parent.type.name;
-        if (
-          parentName === "column" ||
-          parentName === "tableCell" ||
-          parentName === "tableHeader" ||
-          parentName === "callout" ||
-          parentName === "blockquote"
-        ) {
-          return i18n.t("Write...");
+        const doc = editor.state.doc;
+        if (pos >= 0 && pos <= doc.content.size) {
+          const parentName = doc.resolve(pos).parent.type.name;
+          if (
+            parentName === "column" ||
+            parentName === "tableCell" ||
+            parentName === "tableHeader" ||
+            parentName === "callout" ||
+            parentName === "blockquote"
+          ) {
+            return i18n.t("Write...");
+          }
         }
         return i18n.t('Write anything. Enter "/" for commands');
       }

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

@@ -0,0 +1,64 @@
+import { isNodeEmpty } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
+import { Placeholder as TiptapPlaceholder } from "@tiptap/extensions";
+
+export const Placeholder = TiptapPlaceholder.extend({
+  addProseMirrorPlugins() {
+    const editor = this.editor;
+    const options = this.options;
+    const dataAttribute = `data-${options.dataAttribute || "placeholder"}`;
+
+    return [
+      new Plugin({
+        key: new PluginKey("docmostPlaceholder"),
+        props: {
+          decorations: (state) => {
+            if (options.showOnlyWhenEditable && !editor.isEditable) {
+              return null;
+            }
+
+            const { doc, selection } = state;
+            const { anchor } = selection;
+            const decorations: Decoration[] = [];
+            const isEmptyDoc = editor.isEmpty;
+
+            doc.descendants((node, pos) => {
+              if (!node.type.isTextblock) {
+                return options.includeChildren;
+              }
+
+              const hasAnchor = anchor >= pos && anchor <= pos + node.nodeSize;
+              const isEmpty = !node.isLeaf && isNodeEmpty(node);
+
+              if ((hasAnchor || !options.showOnlyCurrent) && isEmpty) {
+                const emptyNodeClass =
+                  typeof options.emptyNodeClass === "function"
+                    ? options.emptyNodeClass({ editor, node, pos, hasAnchor })
+                    : options.emptyNodeClass;
+                const classes = [emptyNodeClass];
+                if (isEmptyDoc) {
+                  classes.push(options.emptyEditorClass);
+                }
+
+                decorations.push(
+                  Decoration.node(pos, pos + node.nodeSize, {
+                    class: classes.join(" "),
+                    [dataAttribute]:
+                      typeof options.placeholder === "function"
+                        ? options.placeholder({ editor, node, pos, hasAnchor })
+                        : options.placeholder,
+                  }),
+                );
+              }
+
+              return options.includeChildren;
+            });
+
+            return DecorationSet.create(doc, decorations);
+          },
+        },
+      }),
+    ];
+  },
+});

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

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

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

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

apps/server/package.json

@@ -40,14 +40,14 @@
     "@clickhouse/client": "1.18.2",
     "@docmost/base-formula": "workspace:*",
     "@docmost/pdf-inspector": "1.9.6",
-    "@fastify/cookie": "^11.0.2",
-    "@fastify/multipart": "^10.0.0",
-    "@fastify/static": "^9.1.3",
-    "@keyv/redis": "^5.1.6",
+    "@fastify/cookie": "11.0.2",
+    "@fastify/multipart": "10.0.0",
+    "@fastify/static": "10.1.2",
+    "@keyv/redis": "5.1.6",
     "@langchain/core": "1.1.46",
     "@langchain/textsplitters": "1.0.1",
-    "@modelcontextprotocol/sdk": "1.29.0",
-    "@nest-lab/throttler-storage-redis": "^1.2.0",
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "@nest-lab/throttler-storage-redis": "1.2.0",
     "@nestjs-labs/nestjs-ioredis": "11.0.4",
     "@nestjs/bullmq": "11.0.4",
     "@nestjs/cache-manager": "3.1.3",
@@ -88,7 +88,6 @@
     "kysely-migration-cli": "0.4.2",
     "kysely-postgres-js": "3.0.0",
     "ldapts": "8.1.7",
-    "lib0": "0.2.117",
     "mammoth": "1.12.0",
     "mime-types": "3.0.2",
     "msgpackr": "^1.11.9",
@@ -118,9 +117,8 @@
     "stripe": "^17.7.0",
     "tlds": "1.261.0",
     "tmp-promise": "3.0.3",
-    "tseep": "1.3.1",
     "typesense": "3.0.5",
-    "undici": "7.28.0",
+    "undici": "7.29.0",
     "ws": "8.21.0",
     "yauzl": "3.4.0",
     "zod": "4.3.6"

apps/server/src/app.module.ts

@@ -26,6 +26,7 @@ import KeyvRedis from '@keyv/redis';
 import { LoggerModule } from './common/logger/logger.module';
 import { ClsModule } from 'nestjs-cls';
 import { NoopAuditModule } from './integrations/audit/audit.module';
+import { NoopPageAnalyticsModule } from './integrations/page-analytics/page-analytics.module';
 import { ThrottleModule } from './integrations/throttle/throttle.module';
 
 const enterpriseModules = [];
@@ -50,6 +51,7 @@ try {
     }),
     LoggerModule,
     NoopAuditModule,
+    NoopPageAnalyticsModule,
     CoreModule,
     DatabaseModule,
     EnvironmentModule,

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

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

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

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

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

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

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

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

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

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

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

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

apps/server/src/common/features.ts

@@ -15,6 +15,7 @@ export const Feature = {
   SCIM: 'scim',
   PAGE_VERIFICATION: 'page:verification',
   AUDIT_LOGS: 'audit:logs',
+  PAGE_ANALYTICS: 'analytics:page-analytics',
   RETENTION: 'retention',
   SHARING_CONTROLS: 'sharing:controls',
   VIEWER_COMMENTS: 'comment:viewer',

apps/server/src/core/casl/abilities/workspace-ability.factory.ts

@@ -42,6 +42,7 @@ function buildWorkspaceOwnerAbility() {
   can(WorkspaceCaslAction.Manage, WorkspaceCaslSubject.Attachment);
   can(WorkspaceCaslAction.Manage, WorkspaceCaslSubject.API);
   can(WorkspaceCaslAction.Manage, WorkspaceCaslSubject.Audit);
+  can(WorkspaceCaslAction.Manage, WorkspaceCaslSubject.PageAnalytics);
 
   return build();
 }

apps/server/src/core/casl/interfaces/workspace-ability.type.ts

@@ -13,6 +13,7 @@ export enum WorkspaceCaslSubject {
   Attachment = 'attachment',
   API = 'api_key',
   Audit = 'audit',
+  PageAnalytics = 'page_analytics'
 }
 
 export type IWorkspaceAbility =
@@ -22,4 +23,5 @@ export type IWorkspaceAbility =
   | [WorkspaceCaslAction, WorkspaceCaslSubject.Group]
   | [WorkspaceCaslAction, WorkspaceCaslSubject.Attachment]
   | [WorkspaceCaslAction, WorkspaceCaslSubject.API]
-  | [WorkspaceCaslAction, WorkspaceCaslSubject.Audit];
+  | [WorkspaceCaslAction, WorkspaceCaslSubject.Audit]
+  | [WorkspaceCaslAction, WorkspaceCaslSubject.PageAnalytics];

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

@@ -51,6 +51,10 @@ import {
   AUDIT_SERVICE,
   IAuditService,
 } from '../../integrations/audit/audit.service';
+import {
+  PAGE_ANALYTICS_SERVICE,
+  IPageAnalyticsService,
+} from '../../integrations/page-analytics/page-analytics.service';
 import { getPageTitle } from '../../common/helpers';
 
 @UseGuards(JwtAuthGuard)
@@ -65,6 +69,7 @@ export class PageController {
     private readonly backlinkService: BacklinkService,
     private readonly labelService: LabelService,
     @Inject(AUDIT_SERVICE) private readonly auditService: IAuditService,
+    @Inject(PAGE_ANALYTICS_SERVICE) private readonly pageAnalyticsService: IPageAnalyticsService,
   ) {}
 
   @HttpCode(HttpStatus.OK)
@@ -88,6 +93,13 @@ export class PageController {
 
     const permissions = { canEdit, hasRestriction };
 
+    void this.pageAnalyticsService.track({
+      pageId: page.id,
+      workspaceId: page.workspaceId,
+      spaceId: page.spaceId,
+      userId: user.id,
+    });
+
     if (dto.format && dto.format !== 'json' && page.content) {
       const contentOutput =
         dto.format === 'markdown'

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

@@ -35,6 +35,10 @@ import {
   AUDIT_SERVICE,
   IAuditService,
 } from '../../integrations/audit/audit.service';
+import {
+  PAGE_ANALYTICS_SERVICE,
+  IPageAnalyticsService,
+} from '../../integrations/page-analytics/page-analytics.service';
 
 @UseGuards(JwtAuthGuard)
 @Controller('shares')
@@ -47,6 +51,8 @@ export class ShareController {
     private readonly pageAccessService: PageAccessService,
     private readonly licenseCheckService: LicenseCheckService,
     @Inject(AUDIT_SERVICE) private readonly auditService: IAuditService,
+    @Inject(PAGE_ANALYTICS_SERVICE)
+    private readonly pageAnalyticsService: IPageAnalyticsService,
   ) {}
 
   @HttpCode(HttpStatus.OK)
@@ -79,6 +85,14 @@ export class ShareController {
       throw new NotFoundException('Shared page not found');
     }
 
+    void this.pageAnalyticsService.track({
+      pageId: shareData.page.id,
+      workspaceId: workspace.id,
+      spaceId: shareData.page.spaceId,
+      shareId: shareData.share.id,
+      userId: null,
+    });
+
     return {
       ...shareData,
       features: this.licenseCheckService.resolveFeatures(

apps/server/src/database/migrations/20260809T000000-page-analytics.ts

@@ -0,0 +1,64 @@
+import { Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable('page_analytics')
+    .ifNotExists()
+    .addColumn('id', 'uuid', (col) =>
+      col.primaryKey().defaultTo(sql`gen_uuid_v7()`),
+    )
+    .addColumn('workspace_id', 'uuid', (col) =>
+      col.references('workspaces.id').onDelete('cascade').notNull(),
+    )
+    .addColumn('page_id', 'uuid', (col) =>
+      col.references('pages.id').onDelete('cascade').notNull(),
+    )
+    .addColumn('space_id', 'uuid', (col) =>
+      col.references('spaces.id').onDelete('cascade'),
+    )
+    .addColumn('user_id', 'uuid', (col) =>
+      col.references('users.id').onDelete('set null'),
+    )
+    .addColumn('share_id', 'uuid')
+    .addColumn('visitor_id', 'varchar', (col) => col.notNull())
+    .addColumn('view_date', 'varchar', (col) => col.notNull())
+    .addColumn('hits', 'int8', (col) => col.notNull().defaultTo(1))
+    .addColumn('last_viewed_at', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`now()`),
+    )
+    .addColumn('created_at', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`now()`),
+    )
+    .execute();
+
+  await db.schema
+    .createIndex('idx_page_analytics_workspace_page_date')
+    .ifNotExists()
+    .on('page_analytics')
+    .columns(['workspace_id', 'page_id', 'view_date'])
+    .execute();
+
+  await sql`
+    CREATE UNIQUE INDEX IF NOT EXISTS
+      uq_page_analytics_workspace_page_identity
+    ON page_analytics (
+      workspace_id,
+      page_id,
+      COALESCE(user_id::text, visitor_id)
+    )
+  `.execute(db);
+
+  await db.schema
+    .alterTable('workspaces')
+    .addColumn('page_analytics_retention_days', 'int8', (col) => col)
+    .execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .alterTable('workspaces')
+    .dropColumn('page_analytics_retention_days')
+    .execute();
+
+  await db.schema.dropTable('page_analytics').ifExists().execute();
+}

apps/server/src/database/types/db.d.ts

@@ -437,6 +437,7 @@ export interface WorkspaceInvitations {
 }
 
 export interface Workspaces {
+  pageAnalyticsRetentionDays: Generated<number>;
   auditRetentionDays: Generated<number>;
   trashRetentionDays: Generated<number>;
   billingEmail: string | null;
@@ -544,6 +545,20 @@ export interface PagePermissions {
   updatedAt: Generated<Timestamp>;
 }
 
+export interface PageAnalytics {
+  id: Generated<string>;
+  workspaceId: string;
+  pageId: string;
+  spaceId: string | null;
+  shareId: string | null;
+  userId: string | null;
+  visitorId: string;
+  viewDate: string;
+  hits: Generated<number>;
+  lastViewedAt: Generated<Timestamp>;
+  createdAt: Generated<Timestamp>;
+}
+
 export interface PageVerifications {
   id: Generated<string>;
   pageId: string;
@@ -662,6 +677,7 @@ export interface DB {
   pagePermissions: PagePermissions;
   pageHistory: PageHistory;
   pageLabels: PageLabels;
+  pageAnalytics: PageAnalytics;
   pageVerifications: PageVerifications;
   pageVerifiers: PageVerifiers;
   pages: Pages;

apps/server/src/database/types/entity.types.ts

@@ -1,6 +1,7 @@
 import { Insertable, Selectable, Updateable } from 'kysely';
 import {
   AiChats,
+  PageAnalytics as _PageAnalytics,
   AiChatMessages,
   Attachments,
   BaseProperties,
@@ -107,6 +108,10 @@ export type PageHistory = Selectable<History>;
 export type InsertablePageHistory = Insertable<History>;
 export type UpdatablePageHistory = Updateable<Omit<History, 'id'>>;
 
+export type PageAnalytics = Selectable<_PageAnalytics>;
+export type InsertablePageAnalytics = Insertable<_PageAnalytics>;
+export type UpdatablePageAnalytics = Updateable<Omit<_PageAnalytics, 'id'>>;
+
 // Comment
 export type Comment = Selectable<Comments>;
 export type InsertableComment = Insertable<Comments>;

apps/server/src/integrations/page-analytics/page-analytics.module.ts

@@ -0,0 +1,14 @@
+import { Global, Module } from '@nestjs/common';
+import { PAGE_ANALYTICS_SERVICE, NoopPageAnalyticsService } from './page-analytics.service';
+
+@Global()
+@Module({
+  providers: [
+    {
+      provide: PAGE_ANALYTICS_SERVICE,
+      useClass: NoopPageAnalyticsService,
+    },
+  ],
+  exports: [PAGE_ANALYTICS_SERVICE],
+})
+export class NoopPageAnalyticsModule {}

apps/server/src/integrations/page-analytics/page-analytics.service.ts

@@ -0,0 +1,21 @@
+import { Injectable } from '@nestjs/common';
+
+export type PageAnalyticsPayload = {
+  pageId: string;
+  workspaceId?: string;
+  spaceId?: string;
+  shareId?: string;
+  userId?: string | null;
+  visitorId?: string;
+};
+
+export const PAGE_ANALYTICS_SERVICE = Symbol('PAGE_ANALYTICS_SERVICE');
+
+export interface IPageAnalyticsService {
+  track(payload: PageAnalyticsPayload): void | Promise<void>;
+}
+
+@Injectable()
+export class NoopPageAnalyticsService implements IPageAnalyticsService {
+  track(_payload: PageAnalyticsPayload): void {}
+}

apps/server/src/integrations/queue/constants/queue.constants.ts

@@ -9,6 +9,7 @@ export enum QueueName {
   HISTORY_QUEUE = '{history-queue}',
   NOTIFICATION_QUEUE = '{notification-queue}',
   AUDIT_QUEUE = '{audit-queue}',
+  PAGE_ANALYTICS_QUEUE = '{page-analytics-queue}',
   BASE_QUEUE = '{base-queue}',
 }
 
@@ -81,6 +82,8 @@ export enum QueueJob {
 
   AUDIT_LOG = 'audit-log',
   AUDIT_CLEANUP = 'audit-cleanup',
+  PAGE_ANALYTICS_TRACK = 'page-analytics-track',
+  PAGE_ANALYTICS_CLEANUP = 'page-analytics-cleanup',
 
   PDF_EXPORT_TASK = 'pdf-export-task',
   PDF_EXPORT_CLEANUP = 'pdf-export-cleanup',

apps/server/src/integrations/queue/queue.module.ts

@@ -92,6 +92,14 @@ import { GeneralQueueProcessor } from './processors/general-queue.processor';
         attempts: 3,
       },
     }),
+    BullModule.registerQueue({
+      name: QueueName.PAGE_ANALYTICS_QUEUE,
+      defaultJobOptions: {
+        removeOnComplete: true,
+        removeOnFail: true,
+        attempts: 3,
+      },
+    }),
     BullModule.registerQueue({
       name: QueueName.BASE_QUEUE,
       defaultJobOptions: {

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

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

package.json

@@ -23,47 +23,49 @@
     "@casl/ability": "6.8.0",
     "@docmost/editor-ext": "workspace:*",
     "@floating-ui/dom": "1.7.3",
-    "@hocuspocus/provider": "3.4.4",
-    "@hocuspocus/server": "3.4.4",
-    "@hocuspocus/transformer": "3.4.4",
+    "@hocuspocus/common": "4.4.0",
+    "@hocuspocus/provider": "4.4.0",
+    "@hocuspocus/provider-react": "4.4.0",
+    "@hocuspocus/server": "4.4.0",
+    "@hocuspocus/transformer": "4.4.0",
     "@joplin/turndown": "4.0.82",
     "@joplin/turndown-plugin-gfm": "1.0.64",
     "@sindresorhus/slugify": "3.0.0",
-    "@tiptap/core": "3.27.1",
-    "@tiptap/extension-audio": "3.27.1",
-    "@tiptap/extension-code-block": "3.27.1",
-    "@tiptap/extension-collaboration": "3.27.1",
-    "@tiptap/extension-collaboration-caret": "3.27.1",
-    "@tiptap/extension-color": "3.27.1",
-    "@tiptap/extension-document": "3.27.1",
-    "@tiptap/extension-heading": "3.27.1",
-    "@tiptap/extension-highlight": "3.27.1",
-    "@tiptap/extension-history": "3.27.1",
-    "@tiptap/extension-image": "3.27.1",
-    "@tiptap/extension-link": "3.27.1",
-    "@tiptap/extension-list": "3.27.1",
-    "@tiptap/extension-placeholder": "3.27.1",
-    "@tiptap/extension-subscript": "3.27.1",
-    "@tiptap/extension-superscript": "3.27.1",
-    "@tiptap/extension-table": "3.27.1",
-    "@tiptap/extension-text": "3.27.1",
-    "@tiptap/extension-text-align": "3.27.1",
-    "@tiptap/extension-text-style": "3.27.1",
-    "@tiptap/extension-typography": "3.27.1",
-    "@tiptap/extension-unique-id": "3.27.1",
-    "@tiptap/extension-youtube": "3.27.1",
-    "@tiptap/html": "3.27.1",
-    "@tiptap/pm": "3.27.1",
-    "@tiptap/react": "3.27.1",
-    "@tiptap/starter-kit": "3.27.1",
-    "@tiptap/suggestion": "3.27.1",
-    "@tiptap/y-tiptap": "3.0.5",
+    "@tiptap/core": "3.29.2",
+    "@tiptap/extension-audio": "3.29.2",
+    "@tiptap/extension-code-block": "3.29.2",
+    "@tiptap/extension-collaboration": "3.29.2",
+    "@tiptap/extension-collaboration-caret": "3.29.2",
+    "@tiptap/extension-color": "3.29.2",
+    "@tiptap/extension-document": "3.29.2",
+    "@tiptap/extension-heading": "3.29.2",
+    "@tiptap/extension-highlight": "3.29.2",
+    "@tiptap/extension-history": "3.29.2",
+    "@tiptap/extension-image": "3.29.2",
+    "@tiptap/extension-link": "3.29.2",
+    "@tiptap/extension-list": "3.29.2",
+    "@tiptap/extension-placeholder": "3.29.2",
+    "@tiptap/extension-subscript": "3.29.2",
+    "@tiptap/extension-superscript": "3.29.2",
+    "@tiptap/extension-table": "3.29.2",
+    "@tiptap/extension-text": "3.29.2",
+    "@tiptap/extension-text-align": "3.29.2",
+    "@tiptap/extension-text-style": "3.29.2",
+    "@tiptap/extension-typography": "3.29.2",
+    "@tiptap/extension-unique-id": "3.29.2",
+    "@tiptap/extension-youtube": "3.29.2",
+    "@tiptap/html": "3.29.2",
+    "@tiptap/pm": "3.29.2",
+    "@tiptap/react": "3.29.2",
+    "@tiptap/starter-kit": "3.29.2",
+    "@tiptap/suggestion": "3.29.2",
+    "@tiptap/y-tiptap": "3.0.7",
     "bytes": "3.1.2",
     "cross-env": "10.1.0",
     "date-fns": "4.1.0",
     "diff": "8.0.3",
     "docx": "9.7.1",
-    "dompurify": "3.4.11",
+    "dompurify": "3.4.12",
     "fractional-indexing-jittered": "1.0.0",
     "highlight.js": "11.11.1",
     "image-dimensions": "2.5.0",
@@ -79,12 +81,12 @@
     "yjs": "^13.6.30"
   },
   "devDependencies": {
-    "@nx/js": "22.6.1",
+    "@nx/js": "22.7.2",
     "@types/bytes": "3.1.5",
     "@types/qrcode": "1.5.6",
     "@types/turndown": "5.0.6",
-    "concurrently": "9.2.3",
-    "nx": "22.6.1",
+    "concurrently": "10.0.4",
+    "nx": "22.7.2",
     "tsx": "^4.21.0"
   },
   "workspaces": {
@@ -93,5 +95,5 @@
       "packages/*"
     ]
   },
-  "packageManager": "pnpm@11.13.0"
+  "packageManager": "pnpm@11.15.1"
 }

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

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

pnpm-workspace.yaml

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