test: check the built packages in plain Node, and turn the Next.js server-util test on again

packages/server-util/src/context/ServerBlockNoteEditor.ts

@@ -66,8 +66,8 @@ export class ServerBlockNoteEditor<
     globalThis.document = this.jsdom.window.document;
     (globalThis as any).window = this.jsdom.window;
     (globalThis as any).window.__TEST_OPTIONS = (
-      prevWindow as any
-    )?.__TEST_OPTIONS;
+      (prevWindow as any) ?? globalThis
+    ).__TEST_OPTIONS;
     try {
       return await fn();
     } finally {

packages/server-util/vitestSetup.ts

@@ -1,10 +1,11 @@
 import { afterEach, beforeEach } from "vite-plus/test";
 
+// No `window`, as in the Node apps that use this package. The editor reads
+// `__TEST_OPTIONS` off `globalThis` when there is no `window`.
 beforeEach(() => {
-  globalThis.window = globalThis.window || ({} as any);
-  (window as Window & { __TEST_OPTIONS?: any }).__TEST_OPTIONS = {};
+  (globalThis as { __TEST_OPTIONS?: object }).__TEST_OPTIONS = {};
 });
 
 afterEach(() => {
-  delete (window as Window & { __TEST_OPTIONS?: any }).__TEST_OPTIONS;
+  delete (globalThis as { __TEST_OPTIONS?: object }).__TEST_OPTIONS;
 });

tests/nextjs-test-app/.gitignore

@@ -3,3 +3,4 @@ node_modules
 .tarballs
 package-lock.json
 next-env.d.ts
+AGENTS.md

tests/nextjs-test-app/package.json

@@ -3,14 +3,16 @@
   "private": true,
   "version": "0.0.0",
   "dependencies": {
-    "@blocknote/core": "file:.tarballs/blocknote-core-0.50.0.tgz",
-    "@blocknote/mantine": "file:.tarballs/blocknote-mantine-0.50.0.tgz",
-    "@blocknote/react": "file:.tarballs/blocknote-react-0.50.0.tgz",
-    "@blocknote/server-util": "file:.tarballs/blocknote-server-util-0.50.0.tgz",
+    "@blocknote/core": "file:.tarballs/blocknote-core.tgz",
+    "@blocknote/mantine": "file:.tarballs/blocknote-mantine.tgz",
+    "@blocknote/react": "file:.tarballs/blocknote-react.tgz",
+    "@blocknote/server-util": "file:.tarballs/blocknote-server-util.tgz",
     "@mantine/core": "^9.0.2",
     "@mantine/hooks": "^9.0.2",
     "next": "^16.0.0",
     "react": "^19.2.3",
-    "react-dom": "^19.2.3"
+    "react-dom": "^19.2.3",
+    "y-prosemirror": "^1.3.7",
+    "yjs": "^13.6.33"
   }
 }

tests/nextjs-test-app/setup.sh

@@ -29,33 +29,13 @@ for pkg in core react server-util mantine; do
   pnpm pack --pack-destination "$TARBALLS_DIR" 2>/dev/null
 done
 
-# Update package.json to point to tarballs
+# Fixed names, so that package.json does not change with the version
 cd "$TARBALLS_DIR"
-CORE_TGZ=$(ls blocknote-core-*.tgz)
-REACT_TGZ=$(ls blocknote-react-*.tgz)
-SERVER_TGZ=$(ls blocknote-server-util-*.tgz)
-MANTINE_TGZ=$(ls blocknote-mantine-*.tgz)
+for pkg in core react server-util mantine; do
+  mv blocknote-$pkg-*.tgz blocknote-$pkg.tgz
+done
 
 cd "$SCRIPT_DIR"
-cat > package.json << EOF
-{
-  "name": "@blocknote/nextjs-test-app",
-  "private": true,
-  "version": "0.0.0",
-  "dependencies": {
-    "@blocknote/core": "file:.tarballs/$CORE_TGZ",
-    "@blocknote/mantine": "file:.tarballs/$MANTINE_TGZ",
-    "@blocknote/react": "file:.tarballs/$REACT_TGZ",
-    "@blocknote/server-util": "file:.tarballs/$SERVER_TGZ",
-    "@mantine/core": "^9.0.2",
-    "@mantine/hooks": "^9.0.2",
-    "next": "^16.0.0",
-    "react": "^19.2.3",
-    "react-dom": "^19.2.3"
-  }
-}
-EOF
-
 # Install with npm (not pnpm — avoid workspace resolution)
 rm -rf node_modules .next package-lock.json
 npm install --ignore-scripts

