notion formatter

WIP
feat: add stream upload support and improve file handling
2025-11-10 07:02:06 +10:00 · 2025-05-25 20:06:21 -07:00 · 2025-05-25 17:59:28 -07:00 · 2025-05-23 22:31:37 -07:00 · 2025-05-23 12:40:34 -07:00 · 2025-05-22 12:51:25 -07:00
23 changed files with 1655 additions and 25 deletions
--- a/apps/server/package.json
+++ b/apps/server/package.json
@ -31,6 +31,7 @@
  },
  "dependencies": {
    "@aws-sdk/client-s3": "3.701.0",
+    "@aws-sdk/lib-storage": "^3.701.0",
    "@aws-sdk/s3-request-presigner": "3.701.0",
    "@casl/ability": "^6.7.3",
    "@fastify/cookie": "^11.0.2",
@ -80,7 +81,9 @@
    "sanitize-filename-ts": "^1.0.2",
    "socket.io": "^4.8.1",
    "stripe": "^17.5.0",
-    "ws": "^8.18.0"
+    "tmp-promise": "^3.0.3",
+    "ws": "^8.18.0",
+    "yauzl": "^3.2.0"
  },
  "devDependencies": {
    "@eslint/js": "^9.20.0",
@ -99,6 +102,7 @@
    "@types/pg": "^8.11.11",
    "@types/supertest": "^6.0.2",
    "@types/ws": "^8.5.14",
+    "@types/yauzl": "^2.10.3",
    "eslint": "^9.20.1",
    "eslint-config-prettier": "^10.0.1",
    "globals": "^15.15.0",
--- a/apps/server/src/common/helpers/utils.ts
+++ b/apps/server/src/common/helpers/utils.ts
@ -1,5 +1,6 @@
 import * as path from 'path';
 import * as bcrypt from 'bcrypt';
+import { sanitize } from 'sanitize-filename-ts';

 export const envPath = path.resolve(process.cwd(), '..', '..', '.env');

@ -62,3 +63,8 @@ export function extractDateFromUuid7(uuid7: string) {

  return new Date(timestamp);
 }
+
+export function sanitizeFileName(fileName: string): string {
+  const sanitizedFilename = sanitize(fileName).replace(/ /g, '_');
+  return sanitizedFilename.slice(0, 255);
+}
--- a/apps/server/src/database/migrations/20250521T154949-file_tasks.ts
+++ b/apps/server/src/database/migrations/20250521T154949-file_tasks.ts
@ -0,0 +1,45 @@
+import { Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable('file_tasks')
+    .addColumn('id', 'uuid', (col) =>
+      col.primaryKey().defaultTo(sql`gen_uuid_v7()`),
+    )
+    //type: import or export
+    .addColumn('type', 'varchar', (col) => col)
+    // source - generic, notion, confluence
+    // type or provider?
+    .addColumn('source', 'varchar', (col) => col)
+    // status (enum: PENDING|PROCESSING|SUCCESS|FAILED),
+    .addColumn('status', 'varchar', (col) => col)
+    // file name
+    // file path
+    // file size
+
+    .addColumn('file_name', 'varchar', (col) => col.notNull())
+    .addColumn('file_path', 'varchar', (col) => col.notNull())
+    .addColumn('file_size', 'int8', (col) => col)
+    .addColumn('file_ext', 'varchar', (col) => col)
+
+    .addColumn('creator_id', 'uuid', (col) => col.references('users.id'))
+    .addColumn('space_id', 'uuid', (col) =>
+      col.references('spaces.id').onDelete('cascade'),
+    )
+    .addColumn('workspace_id', 'uuid', (col) =>
+      col.references('workspaces.id').onDelete('cascade').notNull(),
+    )
+    .addColumn('created_at', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`now()`),
+    )
+    .addColumn('updated_at', 'timestamptz', (col) =>
+      col.notNull().defaultTo(sql`now()`),
+    )
+    .addColumn('completed_at', 'timestamptz', (col) => col)
+    .addColumn('deleted_at', 'timestamptz', (col) => col)
+    .execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await db.schema.dropTable('file_tasks').execute();
+}
--- a/apps/server/src/database/types/db.d.ts
+++ b/apps/server/src/database/types/db.d.ts
@ -122,6 +122,24 @@ export interface Comments {
  workspaceId: string;
 }

+export interface FileTasks {
+  completedAt: Timestamp | null;
+  createdAt: Generated<Timestamp>;
+  creatorId: string | null;
+  deletedAt: Timestamp | null;
+  fileExt: string | null;
+  fileName: string;
+  filePath: string;
+  fileSize: Int8 | null;
+  id: Generated<string>;
+  source: string | null;
+  spaceId: string | null;
+  status: string | null;
+  type: string | null;
+  updatedAt: Generated<Timestamp>;
+  workspaceId: string;
+}
+
 export interface Groups {
  createdAt: Generated<Timestamp>;
  creatorId: string | null;
@ -298,6 +316,7 @@ export interface DB {
  backlinks: Backlinks;
  billing: Billing;
  comments: Comments;
+  fileTasks: FileTasks;
  groups: Groups;
  groupUsers: GroupUsers;
  pageHistory: PageHistory;
--- a/apps/server/src/database/types/entity.types.ts
+++ b/apps/server/src/database/types/entity.types.ts
@ -17,6 +17,7 @@ import {
  AuthProviders,
  AuthAccounts,
  Shares,
+  FileTasks,
 } from './db';

 // Workspace
@ -107,3 +108,8 @@ export type UpdatableAuthAccount = Updateable<Omit<AuthAccounts, 'id'>>;
 export type Share = Selectable<Shares>;
 export type InsertableShare = Insertable<Shares>;
 export type UpdatableShare = Updateable<Omit<Shares, 'id'>>;
+
+// File Task
+export type FileTask = Selectable<FileTasks>;
+export type InsertableFileTask = Insertable<FileTasks>;
+export type UpdatableFileTask = Updateable<Omit<FileTasks, 'id'>>;
--- a/apps/server/src/integrations/export/turndown-utils.ts
+++ b/apps/server/src/integrations/export/turndown-utils.ts
@ -1,5 +1,6 @@
 import * as TurndownService from '@joplin/turndown';
 import * as TurndownPluginGfm from '@joplin/turndown-plugin-gfm';
+import * as path from 'path';

 export function turndown(html: string): string {
  const turndownService = new TurndownService({
@ -23,6 +24,7 @@ export function turndown(html: string): string {
    mathInline,
    mathBlock,
    iframeEmbed,
+    video,
  ]);
  return turndownService.turndown(html).replaceAll('<br>', ' ');
 }
@ -87,8 +89,12 @@ function preserveDetail(turndownService: TurndownService) {
      }

      const detailsContent = Array.from(node.childNodes)
-        .filter(child => child.nodeName !== 'SUMMARY')
-        .map(child => (child.nodeType === 1 ? turndownService.turndown((child as HTMLElement).outerHTML) : child.textContent))
+        .filter((child) => child.nodeName !== 'SUMMARY')
+        .map((child) =>
+          child.nodeType === 1
+            ? turndownService.turndown((child as HTMLElement).outerHTML)
+            : child.textContent,
+        )
        .join('');

      return `\n<details>\n${detailSummary}\n\n${detailsContent}\n\n</details>\n`;
@ -135,3 +141,16 @@ function iframeEmbed(turndownService: TurndownService) {
    },
  });
 }
