docs(mcp): поправить устаревшую ссылку footnote-authoring.ts -> @docmost/prosemirror-markdown

#429 (дедуп node-ops) перенёс footnoteContentKey в @docmost/prosemirror-markdown
и удалил footnote-authoring.ts, но два docstring-комментария в
footnote-normalize-merge.ts всё ещё ссылались на старое имя файла. Только
комментарии, на сборку/поведение не влияет.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

packages/mcp/src/client.ts

@@ -42,7 +42,6 @@ import {
   insertTableRow,
   deleteTableRow,
   updateTableCell,
-  findInvalidNode,
 } from "@docmost/prosemirror-markdown";
 import { searchInDoc, SearchOptions } from "./lib/page-search.js";
 import { withPageLock } from "./lib/page-lock.js";
@@ -554,18 +553,16 @@ export class DocmostClient {
     // forever and accumulate duplicates).
     const MAX_PAGES = 50;
 
-    let cursor: string | undefined;
+    let page = 1;
     let allItems: T[] = [];
-    let truncated = false;
+    let hasNextPage = true;
 
-    for (let page = 0; page < MAX_PAGES; page++) {
-      const payload: Record<string, any> = {
+    while (hasNextPage && page <= MAX_PAGES) {
+      const response = await this.client.post(endpoint, {
         ...basePayload,
         limit: clampedLimit,
-      };
-      if (cursor) payload.cursor = cursor;
-
-      const response = await this.client.post(endpoint, payload);
+        page,
+      });
 
       const data = response.data;
       const items = data.data?.items || data.items || [];
@@ -573,28 +570,22 @@ export class DocmostClient {
 
       allItems = allItems.concat(items);
 
-      // Advance strictly via the server-issued cursor. A missing nextCursor (or
-      // hasNextPage false) means we reached the end. A cursor identical to the
-      // one we just sent means the server did not understand our pagination
-      // param — stop instead of re-fetching page one forever and duplicating.
-      const next = meta?.hasNextPage ? meta?.nextCursor : null;
-      if (!next || next === cursor) {
-        // If the server still reports more pages but stopped issuing a usable
-        // cursor at the ceiling, flag the result as truncated below.
-        if (page === MAX_PAGES - 1 && meta?.hasNextPage) truncated = true;
+      // Stop if the page is empty or shorter than the requested size: a full
+      // page worth of items is the only situation where another page can exist,
+      // so this defends against a stuck hasNextPage flag in addition to it.
+      if (items.length === 0 || items.length < clampedLimit) {
         break;
       }
-      cursor = next;
 
-      // Reaching the ceiling with more pages still available means the result
-      // set is truncated.
-      if (page === MAX_PAGES - 1) truncated = true;
+      hasNextPage = meta?.hasNextPage || false;
+      page++;
     }
 
     // If the loop stopped because it hit the MAX_PAGES ceiling while the server
-    // still reported more results, the result set is truncated — warn so the
-    // caller is not silently handed an incomplete list.
-    if (truncated) {
+    // still reported more results (hasNextPage true and the last page was
+    // full), the result set is truncated — warn so the caller is not silently
+    // handed an incomplete list.
+    if (hasNextPage && page > MAX_PAGES) {
       console.warn(
         `paginateAll: results from "${endpoint}" truncated at the ${MAX_PAGES}-page cap; more pages exist on the server`,
       );
@@ -628,10 +619,9 @@ export class DocmostClient {
    * Tree (`tree` true): the space's FULL page hierarchy as a nested tree (each
    * node has a `children` array). This mode REQUIRES `spaceId` (a page tree is
    * scoped to one space) and IGNORES `limit` — the whole hierarchy is returned.
-   * It fetches the tree via `enumerateSpacePages`, which on the fork server
-   * resolves to a single `/pages/tree` request returning the whole
-   * permission-filtered flat page set (soft-deleted pages excluded
-   * server-side).
+   * It walks the sidebar tree via `enumerateSpacePages`, which performs N
+   * sidebar requests and is bounded by that method's 10000-node cap (and skips
+   * soft-deleted pages server-side).
    */
   async listPages(spaceId?: string, limit: number = 50, tree: boolean = false) {
     await this.ensureAuthenticated();
@@ -642,8 +632,8 @@ export class DocmostClient {
           "list_pages: tree mode requires a spaceId (a page tree is scoped to one space). Pass spaceId, or omit tree to get the recent-pages list.",
         );
       }
-      const { pages } = await this.enumerateSpacePages(spaceId);
-      return buildPageTree(pages);
+      const nodes = await this.enumerateSpacePages(spaceId);
+      return buildPageTree(nodes);
     }
 
     const clampedLimit = Math.max(1, Math.min(100, limit));
@@ -665,123 +655,57 @@ export class DocmostClient {
   async listSidebarPages(spaceId: string, pageId?: string) {
     await this.ensureAuthenticated();
 
-    // Paginate via the server-issued cursor. The server switched from OFFSET
-    // (`page`) to CURSOR (`cursor`/`nextCursor`) pagination, and the global
-    // ValidationPipe(whitelist:true) SILENTLY STRIPS the obsolete `page` field
-    // — so the old offset loop got the SAME first page every time (with
-    // hasNextPage stuck true) and dropped every child beyond the first page.
+    // Paginate: the endpoint returns server-paged children, so posting only
+    // { page: 1 } silently dropped every child beyond the first page. Loop on
+    // meta.hasNextPage (with a MAX_PAGES ceiling like paginateAll, guarding
+    // against a stuck hasNextPage flag) and accumulate all children.
     const MAX_PAGES = 50;
-    let cursor: string | undefined;
+    let page = 1;
     let allItems: any[] = [];
-    let truncated = false;
+    let hasNextPage = true;
 
-    for (let i = 0; i < MAX_PAGES; i++) {
-      // limit: 100 is the server-side Max; cuts request count 5x vs the default 20.
-      const payload: Record<string, any> = { spaceId, limit: 100 };
+    while (hasNextPage && page <= MAX_PAGES) {
       // Only send pageId when scoping to a page's children; omit it for roots.
+      const payload: Record<string, any> = { spaceId, page };
       if (pageId) payload.pageId = pageId;
-      if (cursor) payload.cursor = cursor;
 
-      const data = (await this.client.post("/pages/sidebar-pages", payload)).data
-        ?.data;
-      allItems = allItems.concat(data?.items ?? []);
+      const response = await this.client.post("/pages/sidebar-pages", payload);
+      const data = response.data?.data ?? response.data;
+      const items = data?.items || [];
+      allItems = allItems.concat(items);
 
-      // Advance strictly via the server-issued cursor; a missing/repeated cursor
-      // means the protocol drifted again — stop instead of looping on page one.
-      const next = data?.meta?.hasNextPage ? data?.meta?.nextCursor : null;
-      if (!next || next === cursor) break;
-      cursor = next;
-
-      // Reaching the ceiling with more pages still available means the child
-      // list is truncated (mirrors paginateAll).
-      if (i === MAX_PAGES - 1) truncated = true;
-    }
-
-    // Warn on real truncation (ceiling hit while the server still had pages) so
-    // the caller is not silently handed an incomplete child list.
-    if (truncated) {
-      console.warn(
-        `listSidebarPages: children of "${pageId ?? spaceId}" truncated at the ${MAX_PAGES}-page cap; more pages exist on the server`,
-      );
+      hasNextPage = data?.meta?.hasNextPage || false;
+      page++;
     }
 
     return allItems;
   }
 
   /**
-   * Enumerate EVERY page in a space (or in a subtree, when rootPageId is given).
+   * Enumerate EVERY page in a space (or in a subtree, when rootPageId is given)
+   * by walking the sidebar-pages tree.
    *
-   * Primary path (fork server): a SINGLE `POST /pages/tree` returns the whole
-   * space (or a subtree) as a flat, permission-filtered list in one request, in
-   * the exact node shape buildPageTree consumes. This replaces the old
-   * per-node BFS, which issued N sidebar requests and — after the server moved
-   * to cursor pagination — silently lost every child past the first sidebar
-   * page (the obsolete `page` param was stripped by ValidationPipe).
+   * Starting set: the children of rootPageId when provided, otherwise the
+   * space root pages. From there it does an iterative breadth-first walk: each
+   * node is collected, and when node.hasChildren is true its direct children
+   * are fetched via listSidebarPages(spaceId, node.id) and enqueued.
    *
-   * The subtree variant (rootPageId given) INCLUDES the root node itself
-   * (getPageAndDescendants seeds with id = rootPageId), unlike the old BFS
-   * which started from the root's children.
+   * This replaces the old "/pages/recent" enumeration, which is a bounded
+   * recent-activity feed (~5000 cap) and therefore misses comments on older
+   * pages that were never recently touched.
    *
-   * Fallback path (stdio mode may target STOCK upstream Docmost, which lacks
-   * `/pages/tree`): on a 404/405 it falls back to the cursor-based BFS below,
-   * walking direct children via the fixed cursor listSidebarPages. Safeguards:
-   * a `visited` Set of page ids prevents re-processing a node (cycles /
-   * duplicate references), and a hard node cap bounds pathological trees so the
-   * walk always terminates.
-   *
-   * Returns `{ pages, truncated }`. `truncated` is true ONLY when the fallback
-   * BFS stopped at its MAX_NODES cap — the primary /pages/tree path is uncapped
-   * and always returns the complete set, so it never reports truncation.
+   * Safeguards: a `visited` Set of page ids prevents re-processing a node
+   * (cycles / duplicate references), and a hard node cap bounds pathological
+   * trees so the walk always terminates.
    */
   private async enumerateSpacePages(
     spaceId: string,
     rootPageId?: string,
-  ): Promise<{ pages: any[]; truncated: boolean }> {
-    await this.ensureAuthenticated();
-
-    // Single request replaces the whole BFS: /pages/tree returns the full
-    // permission-filtered flat page set of a space (or a subtree) at once. This
-    // path is uncapped, so it is never truncated.
-    const payload = rootPageId ? { pageId: rootPageId } : { spaceId };
-    try {
-      const response = await this.client.post("/pages/tree", payload);
-      const pages = (response.data?.data ?? response.data)?.items ?? [];
-      return { pages, truncated: false };
-    } catch (e: any) {
-      // Only fall back when the endpoint is absent (stock upstream Docmost);
-      // any other error is a genuine failure and must propagate.
-      if (
-        !axios.isAxiosError(e) ||
-        (e.response?.status !== 404 && e.response?.status !== 405)
-      ) {
-        throw e;
-      }
-    }
-
-    // Fallback: cursor-based breadth-first walk via listSidebarPages.
+  ): Promise<any[]> {
     const MAX_NODES = 10000;
     const result: any[] = [];
     const visited = new Set<string>();
 
-    // Seed with the root node itself when scoping to a subtree, so its own
-    // comments aren't dropped: the primary /pages/tree seeds
-    // getPageAndDescendants with id = rootPageId (root included), but
-    // listSidebarPages(spaceId, rootPageId) returns only the root's CHILDREN.
-    // The `visited` set below prevents a double-add if the root also appears
-    // among the children. getPageRaw returns a page whose id/title/spaceId are
-    // exactly what buildPageTree and check_new_comments consume.
-    if (rootPageId) {
-      try {
-        const root = await this.getPageRaw(rootPageId);
-        if (root?.id) {
-          result.push(root);
-          visited.add(root.id);
-        }
-      } catch {
-        // Non-fatal: if the root can't be read, fall through to children-only.
-      }
-    }
-
     // Seed the queue with the starting level (subtree children or roots).
     const queue: any[] = await this.listSidebarPages(spaceId, rootPageId);
 
@@ -806,12 +730,7 @@ export class DocmostClient {
       }
     }
 
-    // Truncated only when the cap was hit with the queue still non-empty (real
-    // truncation, not a natural end at exactly MAX_NODES).
-    return {
-      pages: result,
-      truncated: result.length >= MAX_NODES && queue.length > 0,
-    };
+    return result;
   }
 
   /** Raw page info including the ProseMirror JSON content and slugId. */
@@ -1661,27 +1580,6 @@ export class DocmostClient {
     }
   }
 
-  /**
-   * Pre-write SHAPE gate (#409). Walk the WHOLE node tree with the shared
-   * `findInvalidNode` and throw a rich, path-anchored error the instant a nested
-   * node has an absent/unknown `type` (or an unknown mark) — the exact shape that
-   * otherwise surfaces DEEP in the Yjs encode as the cryptic
-   * `Unknown node type: undefined`, but only AFTER a collab session was opened
-   * and a page lock taken. Calling this BEFORE `getCollabTokenWithReauth` /
-   * `mutatePageContent` fails fast: no collab connection, no lock, deterministic
-   * message. `op` names the tool for the message prefix (e.g. "patch_node").
-   *
-   * `findInvalidNode` derives its "known type" set from the very same
-   * `docmostExtensions` the encode path uses, so a node this gate accepts is one
-   * the encoder will accept too.
-   */
-  private assertValidNodeShape(op: string, node: any): void {
-    const bad = findInvalidNode(node);
-    if (bad) {
-      throw new Error(`${op}: invalid node — ${bad.summary}`);
-    }
-  }
-
   /**
    * Replace page content with a raw ProseMirror JSON document (lossless) and/or
    * update its title. Both `doc` and `title` are optional, but at least one must
@@ -1733,12 +1631,6 @@ export class DocmostClient {
     // page on overwrite.
     this.validateDocStructure(doc);
 
-    // #409: beyond the string-`type` check above, reject a nested node whose
-    // `type` is a string but NOT a known Docmost schema node (a typo/unknown
-    // block) — the same `Unknown node type` the encoder throws — with a rich,
-    // path-anchored message, still BEFORE any collab connection.
-    this.assertValidNodeShape("update_page_json", doc);
-
     // Sanitize URLs before writing. This closes the JSON-path bypass: unlike
     // the markdown link path (which TipTap sanitizes), raw JSON could otherwise
     // inject javascript:/data: link hrefs or media srcs straight into the doc.
@@ -2159,14 +2051,6 @@ export class DocmostClient {
       target.attrs.id = nodeId;
     }
 
-    // #409: fail fast on a malformed node SHAPE (a nested child with an
-    // absent/unknown `type`, e.g. a text leaf written as `{"text":"foo"}` with
-    // no `"type":"text"`) BEFORE opening a collab session or taking the page
-    // lock — the root-only `typeof node.type === "string"` check above never
-    // sees nested children, and the encoder's `Unknown node type: undefined`
-    // would otherwise only surface after the connection.
-    this.assertValidNodeShape("patch_node", target);
-
     const collabToken = await this.getCollabTokenWithReauth();
     // Open the collab doc by the canonical UUID, never the slugId (#260).
     const pageUuid = await this.resolvePageId(pageId);
@@ -2257,11 +2141,6 @@ export class DocmostClient {
       }
     }
 
-    // #409: fail fast on a malformed node SHAPE (a nested child with an
-    // absent/unknown `type`) BEFORE opening a collab session or taking the page
-    // lock — the root-only check above never sees nested children.
-    this.assertValidNodeShape("insert_node", node);
-
     const collabToken = await this.getCollabTokenWithReauth();
     // Open the collab doc by the canonical UUID, never the slugId (#260).
     const pageUuid = await this.resolvePageId(pageId);
@@ -2485,13 +2364,7 @@ export class DocmostClient {
     let allComments: any[] = [];
     let cursor: string | null = null;
 
-    // Hard ceiling + immovable-cursor guard (mirrors paginateAll): if /comments
-    // ever stops advancing the cursor (the exact #442 drift scenario) this loop
-    // would otherwise spin forever accumulating duplicates.
-    const MAX_PAGES = 50;
-    let truncated = false;
-
-    for (let page = 0; page < MAX_PAGES; page++) {
+    do {
       const payload: Record<string, any> = { pageId, limit: 100 };
       if (cursor) payload.cursor = cursor;
 
@@ -2499,23 +2372,8 @@ export class DocmostClient {
       const data = response.data.data || response.data;
       const items = data.items || [];
       allComments = allComments.concat(items);
-
-      // Advance strictly via the server-issued cursor. A missing nextCursor or a
-      // cursor identical to the one we just sent means the end (or a server that
-      // ignores our pagination param) — stop instead of re-fetching page one.
-      const next: string | null = data.meta?.nextCursor || null;
-      if (!next || next === cursor) break;
-      cursor = next;
-
-      // Reaching the ceiling with a still-advancing cursor means truncation.
-      if (page === MAX_PAGES - 1) truncated = true;
-    }
-
-    if (truncated) {
-      console.warn(
-        `listComments: comments for "${pageId}" truncated at the ${MAX_PAGES}-page cap; more pages exist on the server`,
-      );
-    }
+      cursor = data.meta?.nextCursor || null;
+    } while (cursor);
 
     const mapped = allComments.map((comment: any) => {
       const markdown = comment.content
@@ -2988,27 +2846,36 @@ export class DocmostClient {
       );
     }
 
-    // 1. Enumerate the FULL set of pages in scope via the page tree (a complete
-    // page index), NOT the bounded "/pages/recent" feed which caps at ~5000
-    // recent items and silently misses comments on older pages.
+    // 1. Enumerate the FULL set of pages in scope by walking the sidebar-pages
+    // tree (a complete page index), NOT the bounded "/pages/recent" feed which
+    // caps at ~5000 recent items and silently misses comments on older pages.
     //
     // Subtree scope: when parentPageId is given, the scope is that page ITSELF
-    // plus every descendant. Otherwise the scope is the whole space (all roots
-    // and their descendants).
+    // plus every descendant (enumerateSpacePages walks its children). Otherwise
+    // the scope is the whole space (all roots and their descendants).
     //
     // NOTE: do NOT pre-filter by page.updatedAt — creating a comment does not
     // bump it (verified on a live server), so such a filter silently misses
     // comments on pages that were not otherwise edited. The complete tree walk
     // already restricts the scope correctly, so no recent-feed allow-list is
     // needed any more.
-    //
-    // The subtree scope (parentPageId given) already INCLUDES the root node
-    // itself: /pages/tree seeds getPageAndDescendants with id = parentPageId, so
-    // no separate getPageRaw fetch for the parent is needed.
-    const { pages: pagesInScope, truncated } = await this.enumerateSpacePages(
-      spaceId,
-      parentPageId,
-    );
+    let pagesInScope: any[];
+    if (parentPageId) {
+      const subtree = await this.enumerateSpacePages(spaceId, parentPageId);
+      // Include the parent page node itself alongside its descendants. Fetch it
+      // so its title/id are available even though it is not returned by its own
+      // children listing.
+      let parentNode: any = { id: parentPageId };
+      try {
+        parentNode = await this.getPageRaw(parentPageId);
+      } catch (e: any) {
+        // Fall back to a minimal node if the parent can't be fetched; its
+        // comments are still attempted below (the fetch there is non-fatal).
+      }
+      pagesInScope = [parentNode, ...subtree];
+    } else {
+      pagesInScope = await this.enumerateSpacePages(spaceId);
+    }
 
     // 2. Fetch comments for each page, keep ones created after since
     const results: any[] = [];
@@ -3037,9 +2904,10 @@ export class DocmostClient {
       0,
     );
 
-    // `truncated` is reported by enumerateSpacePages: it is true ONLY when the
-    // stdio fallback BFS hit its node cap. The primary /pages/tree path is
-    // uncapped, so a space with legitimately many pages is not falsely flagged.
+    // enumerateSpacePages caps traversal at 10000 nodes; flag when that cap was
+    // hit so the caller knows the scan may be incomplete (some pages skipped).
+    const truncated = pagesInScope.length >= 10000;
+
     return {
       since,
       scope: parentPageId ? `subtree of ${parentPageId}` : `space ${spaceId}`,

packages/mcp/src/lib/collaboration.ts

@@ -13,11 +13,7 @@ import { JSDOM } from "jsdom";
 import { markdownToProseMirror } from "@docmost/prosemirror-markdown";
 import { docmostExtensions, docmostSchema } from "./docmost-schema.js";
 import { withPageLock } from "./page-lock.js";
-import {
-  sanitizeForYjs,
-  findUnstorableAttr,
-  findInvalidNode,
-} from "@docmost/prosemirror-markdown";
+import { sanitizeForYjs, findUnstorableAttr } from "@docmost/prosemirror-markdown";
 import { canonicalizeFootnotes } from "./footnote-canonicalize.js";
 import { normalizeAndMergeFootnotes } from "./footnote-normalize-merge.js";
 import { VerifyReport } from "./diff.js";
@@ -32,25 +28,11 @@ export { markdownToProseMirror };
  * place. `label` names the stage that failed (diagnostic). `sanitizeForYjs`
  * already stripped `undefined` attrs, so a remaining failure is pinpointed via
  * `findUnstorableAttr`.
- *
- * Diagnostics precedence (#409): the dominant crash here is
- * `Unknown node type: undefined` — a nested node with an absent/unknown `type`
- * (a SHAPE problem, e.g. `{"text":"foo"}` missing `"type":"text"`). That points
- * at the node, not an attribute, so `findInvalidNode` is consulted FIRST and,
- * on a hit, yields a path-anchored node-shape message. Only when the document
- * shape is sound do we fall back to `findUnstorableAttr` (undefined/function/
- * symbol/bigint attr values); the generic "attribute likely holds a value Yjs
- * cannot store" sentence is the last resort.
  */
 function unstorableYjsError(safe: any, label: string, e: unknown): Error {
-  const base = `Failed to encode document to Yjs (${label}): ${e instanceof Error ? e.message : String(e)}.`;
-  const badNode = findInvalidNode(safe);
-  if (badNode) {
-    return new Error(`${base} Invalid node: ${badNode.summary}`);
-  }
   const bad = findUnstorableAttr(safe);
   return new Error(
-    `${base}${bad ? ` Offending attribute: ${bad}.` : " A node/mark attribute likely holds a value Yjs cannot store (e.g. undefined)."}`,
+    `Failed to encode document to Yjs (${label}): ${e instanceof Error ? e.message : String(e)}.${bad ? ` Offending attribute: ${bad}.` : " A node/mark attribute likely holds a value Yjs cannot store (e.g. undefined)."}`,
   );
 }
 

packages/mcp/src/lib/footnote-normalize-merge.ts

@@ -6,7 +6,7 @@
  * typographic quotes («…»/“…”) vs ASCII "…", em/en-dash vs `-`, non-breaking
  * space vs normal space, differing space counts — are not recognized as equal
  * and "fork": two definitions appear where the author meant one. The existing
- * de-dup paths miss this: `footnoteContentKey` (footnote-authoring.ts) only
+ * de-dup paths miss this: `footnoteContentKey` (@docmost/prosemirror-markdown) only
  * collapses ASCII whitespace (quotes/dashes/NBSP untouched), and
  * `canonicalizeFootnotes` keys purely by `attrs.id` (the two forks have
  * different ids), so neither glues the forks together.
@@ -195,7 +195,7 @@ function stableAttrs(attrs: any): string {
 
 /**
  * ATTRS-AWARE merge key for a footnote definition. Deliberately DIVERGES from
- * the shared `footnoteContentKey` (footnote-authoring.ts): that key's mark
+ * the shared `footnoteContentKey` (@docmost/prosemirror-markdown): that key's mark
  * signature is TYPE-ONLY (`m.type`), so two definitions with identical visible
  * text but marks differing only in ATTRIBUTES — most importantly a `link` with a
  * different `href` (footnotes are usually citations/links), also `code` /

packages/mcp/src/tool-specs.ts

@@ -236,10 +236,7 @@ export const SHARED_TOOL_SPECS = {
       'heading {"type":"heading","attrs":{"level":2},"content":' +
       '[{"type":"text","text":"Title"}]}. Bold is a mark: ' +
       '{"type":"text","text":"x","marks":[{"type":"bold"}]}. The node may be a ' +
-      'JSON object or a JSON string (both accepted). EVERY node, including ' +
-      'nested children, must carry a string `type` from the Docmost schema; ' +
-      'text leaves are {"type":"text","text":"..."} (a bare {"text":"..."} is ' +
-      'rejected up front). Cheaper and safer than ' +
+      'JSON object or a JSON string (both accepted). Cheaper and safer than ' +
       'replacing the whole document for one-block structural edits. Reversible: ' +
       'the previous version is kept in page history.',
     tier: 'deferred',
@@ -285,10 +282,7 @@ export const SHARED_TOOL_SPECS = {
       '{"type":"paragraph","content":[{"type":"text","text":"Hello"}]} or a ' +
       'heading {"type":"heading","attrs":{"level":2},"content":' +
       '[{"type":"text","text":"Title"}]}. Bold is a mark: ' +
-      '{"type":"text","text":"x","marks":[{"type":"bold"}]}. EVERY node, ' +
-      'including nested children, must carry a string `type` from the Docmost ' +
-      'schema; text leaves are {"type":"text","text":"..."} (a bare ' +
-      '{"text":"..."} is rejected up front). The node may be a ' +
+      '{"type":"text","text":"x","marks":[{"type":"bold"}]}. The node may be a ' +
       'JSON object or a JSON string (both accepted). Reversible via page history.',
     tier: 'deferred',
     catalogLine:
@@ -711,10 +705,7 @@ export const SHARED_TOOL_SPECS = {
       '"paragraph","content":[{"type":"text","text":"Hi"}]}]}. `content` may be ' +
       'a JSON object or a JSON string (both accepted), and is OPTIONAL: omit it ' +
       'to update only the title (though prefer the rename-page tool for a title-only ' +
-      'change). Supplying neither content nor title is an error. EVERY node, ' +
-      'including nested children, must carry a string `type` from the Docmost ' +
-      'schema; text leaves are {"type":"text","text":"..."} (a bare ' +
-      '{"text":"..."} is rejected up front). Reversible: ' +
+      'change). Supplying neither content nor title is an error. Reversible: ' +
       'the previous version is kept in page history.',
     tier: 'deferred',
     catalogLine:

packages/mcp/test/mock/invalid-node-validation.test.mjs

@@ -1,240 +0,0 @@
-// Mock regression for the FAIL-FAST invalid-node validation (#409).
-//
-// A structural editor (patch_node / insert_node / update_page_json) given a doc
-// whose NESTED child has an absent/unknown `type` (the exact shape the Yjs
-// encoder rejects with `Unknown node type: undefined`) must throw a RICH,
-// path-anchored error BEFORE it ever opens a collab session or takes a page
-// lock. We prove the fail-fast by standing up a collab stack whose HTTP handler
-// records EVERY request: a correct fail-fast never even fetches the collab
-// token (which `getCollabTokenWithReauth`, called AFTER the validation, would
-// request), and never drives a document change on the Hocuspocus doc.
-//
-// The happy path (a well-formed doc) is exercised too: it must reach the collab
-// write and succeed, so the gate is not over-eager.
-//
-// findInvalidNode's per-shape summaries are unit-tested in the package
-// (test/find-invalid-node.test.ts); this exercises the END-TO-END wiring through
-// the real client methods.
-import { test, after } from "node:test";
-import assert from "node:assert/strict";
-import http from "node:http";
-import { WebSocketServer } from "ws";
-import { Hocuspocus } from "@hocuspocus/server";
-import { DocmostClient } from "../../build/client.js";
-import { buildYDoc } from "../../build/lib/collaboration.js";
-
-// A minimal valid seed doc with a real block id, so the happy-path patch_node
-// finds its target.
-const SEED_ID = "seed-para-id";
-function seedDoc() {
-  return {
-    type: "doc",
-    content: [
-      {
-        type: "paragraph",
-        attrs: { id: SEED_ID },
-        content: [{ type: "text", text: "seed" }],
-      },
-    ],
-  };
-}
-
-// Stand up an HTTP server that authenticates + hands out a collab token AND
-// upgrades /collab to a Hocuspocus instance seeded with the doc. `state` records
-// whether the collab token was ever fetched (proving the write path was entered)
-// and whether the Hocuspocus doc ever changed.
-async function spawnCollabStack() {
-  const state = { changed: false, collabTokenFetched: false };
-
-  const hocuspocus = new Hocuspocus({
-    quiet: true,
-    async onLoadDocument() {
-      return buildYDoc(seedDoc());
-    },
-    async onChange() {
-      state.changed = true;
-    },
-  });
-
-  const wss = new WebSocketServer({ noServer: true });
-
-  const server = http.createServer((req, res) => {
-    let raw = "";
-    req.on("data", (c) => (raw += c));
-    req.on("end", () => {
-      if (req.url === "/api/auth/login") {
-        res.writeHead(200, {
-          "Content-Type": "application/json",
-          "Set-Cookie": "authToken=t; Path=/; HttpOnly",
-        });
-        res.end(JSON.stringify({ success: true }));
-        return;
-      }
-      if (req.url === "/api/auth/collab-token") {
-        state.collabTokenFetched = true;
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ data: { token: "collab-jwt" } }));
-        return;
-      }
-      res.writeHead(404, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ message: "not found" }));
-    });
-  });
-
-  server.on("upgrade", (request, socket, head) => {
-    if (!request.url || !request.url.startsWith("/collab")) {
-      socket.destroy();
-      return;
-    }
-    wss.handleUpgrade(request, socket, head, (ws) => {
-      hocuspocus.handleConnection(ws, request);
-    });
-  });
-
-  const baseURL = await new Promise((resolve) => {
-    server.listen(0, "127.0.0.1", () => {
-      const { port } = server.address();
-      resolve(`http://127.0.0.1:${port}/api`);
-    });
-  });
-
-  openStacks.push({ server, hocuspocus });
-  return { state, baseURL };
-}
-
-const openStacks = [];
-after(async () => {
-  await Promise.all(
-    openStacks.map(
-      ({ server, hocuspocus }) =>
-        new Promise((resolve) => {
-          server.close(() => {
-            Promise.resolve(hocuspocus.destroy?.()).finally(resolve);
-          });
-        }),
-    ),
-  );
-});
-
-const PAGE = "11111111-1111-4111-8111-111111111111";
-
-// A node whose NESTED text leaf is missing "type":"text" (dominant #409 shape).
-const nestedTypelessNode = () => ({
-  type: "paragraph",
-  content: [{ text: "oops", marks: [] }],
-});
-
-// A node with a NESTED unknown type NAME (typo).
-const nestedUnknownTypeNode = () => ({
-  type: "paragraph",
-  content: [{ type: "paragraf", content: [{ type: "text", text: "x" }] }],
-});
-
-test("patch_node fails fast on a nested typeless node — no collab connection", async () => {
-  const { state, baseURL } = await spawnCollabStack();
-  const client = new DocmostClient(baseURL, "user@example.com", "pw");
-
-  await assert.rejects(
-    () => client.patchNode(PAGE, SEED_ID, nestedTypelessNode()),
-    (err) => {
-      assert.match(err.message, /patch_node: invalid node/);
-      assert.match(err.message, /missing "type"/);
-      assert.match(err.message, /content\[0\]/); // path-anchored
-      return true;
-    },
-  );
-
-  assert.equal(
-    state.collabTokenFetched,
-    false,
-    "must NOT fetch a collab token — validation runs before getCollabTokenWithReauth",
-  );
-  assert.equal(state.changed, false, "the collab doc must never be written");
-});
-
-test("insert_node fails fast on a nested UNKNOWN type — no collab connection", async () => {
-  const { state, baseURL } = await spawnCollabStack();
-  const client = new DocmostClient(baseURL, "user@example.com", "pw");
-
-  await assert.rejects(
-    () =>
-      client.insertNode(PAGE, nestedUnknownTypeNode(), {
-        position: "append",
-      }),
-    (err) => {
-      assert.match(err.message, /insert_node: invalid node/);
-      assert.match(err.message, /unknown node type "paragraf"/);
-      return true;
-    },
-  );
-
-  assert.equal(state.collabTokenFetched, false);
-  assert.equal(state.changed, false);
-});
-
-test("update_page_json fails fast on a nested typeless node — no collab connection", async () => {
-  const { state, baseURL } = await spawnCollabStack();
-  const client = new DocmostClient(baseURL, "user@example.com", "pw");
-
-  const badDoc = {
-    type: "doc",
-    content: [{ type: "paragraph", content: [{ text: "oops" }] }],
-  };
-
-  await assert.rejects(
-    () => client.updatePageJson(PAGE, badDoc),
-    (err) => {
-      // update_page_json runs validateDocStructure first (string-type check),
-      // which already rejects a typeless node — so the message may come from
-      // either guard, but the write must not happen.
-      assert.match(err.message, /type/i);
-      return true;
-    },
-  );
-
-  assert.equal(state.collabTokenFetched, false);
-  assert.equal(state.changed, false);
-});
-
-test("update_page_json fails fast on a nested UNKNOWN type name — rich #409 message", async () => {
-  const { state, baseURL } = await spawnCollabStack();
-  const client = new DocmostClient(baseURL, "user@example.com", "pw");
-
-  // validateDocStructure passes (type is a string); assertValidNodeShape must
-  // catch the unknown schema name and produce the rich path-anchored message.
-  const badDoc = {
-    type: "doc",
-    content: [{ type: "paragraf", content: [{ type: "text", text: "x" }] }],
-  };
-
-  await assert.rejects(
-    () => client.updatePageJson(PAGE, badDoc),
-    (err) => {
-      assert.match(err.message, /update_page_json: invalid node/);
-      assert.match(err.message, /unknown node type "paragraf"/);
-      return true;
-    },
-  );
-
-  assert.equal(state.collabTokenFetched, false);
-  assert.equal(state.changed, false);
-});
-
-test("patch_node with a well-formed node proceeds to the collab write", async () => {
-  const { state, baseURL } = await spawnCollabStack();
-  const client = new DocmostClient(baseURL, "user@example.com", "pw");
-
-  const result = await client.patchNode(PAGE, SEED_ID, {
-    type: "paragraph",
-    content: [{ type: "text", text: "replacement" }],
-  });
-
-  assert.equal(result.success, true);
-  assert.equal(result.replaced, 1);
-  assert.equal(
-    state.collabTokenFetched,
-    true,
-    "a valid node must reach the collab write path",
-  );
-  assert.equal(state.changed, true, "the collab doc must be written");
-});

packages/mcp/test/mock/pagination-cursor.test.mjs

@@ -1,440 +0,0 @@
-// Mock-HTTP tests for the cursor-pagination migration in DocmostClient (#442).
-//
-// The server switched its list endpoints from OFFSET (`page`) to CURSOR
-// (`cursor`/`nextCursor`) pagination, and the global ValidationPipe silently
-// strips the obsolete `page` field — so the old offset loops re-fetched page
-// one forever (hasNextPage stuck true), dropping every item past the first
-// page. These tests pin the new cursor behaviour and the immovable-cursor
-// guard that prevents a silent spin/duplication if the protocol drifts again.
-//
-// A local http.createServer stands in for Docmost so everything stays
-// deterministic and offline (same harness style as reauth.test.mjs).
-import { test, after } from "node:test";
-import assert from "node:assert/strict";
-import http from "node:http";
-import { DocmostClient } from "../../build/client.js";
-
-function readBody(req) {
-  return new Promise((resolve) => {
-    let raw = "";
-    req.on("data", (chunk) => {
-      raw += chunk;
-    });
-    req.on("end", () => resolve(raw));
-  });
-}
-
-function startServer(handler) {
-  return new Promise((resolve) => {
-    const server = http.createServer(handler);
-    server.listen(0, "127.0.0.1", () => {
-      const { port } = server.address();
-      resolve({ server, baseURL: `http://127.0.0.1:${port}/api` });
-    });
-  });
-}
-
-function closeServer(server) {
-  return new Promise((resolve) => server.close(resolve));
-}
-
-function sendJson(res, status, obj, extraHeaders = {}) {
-  res.writeHead(status, { "Content-Type": "application/json", ...extraHeaders });
-  res.end(JSON.stringify(obj));
-}
-
-const openServers = [];
-async function spawn(handler) {
-  const { server, baseURL } = await startServer(handler);
-  openServers.push(server);
-  return { server, baseURL };
-}
-
-after(async () => {
-  await Promise.all(openServers.map((s) => closeServer(s)));
-});
-
-// A login handler shared by every server below.
-function handleLogin(req, res) {
-  if (req.url === "/api/auth/login") {
-    sendJson(res, 200, { success: true }, {
-      "Set-Cookie": "authToken=t; Path=/; HttpOnly",
-    });
-    return true;
-  }
-  return false;
-}
-
-// -----------------------------------------------------------------------------
-// 1) listSidebarPages: collects every cursor page; #requests == #pages.
-// -----------------------------------------------------------------------------
-test("listSidebarPages walks all cursor pages and collects every item", async () => {
-  // Three pages keyed by the cursor the client sends back.
-  const PAGES = {
-    "": { items: [{ id: "a" }, { id: "b" }], nextCursor: "c1" },
-    c1: { items: [{ id: "c" }, { id: "d" }], nextCursor: "c2" },
-    c2: { items: [{ id: "e" }], nextCursor: null },
-  };
-  let requests = 0;
-  const sentLimits = [];
-
-  const { baseURL } = await spawn(async (req, res) => {
-    const raw = await readBody(req);
-    if (handleLogin(req, res)) return;
-    if (req.url === "/api/pages/sidebar-pages") {
-      requests++;
-      const body = JSON.parse(raw || "{}");
-      sentLimits.push(body.limit);
-      const page = PAGES[body.cursor ?? ""] ?? { items: [], nextCursor: null };
-      sendJson(res, 200, {
-        success: true,
-        data: {
-          items: page.items,
-          meta: {
-            hasNextPage: page.nextCursor != null,
-            nextCursor: page.nextCursor,
-          },
-        },
-      });
-      return;
-    }
-    sendJson(res, 404, {});
-  });
-
-  const client = new DocmostClient(baseURL, "user@example.com", "pw");
-  const all = await client.listSidebarPages("space-1");
-
-  assert.equal(requests, 3, "one request per cursor page");
-  assert.deepEqual(
-    all.map((p) => p.id),
-    ["a", "b", "c", "d", "e"],
-    "all items across all pages collected in order",
-  );
-  assert.ok(
-    sentLimits.every((l) => l === 100),
-    "requests limit:100 (server-side max)",
-  );
-});
-
-// -----------------------------------------------------------------------------
-// 2) REGRESSION on the bug class: server IGNORES the cursor param and always
-//    returns page one with hasNextPage:true -> the immovable-cursor guard must
-//    terminate the loop with no duplicates, NOT spin to MAX_PAGES.
-// -----------------------------------------------------------------------------
-test("listSidebarPages terminates (no dups) when the server ignores the cursor", async () => {
-  let requests = 0;
-
-  const { baseURL } = await spawn(async (req, res) => {
-    await readBody(req);
-    if (handleLogin(req, res)) return;
-    if (req.url === "/api/pages/sidebar-pages") {
-      requests++;
-      // Always the SAME first page with hasNextPage:true and the SAME cursor,
-      // exactly as a server that no longer understands our pagination param.
-      sendJson(res, 200, {
-        success: true,
-        data: {
-          items: [{ id: "x1" }, { id: "x2" }],
-          meta: { hasNextPage: true, nextCursor: "stuck" },
-        },
-      });
-      return;
-    }
-    sendJson(res, 404, {});
-  });
-
-  const client = new DocmostClient(baseURL, "user@example.com", "pw");
-  const all = await client.listSidebarPages("space-1");
-
-  // Request 1 (no cursor) gets "stuck"; request 2 (cursor "stuck") gets "stuck"
-  // again -> guard trips. Far below the MAX_PAGES=50 ceiling; no runaway dups.
-  assert.equal(requests, 2, "stops as soon as the cursor stops moving");
-  assert.equal(all.length, 4, "no runaway accumulation / duplication");
-});
-
-// -----------------------------------------------------------------------------
-// 3a) enumerateSpacePages happy path: a SINGLE /pages/tree request.
-// -----------------------------------------------------------------------------
-test("enumerateSpacePages (via list_pages tree) uses one /pages/tree request", async () => {
-  let treeRequests = 0;
-  let sidebarRequests = 0;
-  let treeBody = null;
-
-  const NODES = [
-    { id: "r1", slugId: "r1s", title: "Root 1", parentPageId: null, hasChildren: true, spaceId: "space-1", position: "a", icon: null, canEdit: true },
-    { id: "c1", slugId: "c1s", title: "Child 1", parentPageId: "r1", hasChildren: false, spaceId: "space-1", position: "a", icon: null, canEdit: true },
-    { id: "r2", slugId: "r2s", title: "Root 2", parentPageId: null, hasChildren: false, spaceId: "space-1", position: "b", icon: null, canEdit: true },
-  ];
-
-  const { baseURL } = await spawn(async (req, res) => {
-    const raw = await readBody(req);
-    if (handleLogin(req, res)) return;
-    if (req.url === "/api/pages/tree") {
-      treeRequests++;
-      treeBody = JSON.parse(raw || "{}");
-      sendJson(res, 200, { success: true, data: { items: NODES } });
-      return;
-    }
-    if (req.url === "/api/pages/sidebar-pages") {
-      sidebarRequests++;
-      sendJson(res, 200, { success: true, data: { items: [], meta: {} } });
-      return;
-    }
-    sendJson(res, 404, {});
-  });
-
-  const client = new DocmostClient(baseURL, "user@example.com", "pw");
-  // list_pages tree:true -> enumerateSpacePages(spaceId) -> buildPageTree.
-  const tree = await client.listPages("space-1", 50, true);
-
-  assert.equal(treeRequests, 1, "exactly one /pages/tree request for the space");
-  assert.equal(sidebarRequests, 0, "no per-node sidebar BFS requests");
-  assert.deepEqual(treeBody, { spaceId: "space-1" }, "space scope posts spaceId only");
-  // buildPageTree nests c1 under r1; two roots at the top level.
-  assert.equal(tree.length, 2, "two root nodes");
-  const r1 = tree.find((n) => n.id === "r1");
-  assert.equal(r1.children.length, 1, "child nested under its root");
-  assert.equal(r1.children[0].id, "c1");
-});
-
-// -----------------------------------------------------------------------------
-// 3b) enumerateSpacePages fallback: /pages/tree 404 -> cursor BFS via sidebar.
-// -----------------------------------------------------------------------------
-test("enumerateSpacePages falls back to the cursor BFS on /pages/tree 404", async () => {
-  let treeRequests = 0;
-  const sidebarCalls = [];
-
-  // Root level: one root with children. Child level (pageId=r1): one leaf.
-  const { baseURL } = await spawn(async (req, res) => {
-    const raw = await readBody(req);
-    if (handleLogin(req, res)) return;
-    if (req.url === "/api/pages/tree") {
-      treeRequests++;
-      // Stock upstream Docmost has no /pages/tree.
-      sendJson(res, 404, { message: "Not Found" });
-      return;
-    }
-    if (req.url === "/api/pages/sidebar-pages") {
-      const body = JSON.parse(raw || "{}");
-      sidebarCalls.push(body.pageId ?? "<root>");
-      if (!body.pageId) {
-        sendJson(res, 200, {
-          success: true,
-          data: {
-            items: [
-              { id: "r1", title: "Root", parentPageId: null, hasChildren: true },
-            ],
-            meta: { hasNextPage: false, nextCursor: null },
-          },
-        });
-      } else if (body.pageId === "r1") {
-        sendJson(res, 200, {
-          success: true,
-          data: {
-            items: [
-              { id: "c1", title: "Leaf", parentPageId: "r1", hasChildren: false },
-            ],
-            meta: { hasNextPage: false, nextCursor: null },
-          },
-        });
-      } else {
-        sendJson(res, 200, {
-          success: true,
-          data: { items: [], meta: { hasNextPage: false, nextCursor: null } },
-        });
-      }
-      return;
-    }
-    sendJson(res, 404, {});
-  });
-
-  const client = new DocmostClient(baseURL, "user@example.com", "pw");
-  const tree = await client.listPages("space-1", 50, true);
-
-  assert.ok(treeRequests >= 1, "the tree endpoint was attempted first");
-  assert.deepEqual(
-    sidebarCalls,
-    ["<root>", "r1"],
-    "fell back to the sidebar BFS: roots then the root's children",
-  );
-  assert.equal(tree.length, 1, "one root in the built tree");
-  assert.equal(tree[0].children[0].id, "c1", "leaf nested via the BFS");
-});
-
-// -----------------------------------------------------------------------------
-// 3c) enumerateSpacePages fallback SUBTREE: /pages/tree 404 + a rootPageId ->
-//     the ROOT page itself must be seeded (via getPageRaw) so its own comments
-//     aren't dropped. listSidebarPages(spaceId, root) returns only the root's
-//     CHILDREN, so without the seed the root would be absent. (Finding 1.)
-// -----------------------------------------------------------------------------
-test("enumerateSpacePages fallback subtree seeds the ROOT page itself", async () => {
-  const sidebarCalls = [];
-  let infoRequests = 0;
-  const commentedPages = [];
-
-  const { baseURL } = await spawn(async (req, res) => {
-    const raw = await readBody(req);
-    if (handleLogin(req, res)) return;
-    if (req.url === "/api/pages/tree") {
-      // Stock upstream Docmost -> fall back to the BFS.
-      sendJson(res, 404, { message: "Not Found" });
-      return;
-    }
-    if (req.url === "/api/pages/info") {
-      // getPageRaw for the root seed. Shape mirrors a real page-info response.
-      infoRequests++;
-      sendJson(res, 200, {
-        success: true,
-        data: { id: "root", title: "Root", spaceId: "space-1", hasChildren: true },
-      });
-      return;
-    }
-    if (req.url === "/api/pages/sidebar-pages") {
-      const body = JSON.parse(raw || "{}");
-      sidebarCalls.push(body.pageId ?? "<root>");
-      // Children of the root: one leaf. (Root itself is NOT in this list.)
-      const items =
-        body.pageId === "root"
-          ? [{ id: "leaf", title: "Leaf", parentPageId: "root", hasChildren: false }]
-          : [];
-      sendJson(res, 200, {
-        success: true,
-        data: { items, meta: { hasNextPage: false, nextCursor: null } },
-      });
-      return;
-    }
-    if (req.url === "/api/comments") {
-      const body = JSON.parse(raw || "{}");
-      commentedPages.push(body.pageId);
-      const items =
-        body.pageId === "root"
-          ? [{ id: "cm1", createdAt: "2030-01-01T00:00:00.000Z", content: null }]
-          : [];
-      sendJson(res, 200, {
-        success: true,
-        data: { items, meta: { nextCursor: null } },
-      });
-      return;
-    }
-    sendJson(res, 404, {});
-  });
-
-  const client = new DocmostClient(baseURL, "user@example.com", "pw");
-  // checkNewComments(space, since, parentPageId) exercises the subtree fallback.
-  const result = await client.checkNewComments(
-    "space-1",
-    "2020-01-01T00:00:00.000Z",
-    "root",
-  );
-
-  assert.equal(infoRequests, 1, "root was seeded via one getPageRaw");
-  assert.equal(sidebarCalls[0], "root", "BFS walked the root's children");
-  assert.ok(
-    commentedPages.includes("root"),
-    "the ROOT page is in scope (its comments were fetched) — not dropped",
-  );
-  assert.ok(commentedPages.includes("leaf"), "the descendant is in scope too");
-  assert.equal(result.checkedPages, 2, "root + one descendant scanned");
-  assert.equal(result.totalNewComments, 1, "the root's fresh comment found");
-});
-
-// -----------------------------------------------------------------------------
-// 5) listComments immovable-cursor guard: the server IGNORES the cursor and
-//    keeps returning the same nextCursor -> the loop must terminate (no
-//    infinite loop, no duplicates), not spin forever. (Finding 4.)
-// -----------------------------------------------------------------------------
-test("listComments terminates (no dups) when the server ignores the cursor", async () => {
-  let requests = 0;
-
-  const { baseURL } = await spawn(async (req, res) => {
-    await readBody(req);
-    if (handleLogin(req, res)) return;
-    if (req.url === "/api/comments") {
-      requests++;
-      // Always the SAME page with the SAME nextCursor, as a server that no
-      // longer advances the cursor would.
-      sendJson(res, 200, {
-        success: true,
-        data: {
-          items: [{ id: "cm1", createdAt: "2030-01-01T00:00:00.000Z", content: null }],
-          meta: { nextCursor: "stuck" },
-        },
-      });
-      return;
-    }
-    sendJson(res, 404, {});
-  });
-
-  const client = new DocmostClient(baseURL, "user@example.com", "pw");
-  const { items } = await client.listComments("page-1", true);
-
-  // Request 1 (no cursor) gets "stuck"; request 2 (cursor "stuck") gets "stuck"
-  // again -> guard trips. Bounded far below MAX_PAGES=50, no runaway dups.
-  assert.equal(requests, 2, "stops as soon as the cursor stops moving");
-  assert.equal(items.length, 2, "no runaway accumulation / duplication");
-});
-
-// -----------------------------------------------------------------------------
-// 4) check_new_comments subtree: the root is included in scope WITHOUT a
-//    separate getPageRaw (/pages/info) request for the parent.
-// -----------------------------------------------------------------------------
-test("checkNewComments subtree includes the root without a separate getPageRaw", async () => {
-  let pageInfoRequests = 0;
-  let treeBody = null;
-  const commentedPages = [];
-
-  // /pages/tree (subtree) returns the parent itself plus a descendant, exactly
-  // as getPageAndDescendants seeds with id = parentPageId.
-  const NODES = [
-    { id: "parent", title: "Parent", parentPageId: null, hasChildren: true },
-    { id: "kid", title: "Kid", parentPageId: "parent", hasChildren: false },
-  ];
-
-  const { baseURL } = await spawn(async (req, res) => {
-    const raw = await readBody(req);
-    if (handleLogin(req, res)) return;
-    if (req.url === "/api/pages/tree") {
-      treeBody = JSON.parse(raw || "{}");
-      sendJson(res, 200, { success: true, data: { items: NODES } });
-      return;
-    }
-    if (req.url === "/api/pages/info") {
-      // If checkNewComments still fetched the parent separately this would fire.
-      pageInfoRequests++;
-      sendJson(res, 200, { success: true, data: { id: "parent" } });
-      return;
-    }
-    if (req.url === "/api/comments") {
-      const body = JSON.parse(raw || "{}");
-      commentedPages.push(body.pageId);
-      // One fresh comment on the parent, none elsewhere.
-      const items =
-        body.pageId === "parent"
-          ? [{ id: "cm1", createdAt: "2030-01-01T00:00:00.000Z", content: null }]
-          : [];
-      sendJson(res, 200, {
-        success: true,
-        data: { items, meta: { nextCursor: null } },
-      });
-      return;
-    }
-    sendJson(res, 404, {});
-  });
-
-  const client = new DocmostClient(baseURL, "user@example.com", "pw");
-  const result = await client.checkNewComments(
-    "space-1",
-    "2020-01-01T00:00:00.000Z",
-    "parent",
-  );
-
-  assert.equal(pageInfoRequests, 0, "no separate getPageRaw for the root");
-  assert.deepEqual(treeBody, { pageId: "parent" }, "subtree scope posts pageId");
-  assert.ok(
-    commentedPages.includes("parent"),
-    "the root itself is in scope (comments fetched for it)",
-  );
-  assert.ok(commentedPages.includes("kid"), "descendants are in scope too");
-  assert.equal(result.checkedPages, 2, "root + one descendant scanned");
-  assert.equal(result.totalNewComments, 1, "the root's fresh comment found");
-});

packages/mcp/test/mock/reauth.test.mjs

@@ -297,12 +297,12 @@ test("a response with ONLY authTokenRefresh (no authToken) rejects login", async
 // -----------------------------------------------------------------------------
 // 5) paginateAll loop guards.
 // -----------------------------------------------------------------------------
-test("paginateAll stops at the MAX_PAGES cap when the server always issues a fresh cursor", async () => {
+test("paginateAll stops at the MAX_PAGES cap when hasNextPage is always true", async () => {
   let pageRequests = 0;
   const LIMIT = 100;
 
   const { baseURL } = await spawn(async (req, res) => {
-    const body = JSON.parse((await readBody(req)) || "{}");
+    await readBody(req);
     if (req.url === "/api/auth/login") {
       sendJson(res, 200, { success: true }, {
         "Set-Cookie": "authToken=t; Path=/; HttpOnly",
@@ -311,18 +311,15 @@ test("paginateAll stops at the MAX_PAGES cap when the server always issues a fre
     }
     if (req.url === "/api/spaces") {
       pageRequests++;
-      // Always return a FULL page AND hasNextPage:true with a FRESH nextCursor
-      // that differs from the one the client just sent, so the immovable-cursor
-      // guard never trips — only the MAX_PAGES ceiling can stop the loop.
+      // Always return a FULL page (== requested limit) AND hasNextPage:true.
+      // Both the page-length check and the hasNextPage flag say "keep going",
+      // so only the MAX_PAGES ceiling can stop the loop.
       const items = Array.from({ length: LIMIT }, (_, i) => ({
         id: `s-${pageRequests}-${i}`,
       }));
       sendJson(res, 200, {
         success: true,
-        data: {
-          items,
-          meta: { hasNextPage: true, nextCursor: `cursor-${pageRequests}` },
-        },
+        data: { items, meta: { hasNextPage: true } },
       });
       return;
     }
@@ -341,7 +338,7 @@ test("paginateAll stops at the MAX_PAGES cap when the server always issues a fre
   assert.equal(all.length, 50 * LIMIT, "accumulates one full page per request");
 });
 
-test("paginateAll stops on the immovable-cursor guard when the server ignores the cursor param", async () => {
+test("paginateAll stops early on a short page even if hasNextPage is true", async () => {
   let pageRequests = 0;
   const LIMIT = 100;
 
@@ -355,17 +352,15 @@ test("paginateAll stops on the immovable-cursor guard when the server ignores th
     }
     if (req.url === "/api/spaces") {
       pageRequests++;
-      // The bug class: the server IGNORES the pagination param and keeps
-      // returning page one with hasNextPage:true and the SAME nextCursor. The
-      // immovable-cursor guard must stop the loop instead of spinning to
-      // MAX_PAGES and duplicating items.
-      const items = Array.from({ length: LIMIT }, (_, i) => ({ id: `s-${i}` }));
+      // First page is full; second page is SHORT (fewer than limit). The short
+      // page must stop the loop immediately even though hasNextPage stays true.
+      const count = pageRequests === 1 ? LIMIT : 3;
+      const items = Array.from({ length: count }, (_, i) => ({
+        id: `s-${pageRequests}-${i}`,
+      }));
       sendJson(res, 200, {
         success: true,
-        data: {
-          items,
-          meta: { hasNextPage: true, nextCursor: "stuck" },
-        },
+        data: { items, meta: { hasNextPage: true } },
       });
       return;
     }
@@ -375,10 +370,8 @@ test("paginateAll stops on the immovable-cursor guard when the server ignores th
   const client = new DocmostClient(baseURL, "user@example.com", "pw");
   const all = await client.paginateAll("/spaces", {}, LIMIT);
 
-  // Request 1 sends no cursor and receives "stuck"; request 2 sends "stuck" and
-  // receives "stuck" again -> guard trips after exactly two requests, no dups.
-  assert.equal(pageRequests, 2, "stops once the cursor stops moving");
-  assert.equal(all.length, 2 * LIMIT, "no runaway accumulation past the guard");
+  assert.equal(pageRequests, 2, "stops right after the first short page");
+  assert.equal(all.length, LIMIT + 3, "full page + short page accumulated");
 });
 
 test("paginateAll handles both {data:{items,meta}} and {items,meta} envelopes", async () => {
@@ -394,16 +387,16 @@ test("paginateAll handles both {data:{items,meta}} and {items,meta} envelopes",
     }
     if (req.url === "/api/groups") {
       bareRequests.push(1);
-      // Page 1: hasNextPage true with a next cursor. Page 2: no next -> stop.
+      // Page 1: full page, hasNextPage true. Page 2: short page -> stop.
       if (bareRequests.length === 1) {
         sendJson(res, 200, {
           items: Array.from({ length: 100 }, (_, i) => ({ id: `g${i}` })),
-          meta: { hasNextPage: true, nextCursor: "c2" },
+          meta: { hasNextPage: true },
         });
       } else {
         sendJson(res, 200, {
           items: [{ id: "tail" }],
-          meta: { hasNextPage: false, nextCursor: null },
+          meta: { hasNextPage: false },
         });
       }
       return;

packages/mcp/test/unit/unstorable-yjs-error.test.mjs

@@ -1,82 +0,0 @@
-// #409: unstorableYjsError diagnostics PRECEDENCE. The opaque Yjs encode failure
-// (`Unknown node type: undefined`) is a node-SHAPE problem, so the shared
-// findInvalidNode is consulted FIRST and yields a path-anchored node message;
-// only a shape-sound doc falls back to findUnstorableAttr (undefined/function/
-// etc. attr values). Exercised through `assertYjsEncodable`, which runs the same
-// encode + error-wrapping the live write path uses.
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import { assertYjsEncodable } from "../../build/lib/collaboration.js";
-import {
-  findInvalidNode,
-  findUnstorableAttr,
-} from "@docmost/prosemirror-markdown";
-
-const doc = (...content) => ({ type: "doc", content });
-
-test("a nested typeless node yields the rich node-shape message (not an attr hint)", () => {
-  const bad = doc({
-    type: "paragraph",
-    content: [{ text: "oops", marks: [] }], // missing "type":"text"
-  });
-  assert.throws(
-    () => assertYjsEncodable(bad),
-    (err) => {
-      assert.match(err.message, /Invalid node:/);
-      assert.match(err.message, /missing "type"/);
-      assert.match(err.message, /content\[0\]/);
-      // It must NOT fall through to the generic attribute sentence.
-      assert.doesNotMatch(err.message, /Offending attribute/);
-      assert.doesNotMatch(
-        err.message,
-        /attribute likely holds a value Yjs cannot store/,
-      );
-      return true;
-    },
-  );
-});
-
-test("PRECEDENCE: a genuine undefined-attr case is a node-SHAPE-clean case, so the attr fallback fires", () => {
-  // A doc whose node shapes are ALL valid but that carries a Yjs-unstorable
-  // undefined attribute. unstorableYjsError checks findInvalidNode FIRST (must
-  // miss here) and only then findUnstorableAttr (must hit) — this is exactly the
-  // division of labor that keeps a real attr problem from being mislabelled as a
-  // node-shape problem, and vice versa. We assert the two helpers directly (the
-  // wrapper is not exported) because sanitizeForYjs strips undefined attrs before
-  // the live encoder ever sees them, so this branch cannot be reached through
-  // assertYjsEncodable without also failing the clone.
-  const attrProblem = doc({
-    type: "paragraph",
-    attrs: { id: "p1", indent: undefined },
-    content: [{ type: "text", text: "hi" }],
-  });
-  // findInvalidNode: shape is clean -> null (so the wrapper does NOT emit
-  // "Invalid node").
-  assert.equal(findInvalidNode(attrProblem), null);
-  // findUnstorableAttr: pinpoints the undefined attr -> the fallback message.
-  assert.match(findUnstorableAttr(attrProblem) ?? "", /indent \(undefined\)/);
-});
-
-test("PRECEDENCE: a node-shape problem is caught by findInvalidNode even when an attr is also unstorable", () => {
-  // Both a shape problem (typeless nested leaf) AND an unstorable attr exist;
-  // findInvalidNode wins, so the model is pointed at the node shape (the real
-  // root cause of `Unknown node type: undefined`), not the attribute.
-  const both = doc({
-    type: "paragraph",
-    attrs: { id: "p1", indent: undefined },
-    content: [{ text: "oops" }],
-  });
-  const shape = findInvalidNode(both);
-  assert.notEqual(shape, null);
-  assert.match(shape.summary, /missing "type"/);
-});
-
-test("a fully valid document encodes without throwing", () => {
-  const good = doc({
-    type: "paragraph",
-    attrs: { id: "p1" },
-    content: [{ type: "text", text: "hi" }],
-  });
-  assert.doesNotThrow(() => assertYjsEncodable(good));
-});

packages/prosemirror-markdown/src/lib/index.ts

@@ -56,7 +56,6 @@ export {
   deleteNodeById,
   sanitizeForYjs,
   findUnstorableAttr,
-  findInvalidNode,
   insertNodeRelative,
   readTable,
   insertTableRow,

packages/prosemirror-markdown/src/lib/node-ops.ts

@@ -14,9 +14,7 @@
  * `content`, non-object nodes, and absent `attrs` are tolerated.
  */
 
-import { getSchema } from "@tiptap/core";
 import { stripInlineMarkdown } from "./text-normalize.js";
-import { docmostExtensions } from "./docmost-schema.js";
 
 /** Deep-clone a JSON-serializable value without mutating the original. */
 function clone<T>(value: T): T {
@@ -385,119 +383,6 @@ export function findUnstorableAttr(doc: any): string | null {
   return null;
 }
 
-/**
- * The Docmost schema's known node and mark NAME sets, derived ONCE from the very
- * same `docmostExtensions` the Yjs encode path builds its schema from
- * (`getSchema(docmostExtensions)` — mirrored in mcp's `docmostSchema`). Deriving
- * both from the same extension list guarantees `findInvalidNode`'s "known type"
- * set matches exactly what `PMNode.fromJSON`/`toYdoc` will actually accept, so
- * the walker never flags a node the encoder would have stored (or vice versa).
- * Lazy + cached: the schema is only built on first use.
- */
-let schemaNames: { nodes: Set<string>; marks: Set<string> } | null = null;
-function getSchemaNames(): { nodes: Set<string>; marks: Set<string> } {
-  if (schemaNames == null) {
-    const schema = getSchema(docmostExtensions);
-    schemaNames = {
-      nodes: new Set(Object.keys(schema.nodes)),
-      marks: new Set(Object.keys(schema.marks)),
-    };
-  }
-  return schemaNames;
-}
-
-/**
- * Depth-first walk of the JSON `content` tree looking for the FIRST node whose
- * SHAPE the Yjs encode path will reject with an opaque
- * `Unknown node type: undefined` (issue #409). Returns `{ path, summary }` for
- * the offending node, or `null` when every node (and every mark) is a known
- * Docmost schema type.
- *
- * Two failure modes are detected, in order, per node:
- *   1. `type` is missing or not a string — the dominant `undefined` case, e.g.
- *      a text leaf written as `{"text":"foo"}` with no `"type":"text"`.
- *   2. `type` is a string but NOT a known Docmost node name (a typo / unknown
- *      block), OR one of the node's marks carries an unknown mark name.
- *
- * The returned `summary` is a model-actionable, path-anchored message such as:
- *   `node.content[2].content[0]: missing "type" (keys: text, marks) — did you
- *    mean {"type": "text", ...}?`
- * or for an unknown type:
- *   `node.content[1]: unknown node type "paragraf" — not in the Docmost schema`
- *
- * `path` is the same dotted JSON path used in the summary (e.g.
- * `node.content[2].content[0]`) so callers can surface it separately. Null-safe:
- * a non-object doc returns `null`.
- *
- * NOTE: This is a SHAPE check, not a full ProseMirror content-model validation
- * (it does not verify that a paragraph may legally contain a table, etc.). Its
- * job is to turn the specific "unknown/absent node type" Yjs crash into a clear,
- * pre-write diagnostic; the schema's own `.check()` still catches deeper
- * content-model violations at encode time.
- */
-export function findInvalidNode(
-  doc: any,
-): { path: string; summary: string } | null {
-  if (!isObject(doc)) return null;
-  const { nodes, marks } = getSchemaNames();
-
-  // Build the "did you mean" hint for a typeless node from its own keys, so the
-  // model sees WHICH object is malformed and the canonical text-leaf fix.
-  const keyHint = (node: Record<string, any>): string => {
-    const keys = Object.keys(node);
-    const looksLikeText =
-      typeof node.text === "string" && node.type === undefined;
-    const suffix = looksLikeText
-      ? ` — did you mean {"type": "text", ...}?`
-      : ` — every node needs a string "type" from the Docmost schema`;
-    return `missing "type" (keys: ${keys.join(", ") || "none"})${suffix}`;
-  };
-
-  const walk = (
-    node: any,
-    path: string,
-  ): { path: string; summary: string } | null => {
-    if (!isObject(node)) return null;
-
-    // (1) missing / non-string type.
-    if (typeof node.type !== "string") {
-      return { path, summary: `${path}: ${keyHint(node)}` };
-    }
-    // (2) string type that is not a known Docmost node.
-    if (!nodes.has(node.type)) {
-      return {
-        path,
-        summary: `${path}: unknown node type "${node.type}" — not in the Docmost schema`,
-      };
-    }
-    // (2b) unknown mark on an otherwise-valid node.
-    if (Array.isArray(node.marks)) {
-      for (let i = 0; i < node.marks.length; i++) {
-        const mark = node.marks[i];
-        if (isObject(mark) && typeof mark.type === "string" && !marks.has(mark.type)) {
-          return {
-            path: `${path}.marks[${i}]`,
-            summary: `${path}.marks[${i}]: unknown mark type "${mark.type}" — not in the Docmost schema`,
-          };
-        }
-      }
-    }
-
-    if (Array.isArray(node.content)) {
-      for (let i = 0; i < node.content.length; i++) {
-        const hit = walk(node.content[i], `${path}.content[${i}]`);
-        if (hit != null) return hit;
-      }
-    }
-    return null;
-  };
-
-  // The root doc node is addressed as "node" (matching the mcp arg name); its
-  // children are node.content[i]. The root itself is checked too so a typeless
-  // root is reported rather than silently skipped.
-  return walk(doc, "node");
-}
-
 /**
  * Table structural node types and the container each must live directly inside.
  * Used by `insertNodeRelative` to splice rows/cells into the correct ancestor

packages/prosemirror-markdown/test/find-invalid-node.test.ts

@@ -1,102 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { findInvalidNode } from '../src/lib/node-ops.js';
-
-// findInvalidNode (#409): a depth-first SHAPE gate that turns the encoder's
-// opaque `Unknown node type: undefined` into a path-anchored, pre-write
-// diagnostic. It flags the FIRST node whose `type` is absent/non-string or not
-// a known Docmost schema node, or that carries an unknown mark; returns null for
-// a well-formed doc.
-
-const doc = (...content: any[]) => ({ type: 'doc', content });
-const para = (...content: any[]) => ({
-  type: 'paragraph',
-  attrs: { id: 'p1' },
-  content,
-});
-const text = (value: string, marks?: any[]) => {
-  const node: any = { type: 'text', text: value };
-  if (marks) node.marks = marks;
-  return node;
-};
-
-describe('findInvalidNode', () => {
-  it('returns null for a fully valid document', () => {
-    const good = doc(
-      para(text('hello ', [{ type: 'bold' }]), text('world')),
-      {
-        type: 'heading',
-        attrs: { id: 'h1', level: 2 },
-        content: [text('Title')],
-      },
-    );
-    expect(findInvalidNode(good)).toBeNull();
-  });
-
-  it('flags a NESTED typeless text leaf with a path-precise summary', () => {
-    // A text leaf written as {"text":"foo"} with no "type":"text" — the dominant
-    // `Unknown node type: undefined` cause.
-    const bad = doc(
-      para(text('ok')),
-      para({ text: 'foo', marks: [] } as any),
-    );
-    const hit = findInvalidNode(bad);
-    expect(hit).not.toBeNull();
-    // Second paragraph (index 1), first child (index 0).
-    expect(hit!.path).toBe('node.content[1].content[0]');
-    expect(hit!.summary).toContain('node.content[1].content[0]');
-    expect(hit!.summary).toContain('missing "type"');
-    expect(hit!.summary).toContain('keys: text, marks');
-    expect(hit!.summary).toContain('did you mean {"type": "text", ...}');
-  });
-
-  it('flags a non-string type (e.g. numeric)', () => {
-    const bad = doc(para({ type: 123, content: [] } as any));
-    const hit = findInvalidNode(bad);
-    expect(hit).not.toBeNull();
-    expect(hit!.path).toBe('node.content[0].content[0]');
-    expect(hit!.summary).toContain('missing "type"');
-  });
-
-  it('flags an UNKNOWN node type name that is not in the Docmost schema', () => {
-    const bad = doc({
-      type: 'paragraf', // typo — not a real node
-      attrs: { id: 'x' },
-      content: [text('hi')],
-    });
-    const hit = findInvalidNode(bad);
-    expect(hit).not.toBeNull();
-    expect(hit!.path).toBe('node.content[0]');
-    expect(hit!.summary).toContain('unknown node type "paragraf"');
-    expect(hit!.summary).toContain('not in the Docmost schema');
-  });
-
-  it('flags an UNKNOWN mark type on an otherwise-valid node', () => {
-    const bad = doc(para(text('hi', [{ type: 'blink' }])));
-    const hit = findInvalidNode(bad);
-    expect(hit).not.toBeNull();
-    expect(hit!.path).toBe('node.content[0].content[0].marks[0]');
-    expect(hit!.summary).toContain('unknown mark type "blink"');
-  });
-
-  it('accepts every real Docmost node/mark type it is asked about', () => {
-    // Known node (callout) and known marks (italic, code) must NOT be flagged.
-    const good = doc({
-      type: 'callout',
-      attrs: { id: 'c1', type: 'info' },
-      content: [para(text('x', [{ type: 'italic' }, { type: 'code' }]))],
-    });
-    expect(findInvalidNode(good)).toBeNull();
-  });
-
-  it('reports the root itself when the root is typeless', () => {
-    const hit = findInvalidNode({ content: [] } as any);
-    expect(hit).not.toBeNull();
-    expect(hit!.path).toBe('node');
-  });
-
-  it('is null-safe for non-object input', () => {
-    expect(findInvalidNode(null)).toBeNull();
-    expect(findInvalidNode(undefined)).toBeNull();
-    expect(findInvalidNode('nope' as any)).toBeNull();
-  });
-});