tests/src/unit/builtPackages/builtPackages.test.ts

@@ -0,0 +1,69 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { describe, expect, it } from "vite-plus/test";
+
+// These tests check the build output as an app installs it: in plain Node,
+// without the aliases to the sources that the other tests use. They cannot find
+// a missing dependency, as the workspace installs all of them (see nextjs/).
+const packagesDir = resolve(__dirname, "../../../../packages");
+
+function publishedPackages() {
+  return readdirSync(packagesDir).flatMap((dir) => {
+    const path = join(packagesDir, dir, "package.json");
+    if (!existsSync(path)) {
+      return [];
+    }
+    const pkg = JSON.parse(readFileSync(path, "utf8"));
+    return pkg.private ? [] : [{ dir, pkg }];
+  });
+}
+
+function exportTargets(exports: unknown): string[] {
+  if (typeof exports === "string") {
+    return [exports];
+  }
+  if (exports && typeof exports === "object") {
+    return Object.values(exports).flatMap(exportTargets);
+  }
+  return [];
+}
+
+function runNode(script: string, env: Record<string, string> = {}) {
+  return execFileSync(process.execPath, [join(__dirname, script)], {
+    encoding: "utf8",
+    env: { ...process.env, ...env },
+    timeout: 120_000,
+  });
+}
+
+// CI runs this after `vp run -r build`. Locally, it waits for a build.
+describe.skipIf(!existsSync(join(packagesDir, "core/dist")) && !process.env.CI)(
+  "Built packages",
+  () => {
+    it("point to files that exist", () => {
+      const missing = publishedPackages().flatMap(({ dir, pkg }) =>
+        [pkg.main, pkg.module, pkg.types, ...exportTargets(pkg.exports)]
+          .filter((target): target is string => typeof target === "string")
+          .filter((target) => !existsSync(resolve(packagesDir, dir, target)))
+          .map((target) => `${pkg.name}: ${target}`),
+      );
+      expect([...new Set(missing)]).toEqual([]);
+    });
+
+    it("load in plain Node", { timeout: 60_000 }, () => {
+      expect(JSON.parse(runNode("loadEntries.mjs"))).toEqual([]);
+    });
+
+    // React's development build crashed the process after the export (#3230).
+    it.each(["development", "production"])(
+      "export React and optional blocks on a server (NODE_ENV=%s)",
+      { timeout: 60_000 },
+      (nodeEnv) => {
+        expect(runNode("serverExport.mjs", { NODE_ENV: nodeEnv })).toContain(
+          "exported",
+        );
+      },
+    );
+  },
+);

tests/src/unit/builtPackages/loadEntries.mjs

@@ -0,0 +1,37 @@
+// Imports every entry of every published package from its build output, in
+// plain Node (no bundler, no Vitest), and prints the entries that fail as JSON.
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const packagesDir = resolve(import.meta.dirname, "../../../../packages");
+
+const failures = [];
+for (const dir of readdirSync(packagesDir)) {
+  const packageJSONPath = join(packagesDir, dir, "package.json");
+  if (!existsSync(packageJSONPath)) {
+    continue;
+  }
+  const pkg = JSON.parse(readFileSync(packageJSONPath, "utf8"));
+  if (pkg.private || !pkg.exports) {
+    continue;
+  }
+  for (const [subpath, target] of Object.entries(pkg.exports)) {
+    const file =
+      typeof target === "string" ? target : (target.import ?? target.default);
+    // Stylesheets and WebAssembly files are for bundlers, not for Node.
+    if (!file || !/\.m?js$/.test(file)) {
+      continue;
+    }
+    try {
+      await import(pathToFileURL(resolve(packagesDir, dir, file)).href);
+    } catch (error) {
+      failures.push({
+        entry: pkg.name + subpath.slice(1),
+        error: String(error).split("\n")[0],
+      });
+    }
+  }
+}
+
+console.log(JSON.stringify(failures));

tests/src/unit/builtPackages/serverExport.mjs

