@matfsw/docusaurus-plantuml-plugin 1.6.2 → 1.7.0

package/CHANGELOG.md

@@ -7,6 +7,49 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.7.0] - 2026-09-02
+
+### Added
+
+- **Support for PlantUML diagrams up to 32768 points tall or wide, instead of 4096.** The
+  bundled `@plantuml/core` refuses to serialize anything larger, reporting
+  `Diagram too large for browser rendering: 278x5667 (max 4096)` — about forty stacked class
+  boxes, which a real architecture diagram or release runbook passes without trying.
+
+  It is not an SVG or a browser limit, and there is no engine option behind it:
+  `renderToString` takes only `{dark}`. Nor is there a way around it from diagram source. The
+  check reads the *pre-scale* dimensions, so `scale` does nothing; `skinparam dpi` does not
+  move it; `left to right direction` only swaps which of the two numbers is too large. Only
+  shrinking the layout by hand worked, which for a large diagram means drawing a different
+  diagram.
+
+  The plugin now rewrites that ceiling in the engine it serves. Diagrams that previously
+  showed an error panel render normally, in both dimensions. The rewrite is two literal
+  replacements whose occurrence counts are verified before either is applied, so a future
+  `@plantuml/core` that changes shape fails the build naming the version rather than silently
+  going unpatched — and the unit suite runs the patcher against the installed engine, so a
+  dependency bump catches it here first. See
+  [ADR 0007](docs/adr/0007-engine-size-ceiling-patch.md).
+
+### Changed
+
+- **The runtime assets moved to `assets/plantuml-client-<coreVersion>-max32768/`.** What is
+  served is a patched engine, so a reader holding a cached copy of the unpatched one must not
+  be handed it from the old URL. The standard library is nested inside that directory and is
+  therefore re-downloaded once. No configuration changes.
+- **A very large diagram is no longer refused quickly.** It renders instead, but the resulting
+  SVG is parsed synchronously twice on its way in — once to detect engine error pictures, once
+  by the sanitizer — so a diagram of many thousands of points can stall the tab briefly and may
+  need `renderTimeoutMs` raised above its 20 s default. A very wide diagram is scaled down to
+  the content column, which keeps the page layout intact but can leave it too small to read
+  until it is zoomed or maximized.
+
+## [1.6.3] - 2026-08-31
+
+### Changed
+
+- Bump the all group across 1 directory with 6 updates (#35)
+
 ## [1.6.2] - 2026-08-24
 
 ### Changed
@@ -609,7 +652,9 @@ Initial release.
   opt-out.
 - Plugin option validation that rejects unknown keys and out-of-range values at build time.
 
-[Unreleased]: https://github.com/matf/docusaurus-plantuml-plugin/compare/v1.6.2...HEAD
+[Unreleased]: https://github.com/matf/docusaurus-plantuml-plugin/compare/v1.7.0...HEAD
+[1.7.0]: https://github.com/matf/docusaurus-plantuml-plugin/compare/v1.6.3...v1.7.0
+[1.6.3]: https://github.com/matf/docusaurus-plantuml-plugin/compare/v1.6.2...v1.6.3
 [1.6.2]: https://github.com/matf/docusaurus-plantuml-plugin/compare/v1.6.1...v1.6.2
 [1.6.1]: https://github.com/matf/docusaurus-plantuml-plugin/compare/v1.6.0...v1.6.1
 [1.6.0]: https://github.com/matf/docusaurus-plantuml-plugin/compare/v1.5.2...v1.6.0

package/README.md

@@ -1043,7 +1043,7 @@ Failures are classified internally as one of:
 | Kind        | Cause                                                                                                                                                                                  |
 | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `load`      | `viz-global.js` or `plantuml.js` could not be fetched, timed out, or was not the expected module (usually a proxy or service worker returning the wrong file).                         |
-| `engine`    | The engine threw, or its output could not be used at all.                                                                                                                              |
+| `engine`    | The engine threw, or its output could not be used at all. Includes `Diagram too large for browser rendering: WxH (max 32768)` — see [Diagram size](#diagram-size).                     |
 | `diagram`   | The source is not valid PlantUML.                                                                                                                                                      |
 | `syntax`    | The source is not valid DOT. Carries Graphviz's own diagnostic, including the line number.                                                                                             |
 | `too-large` | A DOT source exceeded `graphviz.maxSourceBytes`.                                                                                                                                       |
@@ -1065,25 +1065,61 @@ The two engines report invalid source very differently:
 - **Invalid DOT is reported as structured data**, so the panel shows Graphviz's own message
   verbatim — `syntax error in line 3 near '}'` — with no heuristics involved.
 
+## Diagram size
+
+`@plantuml/core` refuses to serialize a diagram wider or taller than a fixed number of
+PlantUML points, reporting it through its error callback:
+
+```text
+Diagram too large for browser rendering: 78x12916 (max 4096)
+```
+
+Upstream that limit is **4096**. This plugin patches the engine it serves and raises it to
+**32768**, so diagrams that the stock engine rejects render normally here. It is not
+configurable — one constant, applied on every build.
+
+The limit is not something a diagram can talk its way around, which is why patching it was
+worth doing. Measured against the engine:
+
+| Attempt                   | Effect                                                   |
+| ------------------------- | -------------------------------------------------------- |
+| `scale 0.3`               | **none** — the check reads the pre-scale dimensions      |
+| `skinparam dpi 40`        | **none** — `dpi` affects raster output, not this measure |
+| `left to right direction` | none; it transposes width and height                     |
+| `skinparam ranksep 5`     | works — it genuinely shrinks the layout                  |
+
+If you still hit the ceiling at 32768, the levers that work are the ones that make the
+diagram smaller: fewer nodes and edges, tighter `skinparam ranksep`/`nodesep`, a smaller
+`skinparam defaultFontSize`, or splitting one diagram into several fences.
+
+**A very large diagram is not free.** A 30 000-point diagram is a multi-hundred-KB SVG, and
+both the error detection and the DOMPurify sanitization parse it synchronously on the main
+thread. Such a diagram can visibly stall the tab while it lands, and may need
+`renderTimeoutMs` raised above its 20 s default. See
+[ADR 0007](docs/adr/0007-engine-size-ceiling-patch.md).
+
 ## `baseUrl` support
 
 The runtime assets are emitted into
 
 ```text
-<baseUrl>assets/plantuml-client-<coreVersion>/
+<baseUrl>assets/plantuml-client-<coreVersion>-max32768/
 ```
 
 and resolved in the browser through Docusaurus' own `useBaseUrl()`. A site deployed at
 `baseUrl: '/plantuml-test/'` therefore fetches:
 
 ```text
-/plantuml-test/assets/plantuml-client-1.2026.6/viz-global.js
-/plantuml-test/assets/plantuml-client-1.2026.6/plantuml.js
+/plantuml-test/assets/plantuml-client-1.2026.6-max32768/viz-global.js
+/plantuml-test/assets/plantuml-client-1.2026.6-max32768/plantuml.js
 ```
 
 No path is hard-coded to the site root, so project-pages deployments and reverse-proxied
 subpaths work without configuration. The engine version is part of the directory name, so an
-upgrade changes the URL and stale caches are defeated automatically. The bundled example site
+upgrade changes the URL and stale caches are defeated automatically. The `-max32768` segment
+is part of the same identity: what is served is a _patched_ engine (see
+[Diagram size](#diagram-size)), and a reader holding a cached copy from a plugin version that
+patched differently must not be handed it from the same URL. The bundled example site
 deploys under a non-root `baseUrl` precisely so this path is exercised on every build.
 
 ## Browser compatibility
@@ -1430,6 +1466,16 @@ too and was rejected: it carries one person's account reach and expires on a cal
 - **One PlantUML diagram renders at a time.** The PlantUML engine has module-level shared
   state, so a page with many large diagrams renders them sequentially. This is a correctness
   requirement, not a tuning knob. Graphviz has no such constraint and is not queued.
+- **PlantUML diagrams are capped at 32768 points in each dimension.** The bundled engine has
+  a hard ceiling with no option behind it; the plugin patches it up from the stock 4096, but
+  it cannot be removed or configured. Past that, the diagram itself has to get smaller — see
+  [Diagram size](#diagram-size). The raised ceiling also means a genuinely enormous diagram
+  now renders instead of failing fast, and both the error detection and the sanitizer parse
+  the resulting SVG synchronously, so it can stall the tab on its way in.
+- **A `@plantuml/core` release that changes the shape of that ceiling fails the build.** The
+  patch is anchored on two literals whose occurrence counts are verified before anything is
+  rewritten, and the plugin refuses to guess. The unit suite runs the patcher against the
+  installed engine, so a dependency bump that broke it goes red here rather than in your build.
 - **Graphviz rendering blocks the main thread.** Viz.js lays out synchronously. A 300-edge
   graph takes ~26 ms, but a 3 000-edge graph takes ~2.25 s and visibly freezes the page;
   `graphviz.maxSourceBytes` is the guard. Rendering in a Web Worker would remove the ceiling
@@ -1452,7 +1498,7 @@ too and was rejected: it carries one person's account reach and expires on a cal
 ### Diagrams stay on "Loading PlantUML runtime…" and the assets 404 under a subpath
 
 Open the network tab and check the failing URL. It should be
-`<baseUrl>assets/plantuml-client-<version>/viz-global.js`. If the request goes to
+`<baseUrl>assets/plantuml-client-<version>-max32768/viz-global.js`. If the request goes to
 `/assets/...` when your site lives at `/docs/`, the site's `baseUrl` is wrong — not the
 plugin's paths, which are always resolved through `useBaseUrl()`.
 
@@ -1476,7 +1522,7 @@ served as `text/plain`, `application/octet-stream` or `text/html`. The console s
 MIME type checking error. Check with:
 
 ```bash
-curl -I https://example.com/your-base-url/assets/plantuml-client-1.2026.6/plantuml.js
+curl -I https://example.com/your-base-url/assets/plantuml-client-1.2026.6-max32768/plantuml.js
 ```
 
 The `content-type` must be a JavaScript type (`text/javascript` or

package/dist/constants.d.ts

@@ -10,7 +10,26 @@ export declare const PLUGIN_ID = "plantuml-client";
 /** Docusaurus' own default plugin instance id, mirrored to avoid a runtime import. */
 export declare const DEFAULT_PLUGIN_ID = "default";
 export declare const PLUGIN_NAME = "docusaurus-plugin-plantuml-client";
-/** Directory (relative to `baseUrl`) that the PlantUML runtime assets are emitted into. */
+/**
+ * The diagram size ceiling hard-coded in `@plantuml/core`'s own build, in PlantUML points.
+ *
+ * The engine compares the laid-out diagram's width and height against it and refuses anything
+ * larger with `Diagram too large for browser rendering: WxH (max 4096)`.
+ */
+export declare const UPSTREAM_MAX_DIAGRAM_SIZE = 4096;
+/**
+ * The ceiling this plugin patches into the engine it serves. See `src/enginePatch.ts` and
+ * `docs/adr/0007-engine-size-ceiling-patch.md`.
+ */
+export declare const MAX_DIAGRAM_SIZE = 32768;
+/**
+ * Directory (relative to `baseUrl`) that the PlantUML runtime assets are emitted into.
+ *
+ * The `-max…` segment is part of the engine's identity, not decoration: the file served here
+ * is a *patched* `plantuml.js`, so a reader holding a cached copy from a plugin version that
+ * patched to a different ceiling — or did not patch at all — must not be handed it from the
+ * same URL. Same reasoning as the `stdlib-<revision>` segment nested inside this one.
+ */
 export declare function assetsDirForVersion(coreVersion: string): string;
 export declare const VIZ_SCRIPT_FILENAME = "viz-global.js";
 export declare const PLANTUML_MODULE_FILENAME = "plantuml.js";

package/dist/constants.js

@@ -10,9 +10,28 @@ export const PLUGIN_ID = 'plantuml-client';
 /** Docusaurus' own default plugin instance id, mirrored to avoid a runtime import. */
 export const DEFAULT_PLUGIN_ID = 'default';
 export const PLUGIN_NAME = `docusaurus-plugin-${PLUGIN_ID}`;
-/** Directory (relative to `baseUrl`) that the PlantUML runtime assets are emitted into. */
+/**
+ * The diagram size ceiling hard-coded in `@plantuml/core`'s own build, in PlantUML points.
+ *
+ * The engine compares the laid-out diagram's width and height against it and refuses anything
+ * larger with `Diagram too large for browser rendering: WxH (max 4096)`.
+ */
+export const UPSTREAM_MAX_DIAGRAM_SIZE = 4096;
+/**
+ * The ceiling this plugin patches into the engine it serves. See `src/enginePatch.ts` and
+ * `docs/adr/0007-engine-size-ceiling-patch.md`.
+ */
+export const MAX_DIAGRAM_SIZE = 32_768;
+/**
+ * Directory (relative to `baseUrl`) that the PlantUML runtime assets are emitted into.
+ *
+ * The `-max…` segment is part of the engine's identity, not decoration: the file served here
+ * is a *patched* `plantuml.js`, so a reader holding a cached copy from a plugin version that
+ * patched to a different ceiling — or did not patch at all — must not be handed it from the
+ * same URL. Same reasoning as the `stdlib-<revision>` segment nested inside this one.
+ */
 export function assetsDirForVersion(coreVersion) {
-    return `assets/${PLUGIN_ID}-${coreVersion}`;
+    return `assets/${PLUGIN_ID}-${coreVersion}-max${MAX_DIAGRAM_SIZE}`;
 }
 export const VIZ_SCRIPT_FILENAME = 'viz-global.js';
 export const PLANTUML_MODULE_FILENAME = 'plantuml.js';

package/dist/enginePatch.d.ts

@@ -0,0 +1,41 @@
+/**
+ * How many bytes the patch adds. Every replacement is ASCII, so the byte delta is the
+ * character delta, and it is fixed for a given {@link MAX_DIAGRAM_SIZE}. This is what makes
+ * an already-generated file cheap to validate: its size is an exact fingerprint.
+ */
+export declare const PATCH_SIZE_DELTA: number;
+/**
+ * Rewrites the engine source so it accepts diagrams up to {@link MAX_DIAGRAM_SIZE} points.
+ *
+ * Both literals are counted *before* anything is replaced, so an engine that changed shape
+ * fails the build with a name attached rather than being silently half-patched. Patching the
+ * message as well as the comparison is not cosmetic — an engine that still reported
+ * `(max 4096)` while refusing at 32768 would send every future reader of that error down the
+ * wrong path. It is also safe: TeaVM's string pool is a plain list of JavaScript string
+ * literals, so a literal that changes length does not disturb its neighbours.
+ */
+export declare function patchEngineSource(source: string, coreVersion: string): string;
+export interface ResolvePatchedEngineOptions {
+    /** Absolute path of the vendored `plantuml.js` inside the installed `@plantuml/core`. */
+    vendoredPath: string;
+    /** Installed `@plantuml/core` version, which names the cache directory. */
+    coreVersion: string;
+    /** Site directory, used when `cacheDir` is absent. */
+    siteDir: string;
+    /**
+     * Where the patched engine is cached. Docusaurus passes its `generatedFilesDir`; when it
+     * is absent the site's `.docusaurus` directory is assumed, as in `src/stdlib.ts`.
+     */
+    cacheDir?: string;
+}
+/**
+ * Returns the path of the `plantuml.js` this build should serve, generating it if needed.
+ *
+ * The basename stays `plantuml.js`: the copy pattern emits `[name][ext]`, and the browser
+ * loader joins {@link PLANTUML_MODULE_FILENAME} onto the assets directory.
+ *
+ * Generation is skipped when the cached file is already the right size. That check is exact
+ * rather than approximate — {@link PATCH_SIZE_DELTA} is fixed — and it is O(1) where reading
+ * 7 MB back to inspect its contents would not be.
+ */
+export declare function resolvePatchedEngine(options: ResolvePatchedEngineOptions): string;

package/dist/enginePatch.js

@@ -0,0 +1,120 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { MAX_DIAGRAM_SIZE, PLANTUML_MODULE_FILENAME, PLUGIN_NAME, UPSTREAM_MAX_DIAGRAM_SIZE, } from './constants.js';
+/**
+ * Raises the diagram size ceiling compiled into `@plantuml/core`.
+ *
+ * The engine measures the laid-out diagram and refuses to serialize anything wider or taller
+ * than 4096 points, reporting `Diagram too large for browser rendering: 78x12916 (max 4096)`
+ * through its error callback. `renderToString` takes only `{dark}`, so there is no option to
+ * turn this off, and no way to work around it from diagram source: the check runs *before* a
+ * `scale` directive is applied, `skinparam dpi` does not move it, and `left to right
+ * direction` only transposes the two numbers. Shrinking the Graphviz layout by hand —
+ * `skinparam ranksep`, fewer nodes, smaller fonts — is the only lever an author has.
+ *
+ * The ceiling is arbitrary. It is not an SVG or a browser constraint; patched to 65536 the
+ * same engine produced correct SVG for a 79x43157 diagram. So this plugin patches it, and
+ * serves the patched file rather than the vendored one.
+ *
+ * See `docs/adr/0007-engine-size-ceiling-patch.md` for the evidence and the rejected
+ * alternatives.
+ */
+/**
+ * The comparison the engine guards on, as it appears in the minified bundle:
+ *
+ * ```js
+ * p=o.bBY;if(!(p>4096.0)){q=o.bB0;if(!(q>4096.0)){ …serialize… }}
+ * ```
+ *
+ * Deliberately anchored on `>4096.0)` rather than on the surrounding code: `p`, `q` and `o`
+ * are TeaVM-mangled locals that are renamed by every `@plantuml/core` build, so a pattern
+ * that named them would break on a release that changed nothing meaningful.
+ */
+const COMPARISON = `>${UPSTREAM_MAX_DIAGRAM_SIZE}.0)`;
+/**
+ * `4096.0` occurs exactly twice in the whole 7 MB bundle, and both occurrences are the width
+ * and height halves of this one guard. That makes the count the safety property: two matches
+ * means the engine still has the shape this patch was written against, and any other number
+ * means it does not.
+ */
+const COMPARISON_OCCURRENCES = 2;
+/** The suffix of the engine's own error message, in TeaVM's string pool. */
+const MESSAGE_SUFFIX = ` (max ${UPSTREAM_MAX_DIAGRAM_SIZE})`;
+const MESSAGE_SUFFIX_OCCURRENCES = 1;
+const PATCHED_COMPARISON = `>${MAX_DIAGRAM_SIZE}.0)`;
+const PATCHED_MESSAGE_SUFFIX = ` (max ${MAX_DIAGRAM_SIZE})`;
+/**
+ * How many bytes the patch adds. Every replacement is ASCII, so the byte delta is the
+ * character delta, and it is fixed for a given {@link MAX_DIAGRAM_SIZE}. This is what makes
+ * an already-generated file cheap to validate: its size is an exact fingerprint.
+ */
+export const PATCH_SIZE_DELTA = COMPARISON_OCCURRENCES * (PATCHED_COMPARISON.length - COMPARISON.length) +
+    MESSAGE_SUFFIX_OCCURRENCES * (PATCHED_MESSAGE_SUFFIX.length - MESSAGE_SUFFIX.length);
+/** Directory under the Docusaurus cache that generated engine builds live in. */
+const CACHE_SUBDIRECTORY = 'plantuml-engine';
+function countOccurrences(haystack, needle) {
+    let count = 0;
+    let index = haystack.indexOf(needle);
+    while (index !== -1) {
+        count += 1;
+        index = haystack.indexOf(needle, index + needle.length);
+    }
+    return count;
+}
+function assertOccurrences(source, needle, expected, coreVersion) {
+    const found = countOccurrences(source, needle);
+    if (found === expected)
+        return;
+    throw new Error(`[${PLUGIN_NAME}] Cannot raise the diagram size ceiling of ` +
+        `'@plantuml/core@${coreVersion}': expected ${expected} occurrence(s) of ` +
+        `${JSON.stringify(needle)} in '${PLANTUML_MODULE_FILENAME}', found ${found}. ` +
+        'The engine no longer has the shape this plugin patches, which means the installed ' +
+        '@plantuml/core is not one this plugin supports. Pin @plantuml/core to the last ' +
+        'version that worked, or upgrade this plugin.');
+}
+/**
+ * Rewrites the engine source so it accepts diagrams up to {@link MAX_DIAGRAM_SIZE} points.
+ *
+ * Both literals are counted *before* anything is replaced, so an engine that changed shape
+ * fails the build with a name attached rather than being silently half-patched. Patching the
+ * message as well as the comparison is not cosmetic — an engine that still reported
+ * `(max 4096)` while refusing at 32768 would send every future reader of that error down the
+ * wrong path. It is also safe: TeaVM's string pool is a plain list of JavaScript string
+ * literals, so a literal that changes length does not disturb its neighbours.
+ */
+export function patchEngineSource(source, coreVersion) {
+    assertOccurrences(source, COMPARISON, COMPARISON_OCCURRENCES, coreVersion);
+    assertOccurrences(source, MESSAGE_SUFFIX, MESSAGE_SUFFIX_OCCURRENCES, coreVersion);
+    return source
+        .split(COMPARISON)
+        .join(PATCHED_COMPARISON)
+        .split(MESSAGE_SUFFIX)
+        .join(PATCHED_MESSAGE_SUFFIX);
+}
+/**
+ * Returns the path of the `plantuml.js` this build should serve, generating it if needed.
+ *
+ * The basename stays `plantuml.js`: the copy pattern emits `[name][ext]`, and the browser
+ * loader joins {@link PLANTUML_MODULE_FILENAME} onto the assets directory.
+ *
+ * Generation is skipped when the cached file is already the right size. That check is exact
+ * rather than approximate — {@link PATCH_SIZE_DELTA} is fixed — and it is O(1) where reading
+ * 7 MB back to inspect its contents would not be.
+ */
+export function resolvePatchedEngine(options) {
+    const { vendoredPath, coreVersion, siteDir, cacheDir } = options;
+    const generatedDir = cacheDir ?? path.join(siteDir, '.docusaurus');
+    const target = path.join(generatedDir, CACHE_SUBDIRECTORY, coreVersion, PLANTUML_MODULE_FILENAME);
+    const expectedSize = fs.statSync(vendoredPath).size + PATCH_SIZE_DELTA;
+    if (fs.existsSync(target) && fs.statSync(target).size === expectedSize)
+        return target;
+    const patched = patchEngineSource(fs.readFileSync(vendoredPath, 'utf8'), coreVersion);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    // `.docusaurus` is shared by every locale, and Docusaurus builds locales in separate
+    // processes. Writing 7 MB in place would let a concurrent build read a torn file — and a
+    // torn file of the right length would pass the size check above. Rename is atomic.
+    const temporary = `${target}.${process.pid}.tmp`;
+    fs.writeFileSync(temporary, patched, 'utf8');
+    fs.renameSync(temporary, target);
+    return target;
+}

package/dist/index.cjs

@@ -46,7 +46,7 @@ var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${_
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // src/index.ts
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 var import_node_url = require("url");
 var import_copy_webpack_plugin = __toESM(require("copy-webpack-plugin"), 1);
 
@@ -59,8 +59,10 @@ var import_node_path = __toESM(require("path"), 1);
 var PLUGIN_ID = "plantuml-client";
 var DEFAULT_PLUGIN_ID = "default";
 var PLUGIN_NAME = `docusaurus-plugin-${PLUGIN_ID}`;
+var UPSTREAM_MAX_DIAGRAM_SIZE = 4096;
+var MAX_DIAGRAM_SIZE = 32768;
 function assetsDirForVersion(coreVersion) {
-  return `assets/${PLUGIN_ID}-${coreVersion}`;
+  return `assets/${PLUGIN_ID}-${coreVersion}-max${MAX_DIAGRAM_SIZE}`;
 }
 var VIZ_SCRIPT_FILENAME = "viz-global.js";
 var PLANTUML_MODULE_FILENAME = "plantuml.js";
@@ -94,6 +96,52 @@ function assertRuntimeFile(file, version) {
   );
 }
 
+// src/enginePatch.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var COMPARISON = `>${UPSTREAM_MAX_DIAGRAM_SIZE}.0)`;
+var COMPARISON_OCCURRENCES = 2;
+var MESSAGE_SUFFIX = ` (max ${UPSTREAM_MAX_DIAGRAM_SIZE})`;
+var MESSAGE_SUFFIX_OCCURRENCES = 1;
+var PATCHED_COMPARISON = `>${MAX_DIAGRAM_SIZE}.0)`;
+var PATCHED_MESSAGE_SUFFIX = ` (max ${MAX_DIAGRAM_SIZE})`;
+var PATCH_SIZE_DELTA = COMPARISON_OCCURRENCES * (PATCHED_COMPARISON.length - COMPARISON.length) + MESSAGE_SUFFIX_OCCURRENCES * (PATCHED_MESSAGE_SUFFIX.length - MESSAGE_SUFFIX.length);
+var CACHE_SUBDIRECTORY = "plantuml-engine";
+function countOccurrences(haystack, needle) {
+  let count = 0;
+  let index = haystack.indexOf(needle);
+  while (index !== -1) {
+    count += 1;
+    index = haystack.indexOf(needle, index + needle.length);
+  }
+  return count;
+}
+function assertOccurrences(source, needle, expected, coreVersion) {
+  const found = countOccurrences(source, needle);
+  if (found === expected) return;
+  throw new Error(
+    `[${PLUGIN_NAME}] Cannot raise the diagram size ceiling of '@plantuml/core@${coreVersion}': expected ${expected} occurrence(s) of ${JSON.stringify(needle)} in '${PLANTUML_MODULE_FILENAME}', found ${found}. The engine no longer has the shape this plugin patches, which means the installed @plantuml/core is not one this plugin supports. Pin @plantuml/core to the last version that worked, or upgrade this plugin.`
+  );
+}
+function patchEngineSource(source, coreVersion) {
+  assertOccurrences(source, COMPARISON, COMPARISON_OCCURRENCES, coreVersion);
+  assertOccurrences(source, MESSAGE_SUFFIX, MESSAGE_SUFFIX_OCCURRENCES, coreVersion);
+  return source.split(COMPARISON).join(PATCHED_COMPARISON).split(MESSAGE_SUFFIX).join(PATCHED_MESSAGE_SUFFIX);
+}
+function resolvePatchedEngine(options) {
+  const { vendoredPath, coreVersion, siteDir, cacheDir } = options;
+  const generatedDir = cacheDir ?? import_node_path2.default.join(siteDir, ".docusaurus");
+  const target = import_node_path2.default.join(generatedDir, CACHE_SUBDIRECTORY, coreVersion, PLANTUML_MODULE_FILENAME);
+  const expectedSize = import_node_fs2.default.statSync(vendoredPath).size + PATCH_SIZE_DELTA;
+  if (import_node_fs2.default.existsSync(target) && import_node_fs2.default.statSync(target).size === expectedSize) return target;
+  const patched = patchEngineSource(import_node_fs2.default.readFileSync(vendoredPath, "utf8"), coreVersion);
+  import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(target), { recursive: true });
+  const temporary = `${target}.${process.pid}.tmp`;
+  import_node_fs2.default.writeFileSync(temporary, patched, "utf8");
+  import_node_fs2.default.renameSync(temporary, target);
+  return target;
+}
+
 // src/options.ts
 var GRAPHVIZ_ENGINES = [
   "circo",
@@ -405,12 +453,12 @@ function resolveOptions(rawOptions) {
 
 // src/stdlib.ts
 var import_node_crypto = __toESM(require("crypto"), 1);
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 
 // src/stdlibBundle.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 
 // src/stdlibShared.ts
 var STDLIB_EXAMPLES_DIRECTORY = "_examples_";
@@ -444,17 +492,17 @@ function isSkippedDirectory(name) {
   return name.startsWith("_") && name.endsWith("_");
 }
 function collectFiles(directory, namespaceRoot) {
-  const entries = import_node_fs2.default.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+  const entries = import_node_fs3.default.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
   const files = [];
   for (const entry of entries) {
-    const absolutePath = import_node_path2.default.join(directory, entry.name);
+    const absolutePath = import_node_path3.default.join(directory, entry.name);
     if (entry.isDirectory()) {
       if (!isSkippedDirectory(entry.name)) files.push(...collectFiles(absolutePath, namespaceRoot));
       continue;
     }
-    const extension = import_node_path2.default.extname(entry.name).toLowerCase();
+    const extension = import_node_path3.default.extname(entry.name).toLowerCase();
     if (extension !== ".puml" && extension !== ".json") continue;
-    const key = import_node_path2.default.relative(namespaceRoot, absolutePath).split(import_node_path2.default.sep).join("/").toLowerCase();
+    const key = import_node_path3.default.relative(namespaceRoot, absolutePath).split(import_node_path3.default.sep).join("/").toLowerCase();
     files.push({
       key,
       absolutePath,
@@ -465,9 +513,9 @@ function collectFiles(directory, namespaceRoot) {
   return files;
 }
 function readNamespaceInfo(namespaceRoot) {
-  const readme = import_node_path2.default.join(namespaceRoot, "README.md");
-  if (!import_node_fs2.default.existsSync(readme)) return {};
-  const lines = import_node_fs2.default.readFileSync(readme, "utf8").split(/\r\n|\r|\n/);
+  const readme = import_node_path3.default.join(namespaceRoot, "README.md");
+  if (!import_node_fs3.default.existsSync(readme)) return {};
+  const lines = import_node_fs3.default.readFileSync(readme, "utf8").split(/\r\n|\r|\n/);
   if (lines[0]?.trim() !== "---") return {};
   const info = {};
   for (const line of lines.slice(1)) {
@@ -506,8 +554,8 @@ function stdlibBundleFileName(namespace) {
   return `${namespace.toLowerCase()}.min.js`;
 }
 function buildStdlibNamespace(stdlibRoot, directoryName) {
-  const namespaceRoot = import_node_path2.default.join(stdlibRoot, directoryName);
-  if (!import_node_fs2.default.existsSync(namespaceRoot) || !import_node_fs2.default.statSync(namespaceRoot).isDirectory()) {
+  const namespaceRoot = import_node_path3.default.join(stdlibRoot, directoryName);
+  if (!import_node_fs3.default.existsSync(namespaceRoot) || !import_node_fs3.default.statSync(namespaceRoot).isDirectory()) {
     throw new Error(`'${namespaceRoot}' is not a plantuml-stdlib namespace directory.`);
   }
   const namespace = directoryName.toLowerCase();
@@ -528,7 +576,7 @@ function buildStdlibNamespace(stdlibRoot, directoryName) {
     `  var J = (w.PLANTUML_STDLIB_JSON[${quoted}] = w.PLANTUML_STDLIB_JSON[${quoted}] || {});`
   ];
   for (const file of files) {
-    const text = import_node_fs2.default.readFileSync(file.absolutePath, "utf8");
+    const text = import_node_fs3.default.readFileSync(file.absolutePath, "utf8");
     const bare = withoutExtension(file.key);
     const target = file.extension === ".puml" ? "P" : "J";
     const value = file.extension === ".puml" ? toJsLiteral(unwrapDocument(text.split(/\r\n|\r|\n/))) : toJsonLiteral(text, file.absolutePath);
@@ -556,16 +604,16 @@ function buildStdlibNamespace(stdlibRoot, directoryName) {
 
 // src/stdlib.ts
 function vendoredDirectory(currentDir2) {
-  return import_node_path3.default.join(currentDir2, "..", "assets", "stdlib");
+  return import_node_path4.default.join(currentDir2, "..", "assets", "stdlib");
 }
 function readVendoredManifest(directory) {
-  const manifestPath = import_node_path3.default.join(directory, "manifest.json");
-  if (!import_node_fs3.default.existsSync(manifestPath)) {
+  const manifestPath = import_node_path4.default.join(directory, "manifest.json");
+  if (!import_node_fs4.default.existsSync(manifestPath)) {
     throw new Error(
       `[${PLUGIN_NAME}] The vendored standard library manifest is missing from '${manifestPath}'. This is a packaging fault: reinstall the plugin, or run 'npm run stdlib:update' if you are working in a checkout of it.`
     );
   }
-  return JSON.parse(import_node_fs3.default.readFileSync(manifestPath, "utf8"));
+  return JSON.parse(import_node_fs4.default.readFileSync(manifestPath, "utf8"));
 }
 function digest(...parts) {
   const hash = import_node_crypto.default.createHash("sha256");
@@ -575,13 +623,13 @@ function digest(...parts) {
 function directoryStamp(directory) {
   const parts = [];
   const walk = (current) => {
-    for (const entry of import_node_fs3.default.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
-      const absolute = import_node_path3.default.join(current, entry.name);
+    for (const entry of import_node_fs4.default.readdirSync(current, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
+      const absolute = import_node_path4.default.join(current, entry.name);
       if (entry.isDirectory()) {
         walk(absolute);
         continue;
       }
-      const stats = import_node_fs3.default.statSync(absolute);
+      const stats = import_node_fs4.default.statSync(absolute);
       parts.push(`${absolute}:${stats.size}:${stats.mtimeMs}`);
     }
   };
@@ -590,10 +638,10 @@ function directoryStamp(directory) {
 }
 function findNamespaceDirectory(sourceRoots, namespace) {
   for (const root of sourceRoots) {
-    if (!import_node_fs3.default.existsSync(root)) continue;
-    for (const entry of import_node_fs3.default.readdirSync(root, { withFileTypes: true })) {
+    if (!import_node_fs4.default.existsSync(root)) continue;
+    for (const entry of import_node_fs4.default.readdirSync(root, { withFileTypes: true })) {
       if (entry.isDirectory() && entry.name.toLowerCase() === namespace) {
-        return import_node_path3.default.join(root, entry.name);
+        return import_node_path4.default.join(root, entry.name);
       }
     }
   }
@@ -615,8 +663,8 @@ function resolveStdlibAssets({
     if (namespace in namespaces) return;
     const entry = vendoredNamespaces[namespace];
     if (!entry) return;
-    const bundlePath = import_node_path3.default.join(directory, entry.file);
-    if (!import_node_fs3.default.existsSync(bundlePath)) {
+    const bundlePath = import_node_path4.default.join(directory, entry.file);
+    if (!import_node_fs4.default.existsSync(bundlePath)) {
       throw new Error(
         `[${PLUGIN_NAME}] The vendored standard library manifest lists '${entry.file}', but '${bundlePath}' does not exist. Reinstall the plugin.`
       );
@@ -640,8 +688,8 @@ function resolveStdlibAssets({
     }
   }
   for (const namespace of selected) addVendored(namespace);
-  const sourceRoots = options.source.map((entry) => import_node_path3.default.resolve(siteDir, entry));
-  const generatedDir = import_node_path3.default.join(cacheDir ?? import_node_path3.default.join(siteDir, ".docusaurus"), "plantuml-stdlib");
+  const sourceRoots = options.source.map((entry) => import_node_path4.default.resolve(siteDir, entry));
+  const generatedDir = import_node_path4.default.join(cacheDir ?? import_node_path4.default.join(siteDir, ".docusaurus"), "plantuml-stdlib");
   const stamps = [];
   for (const namespace of options.include) {
     const namespaceDir = findNamespaceDirectory(sourceRoots, namespace);
@@ -652,12 +700,12 @@ function resolveStdlibAssets({
     }
     const stamp = directoryStamp(namespaceDir);
     stamps.push(`${namespace}:${stamp}`);
-    const cached = import_node_path3.default.join(generatedDir, stamp, stdlibBundleFileName(namespace));
-    if (!import_node_fs3.default.existsSync(cached)) {
-      const bundle = buildStdlibNamespace(import_node_path3.default.dirname(namespaceDir), import_node_path3.default.basename(namespaceDir));
-      import_node_fs3.default.mkdirSync(import_node_path3.default.dirname(cached), { recursive: true });
-      import_node_fs3.default.writeFileSync(cached, bundle.script, "utf8");
-      import_node_fs3.default.writeFileSync(
+    const cached = import_node_path4.default.join(generatedDir, stamp, stdlibBundleFileName(namespace));
+    if (!import_node_fs4.default.existsSync(cached)) {
+      const bundle = buildStdlibNamespace(import_node_path4.default.dirname(namespaceDir), import_node_path4.default.basename(namespaceDir));
+      import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(cached), { recursive: true });
+      import_node_fs4.default.writeFileSync(cached, bundle.script, "utf8");
+      import_node_fs4.default.writeFileSync(
         `${cached}.json`,
         JSON.stringify({
           dependencies: bundle.dependencies,
@@ -666,9 +714,9 @@ function resolveStdlibAssets({
         "utf8"
       );
     }
-    const meta = JSON.parse(import_node_fs3.default.readFileSync(`${cached}.json`, "utf8"));
+    const meta = JSON.parse(import_node_fs4.default.readFileSync(`${cached}.json`, "utf8"));
     const previous = files.findIndex(
-      (file) => import_node_path3.default.basename(file) === stdlibBundleFileName(namespace)
+      (file) => import_node_path4.default.basename(file) === stdlibBundleFileName(namespace)
     );
     if (previous !== -1) files.splice(previous, 1);
     files.push(cached);
@@ -687,7 +735,7 @@ function resolveStdlibAssets({
 }
 
 // src/index.ts
-var currentDir = import_node_path4.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+var currentDir = import_node_path5.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
 function createCopyPlugin(currentBundler, patterns) {
   if (currentBundler?.name === "rspack") {
     const { CopyRspackPlugin } = currentBundler.instance;
@@ -714,7 +762,7 @@ function plantumlPlugin(context, options = {}) {
   return {
     name: PLUGIN_NAME,
     getThemePath() {
-      return import_node_path4.default.join(currentDir, "theme");
+      return import_node_path5.default.join(currentDir, "theme");
     },
     contentLoaded({ actions }) {
       const globalData = {
@@ -729,8 +777,14 @@ function plantumlPlugin(context, options = {}) {
       if (isServer) {
         return {};
       }
+      const engine = resolvePatchedEngine({
+        vendoredPath: import_node_path5.default.join(core.packageDir, PLANTUML_MODULE_FILENAME),
+        coreVersion: core.version,
+        siteDir: context.siteDir,
+        cacheDir: context.generatedFilesDir
+      });
       const patterns = core.files.map((absolutePath) => ({
-        from: absolutePath,
+        from: import_node_path5.default.basename(absolutePath) === PLANTUML_MODULE_FILENAME ? engine : absolutePath,
         to: `${assetsDir}/[name][ext]`,
         // These files are already minified upstream; re-processing 8 MB is wasted work.
         info: { minimized: true }

package/dist/index.js

@@ -2,7 +2,8 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import CopyWebpackPlugin from 'copy-webpack-plugin';
 import { locatePlantUmlCore } from './assets.js';
-import { assetsDirForVersion, DEFAULT_PLUGIN_ID, PLUGIN_NAME } from './constants.js';
+import { assetsDirForVersion, DEFAULT_PLUGIN_ID, PLANTUML_MODULE_FILENAME, PLUGIN_NAME, } from './constants.js';
+import { resolvePatchedEngine } from './enginePatch.js';
 import { resolveOptions, } from './options.js';
 import { resolveStdlibAssets } from './stdlib.js';
 export { DEFAULT_OPTIONS, PlantUmlOptionsError, resolveOptions } from './options.js';
@@ -62,8 +63,18 @@ export default function plantumlPlugin(context, options = {}) {
             if (isServer) {
                 return {};
             }
+            // The engine is patched to raise its 4096-point diagram ceiling, so what is emitted is
+            // a generated file rather than the vendored one. It happens here rather than in the
+            // plugin factory so that `swizzle`, `write-translations` and the server compilation do
+            // not each pay to read and rewrite 7 MB for output they never emit.
+            const engine = resolvePatchedEngine({
+                vendoredPath: path.join(core.packageDir, PLANTUML_MODULE_FILENAME),
+                coreVersion: core.version,
+                siteDir: context.siteDir,
+                cacheDir: context.generatedFilesDir,
+            });
             const patterns = core.files.map((absolutePath) => ({
-                from: absolutePath,
+                from: path.basename(absolutePath) === PLANTUML_MODULE_FILENAME ? engine : absolutePath,
                 to: `${assetsDir}/[name][ext]`,
                 // These files are already minified upstream; re-processing 8 MB is wasted work.
                 info: { minimized: true },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matfsw/docusaurus-plantuml-plugin",
-  "version": "1.6.2",
+  "version": "1.7.0",
   "description": "Render PlantUML diagrams in Docusaurus 3 entirely in the browser - no Java, no PlantUML server, no CDN.",
   "keywords": [
     "docusaurus",