Merge branch 'docmost:main' into main

2025-11-09 20:12:00 +10:00 · 2024-10-01 09:59:55 +10:00
parent 15eb997c92 a2bc374f47
commit d69fff5ef7
75 changed files with 1491 additions and 377 deletions
--- a/.env.example
+++ b/.env.example
@ -32,6 +32,7 @@ SMTP_PORT=587
 SMTP_USERNAME=
 SMTP_PASSWORD=
 SMTP_SECURE=false
+SMTP_IGNORETLS=false

 # Postmark driver config
 POSTMARK_TOKEN=
--- a/apps/client/package.json
+++ b/apps/client/package.json
@ -41,7 +41,6 @@
    "react-drawio": "^0.2.0",
    "react-error-boundary": "^4.0.13",
    "react-helmet-async": "^2.0.5",
-    "react-moveable": "^0.56.0",
    "react-router-dom": "^6.26.1",
    "socket.io-client": "^4.7.5",
    "tippy.js": "^6.3.7",
--- a/apps/client/src/App.tsx
+++ b/apps/client/src/App.tsx
@ -24,6 +24,8 @@ import PageRedirect from "@/pages/page/page-redirect.tsx";
 import Layout from "@/components/layouts/global/layout.tsx";
 import { ErrorBoundary } from "react-error-boundary";
 import InviteSignup from "@/pages/auth/invite-signup.tsx";
