ocean-brain 0.8.0 → 0.8.2

package/server/dist/modules/blocknote.js

@@ -1,6 +1,6 @@
-import { ServerBlockNoteEditor } from "@blocknote/server-util";
 import { ensureTagByName } from "../features/tag/services/organization.js";
 import models from "../models.js";
+import { BlockNoteMarkdownEditor } from "./blocknote-markdown-editor.js";
 const UNSUPPORTED_MARKDOWN_BLOCK_TYPES = /* @__PURE__ */ new Set(["tableOfContents"]);
 const TAG_PLACEHOLDER_PREFIX = "OCEAN_BRAIN_TAG_";
 const TAG_PLACEHOLDER_SUFFIX = "_TOKEN";
@@ -242,7 +242,10 @@ function replaceExplicitReferenceTokens(text, placeholderToReference) {
   });
 }
 const MARKDOWN_ANGLE_BRACKET_TOKEN_PATTERN = /<([^<>\n]+)>/g;
-const MARKDOWN_NUMERIC_TILDE_RANGE_PATTERN = /(\d)~(?=\d)/g;
+const TILDE_RUN_PATTERN = /~+/g;
+const NUMERIC_ENDPOINT_TOKEN_CHARACTER_PATTERN = /[\p{L}\p{M}\p{N}\p{Sc}%‰.,+\-/:°℃℉µμ·²³^]/u;
+const NUMERIC_ENDPOINT_START_PATTERN = /^(?:[+-]?\p{Sc}?|\p{Sc}[+-]?)\p{N}/u;
+const NUMERIC_CHARACTER_REFERENCE_PATTERN = /&#(?:x[0-9a-f]+|\d+);/giu;
 const MARKDOWN_FENCED_CODE_PATTERN = /^ {0,3}(`{3,}|~{3,})/;
 const ANGLE_BRACKET_PLACEHOLDER_PREFIX = "\uE000OBANGLE";
 const ANGLE_BRACKET_PLACEHOLDER_SUFFIX = "\uE001";
@@ -285,19 +288,39 @@ function hasLiteralAngleBracketTextTokenLoss(sourceMarkdown, renderedMarkdown) {
   }
   return false;
 }
-function countNumericTildeRangeMarkers(markdown) {
-  return [...markdown.matchAll(MARKDOWN_NUMERIC_TILDE_RANGE_PATTERN)].length;
+function getNumericTildeRangeRunSignatures(markdown) {
+  const normalizedMarkdown = markdown.replace(/\\(?=~)/g, "");
+  return getNumericTildeRangeRuns(normalizedMarkdown).map((run) => {
+    const leftEndpoint = getNumericEndpointBefore(normalizedMarkdown, run.start);
+    const rightEndpoint = getNumericEndpointAfter(normalizedMarkdown, run.start + run.length);
+    return JSON.stringify([leftEndpoint, run.length, rightEndpoint]);
+  });
 }
 function hasNumericTildeRangeMarkers(markdown) {
-  return countNumericTildeRangeMarkers(markdown) > 0;
+  return getNumericTildeRangeRunSignatures(markdown).length > 0;
 }
 function hasNumericTildeRangeMarkerLoss(sourceMarkdown, renderedMarkdown) {
-  const sourceCount = countNumericTildeRangeMarkers(sourceMarkdown);
-  return sourceCount > 0 && countNumericTildeRangeMarkers(renderedMarkdown) < sourceCount;
+  const sourceRunSignatures = getNumericTildeRangeRunSignatures(sourceMarkdown);
+  if (sourceRunSignatures.length === 0) {
+    return false;
+  }
+  const renderedRunSignatures = getNumericTildeRangeRunSignatures(renderedMarkdown);
+  let renderedIndex = 0;
+  for (const sourceRunSignature of sourceRunSignatures) {
+    while (renderedIndex < renderedRunSignatures.length && renderedRunSignatures[renderedIndex] !== sourceRunSignature) {
+      renderedIndex += 1;
+    }
+    if (renderedIndex === renderedRunSignatures.length) {
+      return true;
+    }
+    renderedIndex += 1;
+  }
+  return false;
 }
 function protectMarkdownNumericTildeRanges(markdown) {
   const protectedLines = [];
   const placeholderToToken = /* @__PURE__ */ new Map();
+  const createPlaceholder = createNumericTildeRangePlaceholderFactory(markdown);
   let activeFence = null;
   for (const line of markdown.split(/(?<=\n)/)) {
     const { body: lineBody, lineEnding } = splitMarkdownLineEnding(line);
@@ -322,7 +345,9 @@ function protectMarkdownNumericTildeRanges(markdown) {
       protectedLines.push(line);
       continue;
     }
-    protectedLines.push(`${protectMarkdownLineNumericTildeRanges(lineBody, placeholderToToken)}${lineEnding}`);
+    protectedLines.push(
+      `${protectMarkdownLineNumericTildeRanges(lineBody, placeholderToToken, createPlaceholder)}${lineEnding}`
+    );
   }
   return {
     markdown: protectedLines.join(""),
@@ -332,6 +357,11 @@ function protectMarkdownNumericTildeRanges(markdown) {
 function protectMarkdownLineEndHardBreakMarkers(markdown) {
   const protectedLines = [];
   const placeholderToToken = /* @__PURE__ */ new Map();
+  const createPlaceholder = createProtectedTextPlaceholderFactory(
+    markdown,
+    HARD_BREAK_PLACEHOLDER_PREFIX,
+    HARD_BREAK_PLACEHOLDER_SUFFIX
+  );
   let activeFence = null;
   const lines = markdown.split(/(?<=\n)/);
   for (const [index, line] of lines.entries()) {
@@ -363,7 +393,8 @@ function protectMarkdownLineEndHardBreakMarkers(markdown) {
         lineBody,
         lineEnding,
         isMarkdownHardBreakContinuationLine(nextLineBody),
-        placeholderToToken
+        placeholderToToken,
+        createPlaceholder
       )}${lineEnding}`
     );
   }