@@ -0,0 +1,73 @@
+// Exports a document with React and optional blocks through
+// `ServerBlockNoteEditor`, in plain Node from the build output, as a server
+// app does.
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const packagesDir = resolve(import.meta.dirname, "../../../../packages");
+
+function entry(dir) {
+  const pkg = JSON.parse(
+    readFileSync(join(packagesDir, dir, "package.json"), "utf8"),
+  );
+  return pathToFileURL(resolve(packagesDir, dir, pkg.exports["."].import)).href;
+}
+
+const { BlockNoteSchema } = await import(entry("core"));
+const { createReactBlockSpec } = await import(entry("react"));
+const { ServerBlockNoteEditor } = await import(entry("server-util"));
+const { createReactInlineMathSpec, createReactMathBlockSpec } = await import(
+  entry("math-block")
+);
+const { createReactDiagramBlockSpec } = await import(entry("diagram-block"));
+const { withMultiColumn } = await import(entry("xl-multi-column"));
+// The React that `@blocknote/react` uses, so that its hooks work.
+const { createElement, useEffect } = createRequire(
+  join(packagesDir, "react/package.json"),
+)("react");
+
+const reactBlock = createReactBlockSpec(
+  { type: "reactBlock", propSchema: {}, content: "inline" },
+  {
+    render: (props) => {
+      useEffect(() => {});
+      return createElement("p", { ref: props.contentRef });
+    },
+  },
+);
+
+const schema = withMultiColumn(BlockNoteSchema.create()).extend({
+  blockSpecs: {
+    mathBlock: createReactMathBlockSpec(),
+    diagram: createReactDiagramBlockSpec(),
+    reactBlock: reactBlock(),
+  },
+  inlineContentSpecs: { math: createReactInlineMathSpec() },
+});
+
+const blocks = [
+  {
+    type: "paragraph",
+    content: ["Inline ", { type: "math", content: "x^2" }, " math"],
+  },
+  { type: "mathBlock", content: "a^2 + b^2 = c^2" },
+  { type: "diagram", content: "graph TD\n  A --> B" },
+  { type: "reactBlock", content: "React block" },
+  {
+    type: "columnList",
+    children: [
+      { type: "column", children: [{ type: "paragraph", content: "Left" }] },
+      { type: "column", children: [{ type: "paragraph", content: "Right" }] },
+    ],
+  },
+];
+
+const editor = ServerBlockNoteEditor.create({ schema });
+await editor.blocksToMarkdownLossy(blocks);
+await editor.blocksToHTMLLossy(blocks);
+await editor.blocksToFullHTML(blocks);
+// Node runs React's queued work before it exits. A crash there (#3230) gives a
+// non-zero exit code, which fails the test.
+console.log("exported");

tests/src/unit/nextjs/serverUtil.test.ts

@@ -6,7 +6,7 @@ import { afterAll, beforeAll, describe, expect, it } from "vite-plus/test";
 const TEST_APP_DIR = path.resolve(__dirname, "../../../nextjs-test-app");
 let PORT: number;
 let BASE_URL: string;
-const MODE = (process.env.NEXTJS_TEST_MODE || "dev") as "dev" | "build";
+const MODE = process.env.NEXTJS_TEST_MODE as "dev" | "build" | undefined;
 
 let nextProcess: ChildProcess;
 let serverOutput = "";
@@ -16,13 +16,12 @@ let serverErrors = "";
  * Regression test for #942: @blocknote/server-util must work in Next.js
  * App Router server contexts (API routes) with serverExternalPackages.
  *
- * Set NEXTJS_TEST_MODE=build to test against a production build (slower
- * but catches different issues). Defaults to dev mode for fast iteration.
+ * Runs only when NEXTJS_TEST_MODE is set, as it packs the packages and
+ * installs them with npm: `dev`, or `build` for a production build (slower
+ * but catches different issues).
  */
-// TODO: Re-enable once @y/prosemirror v14 compatibility issues are resolved.
-// Currently fails because @y/y no longer exports `Text` (needed by @y/prosemirror's
-// sync-plugin) and stale tarball builds cause missing chunk errors.
-describe.skip(`server-util in Next.js App Router (#942) [${MODE}]`, () => {
+const describeIf = MODE ? describe : describe.skip;
+describeIf(`server-util in Next.js App Router (#942) [${MODE}]`, () => {
   beforeAll(async () => {
     PORT = await getPort({ portRange: [3900, 4100] });
     BASE_URL = `http://localhost:${PORT}`;