+import ForgotPassword from "@/pages/auth/forgot-password.tsx";
+import PasswordReset from "./pages/auth/password-reset";

 export default function App() {
  const [, setSocket] = useAtom(socketAtom);
@ -63,6 +65,8 @@ export default function App() {
        <Route path={"/login"} element={<LoginPage />} />
        <Route path={"/invites/:invitationId"} element={<InviteSignup />} />
        <Route path={"/setup/register"} element={<SetupWorkspace />} />
+        <Route path={"/forgot-password"} element={<ForgotPassword />} />
+        <Route path={"/password-reset"} element={<PasswordReset />} />

        <Route path={"/p/:pageSlug"} element={<PageRedirect />} />

--- a/apps/client/src/components/common/recent-changes.tsx
+++ b/apps/client/src/components/common/recent-changes.tsx
@ -5,14 +5,15 @@ import {
  Badge,
  Table,
  ScrollArea,
-} from "@mantine/core";
-import { Link } from "react-router-dom";
-import PageListSkeleton from "@/components/ui/page-list-skeleton.tsx";
-import { buildPageUrl } from "@/features/page/page.utils.ts";
-import { formattedDate } from "@/lib/time.ts";
-import { useRecentChangesQuery } from "@/features/page/queries/page-query.ts";
-import { IconFileDescription } from "@tabler/icons-react";
-import { getSpaceUrl } from "@/lib/config.ts";
+  ActionIcon,
+} from '@mantine/core';
+import { Link } from 'react-router-dom';
+import PageListSkeleton from '@/components/ui/page-list-skeleton.tsx';
+import { buildPageUrl } from '@/features/page/page.utils.ts';
+import { formattedDate } from '@/lib/time.ts';
+import { useRecentChangesQuery } from '@/features/page/queries/page-query.ts';
+import { IconFileDescription } from '@tabler/icons-react';
+import { getSpaceUrl } from '@/lib/config.ts';

 interface Props {
  spaceId?: string;
@ -40,10 +41,14 @@ export default function RecentChanges({ spaceId }: Props) {
                  to={buildPageUrl(page?.space.slug, page.slugId, page.title)}
                >
                  <Group wrap="nowrap">
-                    {page.icon || <IconFileDescription size={18} />}
+                    {page.icon || (
+                      <ActionIcon variant='transparent' color='gray' size={18}>
+                        <IconFileDescription size={18} />
+                      </ActionIcon>
+                    )}

                    <Text fw={500} size="md" lineClamp={1}>
-                      {page.title || "Untitled"}
+                      {page.title || 'Untitled'}
                    </Text>
                  </Group>
                </UnstyledButton>
@ -55,7 +60,7 @@ export default function RecentChanges({ spaceId }: Props) {
                    variant="light"
                    component={Link}
                    to={getSpaceUrl(page?.space.slug)}
-                    style={{ cursor: "pointer" }}
+                    style={{ cursor: 'pointer' }}
                  >
                    {page?.space.name}
                  </Badge>
--- a/apps/client/src/components/ui/error-404.tsx
+++ b/apps/client/src/components/ui/error-404.tsx
@ -1,19 +1,25 @@
 import { Title, Text, Button, Container, Group } from "@mantine/core";
 import classes from "./error-404.module.css";
 import { Link } from "react-router-dom";
+import { Helmet } from "react-helmet-async";

 export function Error404() {
  return (
-    <Container className={classes.root}>
-      <Title className={classes.title}>404 Page Not Found</Title>
-      <Text c="dimmed" size="lg" ta="center" className={classes.description}>
-        Sorry, we can't find the page you are looking for.
-      </Text>
-      <Group justify="center">
-        <Button component={Link} to={"/home"} variant="subtle" size="md">
-          Take me back to homepage
-        </Button>
-      </Group>
-    </Container>
+    <>
+      <Helmet>
+        <title>404 page not found - Docmost</title>
+      </Helmet>
+      <Container className={classes.root}>
+        <Title className={classes.title}>404 Page Not Found</Title>
+        <Text c="dimmed" size="lg" ta="center" className={classes.description}>
+          Sorry, we can't find the page you are looking for.
+        </Text>
+        <Group justify="center">
+          <Button component={Link} to={"/home"} variant="subtle" size="md">
+            Take me back to homepage
+          </Button>
+        </Group>
+      </Container>
+    </>
  );
 }
--- a/apps/client/src/features/auth/components/forgot-password-form.tsx
+++ b/apps/client/src/features/auth/components/forgot-password-form.tsx
@ -0,0 +1,70 @@
+import { useState } from "react";
+import * as z from "zod";
+import { useForm, zodResolver } from "@mantine/form";
+import useAuth from "@/features/auth/hooks/use-auth";
+import { IForgotPassword } from "@/features/auth/types/auth.types";
+import { Box, Button, Container, Text, TextInput, Title } from "@mantine/core";
+import classes from "./auth.module.css";
+import { useRedirectIfAuthenticated } from "@/features/auth/hooks/use-redirect-if-authenticated.ts";
+
+const formSchema = z.object({
+  email: z
+    .string()
+    .min(1, { message: "Email is required" })
+    .email({ message: "Invalid email address" }),
+});
+
+export function ForgotPasswordForm() {
+  const { forgotPassword, isLoading } = useAuth();
+  const [isTokenSent, setIsTokenSent] = useState<boolean>(false);
+  useRedirectIfAuthenticated();
+
+  const form = useForm<IForgotPassword>({
+    validate: zodResolver(formSchema),
+    initialValues: {
+      email: "",
+    },
+  });
+
+  async function onSubmit(data: IForgotPassword) {
+    if (await forgotPassword(data)) {
+      setIsTokenSent(true);
+    }
+  }
+
+  return (
+    <Container size={420} my={40} className={classes.container}>
+      <Box p="xl" mt={200}>
+        <Title order={2} ta="center" fw={500} mb="md">
+          Forgot password
+        </Title>
+
+        <form onSubmit={form.onSubmit(onSubmit)}>
+          {!isTokenSent && (
+            <TextInput
+              id="email"
+              type="email"
+              label="Email"
+              placeholder="email@example.com"
+              variant="filled"
+              {...form.getInputProps("email")}
+            />
+          )}
+
+          {isTokenSent && (
+            <Text>
+              A password reset link has been sent to your email. Please check
+              your inbox.
+            </Text>
+          )}
+
+          {!isTokenSent && (
+            <Button type="submit" fullWidth mt="xl" loading={isLoading}>
+              Send reset link
+            </Button>
+          )}
+        </form>
+      </Box>
+    </Container>
+  );
+}
--- a/apps/client/src/features/auth/components/login-form.tsx
+++ b/apps/client/src/features/auth/components/login-form.tsx
@ -1,4 +1,3 @@
-import * as React from "react";
 import * as z from "zod";
 import { useForm, zodResolver } from "@mantine/form";
 import useAuth from "@/features/auth/hooks/use-auth";
@ -10,9 +9,13 @@ import {
  Button,
  PasswordInput,
  Box,
+
+  Anchor,
 } from "@mantine/core";
 import classes from "./auth.module.css";
 import { useRedirectIfAuthenticated } from "@/features/auth/hooks/use-redirect-if-authenticated.ts";
+import { Link, useNavigate } from "react-router-dom";
+import APP_ROUTE from "@/lib/app-route.ts";

 const formSchema = z.object({
  email: z
@ -62,10 +65,20 @@ export function LoginForm() {
            mt="md"
            {...form.getInputProps("password")}
          />
+
          <Button type="submit" fullWidth mt="xl" loading={isLoading}>
            Sign In
          </Button>
        </form>
+
+        <Anchor
+          to={APP_ROUTE.AUTH.FORGOT_PASSWORD}
+          component={Link}
+          underline="never"
+          size="sm"
+        >
+          Forgot your password?
+        </Anchor>
      </Box>
    </Container>
  );
--- a/apps/client/src/features/auth/components/password-reset-form.tsx
+++ b/apps/client/src/features/auth/components/password-reset-form.tsx
@ -0,0 +1,67 @@
+import * as z from "zod";
+import { useForm, zodResolver } from "@mantine/form";
+import useAuth from "@/features/auth/hooks/use-auth";
+import { IPasswordReset } from "@/features/auth/types/auth.types";
+import {
+  Box,
+  Button,
+  Container,
+  PasswordInput,
+  Text,
+  Title,
+} from "@mantine/core";
+import classes from "./auth.module.css";
+import { useRedirectIfAuthenticated } from "@/features/auth/hooks/use-redirect-if-authenticated.ts";
+
+const formSchema = z.object({
+  newPassword: z
+    .string()
+    .min(8, { message: "Password must contain at least 8 characters" }),
+});
+
+interface PasswordResetFormProps {
+  resetToken?: string;
+}
+
+export function PasswordResetForm({ resetToken }: PasswordResetFormProps) {
+  const { passwordReset, isLoading } = useAuth();
+  useRedirectIfAuthenticated();
+
+  const form = useForm<IPasswordReset>({
+    validate: zodResolver(formSchema),
+    initialValues: {
+      newPassword: "",
+    },
+  });
+
+  async function onSubmit(data: IPasswordReset) {
+    await passwordReset({
+      token: resetToken,
+      newPassword: data.newPassword
+    })
+  }
+
+  return (
+    <Container size={420} my={40} className={classes.container}>
+      <Box p="xl" mt={200}>
+        <Title order={2} ta="center" fw={500} mb="md">
+          Password reset
+        </Title>
+
+        <form onSubmit={form.onSubmit(onSubmit)}>
+          <PasswordInput
+            label="New password"
+            placeholder="Your new password"
+            variant="filled"
+            mt="md"
+            {...form.getInputProps("newPassword")}
+          />
+
+          <Button type="submit" fullWidth mt="xl" loading={isLoading}>
+            Set password
+          </Button>
+        </form>
+      </Box>
+    </Container>
+  );
+}
--- a/apps/client/src/features/auth/hooks/use-auth.ts
+++ b/apps/client/src/features/auth/hooks/use-auth.ts
@ -1,10 +1,22 @@
 import { useState } from "react";
-import { login, setupWorkspace } from "@/features/auth/services/auth-service";
+import {
+  forgotPassword,
+  login,
+  passwordReset,
+  setupWorkspace,
+  verifyUserToken,
+} from "@/features/auth/services/auth-service";
 import { useNavigate } from "react-router-dom";
 import { useAtom } from "jotai";
 import { authTokensAtom } from "@/features/auth/atoms/auth-tokens-atom";
 import { currentUserAtom } from "@/features/user/atoms/current-user-atom";
-import { ILogin, ISetupWorkspace } from "@/features/auth/types/auth.types";
+import {
+  IForgotPassword,
+  ILogin,
+  IPasswordReset,
+  ISetupWorkspace,
+  IVerifyUserToken,
+} from "@/features/auth/types/auth.types";
 import { notifications } from "@mantine/notifications";
 import { IAcceptInvite } from "@/features/workspace/types/workspace.types.ts";
 import { acceptInvitation } from "@/features/workspace/services/workspace-service.ts";
@ -76,6 +88,28 @@ export default function useAuth() {
    }
  };

+  const handlePasswordReset = async (data: IPasswordReset) => {
+    setIsLoading(true);
+
+    try {
+      const res = await passwordReset(data);
+      setIsLoading(false);
+
+      setAuthToken(res.tokens);
+
+      navigate(APP_ROUTE.HOME);
+      notifications.show({
+        message: "Password reset was successful",
+      });
+    } catch (err) {
+      setIsLoading(false);
+      notifications.show({
+        message: err.response?.data.message,
+        color: "red",
+      });
+    }
+  };
+
  const handleIsAuthenticated = async () => {
    if (!authToken) {
      return false;
@ -105,11 +139,50 @@ export default function useAuth() {
    navigate(APP_ROUTE.AUTH.LOGIN);
  };

+  const handleForgotPassword = async (data: IForgotPassword) => {
+    setIsLoading(true);
+
+    try {
+      await forgotPassword(data);
+      setIsLoading(false);
+
+      return true;
+    } catch (err) {
+      console.log(err);
+      setIsLoading(false);
+      notifications.show({
+        message: err.response?.data.message,
+        color: "red",
+      });
+
+      return false;
+    }
+  };
+
+  const handleVerifyUserToken = async (data: IVerifyUserToken) => {
+    setIsLoading(true);
+
+    try {
+      await verifyUserToken(data);
+      setIsLoading(false);
+    } catch (err) {
+      console.log(err);
+      setIsLoading(false);
+      notifications.show({
+        message: err.response?.data.message,
+        color: "red",
+      });
+    }
+  };
+
  return {
    signIn: handleSignIn,
    invitationSignup: handleInvitationSignUp,
    setupWorkspace: handleSetupWorkspace,
    isAuthenticated: handleIsAuthenticated,
+    forgotPassword: handleForgotPassword,
+    passwordReset: handlePasswordReset,
+    verifyUserToken: handleVerifyUserToken,
    logout: handleLogout,
    hasTokens,
    isLoading,
--- a/apps/client/src/features/auth/queries/auth-query.tsx
+++ b/apps/client/src/features/auth/queries/auth-query.tsx
@ -0,0 +1,14 @@
+import { useQuery, UseQueryResult } from "@tanstack/react-query";
+import { verifyUserToken } from "../services/auth-service";
+import { IVerifyUserToken } from "../types/auth.types";
+
+export function useVerifyUserTokenQuery(
+    verify: IVerifyUserToken,
+  ): UseQueryResult<any, Error> {
+    return useQuery({
+      queryKey: ["verify-token", verify],
+      queryFn: () => verifyUserToken(verify),
+      enabled: !!verify.token,
+      staleTime: 0,
+    });
+  }
--- a/apps/client/src/features/auth/services/auth-service.ts
+++ b/apps/client/src/features/auth/services/auth-service.ts
@ -1,10 +1,13 @@
 import api from "@/lib/api-client";
 import {
  IChangePassword,
+  IForgotPassword,
  ILogin,
+  IPasswordReset,
  IRegister,
  ISetupWorkspace,
  ITokenResponse,
+  IVerifyUserToken,
 } from "@/features/auth/types/auth.types";

 export async function login(data: ILogin): Promise<ITokenResponse> {
@ -19,15 +22,30 @@ export async function register(data: IRegister): Promise<ITokenResponse> {
 }*/

 export async function changePassword(
-  data: IChangePassword,
+  data: IChangePassword
 ): Promise<IChangePassword> {
  const req = await api.post<IChangePassword>("/auth/change-password", data);
  return req.data;
 }

 export async function setupWorkspace(
-  data: ISetupWorkspace,
+  data: ISetupWorkspace
 ): Promise<ITokenResponse> {
  const req = await api.post<ITokenResponse>("/auth/setup", data);
  return req.data;
 }
+
+export async function forgotPassword(data: IForgotPassword): Promise<void> {
+  await api.post<any>("/auth/forgot-password", data);
+}
+
+export async function passwordReset(
+  data: IPasswordReset
+): Promise<ITokenResponse> {
+  const req = await api.post<any>("/auth/password-reset", data);
+  return req.data;
+}
+
+export async function verifyUserToken(data: IVerifyUserToken): Promise<any> {
+  return api.post<any>("/auth/verify-token", data);
+}
--- a/apps/client/src/features/auth/types/auth.types.ts
+++ b/apps/client/src/features/auth/types/auth.types.ts
@ -29,3 +29,17 @@ export interface IChangePassword {
  oldPassword: string;
  newPassword: string;
 }
+
+export interface IForgotPassword {
+  email: string;
+}
+
+export interface IPasswordReset {
+  token?: string;
+  newPassword: string;
+}
+
+export interface IVerifyUserToken {
+  token: string;
+  type: string;
+}
--- a/apps/client/src/features/editor/components/code-block/code-block-view.tsx
+++ b/apps/client/src/features/editor/components/code-block/code-block-view.tsx
@ -49,7 +49,7 @@ export default function CodeBlockView(props: NodeViewProps) {
        <Select
          placeholder="auto"
          checkIconPosition="right"
-          data={extension.options.lowlight.listLanguages()}
+          data={extension.options.lowlight.listLanguages().sort()}
          value={languageValue}
          onChange={changeLanguage}
          searchable
--- a/apps/client/src/features/editor/components/math/math.module.css
+++ b/apps/client/src/features/editor/components/math/math.module.css
@ -33,7 +33,7 @@
    border-radius: 4px;
    transition: background-color 0.2s;
    margin: 0 0.1rem;
-    overflow-x: scroll;
+    overflow-x: auto;

    .textInput {
        width: 400px;
--- a/apps/client/src/features/editor/components/slash-menu/menu-items.ts
+++ b/apps/client/src/features/editor/components/slash-menu/menu-items.ts
@ -16,7 +16,8 @@ import {
  IconPhoto,
  IconTable,
  IconTypography,
-  IconMenu4
+  IconMenu4,
+  IconCalendar,
 } from "@tabler/icons-react";
 import {
  CommandProps,
@ -330,6 +331,26 @@ const CommandGroups: SlashMenuGroupedItemsType = {
      command: ({ editor, range }: CommandProps) =>
        editor.chain().focus().deleteRange(range).setExcalidraw().run(),
    },
+    {
+      title: "Date",
+      description: "Insert current date",
+      searchTerms: ["date", "today"],
+      icon: IconCalendar,
+      command: ({ editor, range }: CommandProps) => {
+        const currentDate = new Date().toLocaleDateString("en-US", {
+          year: "numeric",
+          month: "long",
+          day: "numeric",
+        });
+
+        return editor
+          .chain()
+          .focus()
+          .deleteRange(range)
+          .insertContent(currentDate)
+          .run();
+      },
+    },
  ],
 };

--- a/apps/client/src/features/editor/extensions/extensions.ts
+++ b/apps/client/src/features/editor/extensions/extensions.ts
@ -54,9 +54,26 @@ import CodeBlockView from "@/features/editor/components/code-block/code-block-vi
 import DrawioView from "../components/drawio/drawio-view";
 import ExcalidrawView from "@/features/editor/components/excalidraw/excalidraw-view.tsx";
 import plaintext from "highlight.js/lib/languages/plaintext";
+import powershell from "highlight.js/lib/languages/powershell";
+import elixir from "highlight.js/lib/languages/elixir";
+import erlang from "highlight.js/lib/languages/erlang";
+import dockerfile from "highlight.js/lib/languages/dockerfile";
+import clojure from "highlight.js/lib/languages/clojure";
+import fortran from "highlight.js/lib/languages/fortran";
+import haskell from "highlight.js/lib/languages/haskell";
+import scala from "highlight.js/lib/languages/scala";

 const lowlight = createLowlight(common);
 lowlight.register("mermaid", plaintext);
+lowlight.register("powershell", powershell);
+lowlight.register("powershell", powershell);
+lowlight.register("erlang", erlang);
+lowlight.register("elixir", elixir);
+lowlight.register("dockerfile", dockerfile);
+lowlight.register("clojure", clojure);
+lowlight.register("fortran", fortran);
+lowlight.register("haskell", haskell);
+lowlight.register("scala", scala);

 export const mainExtensions = [
  StarterKit.configure({
--- a/apps/client/src/features/group/queries/group-query.ts
+++ b/apps/client/src/features/group/queries/group-query.ts
@ -3,8 +3,8 @@ import {
  useQuery,
  useQueryClient,
  UseQueryResult,
-} from "@tanstack/react-query";
-import { IGroup } from "@/features/group/types/group.types";
+} from '@tanstack/react-query';
+import { IGroup } from '@/features/group/types/group.types';
 import {
  addGroupMember,
  createGroup,
@ -14,22 +14,22 @@ import {
  getGroups,
  removeGroupMember,
  updateGroup,
-} from "@/features/group/services/group-service";
-import { notifications } from "@mantine/notifications";
-import { QueryParams } from "@/lib/types.ts";
+} from '@/features/group/services/group-service';
+import { notifications } from '@mantine/notifications';
+import { QueryParams } from '@/lib/types.ts';

 export function useGetGroupsQuery(
-  params?: QueryParams,
+  params?: QueryParams
 ): UseQueryResult<any, Error> {
  return useQuery({
-    queryKey: ["groups", params],
+    queryKey: ['groups', params],
    queryFn: () => getGroups(params),
  });
 }

 export function useGroupQuery(groupId: string): UseQueryResult<IGroup, Error> {
  return useQuery({
-    queryKey: ["groups", groupId],
+    queryKey: ['groups', groupId],
    queryFn: () => getGroupById(groupId),
    enabled: !!groupId,
  });
@ -37,7 +37,7 @@ export function useGroupQuery(groupId: string): UseQueryResult<IGroup, Error> {

 export function useGroupMembersQuery(groupId: string) {
  return useQuery({
-    queryKey: ["groupMembers", groupId],
+    queryKey: ['groupMembers', groupId],
    queryFn: () => getGroupMembers(groupId),
    enabled: !!groupId,
  });
@ -47,10 +47,10 @@ export function useCreateGroupMutation() {
  return useMutation<IGroup, Error, Partial<IGroup>>({
    mutationFn: (data) => createGroup(data),
    onSuccess: () => {
-      notifications.show({ message: "Group created successfully" });
+      notifications.show({ message: 'Group created successfully' });
    },
    onError: () => {
-      notifications.show({ message: "Failed to create group", color: "red" });
+      notifications.show({ message: 'Failed to create group', color: 'red' });
    },
  });
 }
@ -61,14 +61,14 @@ export function useUpdateGroupMutation() {
  return useMutation<IGroup, Error, Partial<IGroup>>({
    mutationFn: (data) => updateGroup(data),
    onSuccess: (data, variables) => {
-      notifications.show({ message: "Group updated successfully" });
+      notifications.show({ message: 'Group updated successfully' });
      queryClient.invalidateQueries({
-        queryKey: ["group", variables.groupId],
+        queryKey: ['group', variables.groupId],
      });
    },
    onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      const errorMessage = error['response']?.data?.message;
+      notifications.show({ message: errorMessage, color: 'red' });
    },
  });
 }
@ -79,17 +79,19 @@ export function useDeleteGroupMutation() {
  return useMutation({
    mutationFn: (groupId: string) => deleteGroup({ groupId }),
    onSuccess: (data, variables) => {
-      notifications.show({ message: "Group deleted successfully" });
+      notifications.show({ message: 'Group deleted successfully' });

-      const groups = queryClient.getQueryData(["groups"]) as any;
+      const groups = queryClient.getQueryData(['groups']) as any;
      if (groups) {
-        groups.items?.filter((group: IGroup) => group.id !== variables);
-        queryClient.setQueryData(["groups"], groups);
+        groups.items = groups.items?.filter(
+          (group: IGroup) => group.id !== variables
+        );
+        queryClient.setQueryData(['groups'], groups);
      }
    },
    onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      const errorMessage = error['response']?.data?.message;
+      notifications.show({ message: errorMessage, color: 'red' });
    },
  });
 }
@ -100,15 +102,15 @@ export function useAddGroupMemberMutation() {
  return useMutation<void, Error, { groupId: string; userIds: string[] }>({
    mutationFn: (data) => addGroupMember(data),
    onSuccess: (data, variables) => {
-      notifications.show({ message: "Added successfully" });
+      notifications.show({ message: 'Added successfully' });
      queryClient.invalidateQueries({
-        queryKey: ["groupMembers", variables.groupId],
+        queryKey: ['groupMembers', variables.groupId],
      });
    },
    onError: () => {
      notifications.show({
-        message: "Failed to add group members",
-        color: "red",
+        message: 'Failed to add group members',
+        color: 'red',
      });
    },
  });
@ -127,14 +129,14 @@ export function useRemoveGroupMemberMutation() {
  >({
    mutationFn: (data) => removeGroupMember(data),
    onSuccess: (data, variables) => {
-      notifications.show({ message: "Removed successfully" });
+      notifications.show({ message: 'Removed successfully' });
      queryClient.invalidateQueries({
-        queryKey: ["groupMembers", variables.groupId],
+        queryKey: ['groupMembers', variables.groupId],
      });
    },
    onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      const errorMessage = error['response']?.data?.message;
+      notifications.show({ message: errorMessage, color: 'red' });
    },
  });
 }
--- a/apps/client/src/features/page/services/page-service.ts
+++ b/apps/client/src/features/page/services/page-service.ts
@ -64,7 +64,7 @@ export async function exportPage(data: IExportPageParams): Promise<void> {
    .split("filename=")[1]
    .replace(/"/g, "");

-  saveAs(req.data, fileName);
+  saveAs(req.data, decodeURIComponent(fileName));
 }

 export async function importPage(file: File, spaceId: string) {
@ -81,14 +81,17 @@ export async function importPage(file: File, spaceId: string) {
  return req.data;
 }

-export async function uploadFile(file: File, pageId: string, attachmentId?: string): Promise<IAttachment> {
+export async function uploadFile(
+  file: File,
+  pageId: string,
+  attachmentId?: string,
+): Promise<IAttachment> {
  const formData = new FormData();
-  if(attachmentId){
+  if (attachmentId) {
    formData.append("attachmentId", attachmentId);
  }
  formData.append("pageId", pageId);
  formData.append("file", file);
-  

  const req = await api.post<IAttachment>("/files/upload", formData, {
    headers: {
--- a/apps/client/src/features/space/components/delete-space-modal.tsx
+++ b/apps/client/src/features/space/components/delete-space-modal.tsx
@ -0,0 +1,86 @@
+import { Button, Divider, Group, Modal, Text, TextInput } from '@mantine/core';
+import { useDisclosure } from '@mantine/hooks';
+import { useDeleteSpaceMutation } from '../queries/space-query';
+import { useField } from '@mantine/form';
+import { ISpace } from '../types/space.types';
+import { useNavigate } from 'react-router-dom';
+import APP_ROUTE from '@/lib/app-route';
+
+interface DeleteSpaceModalProps {
+  space: ISpace;
+}
+
+export default function DeleteSpaceModal({ space }: DeleteSpaceModalProps) {
+  const [opened, { open, close }] = useDisclosure(false);
+  const deleteSpaceMutation = useDeleteSpaceMutation();
+  const navigate = useNavigate();
+
+  const confirmNameField = useField({
+    initialValue: '',
+    validateOnChange: true,
+    validate: (value) =>
+      value.trim().toLowerCase() === space.name.trim().toLocaleLowerCase()
+        ? null
+        : 'Names do not match',
+  });
+
+  const handleDelete = async () => {
+    if (
+      confirmNameField.getValue().trim().toLowerCase() !==
+      space.name.trim().toLowerCase()
+    ) {
+      confirmNameField.validate();
+      return;
+    }
+
+    try {
+      // pass slug too so we can clear the local cache
+      await deleteSpaceMutation.mutateAsync({ id: space.id, slug: space.slug });
+      navigate(APP_ROUTE.HOME);
+    } catch (error) {
+      console.error('Failed to delete space', error);
+    }
+  };
+
+  return (
+    <>
+      <Button onClick={open} variant="light" color="red">
+        Delete
+      </Button>
+
+      <Modal
+        opened={opened}
+        onClose={close}
+        title="Are you sure you want to delete this space?"
+      >
+        <Divider size="xs" mb="xs" />
+        <Text>
+          All pages, comments, attachments and permissions in this space will be
+          deleted irreversibly.
+        </Text>
+        <Text mt="sm">
+          Type the space name{' '}
+          <Text span fw={500}>
+            '{space.name}'
+          </Text>{' '}
+          to confirm your action.
+        </Text>
+        <TextInput
+          {...confirmNameField.getInputProps()}
+          variant="filled"
+          placeholder="Confirm space name"
+          py="sm"
+          data-autofocus
+        />
+        <Group justify="flex-end" mt="md">
+          <Button onClick={close} variant="default">
+            Cancel
+          </Button>
+          <Button onClick={handleDelete} color="red">
+            Confirm
+          </Button>
+        </Group>
+      </Modal>
+    </>
+  );
+}
--- a/apps/client/src/features/space/components/edit-space-form.tsx
+++ b/apps/client/src/features/space/components/edit-space-form.tsx
@ -8,6 +8,14 @@ import { ISpace } from "@/features/space/types/space.types.ts";
 const formSchema = z.object({
  name: z.string().min(2).max(50),
  description: z.string().max(250),
+  slug: z
+    .string()
+    .min(2)
+    .max(50)
+    .regex(
+      /^[a-zA-Z0-9]+$/,
+      "Space slug must be alphanumeric. No special characters",
+    ),
 });

 type FormValues = z.infer<typeof formSchema>;
@ -23,12 +31,14 @@ export function EditSpaceForm({ space, readOnly }: EditSpaceFormProps) {
    initialValues: {
      name: space?.name,
      description: space?.description || "",
+      slug: space.slug,
    },
  });

  const handleSubmit = async (values: {
    name?: string;
    description?: string;
+    slug?: string;
  }) => {
    const spaceData: Partial<ISpace> = {
      spaceId: space.id,
@ -40,6 +50,10 @@ export function EditSpaceForm({ space, readOnly }: EditSpaceFormProps) {
      spaceData.description = values.description;
    }

+    if (form.isDirty("slug")) {
+      spaceData.slug = values.slug;
+    }
+
    await updateSpaceMutation.mutateAsync(spaceData);
    form.resetDirty();
  };
@ -62,8 +76,8 @@ export function EditSpaceForm({ space, readOnly }: EditSpaceFormProps) {
              id="slug"
              label="Slug"
              variant="filled"
-              readOnly
-              value={space.slug}
+              readOnly={readOnly}
+              {...form.getInputProps("slug")}
            />

            <Textarea
--- a/apps/client/src/features/space/components/sidebar/space-name.module.css
+++ b/apps/client/src/features/space/components/sidebar/space-name.module.css
@ -1,6 +0,0 @@
-.spaceName {
-    display: block;
-    width: 100%;
-    padding: var(--mantine-spacing-sm);
-    color: light-dark(var(--mantine-color-black), var(--mantine-color-dark-0));
-  }
--- a/apps/client/src/features/space/components/sidebar/space-name.tsx
+++ b/apps/client/src/features/space/components/sidebar/space-name.tsx
@ -1,19 +0,0 @@
-import { UnstyledButton, Group, Text } from "@mantine/core";
-import classes from "./space-name.module.css";
-
-interface SpaceNameProps {
-  spaceName: string;
-}
-export function SpaceName({ spaceName }: SpaceNameProps) {
-  return (
-    <UnstyledButton className={classes.spaceName}>
-      <Group>
-        <div style={{ flex: 1 }}>
-          <Text size="md" fw={500} lineClamp={1}>
-            {spaceName}
-          </Text>
-        </div>
-      </Group>
-    </UnstyledButton>
-  );
-}
--- a/apps/client/src/features/space/components/sidebar/space-select.tsx
+++ b/apps/client/src/features/space/components/sidebar/space-select.tsx
@ -0,0 +1,70 @@
+import { useEffect, useState } from 'react';
+import { useDebouncedValue } from '@mantine/hooks';
+import { Avatar, Group, Select, SelectProps, Text } from '@mantine/core';
+import { useGetSpacesQuery } from '@/features/space/queries/space-query.ts';
+import { ISpace } from '../../types/space.types';
+
+interface SpaceSelectProps {
+  onChange: (value: string) => void;
+  value?: string;
+  label?: string;
+}
+
+const renderSelectOption: SelectProps['renderOption'] = ({ option }) => (
+  <Group gap="sm">
+    <Avatar color="initials" variant="filled" name={option.label} size={20} />
+    <div>
+      <Text size="sm">{option.label}</Text>
+    </div>
+  </Group>
+);
+
+export function SpaceSelect({ onChange, label, value }: SpaceSelectProps) {
+  const [searchValue, setSearchValue] = useState('');
+  const [debouncedQuery] = useDebouncedValue(searchValue, 500);
+  const { data: spaces, isLoading } = useGetSpacesQuery({
+    query: debouncedQuery,
+    limit: 50,
+  });
+  const [data, setData] = useState([]);
+
+  useEffect(() => {
+    if (spaces) {
+      const spaceData = spaces?.items
+        .filter((space: ISpace) => space.slug !== value)
+        .map((space: ISpace) => {
+          return {
+            label: space.name,
+            value: space.slug,
+          };
+        });
+
+      const filteredSpaceData = spaceData.filter(
+        (user) =>
+          !data.find((existingUser) => existingUser.value === user.value)
+      );
+      setData((prevData) => [...prevData, ...filteredSpaceData]);
+    }
+  }, [spaces]);
+
+  return (
+    <Select
+      data={data}
+      renderOption={renderSelectOption}
+      maxDropdownHeight={300}
+      //label={label || 'Select space'}
+      placeholder="Search for spaces"
+      searchable
+      searchValue={searchValue}
+      onSearchChange={setSearchValue}
+      clearable
+      variant="filled"
+      onChange={onChange}
+      nothingFoundMessage="No space found"
+      limit={50}
+      checkIconPosition="right"
+      comboboxProps={{ width: 300, withinPortal: false }}
+      dropdownOpened
+    />
+  );
+}
--- a/apps/client/src/features/space/components/sidebar/space-sidebar.tsx
+++ b/apps/client/src/features/space/components/sidebar/space-sidebar.tsx
@ -5,8 +5,8 @@ import {
  Text,
  Tooltip,
  UnstyledButton,
-} from "@mantine/core";
-import { spotlight } from "@mantine/spotlight";
+} from '@mantine/core';
+import { spotlight } from '@mantine/spotlight';
 import {
  IconArrowDown,
  IconDots,
@ -14,27 +14,27 @@ import {
  IconPlus,
  IconSearch,
  IconSettings,
-} from "@tabler/icons-react";
+} from '@tabler/icons-react';

-import classes from "./space-sidebar.module.css";
-import React, { useMemo } from "react";
-import { useAtom } from "jotai";
-import { SearchSpotlight } from "@/features/search/search-spotlight.tsx";
-import { treeApiAtom } from "@/features/page/tree/atoms/tree-api-atom.ts";
-import { Link, useLocation, useParams } from "react-router-dom";
-import clsx from "clsx";
-import { useDisclosure } from "@mantine/hooks";
-import SpaceSettingsModal from "@/features/space/components/settings-modal.tsx";
-import { useGetSpaceBySlugQuery } from "@/features/space/queries/space-query.ts";
-import { SpaceName } from "@/features/space/components/sidebar/space-name.tsx";
-import { getSpaceUrl } from "@/lib/config.ts";
-import SpaceTree from "@/features/page/tree/components/space-tree.tsx";
-import { useSpaceAbility } from "@/features/space/permissions/use-space-ability.ts";
+import classes from './space-sidebar.module.css';
+import React, { useMemo } from 'react';
+import { useAtom } from 'jotai';
+import { SearchSpotlight } from '@/features/search/search-spotlight.tsx';
+import { treeApiAtom } from '@/features/page/tree/atoms/tree-api-atom.ts';
+import { Link, useLocation, useParams } from 'react-router-dom';
+import clsx from 'clsx';
+import { useDisclosure } from '@mantine/hooks';
+import SpaceSettingsModal from '@/features/space/components/settings-modal.tsx';
+import { useGetSpaceBySlugQuery } from '@/features/space/queries/space-query.ts';
+import { getSpaceUrl } from '@/lib/config.ts';
+import SpaceTree from '@/features/page/tree/components/space-tree.tsx';
+import { useSpaceAbility } from '@/features/space/permissions/use-space-ability.ts';
 import {
  SpaceCaslAction,
  SpaceCaslSubject,
-} from "@/features/space/permissions/permissions.type.ts";
-import PageImportModal from "@/features/page/components/page-import-modal.tsx";
+} from '@/features/space/permissions/permissions.type.ts';
+import PageImportModal from '@/features/page/components/page-import-modal.tsx';
+import { SwitchSpace } from './switch-space';

 export function SpaceSidebar() {
  const [tree] = useAtom(treeApiAtom);
@ -52,7 +52,7 @@ export function SpaceSidebar() {
  }

  function handleCreatePage() {
-    tree?.create({ parentId: null, type: "internal", index: 0 });
+    tree?.create({ parentId: null, type: 'internal', index: 0 });
  }

  return (
@ -61,11 +61,12 @@ export function SpaceSidebar() {
        <div
          className={classes.section}
          style={{
-            border: "none",
-            marginBottom: "0",
+            border: 'none',
+            marginTop: 2,
+            marginBottom: 3,
          }}
        >
-          <SpaceName spaceName={space?.name} />
+          <SwitchSpace spaceName={space?.name} spaceSlug={space?.slug} />
        </div>

        <div className={classes.section}>
@ -77,7 +78,7 @@ export function SpaceSidebar() {
                classes.menu,
                location.pathname.toLowerCase() === getSpaceUrl(spaceSlug)
                  ? classes.activeButton
-                  : "",
+                  : ''
              )}
            >
              <div className={classes.menuItemInner}>
@ -114,7 +115,7 @@ export function SpaceSidebar() {

            {spaceAbility.can(
              SpaceCaslAction.Manage,
-              SpaceCaslSubject.Page,
+              SpaceCaslSubject.Page
            ) && (
              <UnstyledButton
                className={classes.menu}
@ -141,7 +142,7 @@ export function SpaceSidebar() {

            {spaceAbility.can(
              SpaceCaslAction.Manage,
-              SpaceCaslSubject.Page,
+              SpaceCaslSubject.Page
            ) && (
              <Group gap="xs">
                <SpaceMenu spaceId={space.id} onSpaceSettings={openSettings} />
@ -165,7 +166,7 @@ export function SpaceSidebar() {
              spaceId={space.id}
              readOnly={spaceAbility.cannot(
                SpaceCaslAction.Manage,
-                SpaceCaslSubject.Page,
+                SpaceCaslSubject.Page
              )}
            />
          </div>
--- a/apps/client/src/features/space/components/sidebar/switch-space.module.css
+++ b/apps/client/src/features/space/components/sidebar/switch-space.module.css
@ -0,0 +1,5 @@
+.spaceName {
+  width: 100%;
+  padding: var(--mantine-spacing-sm);
+  color: light-dark(var(--mantine-color-dark-4), var(--mantine-color-dark-0));
+}
--- a/apps/client/src/features/space/components/sidebar/switch-space.tsx
+++ b/apps/client/src/features/space/components/sidebar/switch-space.tsx
@ -0,0 +1,62 @@
+import classes from './switch-space.module.css';
+import { useNavigate } from 'react-router-dom';
+import { SpaceSelect } from './space-select';
+import { getSpaceUrl } from '@/lib/config';
+import { Avatar, Button, Popover, Text } from '@mantine/core';
+import { IconChevronDown } from '@tabler/icons-react';
+import { useDisclosure } from '@mantine/hooks';
+
+interface SwitchSpaceProps {
+  spaceName: string;
+  spaceSlug: string;
+}
+
+export function SwitchSpace({ spaceName, spaceSlug }: SwitchSpaceProps) {
+  const [opened, { close, open, toggle }] = useDisclosure(false);
+  const navigate = useNavigate();
+
+  const handleSelect = (value: string) => {
+    if (value) {
+      navigate(getSpaceUrl(value));
+      close();
+    }
+  };
+
+  return (
+    <Popover
+      width={300}
+      position="bottom"
+      withArrow
+      shadow="md"
+      opened={opened}
+    >
+      <Popover.Target>
+        <Button
+          variant="subtle"
+          fullWidth
+          justify="space-between"
+          rightSection={<IconChevronDown size={18} />}
+          color="gray"
+          onClick={toggle}
+        >
+          <Avatar
+            size={20}
+            color="initials"
+            variant="filled"
+            name={spaceName}
+          />
+          <Text className={classes.spaceName} size="md" fw={500} lineClamp={1}>
+            {spaceName}
+          </Text>
+        </Button>
+      </Popover.Target>
+      <Popover.Dropdown>
+        <SpaceSelect
+          label={spaceName}
+          value={spaceSlug}
+          onChange={handleSelect}
+        />
+      </Popover.Dropdown>
+    </Popover>
+  );
+}
--- a/apps/client/src/features/space/components/space-details.tsx
+++ b/apps/client/src/features/space/components/space-details.tsx
@ -1,7 +1,8 @@
-import React from "react";
-import { useSpaceQuery } from "@/features/space/queries/space-query.ts";
-import { EditSpaceForm } from "@/features/space/components/edit-space-form.tsx";
-import { Text } from "@mantine/core";
+import React from 'react';
+import { useSpaceQuery } from '@/features/space/queries/space-query.ts';
+import { EditSpaceForm } from '@/features/space/components/edit-space-form.tsx';
+import { Divider, Group, Text } from '@mantine/core';
+import DeleteSpaceModal from './delete-space-modal';

 interface SpaceDetailsProps {
  spaceId: string;
@ -18,6 +19,23 @@ export default function SpaceDetails({ spaceId, readOnly }: SpaceDetailsProps) {
            Details
          </Text>
          <EditSpaceForm space={space} readOnly={readOnly} />
+
+          {!readOnly && (
+            <>
+              <Divider my="lg" />
+
+              <Group justify="space-between" wrap="nowrap" gap="xl">
+                <div>
+                  <Text size="md">Delete space</Text>
+                  <Text size="sm" c="dimmed">
+                    Delete this space with all its pages and data.
+                  </Text>
+                </div>
+
+                <DeleteSpaceModal space={space} />
+              </Group>
+            </>
+          )}
        </div>
      )}
    </>
--- a/apps/client/src/features/space/queries/space-query.ts
+++ b/apps/client/src/features/space/queries/space-query.ts
@ -3,14 +3,14 @@ import {
  useQuery,
  useQueryClient,
  UseQueryResult,
-} from "@tanstack/react-query";
+} from '@tanstack/react-query';
 import {
  IAddSpaceMember,
  IChangeSpaceMemberRole,
  IRemoveSpaceMember,
  ISpace,
  ISpaceMember,
-} from "@/features/space/types/space.types";
+} from '@/features/space/types/space.types';
 import {
  addSpaceMember,
  changeMemberRole,
@ -20,23 +20,23 @@ import {
  removeSpaceMember,
  createSpace,
  updateSpace,
-} from "@/features/space/services/space-service.ts";
-import { notifications } from "@mantine/notifications";
-import { IPagination } from "@/lib/types.ts";
+  deleteSpace,
+} from '@/features/space/services/space-service.ts';
+import { notifications } from '@mantine/notifications';
+import { IPagination, QueryParams } from '@/lib/types.ts';

-export function useGetSpacesQuery(): UseQueryResult<
-  IPagination<ISpace>,
-  Error
-> {
+export function useGetSpacesQuery(
+  params?: QueryParams
+): UseQueryResult<IPagination<ISpace>, Error> {
  return useQuery({
-    queryKey: ["spaces"],
-    queryFn: () => getSpaces(),
+    queryKey: ['spaces', params],
+    queryFn: () => getSpaces(params),
  });
 }

 export function useSpaceQuery(spaceId: string): UseQueryResult<ISpace, Error> {
  return useQuery({
-    queryKey: ["spaces", spaceId],
+    queryKey: ['spaces', spaceId],
    queryFn: () => getSpaceById(spaceId),
    enabled: !!spaceId,
    staleTime: 5 * 60 * 1000,
@ -50,22 +50,22 @@ export function useCreateSpaceMutation() {
    mutationFn: (data) => createSpace(data),
    onSuccess: () => {
      queryClient.invalidateQueries({
-        queryKey: ["spaces"],
+        queryKey: ['spaces'],
      });
-      notifications.show({ message: "Space created successfully" });
+      notifications.show({ message: 'Space created successfully' });
    },
    onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      const errorMessage = error['response']?.data?.message;
+      notifications.show({ message: errorMessage, color: 'red' });
    },
  });
 }

 export function useGetSpaceBySlugQuery(
-  spaceId: string,
+  spaceId: string
 ): UseQueryResult<ISpace, Error> {
  return useQuery({
-    queryKey: ["spaces", spaceId],
+    queryKey: ['spaces', spaceId],
    queryFn: () => getSpaceById(spaceId),
    enabled: !!spaceId,
    staleTime: 5 * 60 * 1000,
@ -78,34 +78,64 @@ export function useUpdateSpaceMutation() {
  return useMutation<ISpace, Error, Partial<ISpace>>({
    mutationFn: (data) => updateSpace(data),
    onSuccess: (data, variables) => {
-      notifications.show({ message: "Space updated successfully" });
+      notifications.show({ message: 'Space updated successfully' });

      const space = queryClient.getQueryData([
-        "space",
+        'space',
        variables.spaceId,
      ]) as ISpace;
      if (space) {
        const updatedSpace = { ...space, ...data };
-        queryClient.setQueryData(["space", variables.spaceId], updatedSpace);
-        queryClient.setQueryData(["space", data.slug], updatedSpace);
+        queryClient.setQueryData(['space', variables.spaceId], updatedSpace);
+        queryClient.setQueryData(['space', data.slug], updatedSpace);
      }

      queryClient.invalidateQueries({
-        queryKey: ["spaces"],
+        queryKey: ['spaces'],
      });
    },
    onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      const errorMessage = error['response']?.data?.message;
+      notifications.show({ message: errorMessage, color: 'red' });
+    },
+  });
+}
+
+export function useDeleteSpaceMutation() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (data: Partial<ISpace>) => deleteSpace(data.id),
+    onSuccess: (data, variables) => {
+      notifications.show({ message: 'Space deleted successfully' });
+
+      if (variables.slug) {
+        queryClient.removeQueries({
+          queryKey: ['spaces', variables.slug],
+          exact: true,
+        });
+      }
+
+      const spaces = queryClient.getQueryData(['spaces']) as any;
+      if (spaces) {
+        spaces.items = spaces.items?.filter(
+          (space: ISpace) => space.id !== variables.id
+        );
+        queryClient.setQueryData(['spaces'], spaces);
+      }
+    },
+    onError: (error) => {
+      const errorMessage = error['response']?.data?.message;
+      notifications.show({ message: errorMessage, color: 'red' });
    },
  });
 }

 export function useSpaceMembersQuery(
-  spaceId: string,
+  spaceId: string
 ): UseQueryResult<IPagination<ISpaceMember>, Error> {
  return useQuery({
-    queryKey: ["spaceMembers", spaceId],
+    queryKey: ['spaceMembers', spaceId],
    queryFn: () => getSpaceMembers(spaceId),
    enabled: !!spaceId,
  });
@ -117,14 +147,14 @@ export function useAddSpaceMemberMutation() {
  return useMutation<void, Error, IAddSpaceMember>({
    mutationFn: (data) => addSpaceMember(data),
    onSuccess: (data, variables) => {
-      notifications.show({ message: "Members added successfully" });
+      notifications.show({ message: 'Members added successfully' });
      queryClient.invalidateQueries({
-        queryKey: ["spaceMembers", variables.spaceId],
+        queryKey: ['spaceMembers', variables.spaceId],
      });
    },
    onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      const errorMessage = error['response']?.data?.message;
+      notifications.show({ message: errorMessage, color: 'red' });
    },
  });
 }
@ -135,14 +165,14 @@ export function useRemoveSpaceMemberMutation() {
  return useMutation<void, Error, IRemoveSpaceMember>({
    mutationFn: (data) => removeSpaceMember(data),
    onSuccess: (data, variables) => {
-      notifications.show({ message: "Removed successfully" });
+      notifications.show({ message: 'Removed successfully' });
      queryClient.refetchQueries({
-        queryKey: ["spaceMembers", variables.spaceId],
+        queryKey: ['spaceMembers', variables.spaceId],
      });
    },
    onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      const errorMessage = error['response']?.data?.message;
+      notifications.show({ message: errorMessage, color: 'red' });
    },
  });
 }
@ -153,15 +183,15 @@ export function useChangeSpaceMemberRoleMutation() {
  return useMutation<void, Error, IChangeSpaceMemberRole>({
    mutationFn: (data) => changeMemberRole(data),
    onSuccess: (data, variables) => {
-      notifications.show({ message: "Member role updated successfully" });
+      notifications.show({ message: 'Member role updated successfully' });
      // due to pagination levels, change in cache instead
      queryClient.refetchQueries({
-        queryKey: ["spaceMembers", variables.spaceId],
+        queryKey: ['spaceMembers', variables.spaceId],
      });
    },
    onError: (error) => {
-      const errorMessage = error["response"]?.data?.message;
-      notifications.show({ message: errorMessage, color: "red" });
+      const errorMessage = error['response']?.data?.message;
+      notifications.show({ message: errorMessage, color: 'red' });
    },
  });
 }
--- a/apps/client/src/features/space/services/space-service.ts
+++ b/apps/client/src/features/space/services/space-service.ts
@ -1,52 +1,56 @@
-import api from "@/lib/api-client";
+import api from '@/lib/api-client';
 import {
  IAddSpaceMember,
  IChangeSpaceMemberRole,
  IRemoveSpaceMember,
  ISpace,
 } from "@/features/space/types/space.types";
-import { IPagination } from "@/lib/types.ts";
+import { IPagination, QueryParams } from "@/lib/types.ts";
 import { IUser } from "@/features/user/types/user.types.ts";

-export async function getSpaces(): Promise<IPagination<ISpace>> {
-  const req = await api.post("/spaces");
+export async function getSpaces(params?: QueryParams): Promise<IPagination<ISpace>> {
+  const req = await api.post("/spaces", params);
  return req.data;
 }

 export async function getSpaceById(spaceId: string): Promise<ISpace> {
-  const req = await api.post<ISpace>("/spaces/info", { spaceId });
+  const req = await api.post<ISpace>('/spaces/info', { spaceId });
  return req.data;
 }

 export async function createSpace(data: Partial<ISpace>): Promise<ISpace> {
-  const req = await api.post<ISpace>("/spaces/create", data);
+  const req = await api.post<ISpace>('/spaces/create', data);
  return req.data;
 }

 export async function updateSpace(data: Partial<ISpace>): Promise<ISpace> {
-  const req = await api.post<ISpace>("/spaces/update", data);
+  const req = await api.post<ISpace>('/spaces/update', data);
  return req.data;
 }

+export async function deleteSpace(spaceId: string): Promise<void> {
+  await api.post<void>('/spaces/delete', { spaceId });
+}
+
 export async function getSpaceMembers(
-  spaceId: string,
+  spaceId: string
 ): Promise<IPagination<IUser>> {
-  const req = await api.post<any>("/spaces/members", { spaceId });
+  const req = await api.post<any>('/spaces/members', { spaceId });
  return req.data;
 }

 export async function addSpaceMember(data: IAddSpaceMember): Promise<void> {
-  await api.post("/spaces/members/add", data);
+  await api.post('/spaces/members/add', data);
 }

 export async function removeSpaceMember(
-  data: IRemoveSpaceMember,
+  data: IRemoveSpaceMember
 ): Promise<void> {
-  await api.post("/spaces/members/remove", data);
+  await api.post('/spaces/members/remove', data);
 }

 export async function changeMemberRole(
-  data: IChangeSpaceMemberRole,
+  data: IChangeSpaceMemberRole
 ): Promise<void> {
-  await api.post("/spaces/members/change-role", data);
+  await api.post('/spaces/members/change-role', data);
 }
--- a/apps/client/src/lib/app-route.ts
+++ b/apps/client/src/lib/app-route.ts
@ -4,6 +4,8 @@ const APP_ROUTE = {
    LOGIN: "/login",
    SIGNUP: "/signup",
    SETUP: "/setup/register",
+    FORGOT_PASSWORD: "/forgot-password",
+    PASSWORD_RESET: "/password-reset",
  },
  SETTINGS: {
    ACCOUNT: {
--- a/apps/client/src/pages/auth/forgot-password.tsx
+++ b/apps/client/src/pages/auth/forgot-password.tsx
@ -0,0 +1,13 @@
+import { ForgotPasswordForm } from "@/features/auth/components/forgot-password-form";
+import { Helmet } from "react-helmet-async";
+
+export default function ForgotPassword() {
+    return (
+        <>
+            <Helmet>
+                <title>Forgot Password - Docmost</title>
+            </Helmet>
+            <ForgotPasswordForm />
+        </>
+    );
+}
--- a/apps/client/src/pages/auth/invite-signup.tsx
+++ b/apps/client/src/pages/auth/invite-signup.tsx
@ -5,7 +5,7 @@ export default function InviteSignup() {
  return (
    <>
      <Helmet>
-        <title>Invitation signup</title>
+        <title>Invitation Signup - Docmost</title>
      </Helmet>
      <InviteSignUpForm />
    </>
--- a/apps/client/src/pages/auth/login.tsx
+++ b/apps/client/src/pages/auth/login.tsx
@ -5,7 +5,7 @@ export default function LoginPage() {
  return (
    <>
      <Helmet>
-        <title>Login</title>
+        <title>Login - Docmost</title>
      </Helmet>
      <LoginForm />
    </>
--- a/apps/client/src/pages/auth/password-reset.tsx
+++ b/apps/client/src/pages/auth/password-reset.tsx
@ -0,0 +1,53 @@
+import { Helmet } from "react-helmet-async";
+import { PasswordResetForm } from "@/features/auth/components/password-reset-form";
+import { Link, useSearchParams } from "react-router-dom";
+import { useVerifyUserTokenQuery } from "@/features/auth/queries/auth-query";
+import { Button, Container, Group, Text } from "@mantine/core";
+import APP_ROUTE from "@/lib/app-route";
+
+export default function PasswordReset() {
+  const [searchParams] = useSearchParams();
+  const { data, isLoading, isError } = useVerifyUserTokenQuery({
+    token: searchParams.get("token"),
+    type: "forgot-password",
+  });
+  const resetToken = searchParams.get("token");
+
+  if (isLoading) {
+    return <div></div>;
+  }
+
+  if (isError || !resetToken) {
+    return (
+      <>
+        <Helmet>
+          <title>Password Reset - Docmost</title>
+        </Helmet>
+        <Container my={40}>
+          <Text size="lg" ta="center">
+            Invalid or expired password reset link
+          </Text>
+          <Group justify="center">
+            <Button
+              component={Link}
+              to={APP_ROUTE.AUTH.LOGIN}
+              variant="subtle"
+              size="md"
+            >
+              Goto login page
+            </Button>
+          </Group>
+        </Container>
+      </>
+    );
+  }
+
+  return (
+    <>
+      <Helmet>
+        <title>Password Reset - Docmost</title>
+      </Helmet>
+      <PasswordResetForm resetToken={resetToken} />
+    </>
+  );
+}
--- a/apps/client/src/pages/auth/setup-workspace.tsx
+++ b/apps/client/src/pages/auth/setup-workspace.tsx
@ -32,7 +32,7 @@ export default function SetupWorkspace() {
    return (
      <>
        <Helmet>
-          <title>Setup workspace</title>
+          <title>Setup Workspace - Docmost</title>
        </Helmet>
        <SetupWorkspaceForm />
      </>
--- a/apps/client/src/theme.ts
+++ b/apps/client/src/theme.ts
@ -1,20 +1,34 @@
-import { createTheme, MantineColorsTuple } from "@mantine/core";
+import { createTheme, MantineColorsTuple } from '@mantine/core';

 const blue: MantineColorsTuple = [
-  "#e7f3ff",
-  "#d0e4ff",
-  "#a1c6fa",
-  "#6ea6f6",
-  "#458bf2",
-  "#2b7af1",
-  "#0b60d8", //
-  "#1b72f2",
-  "#0056c1",
-  "#004aac",
+  '#e7f3ff',
+  '#d0e4ff',
+  '#a1c6fa',
+  '#6ea6f6',
+  '#458bf2',
+  '#2b7af1',
+  '#0b60d8',
+  '#1b72f2',
+  '#0056c1',
+  '#004aac',
+];
+
+const red: MantineColorsTuple = [
+  '#ffebeb',
+  '#fad7d7',
+  '#eeadad',
+  '#e3807f',
+  '#da5a59',
+  '#d54241',
+  '#d43535',
+  '#bc2727',
+  '#a82022',
+  '#93151b',
 ];

 export const theme = createTheme({
  colors: {
    blue,
+    red,
  },
 });
--- a/apps/server/src/common/events/event.contants.ts
+++ b/apps/server/src/common/events/event.contants.ts
@ -0,0 +1,3 @@
+export enum EventName {
+  COLLAB_PAGE_UPDATED = 'collab.page.updated',
+}
--- a/apps/server/src/common/helpers/prosemirror/html/generateJSON.ts
+++ b/apps/server/src/common/helpers/prosemirror/html/generateJSON.ts
@ -1,7 +1,9 @@
 import { Extensions, getSchema } from '@tiptap/core';
 import { DOMParser, ParseOptions } from '@tiptap/pm/model';
-import { Window, DOMParser as HappyDomParser } from 'happy-dom';
+import { Window } from 'happy-dom';

+// this function does not work as intended
+// it has issues with closing tags
 export function generateJSON(
  html: string,
  extensions: Extensions,
@ -10,8 +12,10 @@ export function generateJSON(
  const schema = getSchema(extensions);

  const window = new Window();
-  const dom = new HappyDomParser().parseFromString(html, 'text/html').body;
+  const document = window.document;
+  document.body.innerHTML = html;

-  // @ts-ignore
-  return DOMParser.fromSchema(schema).parse(dom, options).toJSON();
+  return DOMParser.fromSchema(schema)
+    .parse(document as never, options)
+    .toJSON();
 }
--- a/apps/server/src/core/attachment/attachment.controller.ts
+++ b/apps/server/src/core/attachment/attachment.controller.ts
@ -182,7 +182,7 @@ export class AttachmentController {
      if (!inlineFileExtensions.includes(attachment.fileExt)) {
        res.header(
          'Content-Disposition',
-          `attachment; filename="${attachment.fileName}"`,
+          `attachment; filename="${encodeURIComponent(attachment.fileName)}"`,
        );
      }

--- a/apps/server/src/core/attachment/attachment.module.ts
+++ b/apps/server/src/core/attachment/attachment.module.ts
@ -4,10 +4,11 @@ import { AttachmentController } from './attachment.controller';
 import { StorageModule } from '../../integrations/storage/storage.module';
 import { UserModule } from '../user/user.module';
 import { WorkspaceModule } from '../workspace/workspace.module';
+import { AttachmentProcessor } from './processors/attachment.processor';

@Module({
  imports: [StorageModule, UserModule, WorkspaceModule],
  controllers: [AttachmentController],
-  providers: [AttachmentService],
+  providers: [AttachmentService, AttachmentProcessor],
 })
 export class AttachmentModule {}
--- a/apps/server/src/core/attachment/processors/attachment.processor.ts
+++ b/apps/server/src/core/attachment/processors/attachment.processor.ts
@ -0,0 +1,47 @@
+import { Logger, OnModuleDestroy } from '@nestjs/common';
+import { OnWorkerEvent, Processor, WorkerHost } from '@nestjs/bullmq';
+import { Job } from 'bullmq';
+import { AttachmentService } from '../services/attachment.service';
+import { QueueJob, QueueName } from 'src/integrations/queue/constants';
+import { Space } from '@docmost/db/types/entity.types';
+
+@Processor(QueueName.ATTACHEMENT_QUEUE)
+export class AttachmentProcessor extends WorkerHost implements OnModuleDestroy {
+  private readonly logger = new Logger(AttachmentProcessor.name);
+  constructor(private readonly attachmentService: AttachmentService) {
+    super();
+  }
+
+  async process(job: Job<Space, void>): Promise<void> {
+    try {
+      if (job.name === QueueJob.DELETE_SPACE_ATTACHMENTS) {
+        await this.attachmentService.handleDeleteSpaceAttachments(job.data.id);
+      }
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  @OnWorkerEvent('active')
+  onActive(job: Job) {
+    this.logger.debug(`Processing ${job.name} job`);
+  }
+
+  @OnWorkerEvent('failed')
+  onError(job: Job) {
+    this.logger.error(
+      `Error processing ${job.name} job. Reason: ${job.failedReason}`,
+    );
+  }
+
+  @OnWorkerEvent('completed')
+  onCompleted(job: Job) {
+    this.logger.debug(`Completed ${job.name} job`);
+  }
+
+  async onModuleDestroy(): Promise<void> {
+    if (this.worker) {
+      await this.worker.close();
+    }
+  }
+}
--- a/apps/server/src/core/attachment/services/attachment.service.ts
+++ b/apps/server/src/core/attachment/services/attachment.service.ts
@ -256,4 +256,37 @@ export class AttachmentService {
      trx,
    );
  }
+
+  async handleDeleteSpaceAttachments(spaceId: string) {
+    try {
+      const attachments = await this.attachmentRepo.findBySpaceId(spaceId);
+      if (!attachments || attachments.length === 0) {
+        return;
+      }
+
+      const failedDeletions = [];
+
+      await Promise.all(
+        attachments.map(async (attachment) => {
+          try {
+            await this.storageService.delete(attachment.filePath);
+            await this.attachmentRepo.deleteAttachmentById(attachment.id);
+          } catch (err) {
+            failedDeletions.push(attachment.id);
+            this.logger.log(
+              `DeleteSpaceAttachments: failed to delete attachment ${attachment.id}:`,
+              err,
+            );
+          }
+        }),
+      );
+
+      if(failedDeletions.length === attachments.length){
+        throw new Error(`Failed to delete any attachments for spaceId: ${spaceId}`);
+      }
+
+    } catch (err) {
+      throw err;
+    }
+  }
 }
--- a/apps/server/src/core/auth/auth.constants.ts
+++ b/apps/server/src/core/auth/auth.constants.ts
@ -0,0 +1,3 @@
+export enum UserTokenType {
+  FORGOT_PASSWORD = 'forgot-password',
+}
--- a/apps/server/src/core/auth/auth.controller.ts
+++ b/apps/server/src/core/auth/auth.controller.ts
@ -10,7 +10,6 @@ import {
 } from '@nestjs/common';
 import { LoginDto } from './dto/login.dto';
 import { AuthService } from './services/auth.service';
-import { CreateUserDto } from './dto/create-user.dto';
 import { SetupGuard } from './guards/setup.guard';
 import { EnvironmentService } from '../../integrations/environment/environment.service';
 import { CreateAdminUserDto } from './dto/create-admin-user.dto';
@ -19,6 +18,9 @@ import { AuthUser } from '../../common/decorators/auth-user.decorator';
 import { User, Workspace } from '@docmost/db/types/entity.types';
 import { AuthWorkspace } from '../../common/decorators/auth-workspace.decorator';
 import { JwtAuthGuard } from '../../common/guards/jwt-auth.guard';
+import { ForgotPasswordDto } from './dto/forgot-password.dto';
+import { PasswordResetDto } from './dto/password-reset.dto';
+import { VerifyUserTokenDto } from './dto/verify-user-token.dto';

@Controller('auth')
 export class AuthController {
@ -61,4 +63,31 @@ export class AuthController {
  ) {
    return this.authService.changePassword(dto, user.id, workspace.id);
  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('forgot-password')
+  async forgotPassword(
+    @Body() forgotPasswordDto: ForgotPasswordDto,
+    @AuthWorkspace() workspace: Workspace,
+  ) {
+    return this.authService.forgotPassword(forgotPasswordDto, workspace.id);
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('password-reset')
+  async passwordReset(
+    @Body() passwordResetDto: PasswordResetDto,
+    @AuthWorkspace() workspace: Workspace,
+  ) {
+    return this.authService.passwordReset(passwordResetDto, workspace.id);
+  }
+
+  @HttpCode(HttpStatus.OK)
+  @Post('verify-token')
+  async verifyResetToken(
+    @Body() verifyUserTokenDto: VerifyUserTokenDto,
+    @AuthWorkspace() workspace: Workspace,
+  ) {
+    return this.authService.verifyUserToken(verifyUserTokenDto, workspace.id);
+  }
 }
--- a/apps/server/src/core/auth/dto/forgot-password.dto.ts
+++ b/apps/server/src/core/auth/dto/forgot-password.dto.ts
@ -0,0 +1,7 @@
+import { IsEmail, IsNotEmpty } from 'class-validator';
+
+export class ForgotPasswordDto {
+  @IsNotEmpty()
+  @IsEmail()
+  email: string;
+}
--- a/apps/server/src/core/auth/dto/password-reset.dto.ts
+++ b/apps/server/src/core/auth/dto/password-reset.dto.ts
@ -0,0 +1,10 @@
+import { IsString, MinLength } from 'class-validator';
+
+export class PasswordResetDto {
+  @IsString()
+  token: string;
+
+  @IsString()
+  @MinLength(8)
+  newPassword: string;
+}
--- a/apps/server/src/core/auth/dto/verify-user-token.dto.ts
+++ b/apps/server/src/core/auth/dto/verify-user-token.dto.ts
@ -0,0 +1,9 @@
+import { IsString, MinLength } from 'class-validator';
+
+export class VerifyUserTokenDto {
+  @IsString()
+  token: string;
+
+  @IsString()
+  type: string;
+}
--- a/apps/server/src/core/auth/services/auth.service.ts
+++ b/apps/server/src/core/auth/services/auth.service.ts
@ -11,10 +11,25 @@ import { TokensDto } from '../dto/tokens.dto';
 import { SignupService } from './signup.service';
 import { CreateAdminUserDto } from '../dto/create-admin-user.dto';
 import { UserRepo } from '@docmost/db/repos/user/user.repo';
-import { comparePasswordHash, hashPassword } from '../../../common/helpers';
+import {
+  comparePasswordHash,
+  hashPassword,
+  nanoIdGen,
+} from '../../../common/helpers';
 import { ChangePasswordDto } from '../dto/change-password.dto';
 import { MailService } from '../../../integrations/mail/mail.service';
 import ChangePasswordEmail from '@docmost/transactional/emails/change-password-email';
+import { ForgotPasswordDto } from '../dto/forgot-password.dto';
+import ForgotPasswordEmail from '@docmost/transactional/emails/forgot-password-email';
+import { UserTokenRepo } from '@docmost/db/repos/user-token/user-token.repo';
+import { PasswordResetDto } from '../dto/password-reset.dto';
+import { UserToken } from '@docmost/db/types/entity.types';
+import { UserTokenType } from '../auth.constants';
+import { KyselyDB } from '@docmost/db/types/kysely.types';
+import { InjectKysely } from 'nestjs-kysely';
+import { executeTx } from '@docmost/db/utils';
+import { VerifyUserTokenDto } from '../dto/verify-user-token.dto';
+import { EnvironmentService } from 'src/integrations/environment/environment.service';

@Injectable()
 export class AuthService {
@ -22,7 +37,10 @@ export class AuthService {
    private signupService: SignupService,
    private tokenService: TokenService,
    private userRepo: UserRepo,
+    private userTokenRepo: UserTokenRepo,
    private mailService: MailService,
+    private environmentService: EnvironmentService,
+    @InjectKysely() private readonly db: KyselyDB,
  ) {}

  async login(loginDto: LoginDto, workspaceId: string) {
@ -100,4 +118,108 @@ export class AuthService {
      template: emailTemplate,
    });
  }
+
+  async forgotPassword(
+    forgotPasswordDto: ForgotPasswordDto,
+    workspaceId: string,
+  ): Promise<void> {
+    const user = await this.userRepo.findByEmail(
+      forgotPasswordDto.email,
+      workspaceId,
+    );
+
+    if (!user) {
+      return;
+    }
+
+    const token = nanoIdGen(16);
+    const resetLink = `${this.environmentService.getAppUrl()}/password-reset?token=${token}`;
+
+    await this.userTokenRepo.insertUserToken({
+      token: token,
+      userId: user.id,
+      workspaceId: user.workspaceId,
+      expiresAt: new Date(new Date().getTime() + 60 * 60 * 1000), // 1 hour
+      type: UserTokenType.FORGOT_PASSWORD,
+    });
+
+    const emailTemplate = ForgotPasswordEmail({
+      username: user.name,
+      resetLink: resetLink,
+    });
+
+    await this.mailService.sendToQueue({
+      to: user.email,
+      subject: 'Reset your password',
+      template: emailTemplate,
+    });
+  }
+
+  async passwordReset(passwordResetDto: PasswordResetDto, workspaceId: string) {
+    const userToken = await this.userTokenRepo.findById(
+      passwordResetDto.token,
+      workspaceId,
+    );
+
+    if (
+      !userToken ||
+      userToken.type !== UserTokenType.FORGOT_PASSWORD ||
+      userToken.expiresAt < new Date()
+    ) {
+      throw new BadRequestException('Invalid or expired token');
+    }
+
+    const user = await this.userRepo.findById(userToken.userId, workspaceId);
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+
+    const newPasswordHash = await hashPassword(passwordResetDto.newPassword);
+
+    await executeTx(this.db, async (trx) => {
+      await this.userRepo.updateUser(
+        {
+          password: newPasswordHash,
+        },
+        user.id,
+        workspaceId,
+        trx,
+      );
+
+      trx
+        .deleteFrom('userTokens')
+        .where('userId', '=', user.id)
+        .where('type', '=', UserTokenType.FORGOT_PASSWORD)
+        .execute();
+    });
+
+    const emailTemplate = ChangePasswordEmail({ username: user.name });
+    await this.mailService.sendToQueue({
+      to: user.email,
+      subject: 'Your password has been changed',
+      template: emailTemplate,
+    });
+
+    const tokens: TokensDto = await this.tokenService.generateTokens(user);
+
+    return { tokens };
+  }
+
+  async verifyUserToken(
+    userTokenDto: VerifyUserTokenDto,
+    workspaceId: string,
+  ): Promise<void> {
+    const userToken = await this.userTokenRepo.findById(
+      userTokenDto.token,
+      workspaceId,
+    );
+
+    if (
+      !userToken ||
+      userToken.type !== userTokenDto.type ||
+      userToken.expiresAt < new Date()
+    ) {
+      throw new BadRequestException('Invalid or expired token');
+    }
+  }
 }
--- a/apps/server/src/core/auth/services/token.service.ts
+++ b/apps/server/src/core/auth/services/token.service.ts
@ -31,7 +31,7 @@ export class TokenService {
      workspaceId,
      type: JwtType.REFRESH,
    };
-    const expiresIn = '30d'; // todo: fix
+    const expiresIn = this.environmentService.getJwtTokenExpiresIn();
    return this.jwtService.sign(payload, { expiresIn });
  }

--- a/apps/server/src/core/space/services/space.service.ts
+++ b/apps/server/src/core/space/services/space.service.ts
@ -14,6 +14,9 @@ import { executeTx } from '@docmost/db/utils';
 import { InjectKysely } from 'nestjs-kysely';
 import { SpaceMemberService } from './space-member.service';
 import { SpaceRole } from '../../../common/helpers/types/permission';
+import { QueueJob, QueueName } from 'src/integrations/queue/constants';
+import { Queue } from 'bullmq';
+import { InjectQueue } from '@nestjs/bullmq';

@Injectable()
 export class SpaceService {
@ -21,6 +24,7 @@ export class SpaceService {
    private spaceRepo: SpaceRepo,
    private spaceMemberService: SpaceMemberService,
    @InjectKysely() private readonly db: KyselyDB,
+    @InjectQueue(QueueName.ATTACHEMENT_QUEUE) private attachmentQueue: Queue,
  ) {}

  async createSpace(
@ -88,10 +92,24 @@ export class SpaceService {
    updateSpaceDto: UpdateSpaceDto,
    workspaceId: string,
  ): Promise<Space> {
+    if (updateSpaceDto?.slug) {
+      const slugExists = await this.spaceRepo.slugExists(
+        updateSpaceDto.slug,
+        workspaceId,
+      );
+
+      if (slugExists) {
+        throw new BadRequestException(
+          'Space slug exists. Please use a unique space slug',
+        );
+      }
+    }
+
    return await this.spaceRepo.updateSpace(
      {
        name: updateSpaceDto.name,
        description: updateSpaceDto.description,
+        slug: updateSpaceDto.slug,
      },
      updateSpaceDto.spaceId,
      workspaceId,
@ -120,4 +138,14 @@ export class SpaceService {

    return spaces;
  }
+
+  async deleteSpace(spaceId: string, workspaceId: string): Promise<void> {
+    const space = await this.spaceRepo.findById(spaceId, workspaceId);
+    if (!space) {
+      throw new NotFoundException('Space not found');
+    }
+
+    await this.spaceRepo.deleteSpace(spaceId, workspaceId);
+    await this.attachmentQueue.add(QueueJob.DELETE_SPACE_ATTACHMENTS, space);
+  }
 }
--- a/apps/server/src/core/space/space.controller.ts
+++ b/apps/server/src/core/space/space.controller.ts
@ -95,7 +95,7 @@ export class SpaceController {

  @HttpCode(HttpStatus.OK)
  @Post('create')
-  createGroup(
+  createSpace(
    @Body() createSpaceDto: CreateSpaceDto,
    @AuthUser() user: User,
    @AuthWorkspace() workspace: Workspace,
@ -111,7 +111,7 @@ export class SpaceController {

  @HttpCode(HttpStatus.OK)
  @Post('update')
-  async updateGroup(
+  async updateSpace(
    @Body() updateSpaceDto: UpdateSpaceDto,
    @AuthUser() user: User,
    @AuthWorkspace() workspace: Workspace,
@ -126,6 +126,23 @@ export class SpaceController {
    return this.spaceService.updateSpace(updateSpaceDto, workspace.id);
  }

+  @HttpCode(HttpStatus.OK)
+  @Post('delete')
+  async deleteSpace(
+    @Body() spaceIdDto: SpaceIdDto,
+    @AuthUser() user: User,
+    @AuthWorkspace() workspace: Workspace,
+  ) {
+    const ability = await this.spaceAbility.createForUser(
+      user,
+      spaceIdDto.spaceId,
+    );
+    if (ability.cannot(SpaceCaslAction.Manage, SpaceCaslSubject.Settings)) {
+      throw new ForbiddenException();
+    }
+    return this.spaceService.deleteSpace(spaceIdDto.spaceId, workspace.id);
+  }
+
  @HttpCode(HttpStatus.OK)
  @Post('members')
  async getSpaceMembers(
--- a/apps/server/src/core/workspace/services/workspace-invitation.service.ts
+++ b/apps/server/src/core/workspace/services/workspace-invitation.service.ts
@ -248,7 +248,7 @@ export class WorkspaceInvitationService {
      });

      await this.mailService.sendToQueue({
-        to: invitation.email,
+        to: invitedByUser.email,
        subject: `${newUser.name} has accepted your Docmost invite`,
        template: emailTemplate,
      });
--- a/apps/server/src/database/database.module.ts
+++ b/apps/server/src/database/database.module.ts
@ -22,6 +22,7 @@ import { AttachmentRepo } from './repos/attachment/attachment.repo';
 import { KyselyDB } from '@docmost/db/types/kysely.types';
 import * as process from 'node:process';
 import { MigrationService } from '@docmost/db/services/migration.service';
+import { UserTokenRepo } from './repos/user-token/user-token.repo';

 // https://github.com/brianc/node-postgres/issues/811
 types.setTypeParser(types.builtins.INT8, (val) => Number(val));
@ -66,6 +67,7 @@ types.setTypeParser(types.builtins.INT8, (val) => Number(val));
    PageHistoryRepo,
    CommentRepo,
    AttachmentRepo,
+    UserTokenRepo,
  ],
  exports: [
    WorkspaceRepo,
@ -78,6 +80,7 @@ types.setTypeParser(types.builtins.INT8, (val) => Number(val));
    PageHistoryRepo,
    CommentRepo,
    AttachmentRepo,
+    UserTokenRepo,
  ],
 })
 export class DatabaseModule implements OnModuleDestroy, OnApplicationBootstrap {
--- a/apps/server/src/database/migrations/20240903T124647-user-tokens.ts
+++ b/apps/server/src/database/migrations/20240903T124647-user-tokens.ts
@ -0,0 +1,27 @@
+import { sql, Kysely } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable('user_tokens')
+    .addColumn('id', 'uuid', (col) =>
+      col.primaryKey().defaultTo(sql`gen_uuid_v7()`),
+    )
+    .addColumn('token', 'varchar', (col) => col.notNull())
+    .addColumn('type', 'varchar', (col) => col.notNull())
+    .addColumn('user_id', 'uuid', (col) =>
+      col.notNull().references('users.id').onDelete('cascade'),
+    )
+    .addColumn('workspace_id', 'uuid', (col) =>
+      col.references('workspaces.id').onDelete('cascade'),
+    )
+    .addColumn('expires_at', 'timestamptz')
+    .addColumn('used_at', 'timestamptz', (col) => col)
+    .addColumn('created_at', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`now()`),
+    )
+    .execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await db.schema.dropTable('user_tokens').execute();
+}
--- a/apps/server/src/database/repos/attachment/attachment.repo.ts
+++ b/apps/server/src/database/repos/attachment/attachment.repo.ts
@ -40,6 +40,21 @@ export class AttachmentRepo {
      .executeTakeFirst();
  }

+  async findBySpaceId(
+    spaceId: string,
+    opts?: {
+      trx?: KyselyTransaction;
+    },
+  ): Promise<Attachment[]> {
+    const db = dbOrTx(this.db, opts?.trx);
+
+    return db
+      .selectFrom('attachments')
+      .selectAll()
+      .where('spaceId', '=', spaceId)
+      .execute();
+  }
+
  async updateAttachment(
    updatableAttachment: UpdatableAttachment,
    attachmentId: string,
@ -52,7 +67,7 @@ export class AttachmentRepo {
      .executeTakeFirst();
  }

-  async deleteAttachment(attachmentId: string): Promise<void> {
+  async deleteAttachmentById(attachmentId: string): Promise<void> {
    await this.db
      .deleteFrom('attachments')
      .where('id', '=', attachmentId)
--- a/apps/server/src/database/repos/space/space-member.repo.ts
+++ b/apps/server/src/database/repos/space/space-member.repo.ts
@ -64,7 +64,7 @@ export class SpaceMemberRepo {
    } else if (opts.groupId) {
      query = query.where('groupId', '=', opts.groupId);
    } else {
-      throw new BadRequestException('Please provider a userId or groupId');
+      throw new BadRequestException('Please provide a userId or groupId');
    }
    return query.executeTakeFirst();
  }
--- a/apps/server/src/database/repos/user-token/user-token.repo.ts
+++ b/apps/server/src/database/repos/user-token/user-token.repo.ts
@ -0,0 +1,102 @@
+import {
+  InsertableUserToken,
+  UpdatableUserToken,
+  UserToken,
+} from '@docmost/db/types/entity.types';
+import { KyselyDB, KyselyTransaction } from '@docmost/db/types/kysely.types';
+import { dbOrTx } from '@docmost/db/utils';
+import { Injectable } from '@nestjs/common';
+import { InjectKysely } from 'nestjs-kysely';
+
+@Injectable()
+export class UserTokenRepo {
+  constructor(@InjectKysely() private readonly db: KyselyDB) {}
+
+  async findById(
+    token: string,
+    workspaceId: string,
+    trx?: KyselyTransaction,
+  ): Promise<UserToken> {
+    const db = dbOrTx(this.db, trx);
+
+    return db
+      .selectFrom('userTokens')
+      .select([
+        'id',
+        'token',
+        'userId',
+        'workspaceId',
+        'type',
+        'expiresAt',
+        'usedAt',
+        'createdAt',
+      ])
+      .where('token', '=', token)
+      .where('workspaceId', '=', workspaceId)
+      .executeTakeFirst();
+  }
+
+  async insertUserToken(
+    insertableUserToken: InsertableUserToken,
+    trx?: KyselyTransaction,
+  ) {
+    const db = dbOrTx(this.db, trx);
+    return db
+      .insertInto('userTokens')
+      .values(insertableUserToken)
+      .returningAll()
+      .executeTakeFirst();
+  }
+
+  async findByUserId(
+    userId: string,
+    workspaceId: string,
+    tokenType: string,
+    trx?: KyselyTransaction,
+  ): Promise<UserToken[]> {
+    const db = dbOrTx(this.db, trx);
+    return db
+      .selectFrom('userTokens')
+      .select([
+        'id',
+        'token',
+        'userId',
+        'workspaceId',
+        'type',
+        'expiresAt',
+        'usedAt',
+        'createdAt',
+      ])
+      .where('userId', '=', userId)
+      .where('workspaceId', '=', workspaceId)
+      .where('type', '=', tokenType)
+      .orderBy('expiresAt desc')
+      .execute();
+  }
+
+  async updateUserToken(
+    updatableUserToken: UpdatableUserToken,
+    userTokenId: string,
+    trx?: KyselyTransaction,
+  ) {
+    const db = dbOrTx(this.db, trx);
+    return db
+      .updateTable('userTokens')
+      .set(updatableUserToken)
+      .where('id', '=', userTokenId)
+      .execute();
+  }
+
+  async deleteToken(token: string, trx?: KyselyTransaction): Promise<void> {
+    const db = dbOrTx(this.db, trx);
+    await db.deleteFrom('userTokens').where('token', '=', token).execute();
+  }
+
+  async deleteExpiredUserTokens(trx?: KyselyTransaction): Promise<void> {
+    const db = dbOrTx(this.db, trx);
+    await db
+      .deleteFrom('userTokens')
+      .where('expiresAt', '<', new Date())
+      .execute();
+  }
+}
--- a/apps/server/src/database/repos/user/user.repo.ts
+++ b/apps/server/src/database/repos/user/user.repo.ts
@ -102,7 +102,7 @@ export class UserRepo {
      name: insertableUser.name || insertableUser.email.toLowerCase(),
      email: insertableUser.email.toLowerCase(),
      password: await hashPassword(insertableUser.password),
-      locale: 'en',
+      locale: 'en-US',
      role: insertableUser?.role,
      lastLoginAt: new Date(),
    };
--- a/apps/server/src/database/types/db.d.ts
+++ b/apps/server/src/database/types/db.d.ts
@ -1,3 +1,8 @@
+/**
+ * This file was generated by kysely-codegen.
+ * Please do not edit it manually.
+ */
+
 import type { ColumnType } from "kysely";

 export type Generated<T> = T extends ColumnType<infer S, infer I, infer U>
@ -11,7 +16,7 @@ export type Json = JsonValue;
 export type JsonArray = JsonValue[];

 export type JsonObject = {
-  [K in string]?: JsonValue;
+  [x: string]: JsonValue | undefined;
 };

 export type JsonPrimitive = boolean | number | string | null;
@ -157,6 +162,17 @@ export interface Users {
  workspaceId: string | null;
 }

+export interface UserTokens {
+  createdAt: Generated<Timestamp>;
+  expiresAt: Timestamp | null;
+  id: Generated<string>;
+  token: string;
+  type: string;
+  usedAt: Timestamp | null;
+  userId: string;
+  workspaceId: string | null;
+}
+
 export interface WorkspaceInvitations {
  createdAt: Generated<Timestamp>;
  email: string | null;
@ -195,6 +211,7 @@ export interface DB {
  spaceMembers: SpaceMembers;
  spaces: Spaces;
  users: Users;
+  userTokens: UserTokens;
  workspaceInvitations: WorkspaceInvitations;
  workspaces: Workspaces;
 }
--- a/apps/server/src/database/types/entity.types.ts
+++ b/apps/server/src/database/types/entity.types.ts
@ -11,6 +11,7 @@ import {
  GroupUsers,
  SpaceMembers,
  WorkspaceInvitations,
+  UserTokens,
 } from './db';

 // Workspace
@ -71,3 +72,8 @@ export type UpdatableComment = Updateable<Omit<Comments, 'id'>>;
 export type Attachment = Selectable<Attachments>;
 export type InsertableAttachment = Insertable<Attachments>;
 export type UpdatableAttachment = Updateable<Omit<Attachments, 'id'>>;
+
+// User Token
+export type UserToken = Selectable<UserTokens>;
+export type InsertableUserToken = Insertable<UserTokens>;
+export type UpdatableUserToken = Updateable<Omit<UserTokens, 'id'>>;
--- a/apps/server/src/integrations/environment/environment.service.ts
+++ b/apps/server/src/integrations/environment/environment.service.ts
@ -62,9 +62,9 @@ export class EnvironmentService {
  getAwsS3Endpoint(): string {
    return this.configService.get<string>('AWS_S3_ENDPOINT');
  }
-  
+
  getAwsS3ForcePathStyle(): boolean {
-    return this.configService.get<boolean>('AWS_S3_FORCE_PATH_STYLE')
+    return this.configService.get<boolean>('AWS_S3_FORCE_PATH_STYLE');
  }

  getAwsS3Url(): string {
@ -98,6 +98,13 @@ export class EnvironmentService {
    return secure === 'true';
  }

+  getSmtpIgnoreTLS(): boolean {
+    const ignoretls = this.configService
+      .get<string>('SMTP_IGNORETLS', 'false')
+      .toLowerCase();
+    return ignoretls === 'true';
+  }
+
  getSmtpUsername(): string {
    return this.configService.get<string>('SMTP_USERNAME');
  }
--- a/apps/server/src/integrations/export/export.controller.ts
+++ b/apps/server/src/integrations/export/export.controller.ts
@ -61,7 +61,8 @@ export class ImportController {

    res.headers({
      'Content-Type': getMimeType(fileExt),
-      'Content-Disposition': 'attachment; filename="' + fileName + '"',
+      'Content-Disposition':
+        'attachment; filename="' + encodeURIComponent(fileName) + '"',
    });

    res.send(rawContent);
--- a/apps/server/src/integrations/export/turndown-utils.ts
+++ b/apps/server/src/integrations/export/turndown-utils.ts
@ -22,6 +22,7 @@ export function turndown(html: string): string {
    listParagraph,
    mathInline,
    mathBlock,
+    iframeEmbed,
  ]);
  return turndownService.turndown(html).replaceAll('<br>', ' ');
 }
@ -120,3 +121,15 @@ function mathBlock(turndownService: TurndownService) {
    },
  });
 }
+
+function iframeEmbed(turndownService: TurndownService) {
+  turndownService.addRule('iframeEmbed', {
+    filter: function (node: HTMLInputElement) {
+      return node.nodeName === 'IFRAME';
+    },
+    replacement: function (content: any, node: HTMLInputElement) {
+      const src = node.getAttribute('src');
+      return '[' + src + '](' + src + ')';
+    },
+  });
+}
--- a/apps/server/src/integrations/health/redis.health.ts
+++ b/apps/server/src/integrations/health/redis.health.ts
@ -22,6 +22,7 @@ export class RedisHealthIndicator extends HealthIndicator {
      });

      await redis.ping();
+      redis.disconnect();
      return this.getStatus(key, true);
    } catch (e) {
      this.logger.error(e);
--- a/apps/server/src/integrations/import/import.module.ts
+++ b/apps/server/src/integrations/import/import.module.ts
@ -4,6 +4,6 @@ import { ImportController } from './import.controller';

@Module({
  providers: [ImportService],
-  controllers: [ImportController]
+  controllers: [ImportController],
 })
 export class ImportModule {}
--- a/apps/server/src/integrations/import/import.service.ts
+++ b/apps/server/src/integrations/import/import.service.ts
@ -32,8 +32,10 @@ export class ImportService {
  ): Promise<void> {
    const file = await filePromise;
    const fileBuffer = await file.toBuffer();
-    const fileName = sanitize(file.filename).slice(0, 255).split('.')[0];
    const fileExtension = path.extname(file.filename).toLowerCase();
+    const fileName = sanitize(
+      path.basename(file.filename, fileExtension).slice(0, 255),
+    );
    const fileContent = fileBuffer.toString();

    let prosemirrorState = null;
--- a/apps/server/src/integrations/import/utils/callout.marked.ts
+++ b/apps/server/src/integrations/import/utils/callout.marked.ts
@ -0,0 +1,41 @@
+import { Token, marked } from 'marked';
+
+interface CalloutToken {
+  type: 'callout';
+  calloutType: string;
+  text: string;
+  raw: string;
+}
+
+export const calloutExtension = {
+  name: 'callout',
+  level: 'block',
+  start(src: string) {
+    return src.match(/:::/)?.index ?? -1;
+  },
+  tokenizer(src: string): CalloutToken | undefined {
+    const rule = /^:::([a-zA-Z0-9]+)\s+([\s\S]+?):::/;
+    const match = rule.exec(src);
+
+    const validCalloutTypes = ['info', 'success', 'warning', 'danger'];
+
+    if (match) {
+      let type = match[1];
+      if (!validCalloutTypes.includes(type)) {
+        type = 'info';
+      }
+      return {
+        type: 'callout',
+        calloutType: type,
+        raw: match[0],
+        text: match[2].trim(),
+      };
+    }
+  },
+  renderer(token: Token) {
+    const calloutToken = token as CalloutToken;
+    const body = marked.parse(calloutToken.text);
+
+    return `<div data-type="callout" data-callout-type="${calloutToken.calloutType}">${body}</div>`;
+  },
+};
--- a/apps/server/src/integrations/import/utils/marked.utils.ts
+++ b/apps/server/src/integrations/import/utils/marked.utils.ts
@ -1,4 +1,5 @@
 import { marked } from 'marked';
+import { calloutExtension } from './callout.marked';

 marked.use({
  renderer: {
@ -25,6 +26,8 @@ marked.use({
  },
 });

+marked.use({ extensions: [calloutExtension] });
+
 export async function markdownToHtml(markdownInput: string): Promise<string> {
  const YAML_FONT_MATTER_REGEX = /^\s*---[\s\S]*?---\s*/;

--- a/apps/server/src/integrations/mail/providers/mail.provider.ts
+++ b/apps/server/src/integrations/mail/providers/mail.provider.ts
@ -27,11 +27,14 @@ export const mailDriverConfigProvider = {
    switch (driver) {
      case MailOption.SMTP:
        let auth = undefined;
-        if (environmentService.getSmtpUsername() && environmentService.getSmtpPassword()) {
+        if (
+          environmentService.getSmtpUsername() &&
+          environmentService.getSmtpPassword()
+        ) {
          auth = {
-              user: environmentService.getSmtpUsername(),
-              pass: environmentService.getSmtpPassword(),
-            };
+            user: environmentService.getSmtpUsername(),
+            pass: environmentService.getSmtpPassword(),
+          };
        }
        return {
          driver,
@ -41,6 +44,7 @@ export const mailDriverConfigProvider = {
            connectionTimeout: 30 * 1000, // 30 seconds
            auth,
            secure: environmentService.getSmtpSecure(),
+            ignoreTLS: environmentService.getSmtpIgnoreTLS()
          } as SMTPTransport.Options,
        };

--- a/apps/server/src/integrations/queue/constants/queue.constants.ts
+++ b/apps/server/src/integrations/queue/constants/queue.constants.ts
@ -1,7 +1,10 @@
 export enum QueueName {
  EMAIL_QUEUE = '{email-queue}',
+  ATTACHEMENT_QUEUE = '{attachment-queue}',
 }

 export enum QueueJob {
  SEND_EMAIL = 'send-email',
+  DELETE_SPACE_ATTACHMENTS = 'delete-space-attachments',
+  DELETE_PAGE_ATTACHMENTS = 'delete-page-attachments',
 }
--- a/apps/server/src/integrations/queue/queue.module.ts
+++ b/apps/server/src/integrations/queue/queue.module.ts
@ -31,6 +31,9 @@ import { QueueName } from './constants';
    BullModule.registerQueue({
      name: QueueName.EMAIL_QUEUE,
    }),
+    BullModule.registerQueue({
+      name: QueueName.ATTACHEMENT_QUEUE,
+    }),
  ],
  exports: [BullModule],
 })
--- a/apps/server/src/integrations/transactional/emails/forgot-password-email.tsx
+++ b/apps/server/src/integrations/transactional/emails/forgot-password-email.tsx
@ -0,0 +1,28 @@
+import { Button, Link, Section, Text } from '@react-email/components';
+import * as React from 'react';
+import { button, content, paragraph } from '../css/styles';
+import { MailBody } from '../partials/partials';
+
+interface Props {
+  username: string;
+  resetLink: string;
+}
+
+export const ForgotPasswordEmail = ({ username, resetLink }: Props) => {
+  return (
+    <MailBody>
+      <Section style={content}>
+        <Text style={paragraph}>Hi {username},</Text>
+        <Text style={paragraph}>
+          We received a request from you to reset your password.
+        </Text>
+          <Link href={resetLink}> Click here to set a new password</Link>
+        <Text style={paragraph}>
+          If you did not request a password reset, please ignore this email.
+        </Text>
+      </Section>
+    </MailBody>
+  );
+};
+
+export default ForgotPasswordEmail;
--- a/apps/server/src/integrations/transactional/utils/utils.ts
+++ b/apps/server/src/integrations/transactional/utils/utils.ts
@ -1,6 +1,6 @@
 export const formatDate = (date: Date) => {
-  new Intl.DateTimeFormat("en", {
-    dateStyle: "medium",
-    timeStyle: "medium",
+  new Intl.DateTimeFormat('en', {
+    dateStyle: 'medium',
+    timeStyle: 'medium',
  }).format(date);
 };
--- a/packages/editor-ext/src/lib/attachment/attachment.ts
+++ b/packages/editor-ext/src/lib/attachment/attachment.ts
@ -6,10 +6,11 @@ export interface AttachmentOptions {
  HTMLAttributes: Record<string, any>;
  view: any;
 }
+
 export interface AttachmentAttributes {
  url?: string;
  name?: string;
-  mime?: string; // mime type e.g. application/zip
+  mime?: string; // e.g. application/zip
  size?: number;
  attachmentId?: string;
 }
@ -93,6 +94,15 @@ export const Attachment = Node.create<AttachmentOptions>({
        this.options.HTMLAttributes,
        HTMLAttributes,
      ),
+      [
+        "a",
+        {
+          href: HTMLAttributes["data-attachment-url"],
+          class: "attachment",
+          target: "blank",
+        },
+        `${HTMLAttributes["data-attachment-name"]}`,
+      ],
    ];
  },

--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@ -270,9 +270,6 @@ importers:
      react-helmet-async:
        specifier: ^2.0.5
        version: 2.0.5(react@18.3.1)
-      react-moveable:
-        specifier: ^0.56.0
-        version: 0.56.0
      react-router-dom:
        specifier: ^6.26.1
        version: 6.26.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1)
@ -1555,9 +1552,6 @@ packages:
      '@casl/ability': ^3.0.0 || ^4.0.0 || ^5.1.0 || ^6.0.0
      react: ^16.0.0 || ^17.0.0 || ^18.0.0

-  '@cfcs/core@0.0.6':
-    resolution: {integrity: sha512-FxfJMwoLB8MEMConeXUCqtMGqxdtePQxRBOiGip9ULcYYam3WfCgoY6xdnMaSkYvRvmosp5iuG+TiPofm65+Pw==}
-
  '@chevrotain/cst-dts-gen@11.0.3':
    resolution: {integrity: sha512-BvIKpRLeS/8UbfxXxgC33xOumsacaeCKAjAeLyOn7Pcp95HiRbrpl14S+9vaZLolnbssPIUuiUd8IvgkRyt6NQ==}

@ -1586,21 +1580,6 @@ packages:
    resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==}
    engines: {node: '>=12'}

-  '@daybrush/utils@1.13.0':
-    resolution: {integrity: sha512-ALK12C6SQNNHw1enXK+UO8bdyQ+jaWNQ1Af7Z3FNxeAwjYhQT7do+TRE4RASAJ3ObaS2+TJ7TXR3oz2Gzbw0PQ==}
-
-  '@egjs/agent@2.4.3':
-    resolution: {integrity: sha512-XvksSENe8wPeFlEVouvrOhKdx8HMniJ3by7sro2uPF3M6QqWwjzVcmvwoPtdjiX8O1lfRoLhQMp1a7NGlVTdIA==}
-
-  '@egjs/children-differ@1.0.1':
-    resolution: {integrity: sha512-DRvyqMf+CPCOzAopQKHtW+X8iN6Hy6SFol+/7zCUiE5y4P/OB8JP8FtU4NxtZwtafvSL4faD5KoQYPj3JHzPFQ==}
-
-  '@egjs/component@3.0.5':
-    resolution: {integrity: sha512-cLcGizTrrUNA2EYE3MBmEDt2tQv1joVP1Q3oDisZ5nw0MZDx2kcgEXM+/kZpfa/PAkFvYVhRUZwytIQWoN3V/w==}
-
-  '@egjs/list-differ@1.0.1':
-    resolution: {integrity: sha512-OTFTDQcWS+1ZREOdCWuk5hCBgYO4OsD30lXcOCyVOAjXMhgL5rBRDnt/otb6Nz8CzU0L/igdcaQBDLWc4t9gvg==}
-
  '@emnapi/core@1.2.0':
    resolution: {integrity: sha512-E7Vgw78I93we4ZWdYCb4DGAwRROGkMIXk7/y87UmANR+J6qsWusmC3gLt0H+O0KOt5e6O38U8oJamgbudrES/w==}

@ -3009,15 +2988,6 @@ packages:
    cpu: [x64]
    os: [win32]

-  '@scena/dragscroll@1.4.0':
-    resolution: {integrity: sha512-3O8daaZD9VXA9CP3dra6xcgt/qrm0mg0xJCwiX6druCteQ9FFsXffkF8PrqxY4Z4VJ58fFKEa0RlKqbsi/XnRA==}
-
-  '@scena/event-emitter@1.0.5':
-    resolution: {integrity: sha512-AzY4OTb0+7ynefmWFQ6hxDdk0CySAq/D4efljfhtRHCOP7MBF9zUfhKG3TJiroVjASqVgkRJFdenS8ArZo6Olg==}
-
-  '@scena/matrix@1.1.1':
-    resolution: {integrity: sha512-JVKBhN0tm2Srl+Yt+Ywqu0oLgLcdemDQlD1OxmN9jaCTwaFPZ7tY8n6dhVgMEaR9qcR7r+kAlMXnSfNyYdE+Vg==}
-
  '@selderee/plugin-htmlparser2@0.11.0':
    resolution: {integrity: sha512-P33hHGdldxGabLFjPPpaTxVolMrzrcegejx+0GxjrIb9Zv48D8yAIA/QTDR2dFl7Uz7urX8aX6+5bCZslr+gWQ==}

@ -4521,12 +4491,6 @@ packages:
    resolution: {integrity: sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==}
    engines: {node: '>= 8'}

-  css-styled@1.0.8:
-    resolution: {integrity: sha512-tCpP7kLRI8dI95rCh3Syl7I+v7PP+2JYOzWkl0bUEoSbJM+u8ITbutjlQVf0NC2/g4ULROJPi16sfwDIO8/84g==}
-
-  css-to-mat@1.1.1:
-    resolution: {integrity: sha512-kvpxFYZb27jRd2vium35G7q5XZ2WJ9rWjDUMNT36M3Hc41qCrLXFM5iEKMGXcrPsKfXEN+8l/riB4QzwwwiEyQ==}
-
  css-what@6.1.0:
    resolution: {integrity: sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==}
    engines: {node: '>= 6'}
@ -5229,9 +5193,6 @@ packages:
  fractional-indexing-jittered@0.9.1:
    resolution: {integrity: sha512-qyzDZ7JXWf/yZT2rQDpQwFBbIaZS2o+zb0s740vqreXQ6bFQPd8tAy4D1gGN0CUeIcnNHjuvb0EaLnqHhGV/PA==}

-  framework-utils@1.1.0:
-    resolution: {integrity: sha512-KAfqli5PwpFJ8o3psRNs8svpMGyCSAe8nmGcjQ0zZBWN2H6dZDnq+ABp3N3hdUmFeMrLtjOCTXD4yplUJIWceg==}
-
  front-matter@4.0.2:
    resolution: {integrity: sha512-I8ZuJ/qG92NWX8i5x1Y8qyj3vizhXS31OxjKDu3LKP+7/qBgfIKValiZIEwoVoJKUHlhWtYrktkxV1XsX+pPlg==}

@ -5276,9 +5237,6 @@ packages:
    resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
    engines: {node: '>=6.9.0'}

-  gesto@1.19.4:
-    resolution: {integrity: sha512-hfr/0dWwh0Bnbb88s3QVJd1ZRJeOWcgHPPwmiH6NnafDYvhTsxg+SLYu+q/oPNh9JS3V+nlr6fNs8kvPAtcRDQ==}
-
  get-caller-file@2.0.5:
    resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==}
    engines: {node: 6.* || 8.* || >= 10.*}
@ -5876,12 +5834,6 @@ packages:
    resolution: {integrity: sha512-RQrI8rlHY92OLf3rho/Ts8i/XvjgguEjOkO1BEXcU3N8BqPpSzBNwV/G0Ukr+P/l3ivvJUE/Fa/CwbS6HesGNQ==}
    hasBin: true

-  keycode@2.2.1:
-    resolution: {integrity: sha512-Rdgz9Hl9Iv4QKi8b0OlCRQEzp4AgVxyCtz5S/+VIHezDmrDhkp2N2TqBWOLz0/gbeREXOOiI9/4b8BY9uw2vFg==}
-
-  keycon@1.4.0:
-    resolution: {integrity: sha512-p1NAIxiRMH3jYfTeXRs2uWbVJ1WpEjpi8ktzUyBJsX7/wn2qu2VRXktneBLNtKNxJmlUYxRi9gOJt1DuthXR7A==}
-
  keyv@4.5.4:
    resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}

@ -6439,9 +6391,6 @@ packages:
    resolution: {integrity: sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==}
    engines: {node: '>=0.10.0'}

-  overlap-area@1.1.0:
-    resolution: {integrity: sha512-3dlJgJCaVeXH0/eZjYVJvQiLVVrPO4U1ZGqlATtx6QGO3b5eNM6+JgUKa7oStBTdYuGTk7gVoABCW6Tp+dhRdw==}
-
  p-limit@2.3.0:
    resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
    engines: {node: '>=6'}
@ -6867,9 +6816,6 @@ packages:
      '@types/react':
        optional: true

-  react-css-styled@1.1.9:
-    resolution: {integrity: sha512-M7fJZ3IWFaIHcZEkoFOnkjdiUFmwd8d+gTh2bpqMOcnxy/0Gsykw4dsL4QBiKsxcGow6tETUa4NAUcmJF+/nfw==}
-
  react-dnd-html5-backend@14.1.0:
    resolution: {integrity: sha512-6ONeqEC3XKVf4eVmMTe0oPds+c5B9Foyj8p/ZKLb7kL2qh9COYxiBHv3szd6gztqi/efkmriywLUVlPotqoJyw==}

@ -6922,9 +6868,6 @@ packages:
  react-is@18.2.0:
    resolution: {integrity: sha512-xWGDIW6x921xtzPkhiULtthJHoJvBbF3q26fzloPCK0hsvxtPVelvftw3zjbHWSkR2km9Z+4uxbDDK/6Zw9B8w==}

-  react-moveable@0.56.0:
-    resolution: {integrity: sha512-FmJNmIOsOA36mdxbrc/huiE4wuXSRlmon/o+/OrfNhSiYYYL0AV5oObtPluEhb2Yr/7EfYWBHTxF5aWAvjg1SA==}
-
  react-number-format@5.3.1:
    resolution: {integrity: sha512-qpYcQLauIeEhCZUZY9jXZnnroOtdy3jYaS1zQ3M1Sr6r/KMOBEIGNIb7eKT19g2N1wbYgFgvDzs19hw5TrB8XQ==}
    peerDependencies:
@ -6971,9 +6914,6 @@ packages:
    peerDependencies:
      react: '>=16.8'

-  react-selecto@1.26.3:
-    resolution: {integrity: sha512-Ubik7kWSnZyQEBNro+1k38hZaI1tJarE+5aD/qsqCOA1uUBSjgKVBy3EWRzGIbdmVex7DcxznFZLec/6KZNvwQ==}
-
  react-style-singleton@2.2.1:
    resolution: {integrity: sha512-ZWj0fHEMyWkHzKYUr2Bs/4zU6XLmq9HsgBURm7g5pAVfyn49DgUiNgY2d4lXRlYSiCif9YBGpQleewkcqddc7g==}
    engines: {node: '>=10'}
@ -7203,9 +7143,6 @@ packages:
  selderee@0.11.0:
    resolution: {integrity: sha512-5TF+l7p4+OsnP8BCCvSyZiSPc4x4//p5uPwK8TCnVPJYRmU2aYKMpOXvw8zM5a5JvuuCGN1jmsMwuU2W02ukfA==}

-  selecto@1.26.3:
-    resolution: {integrity: sha512-gZHgqMy5uyB6/2YDjv3Qqaf7bd2hTDOpPdxXlrez4R3/L0GiEWDCFaUfrflomgqdb3SxHF2IXY0Jw0EamZi7cw==}
-
  semver@5.7.2:
    resolution: {integrity: sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==}
    hasBin: true
@ -9667,10 +9604,6 @@ snapshots:
      '@casl/ability': 6.7.1
      react: 18.3.1

-  '@cfcs/core@0.0.6':
-    dependencies:
-      '@egjs/component': 3.0.5
-
  '@chevrotain/cst-dts-gen@11.0.3':
    dependencies:
      '@chevrotain/gast': 11.0.3
@ -9699,18 +9632,6 @@ snapshots:
    dependencies:
      '@jridgewell/trace-mapping': 0.3.9

-  '@daybrush/utils@1.13.0': {}
-
-  '@egjs/agent@2.4.3': {}
-
-  '@egjs/children-differ@1.0.1':
-    dependencies:
-      '@egjs/list-differ': 1.0.1
-
-  '@egjs/component@3.0.5': {}
-
-  '@egjs/list-differ@1.0.1': {}
-
  '@emnapi/core@1.2.0':
    dependencies:
      '@emnapi/wasi-threads': 1.0.1
@ -11034,19 +10955,6 @@ snapshots:
  '@rollup/rollup-win32-x64-msvc@4.21.2':
    optional: true

-  '@scena/dragscroll@1.4.0':
-    dependencies:
-      '@daybrush/utils': 1.13.0
-      '@scena/event-emitter': 1.0.5
-
-  '@scena/event-emitter@1.0.5':
-    dependencies:
-      '@daybrush/utils': 1.13.0
-
-  '@scena/matrix@1.1.1':
-    dependencies:
-      '@daybrush/utils': 1.13.0
-
  '@selderee/plugin-htmlparser2@0.11.0':
    dependencies:
      domhandler: 5.0.3
@ -12836,15 +12744,6 @@ snapshots:
      shebang-command: 2.0.0
      which: 2.0.2

-  css-styled@1.0.8:
-    dependencies:
-      '@daybrush/utils': 1.13.0
-
-  css-to-mat@1.1.1:
-    dependencies:
-      '@daybrush/utils': 1.13.0
-      '@scena/matrix': 1.1.1
-
  css-what@6.1.0: {}

  cssesc@3.0.0: {}
@ -13663,8 +13562,6 @@ snapshots:

  fractional-indexing-jittered@0.9.1: {}

-  framework-utils@1.1.0: {}
-
  front-matter@4.0.2:
    dependencies:
      js-yaml: 3.14.1
@ -13712,11 +13609,6 @@ snapshots:

  gensync@1.0.0-beta.2: {}

-  gesto@1.19.4:
-    dependencies:
-      '@daybrush/utils': 1.13.0
-      '@scena/event-emitter': 1.0.5
-
  get-caller-file@2.0.5: {}

  get-intrinsic@1.2.4:
@ -14559,15 +14451,6 @@ snapshots:
    dependencies:
      commander: 8.3.0

-  keycode@2.2.1: {}
-
-  keycon@1.4.0:
-    dependencies:
-      '@cfcs/core': 0.0.6
-      '@daybrush/utils': 1.13.0
-      '@scena/event-emitter': 1.0.5
-      keycode: 2.2.1
-
  keyv@4.5.4:
    dependencies:
      json-buffer: 3.0.1
@ -15118,10 +15001,6 @@ snapshots:

  os-tmpdir@1.0.2: {}

-  overlap-area@1.1.0:
-    dependencies:
-      '@daybrush/utils': 1.13.0
-
  p-limit@2.3.0:
    dependencies:
      p-try: 2.2.0
@ -15569,11 +15448,6 @@ snapshots:
    optionalDependencies:
      '@types/react': 18.3.5

-  react-css-styled@1.1.9:
-    dependencies:
-      css-styled: 1.0.8
-      framework-utils: 1.1.0
-
  react-dnd-html5-backend@14.1.0:
    dependencies:
      dnd-core: 14.0.1
@ -15645,22 +15519,6 @@ snapshots:

  react-is@18.2.0: {}

-  react-moveable@0.56.0:
-    dependencies:
-      '@daybrush/utils': 1.13.0
-      '@egjs/agent': 2.4.3
-      '@egjs/children-differ': 1.0.1
-      '@egjs/list-differ': 1.0.1
-      '@scena/dragscroll': 1.4.0
-      '@scena/event-emitter': 1.0.5
-      '@scena/matrix': 1.1.1
-      css-to-mat: 1.1.1
-      framework-utils: 1.1.0
-      gesto: 1.19.4
-      overlap-area: 1.1.0
-      react-css-styled: 1.1.9
-      react-selecto: 1.26.3
-
  react-number-format@5.3.1(react-dom@18.3.1(react@18.3.1))(react@18.3.1):
    dependencies:
      prop-types: 15.8.1
@ -15704,10 +15562,6 @@ snapshots:
      '@remix-run/router': 1.19.1
      react: 18.3.1

-  react-selecto@1.26.3:
-    dependencies:
-      selecto: 1.26.3
-
  react-style-singleton@2.2.1(@types/react@18.3.5)(react@18.3.1):
    dependencies:
      get-nonce: 1.0.1
@ -15951,19 +15805,6 @@ snapshots:
    dependencies:
      parseley: 0.12.1

-  selecto@1.26.3:
-    dependencies:
-      '@daybrush/utils': 1.13.0
-      '@egjs/children-differ': 1.0.1
-      '@scena/dragscroll': 1.4.0
-      '@scena/event-emitter': 1.0.5
-      css-styled: 1.0.8
-      css-to-mat: 1.1.1
-      framework-utils: 1.1.0
-      gesto: 1.19.4
-      keycon: 1.4.0
-      overlap-area: 1.1.0
-
  semver@5.7.2:
    optional: true