hdoc-tools 0.52.1 → 0.54.0

package/hdoc-build.js

@@ -97,11 +97,32 @@
 
 	// Mutable references updated immediately before each md.render() call so
 	// the highlight and frontmatter plugin callbacks can identify the current
-	// file. Safe because md.render() is synchronous — nothing can interleave
-	// between setting these and reading them back within a single render.
+	// file. md.render() is synchronous, so these are safe to READ from within
+	// the render itself (e.g. the highlight callback reading currentMdFilePath).
+	// They are NOT safe to read back AFTER an await: transform_file runs up to 8
+	// concurrently, so a concurrent render can clobber these while we're awaiting.
+	// Anything needed past the first await must be snapshotted into a local first
+	// (see file_frontmatter in transform_file).
 	let currentMdFilePath = "";
 	let currentFrontmatter = "";
 
+	// Escape a Mermaid definition for safe embedding as the text content of a
+	// <pre class="mermaid"> element. The viewer's client-side plugin reads the
+	// element's textContent, so only HTML-text safety is required here.
+	const escape_html_text = (str) =>
+		str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+	// PDF-only: replace each client-render <pre class="mermaid" data-pdf-svg="…">
+	// block with the baked <img> pointing at its server-rendered SVG. Runs on the
+	// PDF HTML variant just before generate_pdf; the published HTML keeps the
+	// <pre> block for client rendering.
+	const pdfify_mermaid_blocks = (html) =>
+		html.replace(
+			/<pre class="mermaid" data-pdf-svg="([^"]+)">[\s\S]*?<\/pre>/g,
+			(_m, src) =>
+				`<img class="mermaid-diagram" src="${src}" alt="Mermaid Diagram">`,
+		);
+
 	// Shared markdown-it instance — created once, reused for every file.
 	// Previously recreated per file because the highlight callback closed over
 	// the file_path parameter; it now reads currentMdFilePath instead.
@@ -111,12 +132,28 @@
 		linkify: true,
 		typographer: true,
 		highlight: function (str, lang) {
-			if (lang === "mermaid" && process.env.GITHUB_ACTIONS !== 'true') {
-				// markdown-it's highlight callback is synchronous, but Mermaid
-				// rendering is async (puppeteer). So here we only *queue* the
-				// diagram and emit the <img> tag pointing at its eventual SVG;
-				// the actual rendering happens in a batch after all markdown has
-				// been processed (see render_mermaid_queue, before validation/zip).
+			if (lang === "mermaid") {
+				// Published HTML (and serve) render Mermaid client-side via the
+				// viewer's Mermaid plugin: we emit the raw definition inside
+				// <pre class="mermaid"> and the viewer calls mermaid.run() after
+				// injecting the fragment (theme applied via mermaid.initialize).
+				//
+				// PDFs have no JS runtime, so when PDF generation is enabled we ALSO
+				// queue a server-rendered SVG (headless puppeteer, batched after all
+				// markdown — see flush_mermaid_queue) and tag the block with
+				// data-pdf-svg. The PDF-only transform (pdfify_mermaid_blocks) swaps
+				// those tagged blocks for the baked <img> before generate_pdf; the
+				// attribute is inert for the client-rendered HTML.
+				//
+				// Skip the SVG bake entirely when this file won't produce a PDF
+				// (PDF disabled, or this path is PDF-excluded) — otherwise we'd
+				// render headless SVGs that nothing ever consumes.
+				const needs_pdf_svg =
+					pdf_enable && !pdf_path_excluded(currentMdFilePath.relativePath);
+				if (!needs_pdf_svg) {
+					return `<pre class="mermaid">${escape_html_text(str)}</pre>`;
+				}
+
 				const outputFileName = `mermaid-${crypto.createHash("sha256").update(str).digest("hex").slice(0, 16)}.svg`;
 				const outputPath = path.join(mermaid_images_path, outputFileName);
 				const outputLink = `/_books/${doc_id}/mermaid-images/${outputFileName}`;
@@ -135,7 +172,7 @@
 					});
 				}
 
-				return `<img class="mermaid-diagram" src="${outputLink}" alt="Mermaid Diagram">`;
+				return `<pre class="mermaid" data-pdf-svg="${outputLink}">${escape_html_text(str)}</pre>`;
 			}
 		}
 	});
@@ -270,6 +307,16 @@
 			// Render markdown into HTML
 			html_txt = md.render(md_txt);
 