+
+function video(turndownService: TurndownService) {
+  turndownService.addRule('video', {
+    filter: function (node: HTMLInputElement) {
+      return node.tagName === 'VIDEO';
+    },
+    replacement: function (content: any, node: HTMLInputElement) {
+      const src = node.getAttribute('src') || '';
+      const name = path.basename(src);
+      return '[' + name + '](' + src + ')';
+    },
+  });
+}
--- a/apps/server/src/integrations/import/file-task.service.ts
+++ b/apps/server/src/integrations/import/file-task.service.ts
@ -0,0 +1,623 @@
+import { Injectable, Logger } from '@nestjs/common';
+import * as path from 'path';
+import { jsonToText } from '../../collaboration/collaboration.util';
+import { InjectKysely } from 'nestjs-kysely';
+import { KyselyDB } from '@docmost/db/types/kysely.types';
+import { cleanUrlString, extractZip, FileTaskStatus } from './file.utils';
+import { StorageService } from '../storage/storage.service';
+import * as tmp from 'tmp-promise';
+import { pipeline } from 'node:stream/promises';
+import { createReadStream, createWriteStream } from 'node:fs';
+import { ImportService } from './import.service';
+import { promises as fs } from 'fs';
+import {
+  generateSlugId,
+  getMimeType,
+  sanitizeFileName,
+} from '../../common/helpers';
+import { v7 } from 'uuid';
+import { generateJitteredKeyBetween } from 'fractional-indexing-jittered';
+import { FileTask, InsertablePage } from '@docmost/db/types/entity.types';
+import {
+  DOMParser,
+  Node as HDNode,
+  Element as HDElement,
+  Window,
+} from 'happy-dom';
+import { markdownToHtml } from '@docmost/editor-ext';
+import { getAttachmentFolderPath } from '../../core/attachment/attachment.utils';
+import { AttachmentType } from '../../core/attachment/attachment.constants';
+import { getProsemirrorContent } from '../../common/helpers/prosemirror/utils';
+import { not } from 'rxjs/internal/util/not';
+import { notionFormatter } from './import-formatter';
+
+@Injectable()
+export class FileTaskService {
+  private readonly logger = new Logger(FileTaskService.name);
+
+  constructor(
+    private readonly storageService: StorageService,
+    private readonly importService: ImportService,
+    @InjectKysely() private readonly db: KyselyDB,
+  ) {}
+
+  async processZIpImport(fileTaskId: string): Promise<void> {
+    const fileTask = await this.db
+      .selectFrom('fileTasks')
+      .selectAll()
+      .where('id', '=', fileTaskId)
+      .executeTakeFirst();
+
+    if (!fileTask) {
+      this.logger.log(`File task with ID ${fileTaskId} not found`);
+      return;
+    }
+
+    const { path: tmpZipPath, cleanup: cleanupTmpFile } = await tmp.file({
+      prefix: 'docmost-import',
+      postfix: '.zip',
+      discardDescriptor: true,
+    });
+
+    const { path: tmpExtractDir, cleanup: cleanupTmpDir } = await tmp.dir({
+      prefix: 'docmost-extract-',
+      unsafeCleanup: true,
+    });
+
+    const fileStream = await this.storageService.readStream(fileTask.filePath);
+    await pipeline(fileStream, createWriteStream(tmpZipPath));
+
+    await extractZip(tmpZipPath, tmpExtractDir);
+    console.log('extract here');
+
+    // TODO: internal link mentions, backlinks, attachments
+    try {
+      await this.updateTaskStatus(fileTaskId, FileTaskStatus.Processing);
+      // if type == generic
+      await this.processGenericImport({ extractDir: tmpExtractDir, fileTask });
+      await this.updateTaskStatus(fileTaskId, FileTaskStatus.Success);
+    } catch (error) {
+      await this.updateTaskStatus(fileTaskId, FileTaskStatus.Failed);
+      console.error(error);
+    } finally {
+      await cleanupTmpFile();
+      await cleanupTmpDir();
+    }
+  }
+
+  async processGenericImport(opts: {
+    extractDir: string;
+    fileTask: FileTask;
+  }): Promise<void> {
+    const { extractDir, fileTask } = opts;
+
+    const allFiles = await this.collectMarkdownAndHtmlFiles(extractDir);
+    const attachmentCandidates =
+      await this.buildAttachmentCandidates(extractDir);
+
+    console.log('attachment count: ', attachmentCandidates.size);
+
+    const pagesMap = new Map<
+      string,
+      {
+        id: string;
+        slugId: string;
+        name: string;
+        content: string;
+        position?: string | null;
+        parentPageId: string | null;
+        fileExtension: string;
+        filePath: string;
+      }
+    >();
+
+    for (const absPath of allFiles) {
+      const relPath = path
+        .relative(extractDir, absPath)
+        .split(path.sep)
+        .join('/'); // normalize to forward-slashes
+      const ext = path.extname(relPath).toLowerCase();
+      let content = await fs.readFile(absPath, 'utf-8');
+
+      console.log('relative path: ', relPath, ' abs path: ', absPath);
+
+      if (ext.toLowerCase() === '.html' || ext.toLowerCase() === '.md') {
+        // we want to process all inputs as markr
+        if (ext === '.md') {
+          content = await markdownToHtml(content);
+        }
+
+        //content = this.stripAllStyles(content)
+
+        content = await this.rewriteLocalFilesInHtml({
+          html: content,
+          pageRelativePath: relPath,
+          extractDir,
+          pageId: v7(),
+          fileTask,
+          attachmentCandidates,
+        });
+      }
+
+      pagesMap.set(relPath, {
+        id: v7(),
+        slugId: generateSlugId(),
+        name: path.basename(relPath, ext),
+        content,
+        parentPageId: null,
+        fileExtension: ext,
+        filePath: relPath,
+      });
+    }
+
+    // parent/child linking
+    pagesMap.forEach((page, filePath) => {
+      const segments = filePath.split('/');
+      segments.pop();
+      let parentPage = null;
+      while (segments.length) {
+        const tryMd = segments.join('/') + '.md';
+        const tryHtml = segments.join('/') + '.html';
+        if (pagesMap.has(tryMd)) {
+          parentPage = pagesMap.get(tryMd)!;
+          break;
+        }
+        if (pagesMap.has(tryHtml)) {
+          parentPage = pagesMap.get(tryHtml)!;
+          break;
+        }
+        segments.pop();
+      }
+      if (parentPage) page.parentPageId = parentPage.id;
+    });
+
+    // generate position keys
+    const siblingsMap = new Map<string | null, typeof Array.prototype>();
+    pagesMap.forEach((page) => {
+      const sibs = siblingsMap.get(page.parentPageId) || [];
+      sibs.push(page);
+      siblingsMap.set(page.parentPageId, sibs);
+    });
+    siblingsMap.forEach((sibs) => {
+      sibs.sort((a, b) => a.name.localeCompare(b.name));
+      let prevPos: string | null = null;
+      for (const page of sibs) {
+        page.position = generateJitteredKeyBetween(prevPos, null);
+        prevPos = page.position;
+      }
+    });
+
+    const filePathToPageMetaMap = new Map<
+      string,
+      { id: string; title: string; slugId: string }
+    >();
+    pagesMap.forEach((page) => {
+      filePathToPageMetaMap.set(page.filePath, {
+        id: page.id,
+        title: page.name,
+        slugId: page.slugId,
+      });
+    });
+
+    const insertablePages: InsertablePage[] = await Promise.all(
+      Array.from(pagesMap.values()).map(async (page) => {
+        const htmlContent = await this.rewriteInternalLinksToMentionHtml(
+          page.content,
+          page.filePath,
+          filePathToPageMetaMap,
+          fileTask.creatorId,
+        );
+
+        const pmState = getProsemirrorContent(
+          await this.importService.processHTML(notionFormatter(htmlContent)),
+        );
+
+        const { title, prosemirrorJson } =
+          this.importService.extractTitleAndRemoveHeading(pmState);
+
+        return {
+          id: page.id,
+          slugId: page.slugId,
+          title: title || page.name,
+          content: prosemirrorJson,
+          textContent: jsonToText(prosemirrorJson),
+          ydoc: await this.importService.createYdoc(prosemirrorJson),
+          position: page.position!,
+          spaceId: fileTask.spaceId,
+          workspaceId: fileTask.workspaceId,
+          creatorId: fileTask.creatorId,
+          lastUpdatedById: fileTask.creatorId,
+          parentPageId: page.parentPageId,
+        };
+      }),
+    );
+
+    try {
+      await this.db.insertInto('pages').values(insertablePages).execute();
+      //todo: avoid duplicates
+      // log success
+      // backlinks mapping
+      // handle svg diagram nodes
+    } catch (e) {
+      console.error(e);
+    }
+  }
+
+  async rewriteLocalFilesInHtml(opts: {
+    html: string;
+    pageRelativePath: string;
+    extractDir: string;
+    pageId: string;
+    fileTask: FileTask;
+    attachmentCandidates: Map<string, string>;
+  }): Promise<string> {
+    const {
+      html,
+      pageRelativePath,
+      extractDir,
+      pageId,
+      fileTask,
+      attachmentCandidates,
+    } = opts;
+
+    const window = new Window();
+    const doc = window.document;
+    doc.body.innerHTML = html;
+
+    const tasks: Promise<void>[] = [];
+
+    const processFile = (relPath: string) => {
+      const abs = attachmentCandidates.get(relPath)!;
+      const attachmentId = v7();
+      const ext = path.extname(abs);
+
+      const fileNameWithExt =
+        sanitizeFileName(path.basename(abs, ext)) + ext.toLowerCase();
+
+      const storageFilePath = `${getAttachmentFolderPath(AttachmentType.File, fileTask.workspaceId)}/${attachmentId}/${fileNameWithExt}`;
+
+      const apiFilePath = `/api/files/${attachmentId}/${fileNameWithExt}`;
+
+      tasks.push(
+        (async () => {
+          const fileStream = createReadStream(abs);
+          await this.storageService.uploadStream(storageFilePath, fileStream);
+          const stat = await fs.stat(abs);
+
+          const uploaded = await this.db
+            .insertInto('attachments')
+            .values({
+              id: attachmentId,
+              filePath: storageFilePath,
+              fileName: fileNameWithExt,
+              fileSize: stat.size,
+              mimeType: getMimeType(fileNameWithExt),
+              type: 'file',
+              fileExt: ext,
+              creatorId: fileTask.creatorId,
+              workspaceId: fileTask.workspaceId,
+              pageId,
+              spaceId: fileTask.spaceId,
+            })
+            .returningAll()
+            .execute();
+          console.log(uploaded);
+        })(),
+      );
+
+      return {
+        attachmentId,
+        storageFilePath,
+        apiFilePath,
+        fileNameWithExt,
+        abs,
+      };
+    };
+
+    const pageDir = path.dirname(pageRelativePath);
+
+    for (const img of Array.from(doc.getElementsByTagName('img'))) {
+      const src = cleanUrlString(img.getAttribute('src')) ?? '';
+      if (!src || src.startsWith('http')) continue;
+
+      const relPath = this.resolveRelativeAttachmentPath(
+        src,
+        pageDir,
+        attachmentCandidates,
+      );
+      if (!relPath) continue;
+
+      const { attachmentId, apiFilePath, abs } = processFile(relPath);
+      const stat = await fs.stat(abs);
+
+      const width = img.getAttribute('width') || '100%';
+      const align = img.getAttribute('data-align') || 'center';
+
+      img.setAttribute('src', apiFilePath);
+      img.setAttribute('data-attachment-id', attachmentId);
+      img.setAttribute('data-size', stat.size.toString());
+      img.setAttribute('width', width);
+      img.setAttribute('data-align', align);
+
+      this.unwrapFromParagraph(img);
+    }
+
+    // rewrite <video>
+    for (const vid of Array.from(doc.getElementsByTagName('video'))) {
+      const src = cleanUrlString(vid.getAttribute('src')) ?? '';
+      if (!src || src.startsWith('http')) continue;
+
+      const relPath = this.resolveRelativeAttachmentPath(
+        src,
+        pageDir,
+        attachmentCandidates,
+      );
+      if (!relPath) continue;
+
+      const { attachmentId, apiFilePath, abs } = processFile(relPath);
+      const stat = await fs.stat(abs);
+
+      const width = vid.getAttribute('width') || '100%';
+      const align = vid.getAttribute('data-align') || 'center';
+
+      vid.setAttribute('src', apiFilePath);
+      vid.setAttribute('data-attachment-id', attachmentId);
+      vid.setAttribute('data-size', stat.size.toString());
+      vid.setAttribute('width', width);
+      vid.setAttribute('data-align', align);
+
+      // @ts-ignore
+      this.unwrapFromParagraph(vid);
+    }
+
+    // rewrite other attachments via <a>
+    for (const a of Array.from(doc.getElementsByTagName('a'))) {
+      const href = cleanUrlString(a.getAttribute('href')) ?? '';
+      if (!href || href.startsWith('http')) continue;
+
+      const relPath = this.resolveRelativeAttachmentPath(
+        href,
+        pageDir,
+        attachmentCandidates,
+      );
+      if (!relPath) continue;
+
+      const { attachmentId, apiFilePath, abs } = processFile(relPath);
+      const stat = await fs.stat(abs);
+      const ext = path.extname(relPath).toLowerCase();
+
+      if (ext === '.mp4') {
+        const video = doc.createElement('video');
+        video.setAttribute('src', apiFilePath);
+        video.setAttribute('data-attachment-id', attachmentId);
+        video.setAttribute('data-size', stat.size.toString());
+        video.setAttribute('width', '100%');
+        video.setAttribute('data-align', 'center');
+
+        a.replaceWith(video);
+        // @ts-ignore
+        this.unwrapFromParagraph(video);
+      } else {
+        const div = doc.createElement('div') as HDElement;
+        div.setAttribute('data-type', 'attachment');
+        div.setAttribute('data-attachment-url', apiFilePath);
+        div.setAttribute('data-attachment-name', path.basename(abs));
+        div.setAttribute('data-attachment-mime', getMimeType(abs));
+        div.setAttribute('data-attachment-size', stat.size.toString());
+        div.setAttribute('data-attachment-id', attachmentId);
+
+        a.replaceWith(div);
+        this.unwrapFromParagraph(div);
+      }
+    }
+
+    const attachmentDivs = Array.from(
+      doc.querySelectorAll('div[data-type="attachment"]'),
+    );
+    for (const oldDiv of attachmentDivs) {
+      const rawUrl =
+        cleanUrlString(oldDiv.getAttribute('data-attachment-url')) ?? '';
+      if (!rawUrl || rawUrl.startsWith('http')) continue;
+
+      const relPath = this.resolveRelativeAttachmentPath(
+        rawUrl,
+        pageDir,
+        attachmentCandidates,
+      );
+      if (!relPath) continue;
+
+      const { attachmentId, apiFilePath, abs } = processFile(relPath);
+      const stat = await fs.stat(abs);
+      const fileName = path.basename(abs);
+      const mime = getMimeType(abs);
+
+      const div = doc.createElement('div') as HDElement;
+      div.setAttribute('data-type', 'attachment');
+      div.setAttribute('data-attachment-url', apiFilePath);
+      div.setAttribute('data-attachment-name', fileName);
+      div.setAttribute('data-attachment-mime', mime);
+      div.setAttribute('data-attachment-size', stat.size.toString());
+      div.setAttribute('data-attachment-id', attachmentId);
+
+      oldDiv.replaceWith(div);
+      this.unwrapFromParagraph(div);
+    }
+
+    for (const type of ['excalidraw', 'drawio'] as const) {
+      const selector = `div[data-type="${type}"]`;
+      const oldDivs = Array.from(doc.querySelectorAll(selector));
+
+      for (const oldDiv of oldDivs) {
+        const rawSrc = cleanUrlString(oldDiv.getAttribute('data-src')) ?? '';
+        if (!rawSrc || rawSrc.startsWith('http')) continue;
+
+        const relPath = this.resolveRelativeAttachmentPath(
+          rawSrc,
+          pageDir,
+          attachmentCandidates,
+        );
+        if (!relPath) continue;
+
+        const { attachmentId, apiFilePath, abs } = processFile(relPath);
+        const stat = await fs.stat(abs);
+        const fileName = path.basename(abs);
+
+        const width = oldDiv.getAttribute('data-width') || '100%';
+        const align = oldDiv.getAttribute('data-align') || 'center';
+
+        const newDiv = doc.createElement('div') as HDElement;
+        newDiv.setAttribute('data-type', type);
+        newDiv.setAttribute('data-src', apiFilePath);
+        newDiv.setAttribute('data-title', fileName);
+        newDiv.setAttribute('data-width', width);
+        newDiv.setAttribute('data-size', stat.size.toString());
+        newDiv.setAttribute('data-align', align);
+        newDiv.setAttribute('data-attachment-id', attachmentId);
+
+        oldDiv.replaceWith(newDiv);
+        this.unwrapFromParagraph(newDiv);
+      }
+    }
+
+    // wait for all uploads & DB inserts
+    await Promise.all(tasks);
+
+    return doc.documentElement.outerHTML;
+  }
+
+  async rewriteInternalLinksToMentionHtml(
+    html: string,
+    currentFilePath: string,
+    filePathToPageMetaMap: Map<
+      string,
+      { id: string; title: string; slugId: string }
+    >,
+    creatorId: string,
+  ): Promise<string> {
+    const window = new Window();
+    const doc = window.document;
+    doc.body.innerHTML = html;
+
+    // normalize helper
+    const normalize = (p: string) => p.replace(/\\/g, '/');
+
+    for (const a of Array.from(doc.getElementsByTagName('a'))) {
+      const rawHref = a.getAttribute('href');
+      if (!rawHref) continue;
+
+      // skip absolute/external URLs
+      if (rawHref.startsWith('http') || rawHref.startsWith('/api/')) {
+        continue;
+      }
+
+      const decodedRef = decodeURIComponent(rawHref);
+      const parentDir = path.dirname(currentFilePath);
+      const joined = path.join(parentDir, decodedRef);
+      const resolved = normalize(joined);
+
+      const pageMeta = filePathToPageMetaMap.get(resolved);
+      if (!pageMeta) {
+        // not an internal link we know about
+        continue;
+      }
+
+      const mentionEl = doc.createElement('span') as HDElement;
+      mentionEl.setAttribute('data-type', 'mention');
+      mentionEl.setAttribute('data-id', v7());
+      mentionEl.setAttribute('data-entity-type', 'page');
+      mentionEl.setAttribute('data-entity-id', pageMeta.id);
+      mentionEl.setAttribute('data-label', pageMeta.title);
+      mentionEl.setAttribute('data-slug-id', pageMeta.slugId);
+      mentionEl.setAttribute('data-creator-id', creatorId);
+      mentionEl.textContent = pageMeta.title;
+
+      a.replaceWith(mentionEl);
+    }
+
+    return doc.body.innerHTML;
+  }
+
+  unwrapFromParagraph(node: HDElement) {
+    let wrapper = node.closest('p, a') as HDElement | null;
+
+    while (wrapper) {
+      if (wrapper.childNodes.length === 1) {
+        // e.g. <p><node/></p> or <a><node/></a> → <node/>
+        wrapper.replaceWith(node);
+      } else {
+        wrapper.parentNode!.insertBefore(node, wrapper);
+      }
+      wrapper = node.closest('p, a') as HDElement | null;
+    }
+  }
+
+  async buildAttachmentCandidates(
+    extractDir: string,
+  ): Promise<Map<string, string>> {
+    const map = new Map<string, string>();
+    async function walk(dir: string) {
+      for (const ent of await fs.readdir(dir, { withFileTypes: true })) {
+        const abs = path.join(dir, ent.name);
+        if (ent.isDirectory()) {
+          await walk(abs);
+        } else {
+          if (['.md', '.html'].includes(path.extname(ent.name).toLowerCase())) {
+            continue;
+          }
+
+          const rel = path.relative(extractDir, abs).split(path.sep).join('/');
+          map.set(rel, abs);
+        }
+      }
+    }
+
+    await walk(extractDir);
+    return map;
+  }
+
+  async collectMarkdownAndHtmlFiles(dir: string): Promise<string[]> {
+    const results: string[] = [];
+
+    async function walk(current: string) {
+      const entries = await fs.readdir(current, { withFileTypes: true });
+      for (const ent of entries) {
+        const fullPath = path.join(current, ent.name);
+        if (ent.isDirectory()) {
+          await walk(fullPath);
+        } else if (
+          ['.md', '.html'].includes(path.extname(ent.name).toLowerCase())
+        ) {
+          results.push(fullPath);
+        }
+      }
+    }
+
+    await walk(dir);
+    return results;
+  }
+
+  resolveRelativeAttachmentPath(
+    raw: string,
+    pageDir: string,
+    attachmentCandidates: Map<string, string>,
+  ): string | null {
+    const mainRel = decodeURIComponent(raw.replace(/^\.?\/+/, ''));
+    const fallback = path.normalize(path.join(pageDir, mainRel));
+
+    if (attachmentCandidates.has(mainRel)) {
+      return mainRel;
+    }
+    if (attachmentCandidates.has(fallback)) {
+      return fallback;
+    }
+    return null;
+  }
+
+  async updateTaskStatus(fileTaskId: string, status: FileTaskStatus) {
+    await this.db
+      .updateTable('fileTasks')
+      .set({ status: status })
+      .where('id', '=', fileTaskId)
+      .execute();
+  }
+}
--- a/apps/server/src/integrations/import/file.utils.ts
+++ b/apps/server/src/integrations/import/file.utils.ts
@ -0,0 +1,94 @@
+import * as yauzl from 'yauzl';
+import * as path from 'path';
+import * as fs from 'node:fs';
+
+export enum FileTaskType {
+  Import = 'import',
+  Export = 'export',
+}
+
+export enum FileImportType {
+  Generic = 'generic',
+  Notion = 'notion',
+  Confluence = 'confluence',
+}
+
+export enum FileTaskStatus {
+  Pending = 'pending',
+  Processing = 'processing',
+  Success = 'success',
+  Failed = 'failed',
+}
+
+export function getFileTaskFolderPath(
+  type: FileTaskType,
+  workspaceId: string,
+): string {
+  switch (type) {
+    case FileTaskType.Import:
+      return `${workspaceId}/imports`;
+    case FileTaskType.Export:
+      return `${workspaceId}/exports`;
+  }
+}
+
+export function extractZip(source: string, target: string) {
+  //https://github.com/Surfer-Org
+  return new Promise((resolve, reject) => {
+    yauzl.open(
+      source,
+      { lazyEntries: true, decodeStrings: false, autoClose: true },
+      (err, zipfile) => {
+        if (err) return reject(err);
+
+        zipfile.readEntry();
+        zipfile.on('entry', (entry) => {
+          const name = entry.fileName.toString('utf8'); // or 'cp437' if you need the original DOS charset
+          const safeName = name.replace(/^\/+/, ''); // strip any leading slashes
+
+          const fullPath = path.join(target, safeName);
+          const directory = path.dirname(fullPath);
+
+          // <-- skip all macOS metadata
+          if (safeName.startsWith('__MACOSX/')) {
+            return zipfile.readEntry();
+          }
+
+          if (/\/$/.test(entry.fileName)) {
+            // Directory entry
+            try {
+              fs.mkdirSync(fullPath, { recursive: true });
+              zipfile.readEntry();
+            } catch (err) {
+              reject(err);
+            }
+          } else {
+            // File entry
+            try {
+              fs.mkdirSync(directory, { recursive: true });
+              zipfile.openReadStream(entry, (err, readStream) => {
+                if (err) return reject(err);
+                const writeStream = fs.createWriteStream(fullPath);
+                readStream.on('end', () => {
+                  writeStream.end();
+                  zipfile.readEntry();
+                });
+                readStream.pipe(writeStream);
+              });
+            } catch (err) {
+              reject(err);
+            }
+          }
+        });
+
+        zipfile.on('end', resolve);
+        zipfile.on('error', reject);
+      },
+    );
+  });
+}
+
+export function cleanUrlString(url: string): string {
+  const [maybePath] = url.split('?', 1);
+  return maybePath;
+}
--- a/apps/server/src/integrations/import/import-formatter.ts
+++ b/apps/server/src/integrations/import/import-formatter.ts
@ -0,0 +1,127 @@
+import { Window } from 'happy-dom';
+
+export function notionFormatter(html: string): string {
+  const window = new Window();
+  const doc = window.document;
+  doc.body.innerHTML = html;
+
+  // Block math
+  for (const fig of Array.from(doc.querySelectorAll('figure.equation'))) {
+    // get TeX source from the MathML <annotation>
+    const annotation = fig.querySelector(
+      'annotation[encoding="application/x-tex"]',
+    );
+    const tex = annotation?.textContent?.trim() ?? '';
+
+    const mathBlock = doc.createElement('div');
+    mathBlock.setAttribute('data-type', 'mathBlock');
+    mathBlock.setAttribute('data-katex', 'true');
+    mathBlock.textContent = tex;
+
+    fig.replaceWith(mathBlock);
+  }
+
+  // Inline math
+  for (const token of Array.from(
+    doc.querySelectorAll('span.notion-text-equation-token'),
+  )) {
+    // remove the preceding <style> if it’s that KaTeX import
+    const prev = token.previousElementSibling;
+    if (prev?.tagName === 'STYLE') prev.remove();
+
+    const annotation = token.querySelector(
+      'annotation[encoding="application/x-tex"]',
+    );
+    const tex = annotation?.textContent?.trim() ?? '';
+
+    const mathInline = doc.createElement('span');
+    mathInline.setAttribute('data-type', 'mathInline');
+    mathInline.setAttribute('data-katex', 'true');
+    mathInline.textContent = tex;
+    token.replaceWith(mathInline);
+  }
+
+  // Callouts
+  const figs = Array.from(doc.querySelectorAll('figure.callout')).reverse();
+
+  for (const fig of figs) {
+    // find the content <div> (always the 2nd child in a Notion callout)
+    const contentDiv = fig.querySelector(
+      'div:nth-of-type(2)',
+    ) as unknown as HTMLElement | null;
+    if (!contentDiv) continue;
+
+    // pull out every block inside (tables, p, nested callouts, lists…)
+    const blocks = Array.from(contentDiv.childNodes);
+
+    const wrapper = fig.ownerDocument.createElement('div');
+    wrapper.setAttribute('data-type', 'callout');
+    wrapper.setAttribute('data-callout-type', 'info');
+
+    // move each real node into the wrapper (preserves nested structure)
+    // @ts-ignore
+    wrapper.append(...blocks);
+    fig.replaceWith(wrapper);
+  }
+
+  // Todolist
+  const todoLists = Array.from(doc.querySelectorAll('ul.to-do-list'));
+
+  for (const oldList of todoLists) {
+    const newList = doc.createElement('ul');
+    newList.setAttribute('data-type', 'taskList');
+
+    // for each old <li>, create a <li data-type="taskItem" data-checked="…">
+    for (const li of oldList.querySelectorAll('li')) {
+      const isChecked = li.querySelector('.checkbox.checkbox-on') != null;
+      const textSpan = li.querySelector(
+        'span.to-do-children-unchecked, span.to-do-children-checked',
+      );
+      const text = textSpan?.textContent?.trim() ?? '';
+
+      // <li data-type="taskItem" data-checked="true|false">
+      const taskItem = doc.createElement('li');
+      taskItem.setAttribute('data-type', 'taskItem');
+      taskItem.setAttribute('data-checked', String(isChecked));
+
+      //  <label><input type="checkbox" [checked]><span></span></label>
+      const label = doc.createElement('label');
+      const input = doc.createElement('input');
+      input.type = 'checkbox';
+      if (isChecked) input.checked = true;
+      const spacer = doc.createElement('span');
+      label.append(input, spacer);
+
+      const container = doc.createElement('div');
+      const p = doc.createElement('p');
+      p.textContent = text;
+      container.appendChild(p);
+
+      taskItem.append(label, container);
+      newList.appendChild(taskItem);
+    }
+
+    oldList.replaceWith(newList);
+  }
+
+  // Fix toggle blocks
+  const detailsList = Array.from(
+    doc.querySelectorAll('ul.toggle details'),
+  ).reverse();
+
+  // unwrap from ul and li tags
+  for (const details of detailsList) {
+    const li = details.closest('li');
+    if (li) {
+      li.parentNode!.insertBefore(details, li);
+      if (li.childNodes.length === 0) li.remove();
+    }
+
+    const ul = details.closest('ul.toggle');
+    if (ul) {
+      ul.parentNode!.insertBefore(details, ul);
+      if (ul.childNodes.length === 0) ul.remove();
+    }
+  }
+  return doc.body.innerHTML;
+}
--- a/apps/server/src/integrations/import/import.controller.ts
+++ b/apps/server/src/integrations/import/import.controller.ts
@ -83,4 +83,57 @@ export class ImportController {

    return this.importService.importPage(file, user.id, spaceId, workspace.id);
  }