@@ -375,6 +406,11 @@ function protectMarkdownLineEndHardBreakMarkers(markdown) {
 function protectMarkdownTextAngleBrackets(markdown) {
   const protectedLines = [];
   const placeholderToToken = /* @__PURE__ */ new Map();
+  const createPlaceholder = createProtectedTextPlaceholderFactory(
+    markdown,
+    ANGLE_BRACKET_PLACEHOLDER_PREFIX,
+    ANGLE_BRACKET_PLACEHOLDER_SUFFIX
+  );
   let activeFence = null;
   for (const line of markdown.split(/(?<=\n)/)) {
     const { body: lineBody, lineEnding } = splitMarkdownLineEnding(line);
@@ -399,7 +435,9 @@ function protectMarkdownTextAngleBrackets(markdown) {
       protectedLines.push(line);
       continue;
     }
-    protectedLines.push(`${protectMarkdownLineTextAngleBrackets(lineBody, placeholderToToken)}${lineEnding}`);
+    protectedLines.push(
+      `${protectMarkdownLineTextAngleBrackets(lineBody, placeholderToToken, createPlaceholder)}${lineEnding}`
+    );
   }
   return {
     markdown: protectedLines.join(""),
@@ -428,68 +466,69 @@ function isClosingFenceLine(line, fence) {
   const escapedMarker = fence.marker === "`" ? "`" : "~";
   return new RegExp(`^ {0,3}${escapedMarker}{${fence.length},} *$`).test(line);
 }
-function protectMarkdownLineTextAngleBrackets(line, placeholderToToken) {
+function protectMarkdownLineTextAngleBrackets(line, placeholderToToken, createPlaceholder) {
   let result = "";
   let cursor = 0;
   while (cursor < line.length) {
-    const codeStart = line.indexOf("`", cursor);
-    if (codeStart === -1) {
-      result += replaceLiteralAngleBracketTextTokens(line.slice(cursor), placeholderToToken);
-      break;
-    }
-    result += replaceLiteralAngleBracketTextTokens(line.slice(cursor, codeStart), placeholderToToken);
-    const delimiterLength = countRepeatedCharacter(line, codeStart, "`");
-    const codeEnd = line.indexOf("`".repeat(delimiterLength), codeStart + delimiterLength);
-    if (codeEnd === -1) {
-      result += replaceLiteralAngleBracketTextTokens(line.slice(codeStart), placeholderToToken);
+    const codeSpan = findNextInlineCodeSpan(line, cursor);
+    if (!codeSpan) {
+      result += replaceLiteralAngleBracketTextTokens(line.slice(cursor), placeholderToToken, createPlaceholder);
       break;
     }
-    const codeEndExclusive = codeEnd + delimiterLength;
-    result += line.slice(codeStart, codeEndExclusive);
-    cursor = codeEndExclusive;
+    result += replaceLiteralAngleBracketTextTokens(
+      line.slice(cursor, codeSpan.start),
+      placeholderToToken,
+      createPlaceholder
+    );
+    result += line.slice(codeSpan.start, codeSpan.end);
+    cursor = codeSpan.end;
   }
   return result;
 }
-function protectMarkdownLineNumericTildeRanges(line, placeholderToToken) {
+function protectMarkdownLineNumericTildeRanges(line, placeholderToToken, createPlaceholder) {
   let result = "";
   let cursor = 0;
   while (cursor < line.length) {
     const protectedSpan = findNextMarkdownProtectedSpan(line, cursor);
     if (!protectedSpan) {
-      result += replaceNumericTildeRangeMarkers(line.slice(cursor), placeholderToToken);
+      result += replaceNumericTildeRangeMarkers(line.slice(cursor), placeholderToToken, createPlaceholder);
       break;
     }
-    result += replaceNumericTildeRangeMarkers(line.slice(cursor, protectedSpan.start), placeholderToToken);
+    result += replaceNumericTildeRangeMarkers(
+      line.slice(cursor, protectedSpan.start),
+      placeholderToToken,
+      createPlaceholder
+    );
     result += line.slice(protectedSpan.start, protectedSpan.end);
     cursor = protectedSpan.end;
   }
   return result;
 }
 function findNextMarkdownProtectedSpan(line, cursor) {
-  const codeSpan = findNextInlineCodeSpan(line, cursor);
-  const linkDestinationSpan = findNextMarkdownLinkDestinationSpan(line, cursor);
-  if (!codeSpan) {
-    return linkDestinationSpan;
-  }
-  if (!linkDestinationSpan) {
-    return codeSpan;
-  }
-  return codeSpan.start <= linkDestinationSpan.start ? codeSpan : linkDestinationSpan;
+  return [
+    findNextInlineCodeSpan(line, cursor),
+    findNextMarkdownLinkDestinationSpan(line, cursor),
+    findNextMarkdownAngleBracketSpan(line, cursor)
+  ].reduce((nextSpan, span) => {
+    if (!span || nextSpan && nextSpan.start <= span.start) {
+      return nextSpan;
+    }
+    return span;
+  }, null);
 }
 function findNextInlineCodeSpan(line, cursor) {
-  const codeStart = line.indexOf("`", cursor);
-  if (codeStart === -1) {
-    return null;
-  }
-  const delimiterLength = countRepeatedCharacter(line, codeStart, "`");
-  const codeEnd = line.indexOf("`".repeat(delimiterLength), codeStart + delimiterLength);
-  if (codeEnd === -1) {
-    return null;
+  let codeStart = line.indexOf("`", cursor);
+  while (codeStart !== -1) {
+    const delimiterLength = countRepeatedCharacter(line, codeStart, "`");
+    if (!isEscapedMarkdownCharacter(line, codeStart)) {
+      const end = findMatchingBacktickRunEnd(line, codeStart, delimiterLength);
+      if (end !== null) {
+        return { start: codeStart, end };
+      }
+    }
+    codeStart = line.indexOf("`", codeStart + delimiterLength);
   }
-  return {
-    start: codeStart,
-    end: codeEnd + delimiterLength
-  };
+  return null;
 }
 function findNextMarkdownLinkDestinationSpan(line, cursor) {
   const linkDestinationPrefix = line.indexOf("](", cursor);
@@ -497,39 +536,146 @@ function findNextMarkdownLinkDestinationSpan(line, cursor) {
     return null;
   }
   const destinationStart = linkDestinationPrefix + 2;
-  const destinationEnd = line.indexOf(")", destinationStart);
-  if (destinationEnd === -1) {
+  let parenthesisDepth = 0;
+  for (let destinationEnd = destinationStart; destinationEnd < line.length; destinationEnd += 1) {
+    const character = line[destinationEnd];
+    if (character === "\\") {
+      destinationEnd += 1;
+      continue;
+    }
+    if (character === "(") {
+      parenthesisDepth += 1;
+      continue;
+    }
+    if (character !== ")") {
+      continue;
+    }
+    if (parenthesisDepth > 0) {
+      parenthesisDepth -= 1;
+      continue;
+    }
+    return {
+      start: destinationStart,
+      end: destinationEnd
+    };
+  }
+  return null;
+}
+function findNextMarkdownAngleBracketSpan(line, cursor) {
+  const start = line.indexOf("<", cursor);
+  if (start === -1) {
     return null;
   }
-  return {
-    start: destinationStart,
-    end: destinationEnd
-  };
+  const end = line.indexOf(">", start + 1);
+  if (end === -1) {
+    return null;
+  }
+  return { start, end: end + 1 };
 }
-function replaceLiteralAngleBracketTextTokens(text, placeholderToToken) {
+function replaceLiteralAngleBracketTextTokens(text, placeholderToToken, createPlaceholder) {
   return text.replace(MARKDOWN_ANGLE_BRACKET_TOKEN_PATTERN, (match, innerText) => {
     if (isMarkdownAutolinkAngleBracketText(innerText)) {
       return match;
     }
-    const placeholder = createAngleBracketPlaceholder(placeholderToToken.size);
+    const placeholder = createPlaceholder();
     placeholderToToken.set(placeholder, match);
     return placeholder;
   });
 }
-function replaceNumericTildeRangeMarkers(text, placeholderToToken) {
-  return text.replace(MARKDOWN_NUMERIC_TILDE_RANGE_PATTERN, (match, leadingDigit) => {
-    const placeholder = createNumericTildeRangePlaceholder(placeholderToToken.size);
-    placeholderToToken.set(placeholder, "~");
-    return `${leadingDigit}${placeholder}`;
+function isPotentialNumericTildeRangeRun(value, start, end) {
+  if (end - start > 2) {
+    return false;
+  }
+  return getNumericEndpointBefore(value, start) !== null && getNumericEndpointAfter(value, end) !== null;
+}
+function findEndpointTokenBefore(value, end) {
+  let start = end;
+  while (start > 0 && NUMERIC_ENDPOINT_TOKEN_CHARACTER_PATTERN.test(value[start - 1] ?? "")) {
+    start -= 1;
+  }
+  return {
+    start,
+    token: value.slice(start, end)
+  };
+}
+function findEndpointTokenAfter(value, start) {
+  let end = start;
+  while (end < value.length && NUMERIC_ENDPOINT_TOKEN_CHARACTER_PATTERN.test(value[end] ?? "")) {
+    end += 1;
+  }
+  return value.slice(start, end);
+}
+function getNumericEndpointBefore(value, end) {
+  const endpoint = findEndpointTokenBefore(value, end);
+  if (NUMERIC_ENDPOINT_START_PATTERN.test(endpoint.token)) {
+    return endpoint.token;
+  }
+  if (!endpoint.token) {
+    return null;
+  }
+  let previousEnd = endpoint.start;
+  while (previousEnd > 0 && (value[previousEnd - 1] === " " || value[previousEnd - 1] === "	")) {
+    previousEnd -= 1;
+  }
+  if (previousEnd === endpoint.start) {
+    return null;
+  }
+  const previousEndpoint = findEndpointTokenBefore(value, previousEnd);
+  return NUMERIC_ENDPOINT_START_PATTERN.test(previousEndpoint.token) ? value.slice(previousEndpoint.start, end) : null;
+}
+function getNumericEndpointAfter(value, start) {
+  const endpoint = findEndpointTokenAfter(value, start);
+  return NUMERIC_ENDPOINT_START_PATTERN.test(endpoint) ? endpoint : null;
+}
+function getNumericTildeRangeRuns(value) {
+  const numericRuns = [];
+  const pendingNumericBoundaryStrikeOpeners = /* @__PURE__ */ new Set();
+  for (const match of value.matchAll(TILDE_RUN_PATTERN)) {
+    const start = match.index;
+    const length = match[0].length;
+    const end = start + length;
+    if (length > 2) {
+      continue;
+    }
+    const canOpen = end < value.length && !/\s/u.test(value[end] ?? "");
+    const canClose = start > 0 && !/\s/u.test(value[start - 1] ?? "");
+    const isNumericRange = isPotentialNumericTildeRangeRun(value, start, end);
+    if (isNumericRange) {
+      if (canClose && pendingNumericBoundaryStrikeOpeners.delete(length)) {
+        continue;
+      }
+      numericRuns.push({ length, start });
+      continue;
+    }
+    if (canClose && pendingNumericBoundaryStrikeOpeners.delete(length)) {
+      continue;
+    }
+    if (canOpen && getNumericEndpointBefore(value, start) !== null) {
+      pendingNumericBoundaryStrikeOpeners.add(length);
+    }
+  }
+  return numericRuns;
+}
+function replaceNumericTildeRangeMarkers(text, placeholderToToken, createPlaceholder) {
+  const numericRunStarts = new Set(getNumericTildeRangeRuns(text).map((run) => run.start));
+  return text.replace(TILDE_RUN_PATTERN, (tildeRun, offset) => {
+    if (!numericRunStarts.has(offset)) {
+      return tildeRun;
+    }
+    return [...tildeRun].map(() => {
+      const placeholder = createPlaceholder();
+      placeholderToToken.set(placeholder, "~");
+      return placeholder;
+    }).join("");
   });
 }
-function protectMarkdownLineEndHardBreakMarker(line, lineEnding, hasContinuationLine, placeholderToToken) {
+function protectMarkdownLineEndHardBreakMarker(line, lineEnding, hasContinuationLine, placeholderToToken, createPlaceholder) {
   if (!lineEnding || !line.endsWith("\\")) {
     return line;
   }
-  const placeholder = createHardBreakPlaceholder(placeholderToToken.size);
+  const placeholder = createPlaceholder();
   const shouldPreserveAsHardBreak = hasContinuationLine && !hasUnclosedInlineCodeSpanAtLineEnd(line);
-  placeholderToToken.set(placeholder, shouldPreserveAsHardBreak ? "" : "\\");
+  placeholderToToken.set(placeholder, shouldPreserveAsHardBreak ? "\n" : "\\");
   return `${line.slice(0, -1)}${placeholder}`;
 }
 function isMarkdownHardBreakContinuationLine(line) {
@@ -569,14 +715,35 @@ function hasUnclosedInlineCodeSpanAtLineEnd(line) {
   }
   return openDelimiter !== null;
 }
-function createAngleBracketPlaceholder(index) {
-  return `${ANGLE_BRACKET_PLACEHOLDER_PREFIX}${index}${ANGLE_BRACKET_PLACEHOLDER_SUFFIX}`;
+function decodeNumericCharacterReference(reference) {
+  const value = reference.slice(2, -1);
+  const isHexadecimal = value[0]?.toLowerCase() === "x";
+  const codePoint = Number.parseInt(isHexadecimal ? value.slice(1) : value, isHexadecimal ? 16 : 10);
+  if (!Number.isSafeInteger(codePoint) || codePoint < 0 || codePoint > 1114111) {
+    return reference;
+  }
+  return String.fromCodePoint(codePoint);
 }
-function createNumericTildeRangePlaceholder(index) {
-  return `${NUMERIC_TILDE_RANGE_PLACEHOLDER_PREFIX}${index}${NUMERIC_TILDE_RANGE_PLACEHOLDER_SUFFIX}`;
+function createNumericTildeRangePlaceholderFactory(markdown) {
+  return createProtectedTextPlaceholderFactory(
+    markdown,
+    NUMERIC_TILDE_RANGE_PLACEHOLDER_PREFIX,
+    NUMERIC_TILDE_RANGE_PLACEHOLDER_SUFFIX
+  );
 }
-function createHardBreakPlaceholder(index) {
-  return `${HARD_BREAK_PLACEHOLDER_PREFIX}${index}${HARD_BREAK_PLACEHOLDER_SUFFIX}`;
+function createProtectedTextPlaceholderFactory(markdown, prefix, suffix) {
+  const decodedMarkdown = markdown.replace(NUMERIC_CHARACTER_REFERENCE_PATTERN, decodeNumericCharacterReference);
+  const lowercaseMarkdown = markdown.toLowerCase();
+  let index = 0;
+  return () => {
+    let placeholder = `${prefix}${index}${suffix}`;
+    while (markdown.includes(placeholder) || lowercaseMarkdown.includes(encodeURIComponent(placeholder).toLowerCase()) || decodedMarkdown.includes(placeholder)) {
+      index += 1;
+      placeholder = `${prefix}${index}${suffix}`;
+    }
+    index += 1;
+    return placeholder;
+  };
 }
 function countRepeatedCharacter(value, start, character) {
   let cursor = start;
@@ -585,6 +752,28 @@ function countRepeatedCharacter(value, start, character) {
   }
   return cursor - start;
 }
+function isEscapedMarkdownCharacter(value, index) {
+  let precedingBackslashes = 0;
+  for (let cursor = index - 1; cursor >= 0 && value[cursor] === "\\"; cursor -= 1) {
+    precedingBackslashes += 1;
+  }
+  return precedingBackslashes % 2 === 1;
+}
+function findMatchingBacktickRunEnd(line, start, delimiterLength) {
+  let cursor = start + delimiterLength;
+  while (cursor < line.length) {
+    const candidate = line.indexOf("`", cursor);
+    if (candidate === -1) {
+      return null;
+    }
+    const candidateLength = countRepeatedCharacter(line, candidate, "`");
+    if (candidateLength === delimiterLength) {
+      return candidate + candidateLength;
+    }
+    cursor = candidate + candidateLength;
+  }
+  return null;
+}
 function findTagPlaceholderAtCursor(text, cursor, placeholderToTag) {
   for (const [placeholder, tagToken] of placeholderToTag.entries()) {
     if (text.startsWith(placeholder, cursor)) {
@@ -629,13 +818,7 @@ function restoreProtectedTextPlaceholders(blocks, placeholderToToken) {
   if (placeholderToToken.size === 0) {
     return blocks;
   }
-  return mapBlocks(
-    blocks,
-    (content) => mapBlockContent(
-      content,
-      (inline) => restoreProtectedTextInValue(inline, placeholderToToken)
-    )
-  );
+  return restoreProtectedTextInValue(blocks, placeholderToToken);
 }
 function restoreProtectedTextInValue(value, placeholderToToken) {
   if (typeof value === "string") {
@@ -654,6 +837,17 @@ function restoreProtectedTextInValue(value, placeholderToToken) {
 function restoreProtectedText(text, placeholderToToken) {
   let restoredText = text;
   for (const [placeholder, token] of placeholderToToken.entries()) {
+    if (placeholder.startsWith(HARD_BREAK_PLACEHOLDER_PREFIX) && token === "\n") {
+      restoredText = restoredText.split(`${placeholder} `).join(placeholder).split(`${placeholder}
+ `).join(`${placeholder}
+`).split(`${placeholder}\r
+ `).join(`${placeholder}\r
+`);
+    }
+    restoredText = restoredText.replace(
+      new RegExp(encodeURIComponent(placeholder), "gi"),
+      encodeURIComponent(token)
+    );
     restoredText = restoredText.split(placeholder).join(token);
   }
   return restoredText;
@@ -828,7 +1022,7 @@ function collectTagIds(blocks) {
 let editorInstance = null;
 function getEditor() {
   if (!editorInstance) {
-    editorInstance = ServerBlockNoteEditor.create();
+    editorInstance = BlockNoteMarkdownEditor.create();
   }
   return editorInstance;
 }
@@ -943,4 +1137,3 @@ export {
   hasUnsupportedMarkdownBlocks,
   markdownToBlocksJson
 };
-//# sourceMappingURL=blocknote.js.map

package/server/dist/modules/data-maintenance.js

@@ -72,4 +72,3 @@ export {
   runDataMaintenanceInBackground,
   startDataMaintenanceScheduler
 };
-//# sourceMappingURL=data-maintenance.js.map

package/server/dist/modules/error-handler.js

@@ -13,6 +13,7 @@ class AppError extends Error {
 const createAppError = (status, code, message, details) => {
   return new AppError(status, code, message, details);
 };
+const hasErrorType = (error, type) => error instanceof Error && "type" in error && error.type === type;
 const createErrorHandler = () => {
   return (error, _req, res, next) => {
     if (res.headersSent) {
@@ -27,6 +28,13 @@ const createErrorHandler = () => {
       }).end();
       return;
     }
+    if (hasErrorType(error, "encoding.unsupported")) {
+      res.status(415).json({
+        code: "UNSUPPORTED_CONTENT_ENCODING",
+        message: "Compressed request bodies are not supported."
+      }).end();
+      return;
+    }
     if (error instanceof Error && error.message.startsWith("CSRF token ")) {
       res.status(403).json({
         code: "CSRF_TOKEN_INVALID",
@@ -48,4 +56,3 @@ export {
   createAppError,
   createErrorHandler
 };
-//# sourceMappingURL=error-handler.js.map

package/server/dist/modules/graphql.js

@@ -4,4 +4,3 @@ function gql(texts, ...values) {
 export {
   gql
 };
-//# sourceMappingURL=graphql.js.map

package/server/dist/modules/logger.js

@@ -51,4 +51,3 @@ export {
   logger_default as default,
   loggerOptions
 };
-//# sourceMappingURL=logger.js.map

package/server/dist/modules/mcp-auth.js

@@ -128,4 +128,3 @@ export {
   createReadOnlyMcpValidationRule,
   isMcpVersionCompatible
 };
-//# sourceMappingURL=mcp-auth.js.map

package/server/dist/modules/mcp-token.js

@@ -25,4 +25,3 @@ export {
   issueMcpToken,
   verifyMcpToken
 };
-//# sourceMappingURL=mcp-token.js.map

package/server/dist/modules/prisma-runtime.js

@@ -38,4 +38,3 @@ export {
   resolvePrismaSchemaPath,
   runPrismaMigrateDeploy
 };
-//# sourceMappingURL=prisma-runtime.js.map

package/server/dist/modules/rate-limit.js

@@ -29,4 +29,3 @@ export {
   createAuthAttemptRateLimit,
   createSessionAccessRateLimit
 };
-//# sourceMappingURL=rate-limit.js.map

package/server/dist/modules/recovery-retention.js

@@ -23,4 +23,3 @@ export {
   createRetentionCutoff,
   resolveRetentionCutoff
 };
-//# sourceMappingURL=recovery-retention.js.map

package/server/dist/modules/server-events-handler.js

@@ -48,4 +48,3 @@ const createServerEventsHandler = () => {
 export {
   createServerEventsHandler
 };
-//# sourceMappingURL=server-events-handler.js.map

package/server/dist/modules/server-events.js

@@ -29,4 +29,3 @@ export {
   serializeServerEvent,
   subscribeServerEvents
 };
-//# sourceMappingURL=server-events.js.map

package/server/dist/modules/session-store.js

@@ -146,4 +146,3 @@ export {
   TtlMemorySessionStore,
   createSessionStore
 };
-//# sourceMappingURL=session-store.js.map

package/server/dist/modules/use-async.js

@@ -8,4 +8,3 @@ function useAsync(callback) {
 export {
   useAsync as default
 };
-//# sourceMappingURL=use-async.js.map

package/server/dist/paths.js

@@ -12,4 +12,3 @@ const paths = {
 export {
   paths
 };
-//# sourceMappingURL=paths.js.map

package/server/dist/routes/api.js

@@ -51,4 +51,3 @@ const createApiRouter = (authConfig, mcpAdminService) => {
 export {
   createApiRouter
 };
-//# sourceMappingURL=api.js.map

package/server/dist/routes/auth-pages.js

@@ -20,4 +20,3 @@ const createAuthPagesRouter = (authConfig) => {
 export {
   createAuthPagesRouter
 };
-//# sourceMappingURL=auth-pages.js.map

package/server/dist/routes/client.js

@@ -84,4 +84,3 @@ const createClientRouter = (authConfig) => Router().use(
 export {
   createClientRouter
 };
-//# sourceMappingURL=client.js.map

package/server/dist/routes/graphql.js

@@ -34,4 +34,3 @@ const createGraphqlRouter = (authConfig, mcpAdminService) => {
 export {
   createGraphqlRouter
 };
-//# sourceMappingURL=graphql.js.map

package/server/dist/routes/index.js

@@ -8,4 +8,3 @@ export {
   createClientRouter,
   createGraphqlRouter
 };
-//# sourceMappingURL=index.js.map

package/server/dist/routes/mcp.js

@@ -52,4 +52,3 @@ const createMcpRouter = (authConfig, mcpAdminService) => Router().post(
 export {
   createMcpRouter
 };
-//# sourceMappingURL=mcp.js.map

package/server/dist/schema/index.js

@@ -30,4 +30,3 @@ var schema_default = schema;
 export {
   schema_default as default
 };
-//# sourceMappingURL=index.js.map

package/server/dist/start.js

@@ -8,4 +8,3 @@ try {
 `);
   process.exit(1);
 }
-//# sourceMappingURL=start.js.map

package/server/dist/types/index.js

@@ -1,2 +1 @@
 export * from "./input.js";
-//# sourceMappingURL=index.js.map

package/server/dist/types/input.js

@@ -1 +0,0 @@
-//# sourceMappingURL=input.js.map