+			// Capture this file's frontmatter into a local NOW, before any await.
+			// currentFrontmatter is shared module-level state populated by the mdfm
+			// callback during the (synchronous) md.render() above. transform_file runs
+			// up to 8-at-a-time (see the chunked Promise.all in run()), so the await
+			// below yields the event loop and lets a concurrent transform_file reset
+			// and overwrite currentFrontmatter — if we read it back after the await we
+			// would parse another file's frontmatter. Snapshot it while it is still
+			// guaranteed to be ours.
+			const file_frontmatter = currentFrontmatter;
+
 			// md.render() synchronously queued any Mermaid diagrams in this file.
 			// Render them to SVG now (memoized/deduped) so the files exist before
 			// PDF generation below reads them, and before validation/zipping.
@@ -285,7 +332,7 @@
 			let fm_contains_reading_time = false;
 			let fm_contains_description = false;
 
-			const fm_content = currentFrontmatter.split(/\r?\n/);
+			const fm_content = file_frontmatter.split(/\r?\n/);
 			if (fm_content.length >= 0) {
 				for (fm_prop of fm_content) {
 					const fm_id = fm_prop.slice(0, fm_prop.indexOf(":"));
@@ -672,7 +719,12 @@
 
 		let pdf_size = 0;
 		if (pdf_enable && !pdf_path_excluded(file_path.relativePath)) {
-			let pdf_txt = await hdoc_build_pdf.process_images(file_path, html_txt);
+			// Swap client-render Mermaid <pre> blocks for baked SVG <img> (PDF has
+			// no JS runtime), then inline the SVG files via process_images.
+			let pdf_txt = await hdoc_build_pdf.process_images(
+				file_path,
+				pdfify_mermaid_blocks(html_txt),
+			);
 			pdf_txt = `${pdf_header}\n${pdf_txt}`;
 
 			// Generate PDF file from HTML
@@ -696,6 +748,11 @@
 		if (inline_content) html_txt = `${fm_header_str}\n${html_txt}`;
 		else html_txt = `${fm_header_str}\n${doc_header}\n${html_txt}`;
 
+		// The data-pdf-svg attr was only needed by the PDF transform (already run
+		// above). Strip it from the published HTML so the markup is clean and has no
+		// dangling reference to the mermaid-images/ dir (which is deleted before zip).
+		html_txt = html_txt.replace(/ data-pdf-svg="[^"]*"/g, "");
+
 		// Determine output file path (.md → .html for markdown; same path for static HTML)
 		const target_file = is_markdown
 			? file_path.path.replace(path.extname(file_path.path), ".html")
@@ -716,7 +773,13 @@
 			relative_path = relative_path.replace("/index.html", "");
 		}
 
-		const index_data = hdoc_index.transform_html_for_index(html_txt);
+		// Drop Mermaid source from the search index — it's diagram markup, not
+		// prose, and would otherwise pollute results.
+		const index_html = html_txt.replace(
+			/<pre class="mermaid"[^>]*>[\s\S]*?<\/pre>/g,
+			"",
+		);
+		const index_data = hdoc_index.transform_html_for_index(index_html);
 		for (const section of index_data.sections) {
 			index_records.push({
 				relative_path: relative_path,
@@ -1304,6 +1367,14 @@
 		// transform_file (no-op if all are done — rendering is memoized per diagram).
 		await flush_mermaid_queue();
 
+		// Mermaid SVGs are only an intermediate for baking diagrams into PDFs
+		// (process_images inlines them as base64 data URIs at PDF-gen time, already
+		// done above). Published HTML renders Mermaid client-side and references no
+		// SVG, so the directory is dead weight in the output — drop it before zip.
+		if (mermaid_images_path && fs.existsSync(mermaid_images_path)) {
+			fs.rmSync(mermaid_images_path, { recursive: true, force: true });
+		}
+
 		// Output to console
 		console.log(`\n                MD files found: ${conversion_attempted}`);
 		console.log(`Successfully converted to HTML: ${conversion_success}`);

package/hdoc-content-routes.js

@@ -0,0 +1,343 @@
+// Shared /_books/* content + render routes.
+//
+// Extracted from hdoc-serve.js so that both `hdoc serve` (read-only preview)
+// and `hdoc edit` (the upcoming editor surface) mount the SAME content
+// pipeline and renderer. This guarantees preview fidelity == published output
+// for any UI built on top of it.
+//
+// Usage:
+//   const { create_content_handler } = require("./hdoc-content-routes.js");
+//   const content = create_content_handler({
+//     source_path, docId, hdocbook_config, hdocbook_project, nav_inline,
+//   });
+//   content.register(app);
+//   // ...and reuse content.send_content_file / content.send_content_resource_404
+//   //    for your own catch-all (SPA) route.
+
+const fs = require("node:fs");
+const path = require("node:path");
+const stream = require("node:stream");
+
+const hdoc = require(path.join(__dirname, "hdoc-module.js"));
+const mdfm = require("markdown-it-front-matter");
+
+// Escape a Mermaid definition for safe embedding as the text content of a
+// <pre> element. The viewer's client-side Mermaid plugin reads the element's
+// textContent and renders it in the browser, so we only need HTML-text safety
+// here (no theme/frontmatter injection — theme is applied via mermaid.initialize
+// in the viewer).
+function escape_html(str) {
+	return str
+		.replace(/&/g, "&amp;")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;");
+}
+
+// Build a content handler bound to a single book's context.
+//
+// ctx:
+//   source_path      - absolute path to the document source root
+//   docId            - id of the hdocbook being served
+//   hdocbook_config  - parsed hdocbook.json
+//   hdocbook_project - parsed hdocbook-project.json (used for redirects)
+//   nav_inline       - inline-help nav fragment for library.json
+exports.create_content_handler = (ctx) => {
+	const {
+		source_path,
+		docId,
+		hdocbook_config,
+		hdocbook_project,
+		nav_inline,
+	} = ctx;
+
+	// process_includes resolves include paths relative to the source root.
+	const global_source_path = source_path;
+
+	// Render markdown SOURCE to HTML through the same pipeline as published output:
+	// expand_variables -> process_includes -> markdown-it (+ mermaid, tips, frontmatter).
+	//
+	// file_path anchors include resolution (relative to it) and mermaid logging.
+	// md_source is the raw markdown to render — read from disk for serve/publish,
+	// or supplied from the editor buffer for live preview (so preview == published).
+	// Returns { html, frontmatter } where frontmatter is the parsed object or null.
+	async function render_markdown(file_path, md_source) {
+		let md_txt = hdoc.expand_variables(md_source.toString(), docId);
+
+		const includes_processed = await hdoc.process_includes(
+			file_path,
+			md_txt,
+			global_source_path,
+		);
+		md_txt = includes_processed.body;
+
+		// Mermaid diagrams are rendered client-side by the viewer's Mermaid plugin.
+		// We emit the raw definition inside <pre class="mermaid"> and the viewer
+		// calls mermaid.run() after injecting the fragment (theme applied there via
+		// mermaid.initialize). This keeps serve == published and drops the
+		// per-request headless browser entirely.
+		const md = require("markdown-it")({
+			html: true,
+			linkify: true,
+			typographer: true,
+			highlight: function (str, lang) {
+				if (lang === "mermaid") {
+					return `<pre class="mermaid">${escape_html(str)}</pre>`;
+				}
+			}
+		});
+		md.linkify.set({
+			fuzzyEmail: false,
+			fuzzyLink: false,
+			fuzzyIP: false,
+		});
+
+		let frontmatter_content = "";
+		md.use(mdfm, (fm) => {
+			frontmatter_content = fm;
+		});
+
+		const tips = require(`${__dirname}/custom_modules/tips.js`);
+		md.use(tips, { links: true });
+
+		const html = md.render(md_txt.toString());
+
+		const frontmatter = frontmatter_content.length
+			? hdoc.parse_yaml(frontmatter_content)
+			: null;
+		return { html, frontmatter };
+	}
+
+	async function transform_markdown_and_send_html(req, res, file_path) {
+		if (!fs.existsSync(file_path)) return false;
+
+		const { html, frontmatter } = await render_markdown(
+			file_path,
+			fs.readFileSync(file_path).toString(),
+		);
+
+		if (frontmatter) {
+			const base64 = Buffer.from(JSON.stringify(frontmatter), "utf-8").toString(
+				"base64",
+			);
+			res.setHeader("X-frontmatter", base64);
+		}
+
+		res.setHeader("Content-Type", "text/html");
+		res.send(html);
+		return true;
+	}
+
+
+	function send_content_file(req, res, file_path, redirected = false) {
+		let content_txt = hdoc.expand_variables(
+			fs.readFileSync(file_path).toString(),
+			docId,
+		);
+		if (redirected)
+			content_txt = `Redirected from ${redirected}\n\n${content_txt}`;
+
+		const contentType = hdoc.content_type_for_ext(path.extname(file_path));
+
+		if (path.extname(file_path) === ".md") {
+			res.setHeader("Content-Disposition", "inline");
+		}
+
+		res.setHeader("Content-Type", contentType);
+
+		res.send(content_txt);
+	}
+
+	function send_file(req, res, file_path) {
+		// Need to set the content type here??
+		const contentType = hdoc.content_type_for_ext(path.extname(file_path));
+		res.setHeader("Content-Type", contentType);
+
+		// The vendored Mermaid bundle is large (~4.5MB) and content-stable, so cache
+		// it hard — without this the browser re-downloads it on every full page load
+		// when clicking through to diagram pages. Other dev assets stay uncached so
+		// edits to the viewer JS are picked up on refresh.
+		if (path.basename(file_path) === "mermaid.min.js") {
+			res.setHeader("Cache-Control", "public, max-age=604800, immutable");
+		}
+
+		const r = fs.createReadStream(file_path);
+		const ps = new stream.PassThrough();
+		stream.pipeline(r, ps, (err) => {
+			if (err) {
+				console.error(err); // No such file or any other kind of error
+				return res.sendStatus(400).send("Unexpected error");
+			}
+		});
+		ps.pipe(res);
+	}
+
+	function send_content_resource_404(req, res) {
+		res.setHeader("Content-Type", "text/html");
+		res.status(404).send("Content resource not found");
+	}
+
+	// 1. If we request a file with a .html file extension, and that file DOES NOT exist,
+	// we will look for the same file but with a .md extension. If we find that
+	// corresponding markdown file, we will transform that markdown file to HTML and
+	// return the HTML content
+	//
+	// 2. If we request a file, without any file extension then we will look for that file
+	// with a .md extension, and if that file exists, we will transform that markdown
+	// file to HTML and return that file.
+	//
+	// For all other requests, we are going to look on the filesystem.  If we request
+	// a specific file with its extension (including .md files), then we will simply
+	// return the file verbatim as a static file.
+	//
+	// If we request a file without an extension and that file does not exist, we will
+	// assume that is a folder, will append index.html and look for that file, if present
+	// we will send it, if not present we will look for index.md, and if thats present
+	// we will transform to HTML and return that
+	//
+	// Anything else in this handler will return a 404 error
+	function handle_books_request(req, res) {
+		let url = req.url.replace("/_books/", "/");
+
+		console.log("URL Requested:", url);
+
+		// Process redirect
+		if (
+			hdocbook_project.redirects &&
+			Array.isArray(hdocbook_project.redirects) &&
+			hdocbook_project.redirects.length > 0
+		) {
+			const source_url = url.indexOf("/") === 0 ? url : `/${url}`;
+			for (const redir of hdocbook_project.redirects) {
+				redir.url =
+					redir.url.indexOf("/") === 0 ? redir.url : `/${redir.url}`;
+				if (
+					redir.url === source_url &&
+					redir.location &&
+					redir.location !== ""
+				) {
+					url = `${redir.location}`;
+					console.log(`Redirecting to ${url}`);
+				}
+			}
+		}
+
+		const file_path = path.join(source_path, url);
+
+		if (path.extname(file_path) === ".html") {
+			// 1a. check for html files, and send/transform as required
+			if (fs.existsSync(file_path)) {
+				// HTML file exists on disk, just return it verbatim
+				res.setHeader("Content-Type", "text/html");
+				send_file(req, res, file_path);
+				return true;
+			}
+			if (fs.existsSync(file_path.replace(".html", ".md"))) {
+				if (
+					transform_markdown_and_send_html(
+						req,
+						res,
+						file_path.replace(".html", ".md"),
+					)
+				) {
+					return;
+				}
+			}
+		} else if (path.extname(file_path) === ".md") {
+			// If the markdown file exists, just send to caller as is
+			if (fs.existsSync(file_path)) {
+				send_content_file(req, res, file_path);
+				return true;
+			}
+		} else if (path.extname(file_path).length === 0) {
+			// 2. If we request a file, without any file extension
+			if (fs.existsSync(`${file_path}.md`)) {
+				if (transform_markdown_and_send_html(req, res, `${file_path}.md`)) {
+					return;
+				}
+			} else if (fs.existsSync(path.join(`${file_path}index.md`))) {
+				if (
+					transform_markdown_and_send_html(
+						req,
+						res,
+						path.join(file_path, "index.md"),
+					)
+				) {
+					return;
+				}
+			} else if (fs.existsSync(path.join(`${file_path}index.html`))) {
+				res.setHeader("Content-Type", "text/html");
+				send_content_file(req, res, path.join(`${file_path}index.html`));
+				return;
+			} else if (fs.existsSync(`${file_path}/index.md`)) {
+				if (
+					transform_markdown_and_send_html(req, res, `${file_path}/index.md`)
+				) {
+					return;
+				}
+			} else if (fs.existsSync(path.join(`${file_path}/index.html`))) {
+				res.setHeader("Content-Type", "text/html");
+				send_content_file(req, res, path.join(`${file_path}/index.html`));
+				return;
+			} else if (fs.existsSync(path.join(`${file_path}.html`))) {
+				res.setHeader("Content-Type", "text/html");
+				send_content_file(req, res, path.join(`${file_path}.html`));
+				return;
+			} else if (fs.existsSync(path.join(`${file_path}.htm`))) {
+				res.setHeader("Content-Type", "text/html");
+				send_content_file(req, res, path.join(`${file_path}.htm`));
+				return;
+			}
+		} else if (fs.existsSync(file_path)) {
+			if (
+				file_path.endsWith("hdocbook.json") ||
+				file_path.endsWith("hdocbook_project.json")
+			) {
+				try {
+					// Read & parse file
+					JSON.parse(fs.readFileSync(file_path));
+				} catch (e) {
+					console.error(`Error parsing hdocbook.json: ${e}`);
+				}
+			}
+			send_file(req, res, file_path);
+			return;
+		}
+
+		// Return a 404 error here
+		send_content_resource_404(req, res);
+	}
+
+	function handle_library_request(req, res) {
+		const library = {
+			books: [
+				{
+					docId: hdocbook_config.docId,
+					title: hdocbook_config.title,
+					nav_inline: nav_inline,
+				},
+			],
+		};
+		res.setHeader("Content-Type", "application/json");
+		res.send(JSON.stringify(library, null, 3));
+	}
+
+	function register(app) {
+		app.get("/_books/library.json", handle_library_request);
+		app.get("/_books/*splat", handle_books_request);
+	}
+
+	return {
+		register,
+		// Exposed so host servers can reuse the same helpers for their own
+		// (SPA / editor) catch-all routes, and the editor's live-preview endpoint.
+		// handle_books_request / handle_library_request are exposed so the editor
+		// can register delegating /_books routes that follow a workspace switch.
+		render_markdown,
+		transform_markdown_and_send_html,
+		send_content_file,
+		send_file,
+		send_content_resource_404,
+		handle_books_request,
+		handle_library_request,
+	};
+};

package/hdoc-edit.js

@@ -15,6 +15,7 @@
 
 (() => {
 	const express = require("express");
+	const compression = require("compression");
 	const fs = require("node:fs");
 	const path = require("node:path");
 	const crypto = require("node:crypto");
@@ -55,6 +56,10 @@
 
 		const app = express();
 
+		// gzip all responses (Accept-Encoding aware). Matters most for the ~4.5MB
+		// client Mermaid bundle, which compresses to ~1.2MB on the wire.
+		app.use(compression());
+
 		// --- Active workspace (book) ---
 		// The book context is MUTABLE so the editor can switch which local clone
 		// it edits at runtime (the GitHub-Desktop "Open" flow). Every route below

package/hdoc-serve.js

@@ -1,5 +1,6 @@
 (() => {
 	const express = require("express");
+	const compression = require("compression");
 	const fs = require("node:fs");
 	const path = require("node:path");
 	const hdoc = require(path.join(__dirname, "hdoc-module.js"));
@@ -78,6 +79,10 @@
 		// Get an express server instance
 		const app = express();
 
+		// gzip all responses (Accept-Encoding aware). Matters most for the ~4.5MB
+		// client Mermaid bundle, which compresses to ~1.2MB on the wire.
+		app.use(compression());
+
 		// Get the path of the book.json file
 		const hdocbook_path = path.join(source_path, docId, "hdocbook.json");
 
@@ -115,6 +120,12 @@
 
 			// If the file exists, send it.
 			if (fs.existsSync(ui_file_path)) {
+				// Stream the large Mermaid bundle (skips per-request variable
+				// expansion over ~4.5MB) and let send_file set a long cache header.
+				if (path.basename(ui_file_path) === "mermaid.min.js") {
+					content.send_file(req, res, ui_file_path);
+					return;
+				}
 				content.send_content_file(req, res, ui_file_path);
 				return;
 			}

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
 	"name": "hdoc-tools",
-	"version": "0.52.0",
+	"version": "0.53.0",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "hdoc-tools",
-			"version": "0.52.0",
+			"version": "0.53.0",
 			"hasInstallScript": true,
 			"license": "ISC",
 			"dependencies": {
@@ -15,6 +15,7 @@
 				"archiver": "8.0.0",
 				"better-sqlite3": "12.11.1",
 				"cheerio": "1.2.0",
+				"compression": "^1.8.1",
 				"express": "5.2.1",
 				"markdown-it": "14.2.0",
 				"markdown-it-container": "4.0.0",
@@ -954,6 +955,60 @@
 				"node": ">=18"
 			}
 		},
+		"node_modules/compressible": {
+			"version": "2.0.18",
+			"resolved": "https://registry.npmjs.org/compressible/-/compressible-2.0.18.tgz",
+			"integrity": "sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==",
+			"license": "MIT",
+			"dependencies": {
+				"mime-db": ">= 1.43.0 < 2"
+			},
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
+		"node_modules/compression": {
+			"version": "1.8.1",
+			"resolved": "https://registry.npmjs.org/compression/-/compression-1.8.1.tgz",
+			"integrity": "sha512-9mAqGPHLakhCLeNyxPkK4xVo746zQ/czLH1Ky+vkitMnWfWZps8r0qXuwhwizagCRttsL4lfG4pIOvaWLpAP0w==",
+			"license": "MIT",
+			"dependencies": {
+				"bytes": "3.1.2",
+				"compressible": "~2.0.18",
+				"debug": "2.6.9",
+				"negotiator": "~0.6.4",
+				"on-headers": "~1.1.0",
+				"safe-buffer": "5.2.1",
+				"vary": "~1.1.2"
+			},
+			"engines": {
+				"node": ">= 0.8.0"
+			}
+		},
+		"node_modules/compression/node_modules/debug": {
+			"version": "2.6.9",
+			"resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+			"integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+			"license": "MIT",
+			"dependencies": {
+				"ms": "2.0.0"
+			}
+		},
+		"node_modules/compression/node_modules/ms": {
+			"version": "2.0.0",
+			"resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+			"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+			"license": "MIT"
+		},
+		"node_modules/compression/node_modules/negotiator": {
+			"version": "0.6.4",
+			"resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.4.tgz",
+			"integrity": "sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.6"
+			}
+		},
 		"node_modules/content-disposition": {
 			"version": "1.1.0",
 			"resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.1.0.tgz",
@@ -2639,6 +2694,15 @@
 				"node": ">= 0.8"
 			}
 		},
+		"node_modules/on-headers": {
+			"version": "1.1.0",
+			"resolved": "https://registry.npmjs.org/on-headers/-/on-headers-1.1.0.tgz",
+			"integrity": "sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A==",
+			"license": "MIT",
+			"engines": {
+				"node": ">= 0.8"
+			}
+		},
 		"node_modules/once": {
 			"version": "1.4.0",
 			"resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "hdoc-tools",
-	"version": "0.52.1",
+	"version": "0.54.0",
 	"description": "Hornbill HDocBook Development Support Tool",
 	"main": "hdoc.js",
 	"bin": {
@@ -14,6 +14,7 @@
 		"hdoc-build-onyx.js",
 		"hdoc-build-pdf.js",
 		"hdoc-bump.js",
+		"hdoc-content-routes.js",
 		"hdoc-create.js",
 		"hdoc-edit.js",
 		"hdoc-help.js",
@@ -49,6 +50,7 @@
 		"archiver": "8.0.0",
 		"better-sqlite3": "12.11.1",
 		"cheerio": "1.2.0",
+		"compression": "1.8.1",
 		"express": "5.2.1",
 		"markdown-it": "14.2.0",
 		"markdown-it-container": "4.0.0",