+
+  @UseInterceptors(FileInterceptor)
+  @UseGuards(JwtAuthGuard)
+  @HttpCode(HttpStatus.OK)
+  // temporary naming
+  @Post('pages/import-zip')
+  async importZip(
+    @Req() req: any,
+    @AuthUser() user: User,
+    @AuthWorkspace() workspace: Workspace,
+  ) {
+    const validFileExtensions = ['.zip'];
+
+    const maxFileSize = bytes('100mb');
+
+    let file = null;
+    try {
+      file = await req.file({
+        limits: { fileSize: maxFileSize, fields: 3, files: 1 },
+      });
+    } catch (err: any) {
+      this.logger.error(err.message);
+      if (err?.statusCode === 413) {
+        throw new BadRequestException(
+          `File too large. Exceeds the 100mb import limit`,
+        );
+      }
+    }
+
+    if (!file) {
+      throw new BadRequestException('Failed to upload file');
+    }
+
+    if (
+      !validFileExtensions.includes(path.extname(file.filename).toLowerCase())
+    ) {
+      throw new BadRequestException('Invalid import file type.');
+    }
+
+    const spaceId = file.fields?.spaceId?.value;
+    const source = file.fields?.source?.value;
+
+    if (!spaceId) {
+      throw new BadRequestException('spaceId or format not found');
+    }
+
+    const ability = await this.spaceAbility.createForUser(user, spaceId);
+    if (ability.cannot(SpaceCaslAction.Edit, SpaceCaslSubject.Page)) {
+      throw new ForbiddenException();
+    }
+
+    return this.importService.importZip(file, source, user.id, spaceId, workspace.id);
+  }
 }
