collabmd 0.1.34 → 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/backlink-index.js

@@ -10,11 +10,15 @@
  * incrementally whenever a file is persisted, created, deleted, or renamed.
  */
 
-import { createWikiTargetIndex, resolveWikiTargetWithIndex } from '../../domain/wiki-link-resolver.js';
-import { getVaultFileExtension, isMarkdownFilePath } from '../../domain/file-kind.js';
+import { createWikiTargetIndex } from '../../domain/wiki-link-resolver.js';
+import { isMarkdownFilePath } from '../../domain/file-kind.js';
+import {
+  collectMarkdownReferences,
+  collectReferenceTargetKeysForFilePath,
+  createReferenceTargetAliasMap,
+} from './markdown-reference-extractor.js';
 import { mapWithConcurrency } from '../shared/async-utils.js';
 
-const WIKI_LINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
 const BACKLINK_BUILD_CONCURRENCY = 8;
 
 function createDeferred() {
@@ -27,39 +31,6 @@ function createDeferred() {
   return { promise, reject, resolve };
 }
 
-function normalizeWikiTargetKey(target = '') {
-  const normalizedTarget = String(target ?? '').trim();
-  if (!normalizedTarget) {
-    return '';
-  }
-
-  return getVaultFileExtension(normalizedTarget)
-    ? normalizedTarget
-    : `${normalizedTarget}.md`;
-}
-
-function collectWikiTargetKeysForFilePath(filePath = '') {
-  const normalizedPath = String(filePath ?? '').trim();
-  if (!normalizedPath) {
-    return [];
-  }
-
-  const segments = normalizedPath.split('/').filter(Boolean);
-  const keys = [];
-  for (let index = 0; index < segments.length; index += 1) {
-    keys.push(segments.slice(index).join('/'));
-  }
-
-  if (isMarkdownFilePath(normalizedPath)) {
-    const rawSegments = normalizedPath.replace(/\.md$/i, '').split('/').filter(Boolean);
-    for (let index = 0; index < rawSegments.length; index += 1) {
-      keys.push(rawSegments.slice(index).join('/'));
-    }
-  }
-
-  return [...new Set(keys)];
-}
-
 export class BacklinkIndex {
   constructor({
     rebuildDelayMs = 150,
@@ -225,7 +196,10 @@ export class BacklinkIndex {
    * Incrementally update the index when a file's content changes.
    * Call this after every persist / write.
    */
-  updateFile(filePath, content, { refreshIndex = true } = {}) {
+  updateFile(filePath, content, {
+    refreshIndex = true,
+    targetPathAliases = new Map(),
+  } = {}) {
     // Remove old forward links for this file
     this._removeForwardLinks(filePath);
 
@@ -242,7 +216,7 @@ export class BacklinkIndex {
     }
 
     // Re-index with new content
-    this._indexFile(filePath, content);
+    this._indexFile(filePath, content, { targetPathAliases });
   }
 
   /**
@@ -514,38 +488,32 @@ export class BacklinkIndex {
 
   // --- Private methods ---
 
-  _indexFile(filePath, content) {
+  _indexFile(filePath, content, { targetPathAliases = new Map() } = {}) {
     const resolvedTargets = new Set();
     const contextsByTarget = new Map();
     const rawTargetKeys = new Set();
-    const lines = content.split('\n');
-
-    for (const line of lines) {
-      WIKI_LINK_RE.lastIndex = 0;
-      let match;
-      while ((match = WIKI_LINK_RE.exec(line)) !== null) {
-        const target = match[1].trim();
-        if (!target) {
-          continue;
-        }
+    const references = collectMarkdownReferences(content, {
+      sourceFilePath: filePath,
+      targetPathAliases,
+      wikiTargetIndex: this._wikiTargetIndex,
+    });
 
-        const rawTargetKey = normalizeWikiTargetKey(target);
-        if (rawTargetKey) {
-          rawTargetKeys.add(rawTargetKey);
-        }
+    for (const reference of references) {
+      if (reference.rawTargetKey) {
+        rawTargetKeys.add(reference.rawTargetKey);
+      }
 
-        const resolved = this._resolveTarget(target);
-        if (!resolved || resolved === filePath) {
-          continue;
-        }
+      const resolved = reference.resolvedPath;
+      if (!resolved || resolved === filePath) {
+        continue;
+      }
 
-        resolvedTargets.add(resolved);
+      resolvedTargets.add(resolved);
 
-        if (!contextsByTarget.has(resolved)) {
-          contextsByTarget.set(resolved, []);
-        }
-        contextsByTarget.get(resolved).push(line.trim());
+      if (!contextsByTarget.has(resolved)) {
+        contextsByTarget.set(resolved, []);
       }
+      contextsByTarget.get(resolved).push(reference.context);
     }
 
     this.contextsBySource.delete(filePath);
@@ -594,14 +562,6 @@ export class BacklinkIndex {
     this.forward.delete(filePath);
   }
 
-  /**
-   * Resolve a wiki-link target string to a vault file path.
-   * Same logic as the client's resolveWikiTarget.
-   */
-  _resolveTarget(target) {
-    return resolveWikiTargetWithIndex(target, this._wikiTargetIndex);
-  }
-
   _refreshWikiTargetIndex() {
     this._wikiTargetIndex = createWikiTargetIndex(this._fileList);
   }
@@ -629,7 +589,7 @@ export class BacklinkIndex {
   _collectImpactedSourcesForMembershipChanges(pathValues = []) {
     const affectedTargetKeys = new Set();
     pathValues.forEach((pathValue) => {
-      collectWikiTargetKeysForFilePath(pathValue).forEach((targetKey) => {
+      collectReferenceTargetKeysForFilePath(pathValue).forEach((targetKey) => {
         affectedTargetKeys.add(targetKey);
       });
     });
@@ -648,6 +608,7 @@ export class BacklinkIndex {
     renameMap = new Map(),
   } = {}) {
     const refreshedSources = new Set();
+    const targetPathAliases = createReferenceTargetAliasMap(Array.from(renameMap.entries()));
 
     for (const sourcePath of impactedSources) {
       const livePath = renameMap.get(sourcePath) ?? sourcePath;
@@ -666,7 +627,7 @@ export class BacklinkIndex {
       }
 
       refreshedSources.add(livePath);
-      this.updateFile(livePath, content, { refreshIndex: false });
+      this.updateFile(livePath, content, { refreshIndex: false, targetPathAliases });
     }
   }
 }

package/src/server/domain/bases/base-index-snapshot-store.js

@@ -1,16 +1,19 @@
 import { basename, dirname, extname } from 'node:path';
 
-import { createWikiTargetIndex, resolveWikiTargetWithIndex } from '../../../domain/wiki-link-resolver.js';
+import { createWikiTargetIndex } from '../../../domain/wiki-link-resolver.js';
 import {
-  getVaultFileExtension,
   isMarkdownFilePath,
   stripVaultFileExtension,
 } from '../../../domain/file-kind.js';
 import { extractYamlFrontmatter } from '../../../domain/yaml-frontmatter.js';
+import {
+  collectMarkdownReferences,
+  collectReferenceTargetKeysForFilePath,
+  createReferenceTargetAliasMap,
+} from '../markdown-reference-extractor.js';
 import { mapWithConcurrency } from '../../shared/async-utils.js';
 import { createLinkValue, dedupeLinkValues } from './base-expression-runtime.js';
 
-const INTERNAL_LINK_RE = /(!)?\[\[([^\]|#]+)(?:#[^\]|]+)?(?:\|[^\]]+)?\]\]/g;
 const INLINE_TAG_RE = /(^|[\s(])#([A-Za-z0-9/_-]+)/g;
 const INDEX_READ_CONCURRENCY = 8;
 
@@ -42,28 +45,35 @@ function compareVaultPaths(left = '', right = '') {
   return String(left).localeCompare(String(right), undefined, { sensitivity: 'base' });
 }
 
-function extractReferences(markdownText = '', wikiTargetIndex) {
+function extractReferences(markdownText = '', {
+  sourceFilePath = '',
+  targetPathAliases = new Map(),
+  wikiTargetIndex,
+} = {}) {
   const links = [];
   const embeds = [];
-  let match;
-  while ((match = INTERNAL_LINK_RE.exec(String(markdownText ?? ''))) !== null) {
-    const isEmbed = Boolean(match[1]);
-    const rawTarget = String(match[2] ?? '').trim();
-    if (!rawTarget) {
-      continue;
-    }
+  const rawTargetKeys = new Set();
+  const references = collectMarkdownReferences(markdownText, {
+    sourceFilePath,
+    targetPathAliases,
+    wikiTargetIndex,
+  });
 
-    const resolvedPath = resolveWikiTargetWithIndex(rawTarget, wikiTargetIndex);
-    const linkValue = createLinkValue(resolvedPath || rawTarget, {
-      exists: Boolean(resolvedPath),
-      rawTarget,
+  references.forEach((reference) => {
+    const linkValue = createLinkValue(reference.resolvedPath || reference.targetPath || reference.rawTarget, {
+      exists: Boolean(reference.resolvedPath),
+      rawTarget: reference.rawTarget,
     });
     links.push(linkValue);
-    if (isEmbed) {
+    if (reference.isEmbed) {
       embeds.push(linkValue);
     }
-  }
-  return { embeds, links };
+    if (reference.rawTargetKey) {
+      rawTargetKeys.add(reference.rawTargetKey);
+    }
+  });
+
+  return { embeds, links, rawTargetKeys };
 }
 
 function isWorkspaceFileEntry(entry = null) {
@@ -81,39 +91,6 @@ function listWorkspaceFilePaths(workspaceState = {}) {
     .sort(compareVaultPaths);
 }
 
-function normalizeWikiTargetKey(target = '') {
-  const normalizedTarget = String(target ?? '').trim();
-  if (!normalizedTarget) {
-    return '';
-  }
-
-  return getVaultFileExtension(normalizedTarget)
-    ? normalizedTarget
-    : `${normalizedTarget}.md`;
-}
-
-function collectWikiTargetKeysForFilePath(filePath = '') {
-  const normalizedPath = String(filePath ?? '').trim();
-  if (!normalizedPath) {
-    return [];
-  }
-
-  const segments = normalizedPath.split('/').filter(Boolean);
-  const keys = [];
-  for (let index = 0; index < segments.length; index += 1) {
-    keys.push(segments.slice(index).join('/'));
-  }
-
-  if (isMarkdownFilePath(normalizedPath)) {
-    const rawSegments = normalizedPath.replace(/\.md$/i, '').split('/').filter(Boolean);
-    for (let index = 0; index < rawSegments.length; index += 1) {
-      keys.push(rawSegments.slice(index).join('/'));
-    }
-  }
-
-  return [...new Set(keys)];
-}
-
 function createBacklinkEntry(sourcePath = '') {
   return createLinkValue(sourcePath, {
     display: basename(sourcePath),
@@ -160,12 +137,18 @@ export class BaseIndexSnapshotStore {
     return scannedWorkspaceState;
   }
 
-  createSnapshotRow(filePath, workspaceState, wikiTargetIndex, markdownContent = null) {
+  createSnapshotRow(filePath, workspaceState, wikiTargetIndex, markdownContent = null, {
+    targetPathAliases = new Map(),
+  } = {}) {
     const metadata = workspaceState.metadata.get(filePath) ?? null;
     const frontmatter = markdownContent ? extractYamlFrontmatter(markdownContent) : null;
     const noteProperties = isPlainObject(frontmatter?.data) ? frontmatter.data : {};
     const bodyMarkdown = frontmatter?.bodyMarkdown ?? markdownContent ?? '';
-    const references = extractReferences(bodyMarkdown, wikiTargetIndex);
+    const references = extractReferences(bodyMarkdown, {
+      sourceFilePath: filePath,
+      targetPathAliases,
+      wikiTargetIndex,
+    });
     const tags = [...new Set([
       ...normalizeTags(noteProperties.tags),
       ...extractInlineTags(bodyMarkdown),
@@ -193,11 +176,7 @@ export class BaseIndexSnapshotStore {
           .map((link) => link?.path)
           .filter((targetPath) => targetPath && targetPath !== filePath),
       ),
-      rawTargetKeys: new Set(
-        references.links
-          .map((link) => normalizeWikiTargetKey(link?.rawTarget))
-          .filter(Boolean),
-      ),
+      rawTargetKeys: references.rawTargetKeys,
       row: {
         file: fileValue,
         noteProperties,
@@ -373,7 +352,7 @@ export class BaseIndexSnapshotStore {
   collectImpactedSourcesForMembershipChanges(snapshot, pathValues = []) {
     const affectedTargetKeys = new Set();
     pathValues.forEach((pathValue) => {
-      collectWikiTargetKeysForFilePath(pathValue).forEach((targetKey) => {
+      collectReferenceTargetKeysForFilePath(pathValue).forEach((targetKey) => {
         affectedTargetKeys.add(targetKey);
       });
     });
@@ -392,7 +371,9 @@ export class BaseIndexSnapshotStore {
     return impactedPaths;
   }
 
-  async refreshSnapshotRows(snapshot, workspaceState, pathValues = []) {
+  async refreshSnapshotRows(snapshot, workspaceState, pathValues = [], {
+    targetPathAliases = new Map(),
+  } = {}) {
     const filePathsToRefresh = Array.from(new Set(pathValues))
       .filter((pathValue) => {
         const entry = workspaceState?.entries?.get(pathValue);
@@ -403,7 +384,9 @@ export class BaseIndexSnapshotStore {
       const markdownContent = isMarkdownFilePath(filePath)
         ? await this.vaultFileStore.readMarkdownFile(filePath)
         : null;
-      const rowRecord = this.createSnapshotRow(filePath, workspaceState, snapshot.wikiTargetIndex, markdownContent);
+      const rowRecord = this.createSnapshotRow(filePath, workspaceState, snapshot.wikiTargetIndex, markdownContent, {
+        targetPathAliases,
+      });
       this.removeRawTargetSourceContributions(snapshot, filePath);
       snapshot.rowsByPath.set(filePath, rowRecord.row);
       snapshot.forwardLinksByPath.set(filePath, rowRecord.forwardLinks);
@@ -489,6 +472,7 @@ export class BaseIndexSnapshotStore {
     const snapshot = this.indexSnapshot;
     const affectedTargetPaths = new Set();
     const affectedSourcePaths = new Set(markdownPathsToRefresh);
+    const targetPathAliases = createReferenceTargetAliasMap(renamedFileEntries);
     if (membershipChanged) {
       const membershipAffectedPaths = [
         ...deletedFilePaths,
@@ -543,7 +527,7 @@ export class BaseIndexSnapshotStore {
         ...createdFilePaths,
         ...renamedFileEntries.map((entry) => entry.newPath),
         ...affectedSourcePaths,
-      ]);
+      ], { targetPathAliases });
     } else {
       affectedSourcePaths.forEach((pathValue) => {
         this.removeSourceBacklinkContributions(snapshot, pathValue, affectedTargetPaths);

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);
   }