collabmd 0.1.35 → 0.1.36

package/src/client/styles/features/embedded-preview.css

@@ -75,13 +75,12 @@
 
 .preview-content .mermaid-toolbar,
 .mermaid-maximized-root .mermaid-toolbar {
-  justify-content: flex-end;
+  width: 100%;
 }
 
 .preview-content .mermaid-zoom-btn,
 .mermaid-maximized-root .mermaid-zoom-btn {
-  min-width: 32px;
-  line-height: 1.5;
+  flex-shrink: 0;
 }
 
 .preview-content .mermaid-zoom-btn:disabled,
@@ -174,13 +173,12 @@ body.mermaid-maximized-open::before {
 
 .preview-content .plantuml-toolbar,
 .plantuml-maximized-root .plantuml-toolbar {
-  justify-content: flex-end;
+  width: 100%;
 }
 
 .preview-content .plantuml-tool-btn,
 .plantuml-maximized-root .plantuml-tool-btn {
-  min-width: 32px;
-  line-height: 1.5;
+  flex-shrink: 0;
 }
 
 .preview-content .plantuml-frame,

package/src/client/styles/features/media-lightbox.css

@@ -68,6 +68,8 @@
 
 .image-lightbox-btn {
   min-width: 0;
+  min-height: 40px;
+  min-width: 40px;
   padding: 8px 12px;
   border: none;
   border-radius: var(--radius-full);

package/src/server/config/env.js

@@ -322,6 +322,10 @@ export function loadConfig(overrides = {}) {
     httpRequestTimeoutMs: parsePositiveInt(process.env.HTTP_REQUEST_TIMEOUT_MS, 30_000),
     git,
     gitEnabled: git.enabled,
+    maxArchiveEntries: parsePositiveInt(process.env.COLLABMD_MAX_ARCHIVE_ENTRIES, 10_000),
+    maxBaseQueryRows: parsePositiveInt(process.env.COLLABMD_MAX_BASE_QUERY_ROWS, 5_000),
+    maxDownloadFileBytes: parsePositiveInt(process.env.COLLABMD_MAX_DOWNLOAD_FILE_BYTES, 268_435_456),
+    maxInitialSyncBytes: parsePositiveInt(process.env.COLLABMD_MAX_INITIAL_SYNC_BYTES, 16_777_216),
     perfLoggingEnabled: overrides.perfLoggingEnabled ?? isPerfLoggingEnabled(process.env.COLLABMD_PERF_LOGGING),
     port: parsePort(process.env.PORT, 1234),
     nodeEnv,

package/src/server/create-app-server.js

@@ -77,6 +77,7 @@ export function createAppServer(config = loadConfig()) {
   let fileSystemSyncService = null;
   let workspaceMutationCoordinator = null;
   const baseQueryService = new BaseQueryService({
+    maxResultRows: config.maxBaseQueryRows,
     vaultFileStore,
     workspaceStateProvider: () => workspaceMutationCoordinator?.workspaceState ?? null,
     workspaceStateSynchronizer: () => fileSystemSyncService?.flushPendingChanges?.(),
@@ -104,6 +105,7 @@ export function createAppServer(config = loadConfig()) {
         }),
         getHydrateDelayMs: () => testControls.wsRoomHydrateDelayMs,
         idleGraceMs: config.wsRoomIdleGraceMs,
+        maxInitialSyncBytes: config.maxInitialSyncBytes,
         maxBufferedAmountBytes: config.wsMaxBufferedAmountBytes,
         name,
         onEmpty,

package/src/server/domain/bases/base-query-service.js

@@ -53,6 +53,32 @@ function sortRows(rows, sortChain = []) {
   });
 }
 
+function compareRowsBySortChain(left, right, sortChain = []) {
+  for (const sortConfig of sortChain) {
+    const delta = compareValues(left.rawCells[sortConfig.property], right.rawCells[sortConfig.property]);
+    if (delta !== 0) {
+      return sortConfig.direction === 'desc' ? -delta : delta;
+    }
+  }
+
+  return String(left.file.path ?? '').localeCompare(String(right.file.path ?? ''));
+}
+
+function insertSortedBounded(rows, row, {
+  limit,
+  sortChain = [],
+}) {
+  let insertIndex = rows.findIndex((existingRow) => compareRowsBySortChain(row, existingRow, sortChain) < 0);
+  if (insertIndex === -1) {
+    insertIndex = rows.length;
+  }
+
+  rows.splice(insertIndex, 0, row);
+  if (rows.length > limit) {
+    rows.pop();
+  }
+}
+
 function escapeRegExp(value = '') {
   return String(value ?? '').replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
 }
@@ -102,16 +128,19 @@ function pruneFilterNodeForProperty(filterNode, propertyId = '') {
 
 export class BaseQueryService {
   constructor({
+    maxResultRows = 5_000,
     vaultFileStore,
     workspaceStateProvider = null,
     workspaceStateSynchronizer = null,
   }) {
+    this.maxResultRows = maxResultRows;
     this.vaultFileStore = vaultFileStore;
     this.snapshotStore = new BaseIndexSnapshotStore({
       vaultFileStore,
       workspaceStateProvider,
       workspaceStateSynchronizer,
     });
+    this.definitionCache = new Map();
     this.propertyCatalogCache = new Map();
   }
 
@@ -202,6 +231,25 @@ export class BaseQueryService {
     return result;
   }
 
+  getCachedDefinition(cacheKey, baseSource) {
+    const sourceText = String(baseSource ?? '');
+    const existing = this.definitionCache.get(cacheKey);
+    if (existing?.source === sourceText) {
+      return existing.definition;
+    }
+
+    const definition = normalizeBaseDefinition(sourceText);
+    this.definitionCache.set(cacheKey, {
+      definition,
+      source: sourceText,
+    });
+    if (this.definitionCache.size > 50) {
+      const firstKey = this.definitionCache.keys().next().value;
+      this.definitionCache.delete(firstKey);
+    }
+    return definition;
+  }
+
   invalidatePropertyCatalogsExcept(scannedAt = '') {
     Array.from(this.propertyCatalogCache.keys()).forEach((cacheKey) => {
       if (cacheKey !== scannedAt) {
@@ -222,7 +270,7 @@ export class BaseQueryService {
       throw new Error('Base source not found');
     }
 
-    const definition = normalizeBaseDefinition(baseSource);
+    const definition = this.getCachedDefinition(source === null ? `file:${basePath}` : `source:${sourcePath}:${basePath}`, baseSource);
     const snapshot = await this.ensureIndexSnapshot({
       basePath,
       sourcePath,
@@ -251,12 +299,24 @@ export class BaseQueryService {
   collectCandidateRows({
     activeView,
     astCache = new Map(),
+    columns = [],
     definition,
     evaluatedPropertyIds,
+    limit = null,
+    maxRows = this.maxResultRows,
     snapshot,
+    sortChain = [],
+    search = '',
     thisFile,
   }) {
     const rows = [];
+    const effectiveMaxRows = Number.isInteger(maxRows) && maxRows > 0 ? maxRows : Infinity;
+    const effectiveLimit = Number.isInteger(limit) && limit > 0 ? limit : Infinity;
+    const canBoundDuringCollection = Number.isFinite(Math.min(effectiveLimit, effectiveMaxRows))
+      && sortChain.length > 0
+      && !activeView.groupBy?.property
+      && (activeView.summaries?.length ?? 0) === 0;
+    const hardLimit = Math.min(effectiveLimit, effectiveMaxRows);
 
     snapshot.filePaths.forEach((filePath) => {
       const row = snapshot.rowsByPath.get(filePath);
@@ -280,10 +340,23 @@ export class BaseQueryService {
         rawCells[propertyId] = getPropertyValue(propertyId, row, definition, snapshot, thisFile, rowContext);
       });
 
-      rows.push({
+      const candidateRow = {
         file: row.file,
         rawCells,
-      });
+      };
+      if (!rowMatchesSearch(candidateRow, columns, search)) {
+        return;
+      }
+
+      if (canBoundDuringCollection) {
+        insertSortedBounded(rows, candidateRow, {
+          limit: hardLimit,
+          sortChain,
+        });
+        return;
+      }
+
+      rows.push(candidateRow);
     });
 
     return rows;
@@ -378,15 +451,24 @@ export class BaseQueryService {
     });
 
     const astCache = new Map();
+    const sortChain = buildSortChain(context.activeView);
+    const requestedLimit = Number.isInteger(context.activeView.limit) && context.activeView.limit > 0
+      ? context.activeView.limit
+      : null;
     let rows = this.collectCandidateRows({
       ...context,
       astCache,
+      limit: requestedLimit,
+      maxRows: this.maxResultRows,
+      search,
+      sortChain,
     });
-    rows = rows.filter((row) => rowMatchesSearch(row, context.columns, search));
-    rows = sortRows(rows, buildSortChain(context.activeView));
+    rows = sortRows(rows, sortChain);
 
-    if (context.activeView.limit != null) {
-      rows = rows.slice(0, context.activeView.limit);
+    if (requestedLimit != null) {
+      rows = rows.slice(0, Math.min(requestedLimit, this.maxResultRows));
+    } else if (Number.isInteger(this.maxResultRows) && this.maxResultRows > 0) {
+      rows = rows.slice(0, this.maxResultRows);
     }
 
     const payload = buildQueryResultPayload({

package/src/server/domain/collaboration/collaboration-room.js

@@ -165,6 +165,7 @@ export class CollaborationRoom {
     getHydrateDelayMs = null,
     name,
     idleGraceMs = 0,
+    maxInitialSyncBytes = 16_777_216,
     maxBufferedAmountBytes,
     perfLoggingEnabled = false,
     vaultFileStore,
@@ -173,6 +174,7 @@ export class CollaborationRoom {
   }) {
     this.name = name;
     this.idleGraceMs = idleGraceMs;
+    this.maxInitialSyncBytes = maxInitialSyncBytes;
     this.maxBufferedAmountBytes = maxBufferedAmountBytes;
     this.perfLoggingEnabled = perfLoggingEnabled;
     this.documentStore = documentStore ?? new CollaborationDocumentStore({
@@ -576,10 +578,17 @@ export class CollaborationRoom {
     this.debugMetrics.initialSyncCount += 1;
     this.debugMetrics.lastInitialSyncAt = Date.now();
     const initialSyncMessage = this.getInitialSyncMessage();
+    const initialSyncBytes = initialSyncMessage.byteLength;
+    if (initialSyncBytes > this.maxInitialSyncBytes) {
+      console.warn(
+        `[room:${this.name}] Initial sync payload is ${initialSyncBytes} bytes, exceeding ${this.maxInitialSyncBytes} bytes`,
+      );
+    }
     logPerfEvent(this.perfLoggingEnabled, `room:${this.name}`, {
-      bytes: initialSyncMessage.byteLength,
+      bytes: initialSyncBytes,
       count: this.debugMetrics.initialSyncCount,
       event: 'initial-sync',
+      exceedsLimit: initialSyncBytes > this.maxInitialSyncBytes,
     });
     return sendMessage.call(this, ws, initialSyncMessage, this);
   }

package/src/server/infrastructure/http/create-request-handler.js

@@ -63,6 +63,7 @@ export function createRequestHandler(
   const handleVaultApi = createVaultApiHandler({
     baseQueryService,
     backlinkIndex,
+    config,
     docxExporter,
     plantUmlRenderer,
     roomRegistry,

package/src/server/infrastructure/http/create-vault-api-handler.js

@@ -5,6 +5,7 @@ import { createVaultApiQueryHandler } from './create-vault-api-query-handler.js'
 export function createVaultApiHandler({
   baseQueryService = null,
   backlinkIndex,
+  config = {},
   docxExporter = null,
   plantUmlRenderer = null,
   roomRegistry = null,
@@ -14,6 +15,7 @@ export function createVaultApiHandler({
   const handleVaultApiQuery = createVaultApiQueryHandler({
     baseQueryService,
     backlinkIndex,
+    config,
     vaultFileStore,
     workspaceMutationCoordinator,
   });

package/src/server/infrastructure/http/create-vault-api-query-handler.js

@@ -1,5 +1,7 @@
 import archiver from 'archiver';
+import { readdir } from 'node:fs/promises';
 import { basename } from 'node:path';
+import { join } from 'node:path';
 
 import {
   isBaseFilePath,
@@ -9,11 +11,14 @@ import {
   isMermaidFilePath,
   isPlantUmlFilePath,
 } from '../../../domain/file-kind.js';
+import { isIgnoredVaultEntry } from '../persistence/path-utils.js';
 import { parseJsonBody } from './request-body.js';
 import { jsonResponse, sendResponse, sendStreamResponse } from './http-response.js';
 
 const SVG_MIME_TYPE = 'image/svg+xml';
 const SVG_ATTACHMENT_CSP = "default-src 'none'; img-src 'self' data: blob:; style-src 'unsafe-inline'; sandbox";
+const DEFAULT_MAX_ARCHIVE_ENTRIES = 10_000;
+const DEFAULT_MAX_DOWNLOAD_FILE_BYTES = 268_435_456;
 
 function encodeContentDispositionFilename(fileName) {
   return encodeURIComponent(String(fileName ?? ''))
@@ -78,7 +83,8 @@ function selectReadOperation(vaultFileStore, filePath) {
 }
 
 async function streamDirectoryArchive(req, res, {
-  entries = [],
+  maxEntries = 10_000,
+  rootAbsolutePath = '',
   rootName = 'archive',
 } = {}) {
   const archive = archiver('zip', {
@@ -99,22 +105,62 @@ async function streamDirectoryArchive(req, res, {
     stream: archive,
   });
 
-  for (const entry of entries) {
-    if (entry.type === 'directory') {
-      const directoryName = entry.path
-        ? `${rootName}/${entry.path}/`
-        : `${rootName}/`;
-      archive.append('', { name: directoryName });
-      continue;
+  let entryCount = 0;
+  const appendEntry = () => {
+    entryCount += 1;
+    if (entryCount > maxEntries) {
+      throw new Error(`Directory archive exceeds ${maxEntries} entries`);
     }
+  };
 
-    archive.file(entry.absolutePath, {
-      name: `${rootName}/${entry.path}`,
-    });
-  }
+  try {
+    const visitDirectory = async (directoryAbsolutePath, relativeDirectoryPath = '') => {
+      const dirEntries = (await readdir(directoryAbsolutePath, { withFileTypes: true }))
+        .filter((entry) => !isIgnoredVaultEntry(entry.name))
+        .sort((left, right) => {
+          if (left.isDirectory() && !right.isDirectory()) return -1;
+          if (!left.isDirectory() && right.isDirectory()) return 1;
+          return left.name.localeCompare(right.name, undefined, { sensitivity: 'base' });
+        });
+
+      if (dirEntries.length === 0) {
+        appendEntry();
+        archive.append('', {
+          name: relativeDirectoryPath ? `${rootName}/${relativeDirectoryPath}/` : `${rootName}/`,
+        });
+        return;
+      }
 
-  await archive.finalize();
-  await responsePromise;
+      for (const entry of dirEntries) {
+        const childAbsolutePath = join(directoryAbsolutePath, entry.name);
+        const childRelativePath = relativeDirectoryPath
+          ? `${relativeDirectoryPath}/${entry.name}`
+          : entry.name;
+
+        if (entry.isDirectory()) {
+          await visitDirectory(childAbsolutePath, childRelativePath);
+          continue;
+        }
+
+        if (!entry.isFile()) {
+          continue;
+        }
+
+        appendEntry();
+        archive.file(childAbsolutePath, {
+          name: `${rootName}/${childRelativePath}`,
+        });
+      }
+    };
+
+    await visitDirectory(rootAbsolutePath);
+    await archive.finalize();
+    await responsePromise;
+  } catch (error) {
+    archive.destroy(error);
+    await responsePromise.catch(() => {});
+    throw error;
+  }
 }
 
 // --- Route handlers ---
@@ -257,7 +303,7 @@ async function handleFileRead(req, res, requestUrl, { vaultFileStore }) {
   }
 }
 
-async function handleFileDownload(req, res, requestUrl, { vaultFileStore }) {
+async function handleFileDownload(req, res, requestUrl, { config, vaultFileStore }) {
   const filePath = requestUrl.searchParams.get('path');
   if (!filePath) {
     jsonResponse(req, res, 400, { error: 'Missing path parameter' });
@@ -265,19 +311,25 @@ async function handleFileDownload(req, res, requestUrl, { vaultFileStore }) {
   }
 
   try {
-    const download = await vaultFileStore.readDownloadFile(filePath);
+    const download = await vaultFileStore.openDownloadFileStream(filePath, {
+      maxBytes: config.maxDownloadFileBytes ?? DEFAULT_MAX_DOWNLOAD_FILE_BYTES,
+    });
     if (!download) {
       jsonResponse(req, res, 404, { error: 'File not found' });
       return;
     }
+    if (download.error) {
+      jsonResponse(req, res, download.statusCode || 400, { error: download.error });
+      return;
+    }
 
-    sendResponse(req, res, {
-      body: download.content,
+    await sendStreamResponse(req, res, {
       headers: createDownloadHeaders(
         basename(String(download.path ?? 'download')),
         download.mimeType || 'application/octet-stream',
       ),
       statusCode: 200,
+      stream: download.stream,
     });
   } catch (error) {
     console.error('[api] Failed to download file:', error.message);
@@ -285,7 +337,7 @@ async function handleFileDownload(req, res, requestUrl, { vaultFileStore }) {
   }
 }
 
-async function handleDirectoryDownload(req, res, requestUrl, { vaultFileStore }) {
+async function handleDirectoryDownload(req, res, requestUrl, { config, vaultFileStore }) {
   const directoryPath = requestUrl.searchParams.get('path');
   if (!directoryPath) {
     jsonResponse(req, res, 400, { error: 'Missing path parameter' });
@@ -293,14 +345,23 @@ async function handleDirectoryDownload(req, res, requestUrl, { vaultFileStore })
   }
 
   try {
-    const result = await vaultFileStore.listDirectoryEntriesForDownload(directoryPath);
+    const result = await vaultFileStore.resolveDirectoryDownloadRoot(directoryPath);
     if (!result.ok) {
       jsonResponse(req, res, result.error === 'Directory not found' ? 404 : 400, { error: result.error });
       return;
     }
+    const maxArchiveEntries = config.maxArchiveEntries ?? DEFAULT_MAX_ARCHIVE_ENTRIES;
+    const entryCount = await vaultFileStore.countDirectoryDownloadEntries(result.absolute, {
+      maxEntries: maxArchiveEntries,
+    });
+    if (!entryCount.withinLimit) {
+      jsonResponse(req, res, 413, { error: `Directory archive exceeds ${maxArchiveEntries} entries` });
+      return;
+    }
 
     await streamDirectoryArchive(req, res, {
-      entries: result.entries,
+      maxEntries: maxArchiveEntries,
+      rootAbsolutePath: result.absolute,
       rootName: result.rootName || 'archive',
     });
   } catch (error) {
@@ -313,7 +374,7 @@ async function handleDirectoryDownload(req, res, requestUrl, { vaultFileStore })
   }
 }
 
-async function handleAttachmentRead(req, res, requestUrl, { vaultFileStore }) {
+async function handleAttachmentRead(req, res, requestUrl, { config, vaultFileStore }) {
   const filePath = requestUrl.searchParams.get('path');
   if (!filePath) {
     jsonResponse(req, res, 400, { error: 'Missing path parameter' });
@@ -326,16 +387,22 @@ async function handleAttachmentRead(req, res, requestUrl, { vaultFileStore }) {
   }
 
   try {
-    const attachment = await vaultFileStore.readImageAttachmentFile(filePath);
+    const attachment = await vaultFileStore.openImageAttachmentReadStream(filePath, {
+      maxBytes: config.maxDownloadFileBytes ?? DEFAULT_MAX_DOWNLOAD_FILE_BYTES,
+    });
     if (!attachment) {
       jsonResponse(req, res, 404, { error: 'Attachment not found' });
       return;
     }
+    if (attachment.error) {
+      jsonResponse(req, res, attachment.statusCode || 400, { error: attachment.error });
+      return;
+    }
 
-    sendResponse(req, res, {
-      body: attachment.content,
+    await sendStreamResponse(req, res, {
       headers: createAttachmentHeaders(attachment),
       statusCode: 200,
+      stream: attachment.stream,
     });
   } catch (error) {
     console.error('[api] Failed to read attachment:', error.message);
@@ -384,10 +451,17 @@ function createRouteTable(context) {
 export function createVaultApiQueryHandler({
   baseQueryService = null,
   backlinkIndex,
+  config = {},
   vaultFileStore,
   workspaceMutationCoordinator = null,
 }) {
-  const context = { baseQueryService, backlinkIndex, vaultFileStore, workspaceMutationCoordinator };
+  const context = {
+    baseQueryService,
+    backlinkIndex,
+    config,
+    vaultFileStore,
+    workspaceMutationCoordinator,
+  };
   const routes = createRouteTable(context);
 
   return async function handleVaultApiQuery(req, res, requestUrl) {

package/src/server/infrastructure/persistence/vault-file-store.js

@@ -1,3 +1,4 @@
+import { createReadStream } from 'fs';
 import { mkdir, readFile, readdir, rename, rm, rmdir, stat, writeFile } from 'fs/promises';
 import { basename, dirname, extname, join, relative, resolve } from 'path';
 import sharp from 'sharp';
@@ -483,6 +484,36 @@ export class VaultFileStore {
     }
   }
 
+  async openImageAttachmentReadStream(filePath, { maxBytes = Infinity } = {}) {
+    const absolute = this.resolveContentPath(filePath, { requireVaultFile: false });
+    if (!absolute || !isImageAttachmentFilePath(filePath)) {
+      return null;
+    }
+
+    try {
+      const info = await stat(absolute);
+      if (!info.isFile()) {
+        return null;
+      }
+      if (Number(info.size || 0) > maxBytes) {
+        return { error: 'Attachment is too large', statusCode: 413 };
+      }
+
+      return {
+        mimeType: IMAGE_EXTENSION_TO_MIME_TYPE[extname(filePath).toLowerCase()] || 'application/octet-stream',
+        path: filePath,
+        size: Number(info.size || 0),
+        stream: createReadStream(absolute),
+      };
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return null;
+      }
+
+      throw error;
+    }
+  }
+
   async writeMarkdownFile(filePath, content, options = {}) {
     return this.writeContentFile(filePath, content, 'markdown', options);
   }
@@ -602,6 +633,45 @@ export class VaultFileStore {
     }
   }
 
+  async openDownloadFileStream(filePath, { maxBytes = Infinity } = {}) {
+    const normalizedPath = String(filePath ?? '').replace(/\\/g, '/').trim();
+    if (!normalizedPath || !isVaultFilePath(normalizedPath)) {
+      return null;
+    }
+
+    if (isImageAttachmentFilePath(normalizedPath)) {
+      return this.openImageAttachmentReadStream(normalizedPath, { maxBytes });
+    }
+
+    const absolute = this.resolveContentPath(normalizedPath, { requireVaultFile: false });
+    if (!absolute) {
+      return null;
+    }
+
+    try {
+      const info = await stat(absolute);
+      if (!info.isFile()) {
+        return null;
+      }
+      if (Number(info.size || 0) > maxBytes) {
+        return { error: 'File is too large to download', statusCode: 413 };
+      }
+
+      return {
+        mimeType: getDownloadMimeType(normalizedPath),
+        path: normalizedPath,
+        size: Number(info.size || 0),
+        stream: createReadStream(absolute),
+      };
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return null;
+      }
+
+      throw error;
+    }
+  }
+
   async persistCollaborationState(filePath, {
     commentThreads = [],
     content = '',
@@ -861,6 +931,72 @@ export class VaultFileStore {
     };
   }
 
+  async resolveDirectoryDownloadRoot(dirPath) {
+    const normalizedPath = String(dirPath ?? '').replace(/\\/g, '/').trim();
+    const { absolute, error } = resolveVaultDirectoryPath(this.vaultDir, normalizedPath);
+    if (!absolute) {
+      return { ok: false, error };
+    }
+
+    try {
+      const info = await stat(absolute);
+      if (!info.isDirectory()) {
+        return { ok: false, error: 'Directory not found' };
+      }
+    } catch (statError) {
+      if (statError.code === 'ENOENT') {
+        return { ok: false, error: 'Directory not found' };
+      }
+
+      throw statError;
+    }
+
+    return {
+      absolute,
+      ok: true,
+      rootName: basename(normalizedPath),
+    };
+  }
+
+  async countDirectoryDownloadEntries(directoryAbsolutePath, { maxEntries = Infinity } = {}) {
+    let count = 0;
+    const visitDirectory = async (currentDirectoryPath) => {
+      const dirEntries = sortDirectoryEntries(await readdir(currentDirectoryPath, { withFileTypes: true }))
+        .filter((entry) => !isIgnoredVaultEntry(entry.name));
+
+      if (dirEntries.length === 0) {
+        count += 1;
+        return count <= maxEntries;
+      }
+
+      for (const entry of dirEntries) {
+        const childAbsolutePath = join(currentDirectoryPath, entry.name);
+        if (entry.isDirectory()) {
+          const withinLimit = await visitDirectory(childAbsolutePath);
+          if (!withinLimit) {
+            return false;
+          }
+          continue;
+        }
+
+        if (entry.isFile()) {
+          count += 1;
+          if (count > maxEntries) {
+            return false;
+          }
+        }
+      }
+
+      return true;
+    };
+
+    const withinLimit = await visitDirectory(directoryAbsolutePath);
+    return {
+      count,
+      withinLimit,
+    };
+  }
+
   async deleteFile(filePath) {
     const { absolute, error } = resolveVaultFilePath(this.vaultDir, filePath);
     if (!absolute) {