--- a/apps/server/src/integrations/import/import.module.ts
+++ b/apps/server/src/integrations/import/import.module.ts
@ -1,9 +1,13 @@
 import { Module } from '@nestjs/common';
 import { ImportService } from './import.service';
 import { ImportController } from './import.controller';
+import { StorageModule } from '../storage/storage.module';
+import { FileTaskService } from './file-task.service';
+import { FileTaskProcessor } from './processors/file-task.processor';

@Module({
-  providers: [ImportService],
+  providers: [ImportService, FileTaskService, FileTaskProcessor],
  controllers: [ImportController],
+  imports: [StorageModule],
 })
 export class ImportModule {}
--- a/apps/server/src/integrations/import/import.service.ts
+++ b/apps/server/src/integrations/import/import.service.ts
@ -4,7 +4,8 @@ import { MultipartFile } from '@fastify/multipart';
 import { sanitize } from 'sanitize-filename-ts';
 import * as path from 'path';
 import {
-  htmlToJson, jsonToText,
+  htmlToJson,
+  jsonToText,
  tiptapExtensions,
 } from '../../collaboration/collaboration.util';
 import { InjectKysely } from 'nestjs-kysely';
@ -13,7 +14,20 @@ import { generateSlugId } from '../../common/helpers';
 import { generateJitteredKeyBetween } from 'fractional-indexing-jittered';
 import { TiptapTransformer } from '@hocuspocus/transformer';
 import * as Y from 'yjs';
-import { markdownToHtml } from "@docmost/editor-ext";
+import { markdownToHtml } from '@docmost/editor-ext';
+import {
+  FileTaskStatus,
+  FileTaskType,
+  getFileTaskFolderPath,
+} from './file.utils';
+import { v7, v7 as uuid7 } from 'uuid';
+import { StorageService } from '../storage/storage.service';
+import { InjectQueue } from '@nestjs/bullmq';
+import { Queue } from 'bullmq';
+import { QueueJob, QueueName } from '../queue/constants';
+import { Node as PMNode } from '@tiptap/pm/model';
+import { EditorState, Transaction } from '@tiptap/pm/state';
+import { getSchema } from '@tiptap/core';

@Injectable()
 export class ImportService {
@ -21,7 +35,10 @@ export class ImportService {

  constructor(
    private readonly pageRepo: PageRepo,
+    private readonly storageService: StorageService,
    @InjectKysely() private readonly db: KyselyDB,
+    @InjectQueue(QueueName.FILE_TASK_QUEUE)
+    private readonly fileTaskQueue: Queue,
  ) {}

  async importPage(
@ -113,7 +130,7 @@ export class ImportService {

  async createYdoc(prosemirrorJson: any): Promise<Buffer | null> {
    if (prosemirrorJson) {
-      this.logger.debug(`Converting prosemirror json state to ydoc`);
+      // this.logger.debug(`Converting prosemirror json state to ydoc`);

      const ydoc = TiptapTransformer.toYdoc(
        prosemirrorJson,
@ -129,20 +146,34 @@ export class ImportService {
  }

  extractTitleAndRemoveHeading(prosemirrorState: any) {
-    let title = null;
+    let title: string | null = null;
+
+    const content = prosemirrorState.content ?? [];

    if (
-      prosemirrorState?.content?.length > 0 &&
-      prosemirrorState.content[0].type === 'heading' &&
-      prosemirrorState.content[0].attrs?.level === 1
+      content.length > 0 &&
+      content[0].type === 'heading' &&
+      content[0].attrs?.level === 1
    ) {
-      title = prosemirrorState.content[0].content[0].text;
-
-      // remove h1 header node from state
-      prosemirrorState.content.shift();
+      title = content[0].content?.[0]?.text ?? null;
+      content.shift();
    }

-    return { title, prosemirrorJson: prosemirrorState };
+    // ensure at least one paragraph
+    if (content.length === 0) {
+      content.push({
+        type: 'paragraph',
+        content: [],
+      });
+    }
+
+    return {
+      title,
+      prosemirrorJson: {
+        ...prosemirrorState,
+        content,
+      },
+    };
  }

  async getNewPagePosition(spaceId: string): Promise<string> {
@ -161,4 +192,141 @@ export class ImportService {
      return generateJitteredKeyBetween(null, null);
    }
  }
+
+  async importZip(
+    filePromise: Promise<MultipartFile>,
+    source: string,
+    userId: string,
+    spaceId: string,
+    workspaceId: string,
+  ): Promise<void> {
+    const file = await filePromise;
+    const fileBuffer = await file.toBuffer();
+    const fileExtension = path.extname(file.filename).toLowerCase();
+    const fileName = sanitize(
+      path.basename(file.filename, fileExtension).slice(0, 255),
+    );
+
+    const fileTaskId = uuid7();
+    const filePath = `${getFileTaskFolderPath(FileTaskType.Import, workspaceId)}/${fileTaskId}/${fileName}`;
+
+    // upload file
+    await this.storageService.upload(filePath, fileBuffer);
+
+    // store in fileTasks table
+    await this.db
+      .insertInto('fileTasks')
+      .values({
+        id: fileTaskId,
+        type: FileTaskType.Import,
+        source: source,
+        status: FileTaskStatus.Pending,
+        fileName: fileName,
+        filePath: filePath,
+        fileSize: 0,
+        fileExt: 'zip',
+        creatorId: userId,
+        spaceId: spaceId,
+        workspaceId: workspaceId,
+      })
+      .execute();
+
+    // what to send to queue
+    // pass the task ID
+    await this.fileTaskQueue.add(QueueJob.IMPORT_TASK, {
+      fileTaskId: fileTaskId,
+    });
+    // return tasks info
+
+    // when the processor picks it up
+    // we change the status to processing
+    // if it gets processed successfully,
+    // we change the status to success
+    // else failed
+  }
+
+  async markdownOrHtmlToProsemirror(
+    fileContent: string,
+    fileExtension: string,
+  ): Promise<any> {
+    let prosemirrorState = '';
+    if (fileExtension === '.md') {
+      prosemirrorState = await this.processMarkdown(fileContent);
+    } else if (fileExtension.endsWith('.html')) {
+      prosemirrorState = await this.processHTML(fileContent);
+    }
+    return prosemirrorState;
+  }
+
+  async convertInternalLinksToMentionsPM(
+    doc: PMNode,
+    currentFilePath: string,
+    filePathToPageMetaMap: Map<
+      string,
+      { id: string; title: string; slugId: string }
+    >,
+  ): Promise<PMNode> {
+    const schema = getSchema(tiptapExtensions);
+    const state = EditorState.create({ doc, schema });
+    let tr: Transaction = state.tr;
+
+    const normalizePath = (p: string) => p.replace(/\\/g, '/');
+
+    // Collect replacements from the original doc.
+    const replacements: Array<{
+      from: number;
+      to: number;
+      mentionNode: PMNode;
+    }> = [];
+
+    doc.descendants((node, pos) => {
+      if (!node.isText || !node.marks?.length) return;
+
+      // Look for the link mark
+      const linkMark = node.marks.find(
+        (mark) => mark.type.name === 'link' && mark.attrs?.href,
+      );
+      if (!linkMark) return;
+
+      // Compute the range for the entire text node.
+      const from = pos;
+      const to = pos + node.nodeSize;
+
+      // Resolve the path and get page meta.
+      const resolvedPath = normalizePath(
+        path.join(path.dirname(currentFilePath), linkMark.attrs.href),
+      );
+      const pageMeta = filePathToPageMetaMap.get(resolvedPath);
+      if (!pageMeta) return;
+
+      // Create the mention node with all required attributes.
+      const mentionNode = schema.nodes.mention.create({
+        id: v7(),
+        entityType: 'page',
+        entityId: pageMeta.id,
+        label: node.text || pageMeta.title,
+        slugId: pageMeta.slugId,
+        creatorId: 'not available', // This is required per your schema.
+      });
+
+      replacements.push({ from, to, mentionNode });
+    });
+
+    // Apply replacements in reverse order.
+    for (let i = replacements.length - 1; i >= 0; i--) {
+      const { from, to, mentionNode } = replacements[i];
+      try {
+        tr = tr.replaceWith(from, to, mentionNode);
+      } catch (err) {
+        console.error('❌ Failed to insert mention:', err);
+      }
+    }
+    if (tr.docChanged) {
+      console.log('doc changed');
+      console.log(JSON.stringify(state.apply(tr).doc.toJSON()));
+    }
+
+    // Return the updated document if any change was made.
+    return tr.docChanged ? state.apply(tr).doc : doc;
+  }
 }
--- a/apps/server/src/integrations/import/processors/file-task.processor.ts
+++ b/apps/server/src/integrations/import/processors/file-task.processor.ts
@ -0,0 +1,52 @@
+import { Logger, OnModuleDestroy } from '@nestjs/common';
+import { OnWorkerEvent, Processor, WorkerHost } from '@nestjs/bullmq';
+import { Job } from 'bullmq';
+import { QueueJob, QueueName } from 'src/integrations/queue/constants';
+import { FileTaskService } from '../file-task.service';
+
+@Processor(QueueName.FILE_TASK_QUEUE)
+export class FileTaskProcessor extends WorkerHost implements OnModuleDestroy {
+  private readonly logger = new Logger(FileTaskProcessor.name);
+  constructor(private readonly fileTaskService: FileTaskService) {
+    super();
+  }
+
+  async process(job: Job<any, void>): Promise<void> {
+    try {
+      switch (job.name) {
+        case QueueJob.IMPORT_TASK:
+          console.log('import task', job.data.fileTaskId);
+          await this.fileTaskService.processZIpImport(job.data.fileTaskId);
+          break;
+        case QueueJob.EXPORT_TASK:
+          console.log('export task', job.data.fileTaskId);
+      }
+    } catch (err) {
+      console.error(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/integrations/queue/constants/queue.constants.ts
+++ b/apps/server/src/integrations/queue/constants/queue.constants.ts
@ -3,6 +3,7 @@ export enum QueueName {
  ATTACHMENT_QUEUE = '{attachment-queue}',
  GENERAL_QUEUE = '{general-queue}',
  BILLING_QUEUE = '{billing-queue}',
+  FILE_TASK_QUEUE = '{file-task-queue}',
 }

 export enum QueueJob {
@ -19,4 +20,7 @@ export enum QueueJob {
  TRIAL_ENDED = 'trial-ended',
  WELCOME_EMAIL = 'welcome-email',
  FIRST_PAYMENT_EMAIL = 'first-payment-email',
+
+  IMPORT_TASK = 'import-task',
+  EXPORT_TASK = 'export-task',
 }
--- a/apps/server/src/integrations/queue/queue.module.ts
+++ b/apps/server/src/integrations/queue/queue.module.ts
@ -49,6 +49,9 @@ import { BacklinksProcessor } from './processors/backlinks.processor';
    BullModule.registerQueue({
      name: QueueName.BILLING_QUEUE,
    }),
+    BullModule.registerQueue({
+      name: QueueName.FILE_TASK_QUEUE,
+    }),
  ],
  exports: [BullModule],
  providers: [BacklinksProcessor],
--- a/apps/server/src/integrations/storage/drivers/local.driver.ts
+++ b/apps/server/src/integrations/storage/drivers/local.driver.ts
@ -3,8 +3,11 @@ import {
  LocalStorageConfig,
  StorageOption,
 } from '../interfaces';
-import { join } from 'path';
+import { join, dirname } from 'path';
 import * as fs from 'fs-extra';
+import { Readable } from 'stream';
+import { createReadStream, createWriteStream } from 'node:fs';
+import { pipeline } from 'node:stream/promises';

 export class LocalDriver implements StorageDriver {
  private readonly config: LocalStorageConfig;
@ -25,6 +28,16 @@ export class LocalDriver implements StorageDriver {
    }
  }

+  async uploadStream(filePath: string, file: Readable): Promise<void> {
+    try {
+      const fullPath = this._fullPath(filePath);
+      await fs.mkdir(dirname(fullPath), { recursive: true });
+      await pipeline(file, createWriteStream(fullPath));
+    } catch (err) {
+      throw new Error(`Failed to upload file: ${(err as Error).message}`);
+    }
+  }
+
  async copy(fromFilePath: string, toFilePath: string): Promise<void> {
    try {
      if (await this.exists(fromFilePath)) {
@ -43,6 +56,14 @@ export class LocalDriver implements StorageDriver {
    }
  }

+  async readStream(filePath: string): Promise<Readable> {
+    try {
+      return createReadStream(this._fullPath(filePath));
+    } catch (err) {
+      throw new Error(`Failed to read file: ${(err as Error).message}`);
+    }
+  }
+
  async exists(filePath: string): Promise<boolean> {
    try {
      return await fs.pathExists(this._fullPath(filePath));
--- a/apps/server/src/integrations/storage/drivers/s3.driver.ts
+++ b/apps/server/src/integrations/storage/drivers/s3.driver.ts
@ -12,6 +12,7 @@ import { streamToBuffer } from '../storage.utils';
 import { Readable } from 'stream';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
 import { getMimeType } from '../../../common/helpers';
+import { Upload } from '@aws-sdk/lib-storage';

 export class S3Driver implements StorageDriver {
  private readonly s3Client: S3Client;
@ -40,6 +41,26 @@ export class S3Driver implements StorageDriver {
    }
  }

+  async uploadStream(filePath: string, file: Readable): Promise<void> {
+    try {
+      const contentType = getMimeType(filePath);
+
+      const upload = new Upload({
+        client: this.s3Client,
+        params: {
+          Bucket: this.config.bucket,
+          Key: filePath,
+          Body: file,
+          ContentType: contentType,
+        },
+      });
+
+      await upload.done();
+    } catch (err) {
+      throw new Error(`Failed to upload file: ${(err as Error).message}`);
+    }
+  }
+
  async copy(fromFilePath: string, toFilePath: string): Promise<void> {
    try {
      if (await this.exists(fromFilePath)) {
@ -71,6 +92,21 @@ export class S3Driver implements StorageDriver {
    }
  }

+  async readStream(filePath: string): Promise<Readable> {
+    try {
+      const command = new GetObjectCommand({
+        Bucket: this.config.bucket,
+        Key: filePath,
+      });
+
+      const response = await this.s3Client.send(command);
+
+      return response.Body as Readable;
+    } catch (err) {
+      throw new Error(`Failed to read file from S3: ${(err as Error).message}`);
+    }
+  }
+
  async exists(filePath: string): Promise<boolean> {
    try {
      const command = new HeadObjectCommand({
--- a/apps/server/src/integrations/storage/interfaces/storage-driver.interface.ts
+++ b/apps/server/src/integrations/storage/interfaces/storage-driver.interface.ts
@ -1,10 +1,16 @@
+import { Readable } from 'stream';
+
 export interface StorageDriver {
  upload(filePath: string, file: Buffer): Promise<void>;

+  uploadStream(filePath: string, file: Readable): Promise<void>;
+
  copy(fromFilePath: string, toFilePath: string): Promise<void>;

  read(filePath: string): Promise<Buffer>;

+  readStream(filePath: string): Promise<Readable>;
+
  exists(filePath: string): Promise<boolean>;

  getUrl(filePath: string): string;
--- a/apps/server/src/integrations/storage/storage.service.ts
+++ b/apps/server/src/integrations/storage/storage.service.ts
@ -1,6 +1,7 @@
 import { Inject, Injectable, Logger } from '@nestjs/common';
 import { STORAGE_DRIVER_TOKEN } from './constants/storage.constants';
 import { StorageDriver } from './interfaces';
+import { Readable } from 'stream';

@Injectable()
 export class StorageService {
@ -14,6 +15,11 @@ export class StorageService {
    this.logger.debug(`File uploaded successfully. Path: ${filePath}`);
  }

+  async uploadStream(filePath: string, fileContent: Readable) {
+    await this.storageDriver.uploadStream(filePath, fileContent);
+    this.logger.debug(`File uploaded successfully. Path: ${filePath}`);
+  }
+
  async copy(fromFilePath: string, toFilePath: string) {
    await this.storageDriver.copy(fromFilePath, toFilePath);
    this.logger.debug(`File copied successfully. Path: ${toFilePath}`);
@ -23,6 +29,10 @@ export class StorageService {
    return this.storageDriver.read(filePath);
  }

+  async readStream(filePath: string): Promise<Readable> {
+    return this.storageDriver.readStream(filePath);
+  }
+
  async exists(filePath: string): Promise<boolean> {
    return this.storageDriver.exists(filePath);
  }
--- a/packages/editor-ext/src/lib/image/image.ts
+++ b/packages/editor-ext/src/lib/image/image.ts
@ -80,7 +80,7 @@ export const TiptapImage = Image.extend<ImageOptions>({
        default: undefined,
        parseHTML: (element) => element.getAttribute("data-attachment-id"),
        renderHTML: (attributes: ImageAttributes) => ({
-          "data-attachment-id": attributes.align,
+          "data-attachment-id": attributes.attachmentId,
        }),
      },
      size: {
--- a/packages/editor-ext/src/lib/trailing-node.ts
+++ b/packages/editor-ext/src/lib/trailing-node.ts
@ -51,8 +51,13 @@ export const TrailingNode = Extension.create<TrailingNodeExtensionOptions>({
        },
        state: {
          init: (_, state) => {
-            const lastNode = state.tr.doc.lastChild
-            return !nodeEqualsType({ node: lastNode, types: disabledNodes })
+            try {
+              const lastNode = state.tr.doc.lastChild
+              return !nodeEqualsType({ node: lastNode, types: disabledNodes })
+            } catch (err){
+              console.log(err)
+            }
+            return true;
          },
          apply: (tr, value) => {
            if (!tr.docChanged) {
--- a/packages/editor-ext/src/lib/video/video.ts
+++ b/packages/editor-ext/src/lib/video/video.ts
@ -57,7 +57,7 @@ export const TiptapVideo = Node.create<VideoOptions>({
        default: undefined,
        parseHTML: (element) => element.getAttribute("data-attachment-id"),
        renderHTML: (attributes: VideoAttributes) => ({
-          "data-attachment-id": attributes.align,
+          "data-attachment-id": attributes.attachmentId,
        }),
      },
      width: {
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@ -405,6 +405,9 @@ importers:
      '@aws-sdk/client-s3':
        specifier: 3.701.0
        version: 3.701.0
+      '@aws-sdk/lib-storage':
+        specifier: ^3.701.0
+        version: 3.817.0(@aws-sdk/client-s3@3.701.0)
      '@aws-sdk/s3-request-presigner':
        specifier: 3.701.0
        version: 3.701.0
@ -552,9 +555,15 @@ importers:
      stripe:
        specifier: ^17.5.0
        version: 17.5.0
+      tmp-promise:
+        specifier: ^3.0.3
+        version: 3.0.3
      ws:
        specifier: ^8.18.0
        version: 8.18.0
+      yauzl:
+        specifier: ^3.2.0
+        version: 3.2.0
    devDependencies:
      '@eslint/js':
        specifier: ^9.20.0
@ -604,6 +613,9 @@ importers:
      '@types/ws':
        specifier: ^8.5.14
        version: 8.5.14
+      '@types/yauzl':
+        specifier: ^2.10.3
+        version: 2.10.3
      eslint:
        specifier: ^9.20.1
        version: 9.20.1(jiti@1.21.0)
@ -769,6 +781,12 @@ packages:
    peerDependencies:
      '@aws-sdk/client-sts': ^3.696.0

+  '@aws-sdk/lib-storage@3.817.0':
+    resolution: {integrity: sha512-2zOO8+2EmiS049PjLSNdqmmZMQj7fzE1hZJ70A94vO+KNaVhVZYuMOOiOmwMw6ePkTCcFwK40vZIIXwEQQ1v1g==}
+    engines: {node: '>=18.0.0'}
+    peerDependencies:
+      '@aws-sdk/client-s3': ^3.817.0
+
  '@aws-sdk/middleware-bucket-endpoint@3.696.0':
    resolution: {integrity: sha512-V07jishKHUS5heRNGFpCWCSTjRJyQLynS/ncUeE8ZYtG66StOOQWftTwDfFOSoXlIqrXgb4oT9atryzXq7Z4LQ==}
    engines: {node: '>=16.0.0'}
@ -3173,6 +3191,10 @@ packages:
    resolution: {integrity: sha512-yiW0WI30zj8ZKoSYNx90no7ugVn3khlyH/z5W8qtKBtVE6awRALbhSG+2SAHA1r6bO/6M9utxYKVZ3PCJ1rWxw==}
    engines: {node: '>=16.0.0'}

+  '@smithy/abort-controller@4.0.3':
+    resolution: {integrity: sha512-AqXFf6DXnuRBXy4SoK/n1mfgHaKaq36bmkphmD1KO0nHq6xK/g9KHSW4HEsPQUBCGdIEfuJifGHwxFXPIFay9Q==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/chunked-blob-reader-native@3.0.1':
    resolution: {integrity: sha512-VEYtPvh5rs/xlyqpm5NRnfYLZn+q0SRPELbvBV+C/G7IQ+ouTuo+NKKa3ShG5OaFR8NYVMXls9hPYLTvIKKDrQ==}

@ -3187,6 +3209,10 @@ packages:
    resolution: {integrity: sha512-8olpW6mKCa0v+ibCjoCzgZHQx1SQmZuW/WkrdZo73wiTprTH6qhmskT60QLFdT9DRa5mXxjz89kQPZ7ZSsoqqg==}
    engines: {node: '>=16.0.0'}

+  '@smithy/core@3.4.0':
+    resolution: {integrity: sha512-dDYISQo7k0Ml/rXlFIjkTmTcQze/LxhtIRAEmZ6HJ/EI0inVxVEVnrUXJ7jPx6ZP0GHUhFm40iQcCgS5apXIXA==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/credential-provider-imds@3.2.8':
    resolution: {integrity: sha512-ZCY2yD0BY+K9iMXkkbnjo+08T2h8/34oHd0Jmh6BZUSZwaaGlGCyBT/3wnS7u7Xl33/EEfN4B6nQr3Gx5bYxgw==}
    engines: {node: '>=16.0.0'}
@ -3213,6 +3239,10 @@ packages:
  '@smithy/fetch-http-handler@4.1.3':
    resolution: {integrity: sha512-6SxNltSncI8s689nvnzZQc/dPXcpHQ34KUj6gR/HBroytKOd/isMG3gJF/zBE1TBmTT18TXyzhg3O3SOOqGEhA==}

+  '@smithy/fetch-http-handler@5.0.3':
+    resolution: {integrity: sha512-yBZwavI31roqTndNI7ONHqesfH01JmjJK6L3uUpZAhyAmr86LN5QiPzfyZGIxQmed8VEK2NRSQT3/JX5V1njfQ==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/hash-blob-browser@3.1.10':
    resolution: {integrity: sha512-elwslXOoNunmfS0fh55jHggyhccobFkexLYC1ZeZ1xP2BTSrcIBaHV2b4xUQOdctrSNOpMqOZH1r2XzWTEhyfA==}

@ -3235,6 +3265,10 @@ packages:
    resolution: {integrity: sha512-+Fsu6Q6C4RSJiy81Y8eApjEB5gVtM+oFKTffg+jSuwtvomJJrhUJBu2zS8wjXSgH/g1MKEWrzyChTBe6clb5FQ==}
    engines: {node: '>=16.0.0'}

+  '@smithy/is-array-buffer@4.0.0':
+    resolution: {integrity: sha512-saYhF8ZZNoJDTvJBEWgeBccCg+yvp1CX+ed12yORU3NilJScfc6gfch2oVb4QgxZrGUx3/ZJlb+c/dJbyupxlw==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/md5-js@3.0.11':
    resolution: {integrity: sha512-3NM0L3i2Zm4bbgG6Ymi9NBcxXhryi3uE8fIfHJZIOfZVxOkGdjdgjR9A06SFIZCfnEIWKXZdm6Yq5/aPXFFhsQ==}

@ -3246,6 +3280,10 @@ packages:
    resolution: {integrity: sha512-OEJZKVUEhMOqMs3ktrTWp7UvvluMJEvD5XgQwRePSbDg1VvBaL8pX8mwPltFn6wk1GySbcVwwyldL8S+iqnrEQ==}
    engines: {node: '>=16.0.0'}

+  '@smithy/middleware-endpoint@4.1.7':
+    resolution: {integrity: sha512-KDzM7Iajo6K7eIWNNtukykRT4eWwlHjCEsULZUaSfi/SRSBK8BPRqG5FsVfp58lUxcvre8GT8AIPIqndA0ERKw==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/middleware-retry@3.0.34':
    resolution: {integrity: sha512-yVRr/AAtPZlUvwEkrq7S3x7Z8/xCd97m2hLDaqdz6ucP2RKHsBjEqaUA2ebNv2SsZoPEi+ZD0dZbOB1u37tGCA==}
    engines: {node: '>=16.0.0'}
@ -3254,34 +3292,66 @@ packages:
    resolution: {integrity: sha512-KzPAeySp/fOoQA82TpnwItvX8BBURecpx6ZMu75EZDkAcnPtO6vf7q4aH5QHs/F1s3/snQaSFbbUMcFFZ086Mw==}
    engines: {node: '>=16.0.0'}

+  '@smithy/middleware-serde@4.0.6':
+    resolution: {integrity: sha512-YECyl7uNII+jCr/9qEmCu8xYL79cU0fqjo0qxpcVIU18dAPHam/iYwcknAu4Jiyw1uN+sAx7/SMf/Kmef/Jjsg==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/middleware-stack@3.0.11':
    resolution: {integrity: sha512-1HGo9a6/ikgOMrTrWL/WiN9N8GSVYpuRQO5kjstAq4CvV59bjqnh7TbdXGQ4vxLD3xlSjfBjq5t1SOELePsLnA==}
    engines: {node: '>=16.0.0'}

+  '@smithy/middleware-stack@4.0.3':
+    resolution: {integrity: sha512-baeV7t4jQfQtFxBADFmnhmqBmqR38dNU5cvEgHcMK/Kp3D3bEI0CouoX2Sr/rGuntR+Eg0IjXdxnGGTc6SbIkw==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/node-config-provider@3.1.12':
    resolution: {integrity: sha512-O9LVEu5J/u/FuNlZs+L7Ikn3lz7VB9hb0GtPT9MQeiBmtK8RSY3ULmsZgXhe6VAlgTw0YO+paQx4p8xdbs43vQ==}
    engines: {node: '>=16.0.0'}

+  '@smithy/node-config-provider@4.1.2':
+    resolution: {integrity: sha512-SUvNup8iU1v7fmM8XPk+27m36udmGCfSz+VZP5Gb0aJ3Ne0X28K/25gnsrg3X1rWlhcnhzNUUysKW/Ied46ivQ==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/node-http-handler@3.3.3':
    resolution: {integrity: sha512-BrpZOaZ4RCbcJ2igiSNG16S+kgAc65l/2hmxWdmhyoGWHTLlzQzr06PXavJp9OBlPEG/sHlqdxjWmjzV66+BSQ==}
    engines: {node: '>=16.0.0'}

+  '@smithy/node-http-handler@4.0.5':
+    resolution: {integrity: sha512-T7QglZC1vS7SPT44/1qSIAQEx5bFKb3LfO6zw/o4Xzt1eC5HNoH1TkS4lMYA9cWFbacUhx4hRl/blLun4EOCkg==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/property-provider@3.1.11':
    resolution: {integrity: sha512-I/+TMc4XTQ3QAjXfOcUWbSS073oOEAxgx4aZy8jHaf8JQnRkq2SZWw8+PfDtBvLUjcGMdxl+YwtzWe6i5uhL/A==}
    engines: {node: '>=16.0.0'}

+  '@smithy/property-provider@4.0.3':
+    resolution: {integrity: sha512-Wcn17QNdawJZcZZPBuMuzyBENVi1AXl4TdE0jvzo4vWX2x5df/oMlmr/9M5XAAC6+yae4kWZlOYIsNsgDrMU9A==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/protocol-http@4.1.8':
    resolution: {integrity: sha512-hmgIAVyxw1LySOwkgMIUN0kjN8TG9Nc85LJeEmEE/cNEe2rkHDUWhnJf2gxcSRFLWsyqWsrZGw40ROjUogg+Iw==}
    engines: {node: '>=16.0.0'}

+  '@smithy/protocol-http@5.1.1':
+    resolution: {integrity: sha512-Vsay2mzq05DwNi9jK01yCFtfvu9HimmgC7a4HTs7lhX12Sx8aWsH0mfz6q/02yspSp+lOB+Q2HJwi4IV2GKz7A==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/querystring-builder@3.0.11':
    resolution: {integrity: sha512-u+5HV/9uJaeLj5XTb6+IEF/dokWWkEqJ0XiaRRogyREmKGUgZnNecLucADLdauWFKUNbQfulHFEZEdjwEBjXRg==}
    engines: {node: '>=16.0.0'}

+  '@smithy/querystring-builder@4.0.3':
+    resolution: {integrity: sha512-UUzIWMVfPmDZcOutk2/r1vURZqavvQW0OHvgsyNV0cKupChvqg+/NKPRMaMEe+i8tP96IthMFeZOZWpV+E4RAw==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/querystring-parser@3.0.11':
    resolution: {integrity: sha512-Je3kFvCsFMnso1ilPwA7GtlbPaTixa3WwC+K21kmMZHsBEOZYQaqxcMqeFFoU7/slFjKDIpiiPydvdJm8Q/MCw==}
    engines: {node: '>=16.0.0'}

+  '@smithy/querystring-parser@4.0.3':
+    resolution: {integrity: sha512-K5M4ZJQpFCblOJ5Oyw7diICpFg1qhhR47m2/5Ef1PhGE19RaIZf50tjYFrxa6usqcuXyTiFPGo4d1geZdH4YcQ==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/service-error-classification@3.0.11':
    resolution: {integrity: sha512-QnYDPkyewrJzCyaeI2Rmp7pDwbUETe+hU8ADkXmgNusO1bgHBH7ovXJiYmba8t0fNfJx75fE8dlM6SEmZxheog==}
    engines: {node: '>=16.0.0'}
@ -3290,6 +3360,10 @@ packages:
    resolution: {integrity: sha512-1xKSGI+U9KKdbG2qDvIR9dGrw3CNx+baqJfyr0igKEpjbHL5stsqAesYBzHChYHlelWtb87VnLWlhvfCz13H8Q==}
    engines: {node: '>=16.0.0'}

+  '@smithy/shared-ini-file-loader@4.0.3':
+    resolution: {integrity: sha512-vHwlrqhZGIoLwaH8vvIjpHnloShqdJ7SUPNM2EQtEox+yEDFTVQ7E+DLZ+6OhnYEgFUwPByJyz6UZaOu2tny6A==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/signature-v4@4.2.4':
    resolution: {integrity: sha512-5JWeMQYg81TgU4cG+OexAWdvDTs5JDdbEZx+Qr1iPbvo91QFGzjy0IkXAKaXUHqmKUJgSHK0ZxnCkgZpzkeNTA==}
    engines: {node: '>=16.0.0'}
@ -3298,24 +3372,40 @@ packages:
    resolution: {integrity: sha512-9wYrjAZFlqWhgVo3C4y/9kpc68jgiSsKUnsFPzr/MSiRL93+QRDafGTfhhKAb2wsr69Ru87WTiqSfQusSmWipA==}
    engines: {node: '>=16.0.0'}

+  '@smithy/smithy-client@4.3.0':
+    resolution: {integrity: sha512-DNsRA38pN6tYHUjebmwD9e4KcgqTLldYQb2gC6K+oxXYdCTxPn6wV9+FvOa6wrU2FQEnGJoi+3GULzOTKck/tg==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/types@3.7.2':
    resolution: {integrity: sha512-bNwBYYmN8Eh9RyjS1p2gW6MIhSO2rl7X9QeLM8iTdcGRP+eDiIWDt66c9IysCc22gefKszZv+ubV9qZc7hdESg==}
    engines: {node: '>=16.0.0'}

-  '@smithy/types@4.1.0':
-    resolution: {integrity: sha512-enhjdwp4D7CXmwLtD6zbcDMbo6/T6WtuuKCY49Xxc6OMOmUWlBEBDREsxxgV2LIdeQPW756+f97GzcgAwp3iLw==}
+  '@smithy/types@4.3.0':
+    resolution: {integrity: sha512-+1iaIQHthDh9yaLhRzaoQxRk+l9xlk+JjMFxGRhNLz+m9vKOkjNeU8QuB4w3xvzHyVR/BVlp/4AXDHjoRIkfgQ==}
    engines: {node: '>=18.0.0'}

  '@smithy/url-parser@3.0.11':
    resolution: {integrity: sha512-TmlqXkSk8ZPhfc+SQutjmFr5FjC0av3GZP4B/10caK1SbRwe/v+Wzu/R6xEKxoNqL+8nY18s1byiy6HqPG37Aw==}

+  '@smithy/url-parser@4.0.3':
+    resolution: {integrity: sha512-n5/DnosDu/tweOqUUNtUbu7eRIR4J/Wz9nL7V5kFYQQVb8VYdj7a4G5NJHCw6o21ul7CvZoJkOpdTnsQDLT0tQ==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/util-base64@3.0.0':
    resolution: {integrity: sha512-Kxvoh5Qtt0CDsfajiZOCpJxgtPHXOKwmM+Zy4waD43UoEMA+qPxxa98aE/7ZhdnBFZFXMOiBR5xbcaMhLtznQQ==}
    engines: {node: '>=16.0.0'}

+  '@smithy/util-base64@4.0.0':
+    resolution: {integrity: sha512-CvHfCmO2mchox9kjrtzoHkWHxjHZzaFojLc8quxXY7WAAMAg43nuxwv95tATVgQFNDwd4M9S1qFzj40Ul41Kmg==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/util-body-length-browser@3.0.0':
    resolution: {integrity: sha512-cbjJs2A1mLYmqmyVl80uoLTJhAcfzMOyPgjwAYusWKMdLeNtzmMz9YxNl3/jRLoxSS3wkqkf0jwNdtXWtyEBaQ==}

+  '@smithy/util-body-length-browser@4.0.0':
+    resolution: {integrity: sha512-sNi3DL0/k64/LO3A256M+m3CDdG6V7WKWHdAiBBMUN8S3hK3aMPhwnPik2A/a2ONN+9doY9UxaLfgqsIRg69QA==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/util-body-length-node@3.0.0':
    resolution: {integrity: sha512-Tj7pZ4bUloNUP6PzwhN7K386tmSmEET9QtQg0TgdNOnxhZvCssHji+oZTUIuzxECRfG8rdm2PMw2WCFs6eIYkA==}
    engines: {node: '>=16.0.0'}
@ -3328,6 +3418,10 @@ packages:
    resolution: {integrity: sha512-aEOHCgq5RWFbP+UDPvPot26EJHjOC+bRgse5A8V3FSShqd5E5UN4qc7zkwsvJPPAVsf73QwYcHN1/gt/rtLwQA==}
    engines: {node: '>=16.0.0'}

+  '@smithy/util-buffer-from@4.0.0':
+    resolution: {integrity: sha512-9TOQ7781sZvddgO8nxueKi3+yGvkY35kotA0Y6BWRajAv8jjmigQ1sBwz0UX47pQMYXJPahSKEKYFgt+rXdcug==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/util-config-provider@3.0.0':
    resolution: {integrity: sha512-pbjk4s0fwq3Di/ANL+rCvJMKM5bzAQdE5S/6RL5NXgMExFAi6UgQMPOm5yPaIWPpr+EOXKXRonJ3FoxKf4mCJQ==}
    engines: {node: '>=16.0.0'}
@ -3348,10 +3442,18 @@ packages:
    resolution: {integrity: sha512-eFndh1WEK5YMUYvy3lPlVmYY/fZcQE1D8oSf41Id2vCeIkKJXPcYDCZD+4+xViI6b1XSd7tE+s5AmXzz5ilabQ==}
    engines: {node: '>=16.0.0'}

+  '@smithy/util-hex-encoding@4.0.0':
+    resolution: {integrity: sha512-Yk5mLhHtfIgW2W2WQZWSg5kuMZCVbvhFmC7rV4IO2QqnZdbEFPmQnCcGMAX2z/8Qj3B9hYYNjZOhWym+RwhePw==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/util-middleware@3.0.11':
    resolution: {integrity: sha512-dWpyc1e1R6VoXrwLoLDd57U1z6CwNSdkM69Ie4+6uYh2GC7Vg51Qtan7ITzczuVpqezdDTKJGJB95fFvvjU/ow==}
    engines: {node: '>=16.0.0'}

+  '@smithy/util-middleware@4.0.3':
+    resolution: {integrity: sha512-iIsC6qZXxkD7V3BzTw3b1uK8RVC1M8WvwNxK1PKrH9FnxntCd30CSunXjL/8iJBE8Z0J14r2P69njwIpRG4FBQ==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/util-retry@3.0.11':
    resolution: {integrity: sha512-hJUC6W7A3DQgaee3Hp9ZFcOxVDZzmBIRBPlUAk8/fSOEl7pE/aX7Dci0JycNOnm9Mfr0KV2XjIlUOcGWXQUdVQ==}
    engines: {node: '>=16.0.0'}
@ -3360,10 +3462,18 @@ packages:
    resolution: {integrity: sha512-SGhGBG/KupieJvJSZp/rfHHka8BFgj56eek9px4pp7lZbOF+fRiVr4U7A3y3zJD8uGhxq32C5D96HxsTC9BckQ==}
    engines: {node: '>=16.0.0'}

+  '@smithy/util-stream@4.2.1':
+    resolution: {integrity: sha512-W3IR0x5DY6iVtjj5p902oNhD+Bz7vs5S+p6tppbPa509rV9BdeXZjGuRSCtVEad9FA0Mba+tNUtUmtnSI1nwUw==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/util-uri-escape@3.0.0':
    resolution: {integrity: sha512-LqR7qYLgZTD7nWLBecUi4aqolw8Mhza9ArpNEQ881MJJIU2sE5iHCK6TdyqqzcDLy0OPe10IY4T8ctVdtynubg==}
    engines: {node: '>=16.0.0'}

+  '@smithy/util-uri-escape@4.0.0':
+    resolution: {integrity: sha512-77yfbCbQMtgtTylO9itEAdpPXSog3ZxMe09AEhm0dU0NLTalV70ghDZFR+Nfi1C60jnJoh/Re4090/DuZh2Omg==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/util-utf8@2.3.0':
    resolution: {integrity: sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A==}
    engines: {node: '>=14.0.0'}
@ -3372,6 +3482,10 @@ packages:
    resolution: {integrity: sha512-rUeT12bxFnplYDe815GXbq/oixEGHfRFFtcTF3YdDi/JaENIM6aSYYLJydG83UNzLXeRI5K8abYd/8Sp/QM0kA==}
    engines: {node: '>=16.0.0'}

+  '@smithy/util-utf8@4.0.0':
+    resolution: {integrity: sha512-b+zebfKCfRdgNJDknHCob3O7FpeYQN6ZG6YLExMcasDHsCXlsXCEuiPZeLnJLpwa5dvPetGlnGCiMHuLwGvFow==}
+    engines: {node: '>=18.0.0'}
+
  '@smithy/util-waiter@3.2.0':
    resolution: {integrity: sha512-PpjSboaDUE6yl+1qlg3Si57++e84oXdWGbuFUSAciXsVfEZJJJupR2Nb0QuXHiunt2vGR+1PTizOMvnUPaG2Qg==}
    engines: {node: '>=16.0.0'}
@ -4093,6 +4207,9 @@ packages:
  '@types/yargs@17.0.32':
    resolution: {integrity: sha512-xQ67Yc/laOG5uMfX/093MRlGGCIBzZMarVa+gfNKJxWAIgykYpVGkBdbqEzGDDfCrVUj6Hiff4mTZ5BA6TmAog==}

+  '@types/yauzl@2.10.3':
+    resolution: {integrity: sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==}
+
  '@typescript-eslint/eslint-plugin@8.17.0':
    resolution: {integrity: sha512-HU1KAdW3Tt8zQkdvNoIijfWDMvdSweFYm4hWh+KwhPstv+sCmWb89hCIP8msFm9N1R/ooh9honpSuvqKWlYy3w==}
    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
@ -4610,12 +4727,18 @@ packages:
  bser@2.1.1:
    resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==}

+  buffer-crc32@0.2.13:
+    resolution: {integrity: sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==}
+
  buffer-equal-constant-time@1.0.1:
    resolution: {integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==}

  buffer-from@1.1.2:
    resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}

+  buffer@5.6.0:
+    resolution: {integrity: sha512-/gDYp/UtU0eA1ys8bOs9J6a+E/KWIY+DZ+Q2WESNUA0jFRsJOc0SNUO6xJ5SGA1xueg3NL65W6s+NY5l9cunuw==}
+
  buffer@5.7.1:
    resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==}

@ -7196,6 +7319,9 @@ packages:
    resolution: {integrity: sha512-nri2TO5JE3/mRryik9LlHFT53cgHfRK0Lt0BAZQXku/AW3E6XLt2GaY8siWi7dvW/m1z0ecn+J+bpDa9ZN3IsQ==}
    engines: {node: '>=18'}

+  pend@1.2.0:
+    resolution: {integrity: sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==}
+
  pg-cloudflare@1.1.1:
    resolution: {integrity: sha512-xWPagP/4B6BgFO+EKz3JONXv3YDgvkbVrGw2mTo3D6tVDQRh1e7cqVGvyR3BE+eQgAvx1XhW/iEASj4/jCWl3Q==}

@ -8057,6 +8183,9 @@ packages:
    resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==}
    engines: {node: '>= 0.8'}

+  stream-browserify@3.0.0:
+    resolution: {integrity: sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==}
+
  streamsearch@1.1.0:
    resolution: {integrity: sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==}
    engines: {node: '>=10.0.0'}
@ -8248,6 +8377,9 @@ packages:
    resolution: {integrity: sha512-QNtgIqSUb9o2CoUjX9T5TwaIvUUJFU1+12PJkgt42DFV2yf9J6549yTF2uGloQsJ/JOC8X+gIB81ind97hRiIQ==}
    hasBin: true

+  tmp-promise@3.0.3:
+    resolution: {integrity: sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ==}
+
  tmp@0.0.33:
    resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==}
    engines: {node: '>=0.6.0'}
@ -8904,6 +9036,10 @@ packages:
    resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==}
    engines: {node: '>=12'}

+  yauzl@3.2.0:
+    resolution: {integrity: sha512-Ow9nuGZE+qp1u4JIPvg+uCiUr7xGQWdff7JQSk5VGYTAZMDe2q8lxJ10ygv10qmSj031Ty/6FNJpLO4o1Sgc+w==}
+    engines: {node: '>=12'}
+
  yjs@13.6.20:
    resolution: {integrity: sha512-Z2YZI+SYqK7XdWlloI3lhMiKnCdFCVC4PchpdO+mCYwtiTwncjUbnRK9R1JmkNfdmHyDXuWN3ibJAt0wsqTbLQ==}
    engines: {node: '>=16.0.0', npm: '>=8.0.0'}
@ -9334,6 +9470,17 @@ snapshots:
      '@smithy/types': 3.7.2
      tslib: 2.8.1

+  '@aws-sdk/lib-storage@3.817.0(@aws-sdk/client-s3@3.701.0)':
+    dependencies:
+      '@aws-sdk/client-s3': 3.701.0
+      '@smithy/abort-controller': 4.0.3
+      '@smithy/middleware-endpoint': 4.1.7
+      '@smithy/smithy-client': 4.3.0
+      buffer: 5.6.0
+      events: 3.3.0
+      stream-browserify: 3.0.0
+      tslib: 2.8.1
+
  '@aws-sdk/middleware-bucket-endpoint@3.696.0':
    dependencies:
      '@aws-sdk/types': 3.696.0
@ -9471,7 +9618,7 @@ snapshots:

  '@aws-sdk/types@3.734.0':
    dependencies:
-      '@smithy/types': 4.1.0
+      '@smithy/types': 4.3.0
      tslib: 2.8.1

  '@aws-sdk/util-arn-parser@3.693.0':
@ -12161,6 +12308,11 @@ snapshots:
      '@smithy/types': 3.7.2
      tslib: 2.8.1

+  '@smithy/abort-controller@4.0.3':
+    dependencies:
+      '@smithy/types': 4.3.0
+      tslib: 2.8.1
+
  '@smithy/chunked-blob-reader-native@3.0.1':
    dependencies:
      '@smithy/util-base64': 3.0.0
@ -12189,6 +12341,17 @@ snapshots:
      '@smithy/util-utf8': 3.0.0
      tslib: 2.8.1

+  '@smithy/core@3.4.0':
+    dependencies:
+      '@smithy/middleware-serde': 4.0.6
+      '@smithy/protocol-http': 5.1.1
+      '@smithy/types': 4.3.0
+      '@smithy/util-body-length-browser': 4.0.0
+      '@smithy/util-middleware': 4.0.3
+      '@smithy/util-stream': 4.2.1
+      '@smithy/util-utf8': 4.0.0
+      tslib: 2.8.1
+
  '@smithy/credential-provider-imds@3.2.8':
    dependencies:
      '@smithy/node-config-provider': 3.1.12
@ -12235,6 +12398,14 @@ snapshots:
      '@smithy/util-base64': 3.0.0
      tslib: 2.8.1

+  '@smithy/fetch-http-handler@5.0.3':
+    dependencies:
+      '@smithy/protocol-http': 5.1.1
+      '@smithy/querystring-builder': 4.0.3
+      '@smithy/types': 4.3.0
+      '@smithy/util-base64': 4.0.0
+      tslib: 2.8.1
+
  '@smithy/hash-blob-browser@3.1.10':
    dependencies:
      '@smithy/chunked-blob-reader': 4.0.0
@ -12268,6 +12439,10 @@ snapshots:
    dependencies:
      tslib: 2.8.1

+  '@smithy/is-array-buffer@4.0.0':
+    dependencies:
+      tslib: 2.8.1
+
  '@smithy/md5-js@3.0.11':
    dependencies:
      '@smithy/types': 3.7.2
@ -12291,6 +12466,17 @@ snapshots:
      '@smithy/util-middleware': 3.0.11
      tslib: 2.8.1

+  '@smithy/middleware-endpoint@4.1.7':
+    dependencies:
+      '@smithy/core': 3.4.0
+      '@smithy/middleware-serde': 4.0.6
+      '@smithy/node-config-provider': 4.1.2
+      '@smithy/shared-ini-file-loader': 4.0.3
+      '@smithy/types': 4.3.0
+      '@smithy/url-parser': 4.0.3
+      '@smithy/util-middleware': 4.0.3
+      tslib: 2.8.1
+
  '@smithy/middleware-retry@3.0.34':
    dependencies:
      '@smithy/node-config-provider': 3.1.12
@ -12308,11 +12494,22 @@ snapshots:
      '@smithy/types': 3.7.2
      tslib: 2.8.1

+  '@smithy/middleware-serde@4.0.6':
+    dependencies:
+      '@smithy/protocol-http': 5.1.1
+      '@smithy/types': 4.3.0
+      tslib: 2.8.1
+
  '@smithy/middleware-stack@3.0.11':
    dependencies:
      '@smithy/types': 3.7.2
      tslib: 2.8.1

+  '@smithy/middleware-stack@4.0.3':
+    dependencies:
+      '@smithy/types': 4.3.0
+      tslib: 2.8.1
+
  '@smithy/node-config-provider@3.1.12':
    dependencies:
      '@smithy/property-provider': 3.1.11
@ -12320,6 +12517,13 @@ snapshots:
      '@smithy/types': 3.7.2
      tslib: 2.8.1

+  '@smithy/node-config-provider@4.1.2':
+    dependencies:
+      '@smithy/property-provider': 4.0.3
+      '@smithy/shared-ini-file-loader': 4.0.3
+      '@smithy/types': 4.3.0
+      tslib: 2.8.1
+
  '@smithy/node-http-handler@3.3.3':
    dependencies:
      '@smithy/abort-controller': 3.1.9
@ -12328,27 +12532,56 @@ snapshots:
      '@smithy/types': 3.7.2
      tslib: 2.8.1

+  '@smithy/node-http-handler@4.0.5':
+    dependencies:
+      '@smithy/abort-controller': 4.0.3
+      '@smithy/protocol-http': 5.1.1
+      '@smithy/querystring-builder': 4.0.3
+      '@smithy/types': 4.3.0
+      tslib: 2.8.1
+
  '@smithy/property-provider@3.1.11':
    dependencies:
      '@smithy/types': 3.7.2
      tslib: 2.8.1

+  '@smithy/property-provider@4.0.3':
+    dependencies:
+      '@smithy/types': 4.3.0
+      tslib: 2.8.1
+
  '@smithy/protocol-http@4.1.8':
    dependencies:
      '@smithy/types': 3.7.2
      tslib: 2.8.1

+  '@smithy/protocol-http@5.1.1':
+    dependencies:
+      '@smithy/types': 4.3.0
+      tslib: 2.8.1
+
  '@smithy/querystring-builder@3.0.11':
    dependencies:
      '@smithy/types': 3.7.2
      '@smithy/util-uri-escape': 3.0.0
      tslib: 2.8.1

+  '@smithy/querystring-builder@4.0.3':
+    dependencies:
+      '@smithy/types': 4.3.0
+      '@smithy/util-uri-escape': 4.0.0
+      tslib: 2.8.1
+
  '@smithy/querystring-parser@3.0.11':
    dependencies:
      '@smithy/types': 3.7.2
      tslib: 2.8.1

+  '@smithy/querystring-parser@4.0.3':
+    dependencies:
+      '@smithy/types': 4.3.0
+      tslib: 2.8.1
+
  '@smithy/service-error-classification@3.0.11':
    dependencies:
      '@smithy/types': 3.7.2
@ -12358,6 +12591,11 @@ snapshots:
      '@smithy/types': 3.7.2
      tslib: 2.8.1

+  '@smithy/shared-ini-file-loader@4.0.3':
+    dependencies:
+      '@smithy/types': 4.3.0
+      tslib: 2.8.1
+
  '@smithy/signature-v4@4.2.4':
    dependencies:
      '@smithy/is-array-buffer': 3.0.0
@ -12379,11 +12617,21 @@ snapshots:
      '@smithy/util-stream': 3.3.4
      tslib: 2.8.1

+  '@smithy/smithy-client@4.3.0':
+    dependencies:
+      '@smithy/core': 3.4.0
+      '@smithy/middleware-endpoint': 4.1.7
+      '@smithy/middleware-stack': 4.0.3
+      '@smithy/protocol-http': 5.1.1
+      '@smithy/types': 4.3.0
+      '@smithy/util-stream': 4.2.1
+      tslib: 2.8.1
+
  '@smithy/types@3.7.2':
    dependencies:
      tslib: 2.8.1

-  '@smithy/types@4.1.0':
+  '@smithy/types@4.3.0':
    dependencies:
      tslib: 2.8.1

@ -12393,16 +12641,32 @@ snapshots:
      '@smithy/types': 3.7.2
      tslib: 2.8.1

+  '@smithy/url-parser@4.0.3':
+    dependencies:
+      '@smithy/querystring-parser': 4.0.3
+      '@smithy/types': 4.3.0
+      tslib: 2.8.1
+
  '@smithy/util-base64@3.0.0':
    dependencies:
      '@smithy/util-buffer-from': 3.0.0
      '@smithy/util-utf8': 3.0.0
      tslib: 2.8.1

+  '@smithy/util-base64@4.0.0':
+    dependencies:
+      '@smithy/util-buffer-from': 4.0.0
+      '@smithy/util-utf8': 4.0.0
+      tslib: 2.8.1
+
  '@smithy/util-body-length-browser@3.0.0':
    dependencies:
      tslib: 2.8.1

+  '@smithy/util-body-length-browser@4.0.0':
+    dependencies:
+      tslib: 2.8.1
+
  '@smithy/util-body-length-node@3.0.0':
    dependencies:
      tslib: 2.8.1
@ -12417,6 +12681,11 @@ snapshots:
      '@smithy/is-array-buffer': 3.0.0
      tslib: 2.8.1

+  '@smithy/util-buffer-from@4.0.0':
+    dependencies:
+      '@smithy/is-array-buffer': 4.0.0
+      tslib: 2.8.1
+
  '@smithy/util-config-provider@3.0.0':
    dependencies:
      tslib: 2.8.1
@ -12449,11 +12718,20 @@ snapshots:
    dependencies:
      tslib: 2.8.1

+  '@smithy/util-hex-encoding@4.0.0':
+    dependencies:
+      tslib: 2.8.1
+
  '@smithy/util-middleware@3.0.11':
    dependencies:
      '@smithy/types': 3.7.2
      tslib: 2.8.1

+  '@smithy/util-middleware@4.0.3':
+    dependencies:
+      '@smithy/types': 4.3.0
+      tslib: 2.8.1
+
  '@smithy/util-retry@3.0.11':
    dependencies:
      '@smithy/service-error-classification': 3.0.11
@ -12471,10 +12749,25 @@ snapshots:
      '@smithy/util-utf8': 3.0.0
      tslib: 2.8.1

+  '@smithy/util-stream@4.2.1':
+    dependencies:
+      '@smithy/fetch-http-handler': 5.0.3
+      '@smithy/node-http-handler': 4.0.5
+      '@smithy/types': 4.3.0
+      '@smithy/util-base64': 4.0.0
+      '@smithy/util-buffer-from': 4.0.0
+      '@smithy/util-hex-encoding': 4.0.0
+      '@smithy/util-utf8': 4.0.0
+      tslib: 2.8.1
+
  '@smithy/util-uri-escape@3.0.0':
    dependencies:
      tslib: 2.8.1

+  '@smithy/util-uri-escape@4.0.0':
+    dependencies:
+      tslib: 2.8.1
+
  '@smithy/util-utf8@2.3.0':
    dependencies:
      '@smithy/util-buffer-from': 2.2.0
@ -12485,6 +12778,11 @@ snapshots:
      '@smithy/util-buffer-from': 3.0.0
      tslib: 2.8.1

+  '@smithy/util-utf8@4.0.0':
+    dependencies:
+      '@smithy/util-buffer-from': 4.0.0
+      tslib: 2.8.1
+
  '@smithy/util-waiter@3.2.0':
    dependencies:
      '@smithy/abort-controller': 3.1.9
@ -13261,6 +13559,10 @@ snapshots:
    dependencies:
      '@types/yargs-parser': 21.0.3

+  '@types/yauzl@2.10.3':
+    dependencies:
+      '@types/node': 22.13.4
+
  '@typescript-eslint/eslint-plugin@8.17.0(@typescript-eslint/parser@8.17.0(eslint@9.15.0(jiti@1.21.0))(typescript@5.7.2))(eslint@9.15.0(jiti@1.21.0))(typescript@5.7.2)':
    dependencies:
      '@eslint-community/regexpp': 4.12.1
@ -13959,10 +14261,17 @@ snapshots:
    dependencies:
      node-int64: 0.4.0

+  buffer-crc32@0.2.13: {}
+
  buffer-equal-constant-time@1.0.1: {}

  buffer-from@1.1.2: {}

+  buffer@5.6.0:
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+
  buffer@5.7.1:
    dependencies:
      base64-js: 1.5.1
@ -16994,6 +17303,8 @@ snapshots:

  peek-readable@7.0.0: {}

+  pend@1.2.0: {}
+
  pg-cloudflare@1.1.1:
    optional: true

@ -17948,6 +18259,11 @@ snapshots:

  statuses@2.0.1: {}

+  stream-browserify@3.0.0:
+    dependencies:
+      inherits: 2.0.4
+      readable-stream: 3.6.2
+
  streamsearch@1.1.0: {}

  string-length@4.0.2:
@ -18163,6 +18479,10 @@ snapshots:
    dependencies:
      tldts-core: 6.1.72

+  tmp-promise@3.0.3:
+    dependencies:
+      tmp: 0.2.1
+
  tmp@0.0.33:
    dependencies:
      os-tmpdir: 1.0.2
@ -18759,6 +19079,11 @@ snapshots:
      y18n: 5.0.8
      yargs-parser: 21.1.1

+  yauzl@3.2.0:
+    dependencies:
+      buffer-crc32: 0.2.13
+      pend: 1.2.0
+
  yjs@13.6.20:
    dependencies:
      lib0: 0.2.98
Author	SHA1	Message	Date
Philipinho	3bbf7c4475	notion formatter	2025-05-25 20:06:21 -07:00
Philipinho	ca23c9a4f2	WIP	2025-05-25 17:59:28 -07:00
Philipinho	065f888c32	feat: add stream upload support and improve file handling - Add stream upload functionality to storage drivers\n- Improve ZIP file extraction with better encoding handling\n- Fix attachment ID rendering issues\n- Add AWS S3 upload stream support\n- Update dependencies for better compatibility	2025-05-23 22:31:37 -07:00
Philipinho	ec533934de	turndown video tag	2025-05-23 12:40:34 -07:00
Philipinho	ef2a6be59b	fix attachmentId render	2025-05-22 12:51:25 -07:00
Philipinho	915b31b8bd	fix attachmentId render	2025-05-22 12:50:30 -07:00
Philipinho	e2b8899569	WIP	2025-05-21 23:40:43 -07:00
Philipinho	f6e3230eec	Add readstream	2025-05-21 10:58:40 -07:00
Philipinho	625bdc7024	refactor imports - WIP	2025-05-21 10:53:03 -07:00