@ckeditor/ckeditor5-dev-manual-server 57.0.0-alpha.0 → 57.0.0-alpha.1

package/dist/index.js

@@ -1,14 +1,6 @@
-import { createReadStream, existsSync, globSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { createReadStream, globSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import path, { extname, isAbsolute, posix, relative, resolve } from "node:path";
-import { parse, serialize } from "parse5";
-import { appendChild, createElement, getAttribute, getTextContent, hasAttribute, isElementNode, query, removeAttribute, removeNode, setAttribute, setTextContent } from "@parse5/tools";
-import { unified } from "unified";
-import remarkGfm from "remark-gfm";
-import remarkParse from "remark-parse";
-import remarkRehype from "remark-rehype";
-import { toHtml } from "hast-util-to-html";
-import { readFile } from "node:fs/promises";
+import { basename, extname, isAbsolute, posix, relative, resolve } from "node:path";
 //#region src/utils.ts
 /**
 * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
@@ -35,6 +27,20 @@ function cacheValue(compute) {
 function stringifyValues(obj) {
 	return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, JSON.stringify(value)]));
 }
+function normalizePackageName(packageName) {
+	return packageName.replace(/^ckeditor5-/, "");
+}
+/**
+* Builds a predicate that decides whether a package is part of the `include` selection. When the
+* selection is empty every package is included. Package names are matched by their normalized form,
+* so both short (`case-change`) and full (`ckeditor5-case-change`) names work. A `null` package name
+* (an asset without a package segment) is only kept when the selection is empty.
+*/
+function createPackageNameFilter(includePackageNames) {
+	if (includePackageNames.length == 0) return () => true;
+	const normalizedIncludePackageNames = new Set(includePackageNames.map(normalizePackageName));
+	return (packageName) => packageName != null && normalizedIncludePackageNames.has(normalizePackageName(packageName));
+}
 function toPublicFilePath(filePath, workspaceRoot) {
 	const relativeFilePath = relative(workspaceRoot, filePath);
 	if (!relativeFilePath.startsWith("..") && !isAbsolute(relativeFilePath)) return toPublicSpecifier(relativeFilePath);
@@ -55,63 +61,246 @@ function stripLeadingSlash(value) {
 * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
 * For licensing, see LICENSE.md.
 */
+const MANUAL_TESTS_DIRECTORY = "tests/manual/";
+const MANUAL_TEST_SUFFIX$1 = ".manual.html";
+/**
+* Discovers manual test pages. A manual test is a single full HTML document named
+* `<slug>.manual.html` located under a package's `tests/manual/` directory. Plain `.html`
+* files are treated as static fixtures and are never collected here.
+*
+* The `patterns` are package root globs, for example `packages/*`.
+*/
 function collectManualPages(patterns, workspaceRoot) {
-	const groupedFiles = /* @__PURE__ */ new Map();
-	const manualPages = [];
-	for (const relativeFilePath of matchFiles(patterns, workspaceRoot)) {
-		if (relativeFilePath.includes("/_utils/")) continue;
-		const parsedPath = parseManualTestAssetPath(relativeFilePath);
-		if (!parsedPath) continue;
-		const entryKey = `${parsedPath.packageRootPath}/${parsedPath.packageName}/${parsedPath.slug}`;
-		const matchedFiles = groupedFiles.get(entryKey) || {};
-		matchedFiles[parsedPath.extension] = relativeFilePath;
-		groupedFiles.set(entryKey, matchedFiles);
-	}
-	for (const matchedFiles of groupedFiles.values()) {
-		if (!matchedFiles.html) continue;
-		const scriptFilePath = matchedFiles.ts || matchedFiles.js;
-		if (!scriptFilePath) continue;
-		const parsedPath = parseManualTestAssetPath(scriptFilePath);
-		manualPages.push({
-			displayName: humanizeSlug(parsedPath.slug),
-			htmlFilePath: toPublicSpecifier(matchedFiles.html),
-			instructionsFilePath: matchedFiles.md ? toPublicSpecifier(matchedFiles.md) : void 0,
-			packageName: parsedPath.packageName,
-			scriptFilePath: toPublicSpecifier(scriptFilePath),
-			slug: parsedPath.slug
-		});
-	}
-	manualPages.sort((a, b) => a.packageName.localeCompare(b.packageName) || a.slug.localeCompare(b.slug));
-	return new Map(manualPages.map((entry) => [entry.htmlFilePath, entry]));
+	const manualPages = matchManualPageFiles(patterns, workspaceRoot).map((relativeFilePath) => toManualPageEntry(relativeFilePath, workspaceRoot)).toSorted((a, b) => a.packageName.localeCompare(b.packageName) || a.slug.localeCompare(b.slug)).map((entry) => [entry.htmlFilePath, entry]);
+	return new Map(manualPages);
+}
+function matchManualPageFiles(patterns, workspaceRoot) {
+	return patterns.map((pattern) => `${pattern.replace(/\/+$/, "")}/${MANUAL_TESTS_DIRECTORY}**/*${MANUAL_TEST_SUFFIX$1}`).flatMap((pattern) => globSync(pattern, { cwd: workspaceRoot }).map((match) => toPosixPath(match)));
+}
+function toManualPageEntry(relativeFilePath, workspaceRoot) {
+	const directoryStartIndex = relativeFilePath.startsWith(MANUAL_TESTS_DIRECTORY) ? 0 : relativeFilePath.indexOf(`/${MANUAL_TESTS_DIRECTORY}`) + 1;
+	const packagePath = relativeFilePath.slice(0, Math.max(directoryStartIndex - 1, 0));
+	const slugPath = relativeFilePath.slice(directoryStartIndex + 13);
+	return {
+		htmlFilePath: toPublicSpecifier(relativeFilePath),
+		packageName: packagePath ? packagePath.slice(packagePath.lastIndexOf("/") + 1) : basename(workspaceRoot),
+		slug: slugPath.slice(0, -12)
+	};
+}
+//#endregion
+//#region src/manual-test-plugin/plugin.ts
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md.
+*/
+const MANUAL_HEADER_ELEMENT = "ck-manual-header";
+const MANUAL_ENTRIES_VIRTUAL_ID = "virtual:ckeditor5-manual-entries";
+const MANUAL_THEME_ROOT = realpathSync(fileURLToPath(import.meta.resolve("@ckeditor/ckeditor5-dev-manual-server/theme")));
+const MANUAL_CATALOG_FILE_PATH = resolve(MANUAL_THEME_ROOT, "catalog.html");
+const MANUAL_CATALOG_SCRIPT_FILE_PATH = resolve(MANUAL_THEME_ROOT, "catalog.ts");
+const MANUAL_BOOTSTRAP_SCRIPT_FILE_PATH = resolve(MANUAL_THEME_ROOT, "manual-bootstrap.ts");
+const MANUAL_HEADER_SCRIPT_FILE_PATH = resolve(MANUAL_THEME_ROOT, "manual-header.ts");
+function manualTestsPlugin(options) {
+	let workspaceRoot = process.cwd();
+	let base = "/";
+	const includePackageNames = (options.include || []).filter(Boolean);
+	const manualPagesCache = cacheValue(() => filterManualPages(collectManualPages(options.paths, workspaceRoot), includePackageNames));
+	const getManualPages = manualPagesCache.get;
+	const getManualPageEntryForFile = (filePath) => {
+		return getManualPages().get(toPublicSpecifier(relative(workspaceRoot, filePath)));
+	};
+	const getManualCatalogBuildInputFilePath = () => resolve(workspaceRoot, "index.html");
+	const getManualCatalogPublicPath = () => toPublicFilePath(getManualCatalogBuildInputFilePath(), workspaceRoot);
+	const getManualCatalogScriptPublicPath = () => toPublicFilePath(MANUAL_CATALOG_SCRIPT_FILE_PATH, workspaceRoot);
+	const getManualBootstrapScriptPublicPath = () => toPublicFilePath(MANUAL_BOOTSTRAP_SCRIPT_FILE_PATH, workspaceRoot);
+	const getManualHeaderScriptPublicPath = () => toPublicFilePath(MANUAL_HEADER_SCRIPT_FILE_PATH, workspaceRoot);
+	const getManualBuildInputs = () => [getManualCatalogBuildInputFilePath(), ...[...getManualPages().values()].map((entry) => resolve(workspaceRoot, stripLeadingSlash(entry.htmlFilePath)))];
+	const resolvedVirtualModuleId = `\0${MANUAL_ENTRIES_VIRTUAL_ID}`;
+	const getClientEntries = () => [...getManualPages().values()].map((entry) => ({
+		href: toBasePublicPath(entry.htmlFilePath, base),
+		packageName: entry.packageName,
+		slug: entry.slug
+	}));
+	const getManualEntriesJson = () => JSON.stringify(getClientEntries(), null, 2);
+	return {
+		name: "ckeditor5-manual-tests",
+		config() {
+			return { build: { rolldownOptions: { input: getManualBuildInputs() } } };
+		},
+		configResolved(config) {
+			workspaceRoot = config.root;
+			base = config.base || "/";
+			manualPagesCache.invalidate();
+			config.build.rolldownOptions.input = getManualBuildInputs();
+		},
+		configureServer(server) {
+			server.middlewares.use((request, _response, next) => {
+				rewriteCatalogRequest(request, getManualCatalogPublicPath());
+				next();
+			});
+			const clientEnvironment = server.environments.client;
+			keepManualHtmlSourceFresh(clientEnvironment.bundledDev?.memoryFiles, getManualPages, workspaceRoot);
+		},
+		resolveId(source) {
+			if (source == MANUAL_ENTRIES_VIRTUAL_ID) return resolvedVirtualModuleId;
+			if (isManualCatalogBuildInputSpecifier(source, getManualCatalogBuildInputFilePath(), workspaceRoot)) return getManualCatalogBuildInputFilePath();
+			return null;
+		},
+		load(id) {
+			if (id == resolvedVirtualModuleId) return `export const manualTestEntries = ${getManualEntriesJson()};`;
+			if (toPosixPath(id) == toPosixPath(getManualCatalogBuildInputFilePath())) return readFileSync(MANUAL_CATALOG_FILE_PATH, "utf8");
+			return null;
+		},
+		transformIndexHtml: {
+			order: "pre",
+			handler(html, context) {
+				if (isManualCatalogHtmlFile(context.filename, getManualCatalogBuildInputFilePath())) return html.replace("./catalog.ts", getManualCatalogScriptPublicPath());
+				const entry = getManualPageEntryForFile(context.filename);
+				if (!entry) return;
+				const tags = [createModuleScriptTag(getManualBootstrapScriptPublicPath(), "head-prepend")];
+				if (html.includes(`<${MANUAL_HEADER_ELEMENT}`)) tags.push(...createManualHeaderTags(entry, getManualHeaderScriptPublicPath(), toBaseCatalogPath(base, entry.htmlFilePath)));
+				return {
+					html,
+					tags
+				};
+			}
+		}
+	};
+}
+/**
+* Keeps the served manual test HTML in sync with the source file while the dev server runs.
+*
+* Under `experimental.bundledDev`, Vite serves each manual test's HTML from an in-memory bundle
+* produced by the rolldown dev engine. That engine emits the HTML output only during the initial
+* build and never regenerates it when the source `.html` changes: its bundle state reports no
+* stale output for HTML entries, `devEngine.invalidate()` throws on a non-JS module, and even a
+* forced full build leaves the HTML memory file untouched (verified against Vite 8.1.0). A `.html`
+* edit still triggers a full page reload, so without this the browser reloads into the same stale
+* HTML until the server is restarted.
+*
+* The built-in-memory HTML rewrites the entry script, injects the asset tags and manual chrome,
+* and copies the source `<head>` — all inside `<head>`. The markup after `</head>` is a verbatim
+* copy of the source. So on every request we keep the freshly built `<head>` and splice in the
+* current post-`</head>` markup read from disk. Splicing unconditionally (rather than only after a
+* detected change) also covers sources that changed between the initial build and the first request
+* for the page, and it is idempotent for unchanged sources. This reflects edits to the test body
+* without re-running Vite's HTML transform or parsing the document. Any edit that would change
+* what belongs in `<head>` is not picked up this way and still needs a server restart, because
+* reproducing it would require re-running the build pipeline the dev engine refuses to run for HTML
+* entries. That covers edits confined to the `<head>` (styles, meta, extra scripts) as well as
+* adding or removing `<ck-manual-header>` in the body: toggling it changes the injected header
+* chrome (`<meta>` and the component script) in `<head>`, so the chrome only updates after a
+* restart even though the body splice already reflects the element itself.
+*
+* When `bundledDev` is not enabled the store is absent and this is a no-op: Vite's normal dev
+* pipeline already serves fresh HTML on every request.
+*/
+function keepManualHtmlSourceFresh(memoryFiles, getManualPages, workspaceRoot) {
+	if (!memoryFiles) return;
+	const getBundledFile = memoryFiles.get.bind(memoryFiles);
+	memoryFiles.get = (filePath) => {
+		const file = getBundledFile(filePath);
+		if (!file || !getManualPages().has(toPublicSpecifier(filePath))) return file;
+		try {
+			const sourceFilePath = resolve(workspaceRoot, stripLeadingSlash(filePath));
+			const freshHtml = composeFreshManualHtml(file.source, readFileSync(sourceFilePath, "utf8"));
+			return freshHtml == null ? file : { source: freshHtml };
+		} catch {
+			return file;
+		}
+	};
+}
+/**
+* Combines the freshly built `<head>` (asset tags and injected manual chrome) with the current
+* post-`</head>` markup from the source file. Returns `null` when either document is missing a
+* `</head>`, so the caller can fall back to the built output.
+*/
+function composeFreshManualHtml(builtHtml, sourceHtml) {
+	const builtHeadEnd = findHeadCloseTagIndex(builtHtml);
+	const sourceHeadEnd = findHeadCloseTagIndex(sourceHtml);
+	if (builtHeadEnd == -1 || sourceHeadEnd == -1) return null;
+	return builtHtml.slice(0, builtHeadEnd + 7) + sourceHtml.slice(sourceHeadEnd + 7);
+}
+/**
+* Finds the index of the `</head>` closing tag, or `-1` when the document has none. A `</head>`
+* literal may also appear earlier inside a `<head>` comment or an inline script string, so of all
+* the occurrences preceding the `<body>` tag the last one is taken. Without a `<body>` tag (or
+* when every occurrence follows it) the first occurrence wins, matching the pre-heuristic
+* behavior for such malformed documents.
+*/
+function findHeadCloseTagIndex(html) {
+	const firstHeadCloseIndex = /<\/head>/i.exec(html)?.index ?? -1;
+	const bodyMatch = /<body[\s>]/i.exec(html);
+	if (!bodyMatch) return firstHeadCloseIndex;
+	const headClosePattern = /<\/head>/gi;
+	let lastHeadCloseIndex = -1;
+	let match;
+	while ((match = headClosePattern.exec(html)) && match.index < bodyMatch.index) lastHeadCloseIndex = match.index;
+	return lastHeadCloseIndex == -1 ? firstHeadCloseIndex : lastHeadCloseIndex;
+}
+/**
+* Injection contract for the `<ck-manual-header>` component, added to `<head>` only when the
+* page source contains the element:
+* - a `<meta>` carrying the package name and the base-aware catalog href the component reads;
+* - the module `<script>` that defines the custom element (folded into the page bundle under
+*   `bundledDev`, which is fine — it still executes).
+*/
+function createManualHeaderTags(entry, headerScriptPublicPath, catalogHref) {
+	return [{
+		tag: "meta",
+		attrs: {
+			"name": MANUAL_HEADER_ELEMENT,
+			"data-package-name": entry.packageName,
+			"data-catalog-href": catalogHref
+		},
+		injectTo: "head"
+	}, createModuleScriptTag(headerScriptPublicPath)];
 }
-function parseManualTestAssetPath(filePath) {
-	const match = stripLeadingSlash(toPosixPath(filePath)).match(/^(?:(.*?)\/)?([^/]+)\/tests\/manual\/(.+)\.(html|js|md|ts)$/);
-	if (!match) return null;
+function createModuleScriptTag(src, injectTo = "head") {
 	return {
-		extension: match[4],
-		packageName: match[2],
-		packageRootPath: match[1] || "",
-		slug: match[3]
+		tag: "script",
+		attrs: {
+			type: "module",
+			src
+		},
+		injectTo
 	};
 }
-function humanizeSlug(slug) {
-	return slug.split("/").map((pathPart) => pathPart.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ")).join(" / ");
+function filterManualPages(manualPages, includePackageNames) {
+	const isIncluded = createPackageNameFilter(includePackageNames);
+	return new Map([...manualPages].filter(([, entry]) => isIncluded(entry.packageName)));
+}
+function isManualCatalogHtmlFile(filePath, catalogBuildInputFilePath) {
+	const normalizedFilePath = toPosixPath(filePath);
+	return normalizedFilePath == toPosixPath(MANUAL_CATALOG_FILE_PATH) || normalizedFilePath == toPosixPath(catalogBuildInputFilePath);
+}
+function isManualCatalogBuildInputSpecifier(source, catalogBuildInputFilePath, workspaceRoot) {
+	return toPosixPath(resolve(workspaceRoot, source)) == toPosixPath(catalogBuildInputFilePath);
+}
+function toBasePublicPath(publicPath, base) {
+	if (base == "" || base == "./") return `.${publicPath}`;
+	return `${base.replace(/\/$/, "")}${publicPath}`;
+}
+function toBaseCatalogPath(base, entryHtmlFilePath) {
+	if (base == "" || base == "./") return posix.relative(posix.dirname(stripLeadingSlash(entryHtmlFilePath)), "index.html");
+	return base;
+}
+function rewriteCatalogRequest(request, manualCatalogPublicPath) {
+	const url = parseRequestUrl(request.url);
+	if (!url) return;
+	if (url.pathname == "/" || url.pathname == "/index.html") request.url = `${manualCatalogPublicPath}${url.search}`;
 }
-function matchFiles(patterns, workspaceRoot) {
-	return patterns.flatMap((pattern) => globSync(pattern, { cwd: workspaceRoot }).map((match) => toPosixPath(match)));
+function parseRequestUrl(requestUrl) {
+	return URL.parse(requestUrl || "", "http://localhost");
 }
 //#endregion
-//#region src/manual-test-plugin/static-assets.ts
+//#region src/static-assets-plugin/static-assets.ts
 /**
 * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
 * For licensing, see LICENSE.md.
 */
-const PROCESSED_MANUAL_TEST_EXTENSIONS = /* @__PURE__ */ new Set([
-	".html",
-	".js",
-	".md",
-	".ts"
-]);
+const PROCESSED_MANUAL_TEST_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".ts"]);
+const MANUAL_TEST_SUFFIX = ".manual.html";
 const VITE_MODULE_QUERY_PARAMETERS = /* @__PURE__ */ new Set([
 	"import",
 	"raw",
@@ -120,7 +309,7 @@ const VITE_MODULE_QUERY_PARAMETERS = /* @__PURE__ */ new Set([
 	"inline"
 ]);
 function collectManualStaticAssets(patterns, workspaceRoot) {
-	return new Map(patterns.flatMap((pattern) => globSync(pattern, { cwd: workspaceRoot })).sort().filter((relativeFilePath) => statSync(resolve(workspaceRoot, relativeFilePath), { throwIfNoEntry: false })?.isFile()).filter(isManualStaticAssetPath).map((relativeFilePath) => [toPublicSpecifier(relativeFilePath), resolve(workspaceRoot, relativeFilePath)]));
+	return new Map(patterns.map((pattern) => `${pattern.replace(/\/+$/, "")}/tests/manual/**/*`).flatMap((pattern) => globSync(pattern, { cwd: workspaceRoot })).sort().filter((relativeFilePath) => statSync(resolve(workspaceRoot, relativeFilePath), { throwIfNoEntry: false })?.isFile()).filter(isManualStaticAssetPath).map((relativeFilePath) => [toPublicSpecifier(relativeFilePath), resolve(workspaceRoot, relativeFilePath)]));
 }
 function createManualStaticAssetsMiddleware(collectStaticAssets) {
 	return (request, response, next) => {
@@ -163,6 +352,7 @@ function decodePathname(pathname) {
 	}
 }
 function isManualStaticAssetPath(filePath) {
+	if (filePath.endsWith(MANUAL_TEST_SUFFIX)) return false;
 	return extname(filePath) != "" && !PROCESSED_MANUAL_TEST_EXTENSIONS.has(extname(filePath));
 }
 function getContentType(extension) {
@@ -170,6 +360,8 @@ function getContentType(extension) {
 		case ".avif": return "image/avif";
 		case ".css": return "text/css; charset=utf-8";
 		case ".gif": return "image/gif";
+		case ".htm":
+		case ".html": return "text/html; charset=utf-8";
 		case ".ico": return "image/x-icon";
 		case ".jpg":
 		case ".jpeg": return "image/jpeg";
@@ -187,187 +379,22 @@ function getContentType(extension) {
 	}
 }
 //#endregion
-//#region src/manual-test-plugin/parse-markdown.ts
-/**
-* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
-* For licensing, see LICENSE.md.
-*/
-const markdownProcessor = unified().use(remarkParse).use(remarkGfm).use(remarkRehype, { allowDangerousHtml: true });
-function loadRenderedInstructions(entry, workspaceRoot) {
-	if (!entry.instructionsFilePath) return "";
-	const markdown = readFileSync(resolve(workspaceRoot, entry.instructionsFilePath.slice(1)), "utf8").trim();
-	if (!markdown) return "";
-	return toHtml(markdownProcessor.runSync(markdownProcessor.parse(markdown)), { allowDangerousHtml: true });
-}
-//#endregion
-//#region src/manual-test-plugin/shell-html.ts
-/**
-* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
-* For licensing, see LICENSE.md.
-*/
-function createManualShellHtml({ catalogPublicPath = "/", entry, html, shellScriptPublicPath, shellTemplateFilePath, workspaceRoot }) {
-	const shellDocument = parse(readFileSync(shellTemplateFilePath, "utf8").replace("href=\"/\" title=\"Back to test index\"", `href="${catalogPublicPath}" title="Back to test index"`));
-	const shellHead = getRequiredElementByTagName$1(shellDocument, "head");
-	const shellBody = getRequiredElementByTagName$1(shellDocument, "body");
-	const shellTitle = getRequiredElementByTagName$1(shellHead, "title");
-	const shellDataElement = query(shellBody, (candidate) => {
-		return isElementNode(candidate) && getAttribute(candidate, "id") == "manual-shell-data";
-	});
-	const shellScriptElement = getRequiredElementByAttribute(shellHead, "data-manual-shell-script");
-	const manualDocument = parse(html);
-	const manualHead = getRequiredElementByTagName$1(manualDocument, "head");
-	const manualBody = getRequiredElementByTagName$1(manualDocument, "body");
-	const manualTitle = findChildElement(manualHead, "title");
-	const testScriptElement = getRequiredElementByAttribute(shellHead, "data-manual-test-script");
-	const testScriptFileName = posix.basename(entry.scriptFilePath);
-	removeManualTestScriptNodes(manualDocument, testScriptFileName);
-	setTextContent(shellTitle, (manualTitle ? getTextContent(manualTitle) : "").trim() || entry.displayName);
-	setAttribute(shellScriptElement, "src", shellScriptPublicPath);
-	removeAttribute(shellScriptElement, "data-manual-shell-script");
-	setAttribute(testScriptElement, "src", `./${testScriptFileName}`);
-	removeAttribute(testScriptElement, "data-manual-test-script");
-	setTextContent(shellDataElement, stringifyHtmlScriptData(createManualData(entry, workspaceRoot)));
-	copyManualBodyAttributes(manualBody, shellBody);
-	appendChildren(shellHead, manualHead.childNodes.filter(shouldMoveManualHeadNode));
-	appendChild(shellBody, createManualTestContainer(manualBody));
-	return serialize(shellDocument);
-}
-function createManualData(entry, workspaceRoot) {
-	return {
-		displayName: entry.displayName,
-		instructionsHtml: loadRenderedInstructions(entry, workspaceRoot),
-		packageName: entry.packageName
-	};
-}
-function stringifyHtmlScriptData(value) {
-	return JSON.stringify(value).split("<").join("\\u003c");
-}
-function copyManualBodyAttributes(manualBody, shellBody) {
-	for (const { name, value } of manualBody.attrs) {
-		if (name == "class") {
-			setAttribute(shellBody, "class", [getAttribute(shellBody, "class"), value].filter(Boolean).join(" "));
-			continue;
-		}
-		if (!hasAttribute(shellBody, name)) setAttribute(shellBody, name, value);
-	}
-}
-function shouldMoveManualHeadNode(node) {
-	if (!isElementNode(node)) return true;
-	if (node.tagName == "title") return false;
-	if (node.tagName != "meta") return true;
-	return !getAttribute(node, "charset") && getAttribute(node, "name") != "viewport";
-}
-function appendChildren(parent, childNodes) {
-	for (const node of childNodes) {
-		removeNode(node);
-		appendChild(parent, node);
-	}
-}
-function createManualTestContainer(manualBody) {
-	const container = createElement("div", { class: "manual-test-container" });
-	appendChildren(container, [...manualBody.childNodes]);
-	return container;
-}
-function removeManualTestScriptNodes(parent, testScriptFileName) {
-	for (const node of [...parent.childNodes]) {
-		if (!isElementNode(node)) continue;
-		if (isManualTestScriptNode(node, testScriptFileName)) {
-			removeNode(node);
-			continue;
-		}
-		removeManualTestScriptNodes(node, testScriptFileName);
-	}
-}
-function isManualTestScriptNode(node, testScriptFileName) {
-	if (node.tagName != "script") return false;
-	const source = getAttribute(node, "src");
-	if (!source) return false;
-	if (isExternalScriptSource$1(source)) return false;
-	return getScriptModuleName(posix.basename(source.split("?")[0].split("#")[0])) == getScriptModuleName(testScriptFileName);
-}
-function isExternalScriptSource$1(source) {
-	return source.startsWith("http://") || source.startsWith("https://") || source.startsWith("//");
-}
-function getScriptModuleName(fileName) {
-	return fileName.replace(/\.[jt]s$/, "");
-}
-function getRequiredElementByTagName$1(root, tagName) {
-	return query(root, (candidate) => isElementNode(candidate) && candidate.tagName == tagName);
-}
-function getRequiredElementByAttribute(root, attributeName) {
-	return query(root, (candidate) => isElementNode(candidate) && hasAttribute(candidate, attributeName));
-}
-function findChildElement(root, tagName) {
-	return root.childNodes.find((node) => isElementNode(node) && node.tagName == tagName);
-}
-//#endregion
-//#region src/manual-test-plugin/plugin.ts
+//#region src/static-assets-plugin/plugin.ts
 /**
 * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
 * For licensing, see LICENSE.md.
 */
-const MANUAL_ENTRIES_VIRTUAL_ID = "virtual:ckeditor5-manual-entries";
-const MANUAL_THEME_ROOT = realpathSync(fileURLToPath(import.meta.resolve("@ckeditor/ckeditor5-dev-manual-server/theme")));
-const MANUAL_CATALOG_FILE_PATH = resolve(MANUAL_THEME_ROOT, "catalog.html");
-const MANUAL_CATALOG_SCRIPT_FILE_PATH = resolve(MANUAL_THEME_ROOT, "catalog.ts");
-const MANUAL_SHELL_TEMPLATE_FILE_PATH = resolve(MANUAL_THEME_ROOT, "shell.html");
-const MANUAL_SHELL_SCRIPT_FILE_PATH = resolve(MANUAL_THEME_ROOT, "shell.ts");
-function manualTestsPlugin(options) {
+function manualStaticAssetsPlugin(options) {
 	let workspaceRoot = process.cwd();
-	let base = "/";
-	const manualTestPatterns = options.paths;
-	const manualPagePatterns = manualTestPatterns.map(toManualPagePattern);
 	const includePackageNames = (options.include || []).filter(Boolean);
-	const manualPagesCache = cacheValue(() => filterManualPages(collectManualPages(manualPagePatterns, workspaceRoot), includePackageNames));
-	const getManualPages = manualPagesCache.get;
-	const manualStaticAssetsCache = cacheValue(() => collectManualStaticAssets(getManualStaticAssetPatterns(getManualPages(), manualTestPatterns, includePackageNames), workspaceRoot));
-	const getManualStaticAssets = manualStaticAssetsCache.get;
-	const invalidateManualFileCaches = () => {
-		manualPagesCache.invalidate();
-		manualStaticAssetsCache.invalidate();
-	};
-	const getManualPageEntryForFile = (filePath) => {
-		return getManualPages().get(toPublicSpecifier(relative(workspaceRoot, filePath)));
-	};
-	const getManualCatalogBuildInputFilePath = () => resolve(workspaceRoot, "index.html");
-	const getManualCatalogPublicPath = () => toPublicFilePath(getManualCatalogBuildInputFilePath(), workspaceRoot);
-	const getManualCatalogScriptPublicPath = () => toPublicFilePath(MANUAL_CATALOG_SCRIPT_FILE_PATH, workspaceRoot);
-	const getManualShellScriptPublicPath = () => toPublicFilePath(MANUAL_SHELL_SCRIPT_FILE_PATH, workspaceRoot);
-	const getManualCatalogClientPath = (entry) => toBaseCatalogPath(base, entry.htmlFilePath);
-	const getManualBuildInputs = () => [getManualCatalogBuildInputFilePath(), ...[...getManualPages().values()].map((entry) => resolve(workspaceRoot, entry.htmlFilePath.slice(1)))];
-	const resolvedVirtualModuleId = `\0${MANUAL_ENTRIES_VIRTUAL_ID}`;
-	const getClientEntries = () => [...getManualPages().values()].map((entry) => ({
-		displayName: entry.displayName,
-		href: toBasePublicPath(entry.htmlFilePath, base),
-		packageName: entry.packageName,
-		slug: entry.slug
-	}));
-	const getManualEntriesJson = () => JSON.stringify(getClientEntries(), null, 2);
+	const getManualStaticAssets = cacheValue(() => filterManualStaticAssets(collectManualStaticAssets(options.paths, workspaceRoot), includePackageNames, workspaceRoot)).get;
 	return {
-		name: "ckeditor5-manual-tests",
-		config() {
-			return { build: { rolldownOptions: { input: getManualBuildInputs() } } };
-		},
+		name: "ckeditor5-manual-static-assets",
 		configResolved(config) {
 			workspaceRoot = config.root;
-			base = config.base || "/";
-			invalidateManualFileCaches();
-			config.build.rolldownOptions.input = getManualBuildInputs();
 		},
 		configureServer(server) {
-			const { memoryFiles } = server.environments.client;
-			useManualTestMiddlewares(server, getManualCatalogPublicPath, getManualStaticAssets);
-			useBundledDevManualHtmlSource(memoryFiles, getManualPages, getManualShellScriptPublicPath, getManualCatalogClientPath, () => workspaceRoot);
-		},
-		resolveId(source) {
-			if (source == MANUAL_ENTRIES_VIRTUAL_ID) return resolvedVirtualModuleId;
-			if (isManualCatalogBuildInputSpecifier(source, getManualCatalogBuildInputFilePath(), workspaceRoot)) return getManualCatalogBuildInputFilePath();
-			return null;
-		},
-		load(id) {
-			if (id == resolvedVirtualModuleId) return `export const manualTestEntries = ${getManualEntriesJson()};`;
-			if (toPosixPath(id) == toPosixPath(getManualCatalogBuildInputFilePath())) return readFileSync(MANUAL_CATALOG_FILE_PATH, "utf8");
-			return null;
+			server.middlewares.use(createManualStaticAssetsMiddleware(getManualStaticAssets));
 		},
 		generateBundle() {
 			for (const [publicPath, filePath] of getManualStaticAssets()) this.emitFile({
@@ -375,143 +402,16 @@ function manualTestsPlugin(options) {
 				fileName: stripLeadingSlash(publicPath),
 				source: readFileSync(filePath)
 			});
-		},
-		transformIndexHtml: {
-			order: "pre",
-			handler(html, context) {
-				if (isManualCatalogHtmlFile(context.filename, getManualCatalogBuildInputFilePath())) return html.replace("./catalog.ts", getManualCatalogScriptPublicPath());
-				const entry = getManualPageEntryForFile(context.filename);
-				if (!entry) return;
-				return createManualShellHtml({
-					catalogPublicPath: getManualCatalogClientPath(entry),
-					entry,
-					html,
-					shellScriptPublicPath: getManualShellScriptPublicPath(),
-					shellTemplateFilePath: MANUAL_SHELL_TEMPLATE_FILE_PATH,
-					workspaceRoot
-				});
-			}
 		}
 	};
 }
-function useManualTestMiddlewares(server, getManualCatalogPublicPath, getManualStaticAssets) {
-	server.middlewares.use(createManualStaticAssetsMiddleware(getManualStaticAssets));
-	useManualCatalogMiddleware(server, getManualCatalogPublicPath);
+function filterManualStaticAssets(staticAssets, includePackageNames, workspaceRoot) {
+	const isIncluded = createPackageNameFilter(includePackageNames);
+	return new Map([...staticAssets].filter(([publicPath]) => isIncluded(getManualTestPackageName(publicPath, workspaceRoot))));
 }
-function useManualCatalogMiddleware(server, getManualCatalogPublicPath) {
-	server.middlewares.use((request, _response, next) => {
-		rewriteCatalogRequest(request, getManualCatalogPublicPath());
-		next();
-	});
-}
-function useBundledDevManualHtmlSource(memoryFiles, getManualPages, getManualShellScriptPublicPath, getManualCatalogClientPath, getWorkspaceRoot) {
-	if (!memoryFiles) return;
-	const getBundledFile = memoryFiles.get.bind(memoryFiles);
-	memoryFiles.get = (filePath) => {
-		const file = getBundledFile(filePath);
-		const entry = getManualPages().get(toPublicSpecifier(filePath));
-		if (!file || !entry) return file;
-		const workspaceRoot = getWorkspaceRoot();
-		const shellScriptPublicPath = getManualShellScriptPublicPath();
-		const bundledHtml = getFileSource(file);
-		return { source: mergeBundledAssetTags(createManualShellHtml({
-			catalogPublicPath: getManualCatalogClientPath(entry),
-			entry,
-			html: readFileSync(resolve(workspaceRoot, stripLeadingSlash(entry.htmlFilePath)), "utf8"),
-			shellScriptPublicPath,
-			shellTemplateFilePath: MANUAL_SHELL_TEMPLATE_FILE_PATH,
-			workspaceRoot
-		}), bundledHtml, entry, shellScriptPublicPath) };
-	};
-}
-function getFileSource(file) {
-	return typeof file.source == "string" ? file.source : Buffer.from(file.source).toString("utf8");
-}
-function toManualPagePattern(pattern) {
-	if (/\.(?:html|js|md|ts|\{[^}]*\})$/.test(pattern)) return pattern;
-	return `${pattern}.{html,js,md,ts}`;
-}
-function filterManualPages(manualPages, includePackageNames) {
-	if (includePackageNames.length == 0) return manualPages;
-	const normalizedIncludePackageNames = new Set(includePackageNames.map(normalizePackageName));
-	return new Map([...manualPages].filter(([, entry]) => normalizedIncludePackageNames.has(normalizePackageName(entry.packageName))));
-}
-function normalizePackageName(packageName) {
-	return packageName.replace(/^ckeditor5-/, "");
-}
-function getManualStaticAssetPatterns(manualPages, manualTestPatterns, includePackageNames) {
-	if (includePackageNames.length == 0) return manualTestPatterns;
-	return [...new Set([...manualPages.values()].map(getManualTestRootDirectory))].map((manualTestRootDirectory) => `${manualTestRootDirectory}/**/*`);
-}
-function getManualTestRootDirectory(entry) {
-	const htmlFilePath = stripLeadingSlash(entry.htmlFilePath);
-	const manualDirectoryIndex = htmlFilePath.indexOf("/tests/manual/");
-	return htmlFilePath.slice(0, manualDirectoryIndex + 14 - 1);
-}
-function isManualCatalogHtmlFile(filePath, catalogBuildInputFilePath) {
-	const normalizedFilePath = toPosixPath(filePath);
-	return normalizedFilePath == toPosixPath(MANUAL_CATALOG_FILE_PATH) || normalizedFilePath == toPosixPath(catalogBuildInputFilePath);
-}
-function isManualCatalogBuildInputSpecifier(source, catalogBuildInputFilePath, workspaceRoot) {
-	return toPosixPath(resolve(workspaceRoot, source)) == toPosixPath(catalogBuildInputFilePath);
-}
-function toBasePublicPath(publicPath, base) {
-	if (base == "" || base == "./") return `.${publicPath}`;
-	return `${base.replace(/\/$/, "")}${publicPath}`;
-}
-function toBaseCatalogPath(base, entryHtmlFilePath) {
-	if (base == "" || base == "./") return posix.relative(posix.dirname(stripLeadingSlash(entryHtmlFilePath)), "index.html");
-	return base;
-}
-function mergeBundledAssetTags(sourceHtml, bundledHtml, entry, shellScriptPublicPath) {
-	const sourceDocument = parse(sourceHtml);
-	const bundledDocument = parse(bundledHtml);
-	const sourceHead = getRequiredElementByTagName(sourceDocument, "head");
-	const bundledHead = getRequiredElementByTagName(bundledDocument, "head");
-	const testScriptFileName = posix.basename(entry.scriptFilePath);
-	const hasBundledShellAsset = bundledHead.childNodes.some((node) => isBundledModuleAsset(node, "shell"));
-	for (const node of [...sourceHead.childNodes]) if (isSourceTestScript(node, testScriptFileName) || hasBundledShellAsset && isSourceShellScript(node, shellScriptPublicPath)) removeNode(node);
-	for (const node of bundledHead.childNodes.filter(isBundledAssetTag)) {
-		removeNode(node);
-		appendChild(sourceHead, node);
-	}
-	return serialize(sourceDocument);
-}
-function isSourceTestScript(node, testScriptFileName) {
-	if (!isElementNode(node) || node.tagName != "script") return false;
-	const source = getAttribute(node, "src");
-	if (!source) return false;
-	if (isExternalScriptSource(source)) return false;
-	return posix.basename(source) == testScriptFileName;
-}
-function isExternalScriptSource(source) {
-	return source.startsWith("http://") || source.startsWith("https://") || source.startsWith("//");
-}
-function isSourceShellScript(node, shellScriptPublicPath) {
-	return isElementNode(node) && node.tagName == "script" && getAttribute(node, "src") == shellScriptPublicPath;
-}
-function isBundledModuleAsset(node, moduleName) {
-	if (!isElementNode(node)) return false;
-	if (node.tagName == "script") return isBundledModulePath(getAttribute(node, "src"), moduleName);
-	return node.tagName == "link" && getAttribute(node, "rel") == "modulepreload" && isBundledModulePath(getAttribute(node, "href"), moduleName);
-}
-function isBundledModulePath(path, moduleName) {
-	return Boolean(path?.startsWith(`/assets/${moduleName}-`));
-}
-function isBundledAssetTag(node) {
-	if (!isElementNode(node)) return false;
-	return Boolean(node.tagName == "script" && getAttribute(node, "src")?.startsWith("/assets/") || node.tagName == "link" && getAttribute(node, "href")?.startsWith("/assets/"));
-}
-function rewriteCatalogRequest(request, manualCatalogPublicPath) {
-	const url = parseRequestUrl(request.url);
-	if (!url) return;
-	if (url.pathname == "/" || url.pathname == "/index.html") request.url = `${manualCatalogPublicPath}${url.search}`;
-}
-function parseRequestUrl(requestUrl) {
-	return URL.parse(requestUrl || "", "http://localhost");
-}
-function getRequiredElementByTagName(root, tagName) {
-	return query(root, (candidate) => isElementNode(candidate) && candidate.tagName == tagName);
+function getManualTestPackageName(publicPath, workspaceRoot) {
+	if (publicPath.startsWith("/tests/manual/")) return basename(workspaceRoot);
+	return publicPath.match(/^\/(?:.*\/)?([^/]+)\/tests\/manual\//)?.[1] || null;
 }
 //#endregion
 //#region src/debug-plugin/plugin.ts
@@ -561,14 +461,15 @@ function refreshPlugin() {
 		name: "ckeditor5-manual-refresh",
 		apply: "serve",
 		configureServer(server) {
-			const clientEnvironment = server.environments.client;
-			wrapBundledDevClientSend(clientEnvironment.clients);
-			wrapBundledDevFullReloads(clientEnvironment);
+			const bundledDev = server.environments.client.bundledDev;
+			if (!bundledDev) return;
+			wrapBundledDevClientSend(bundledDev.clients);
+			wrapBundledDevFullReloads(bundledDev);
 		}
 	};
 }
 function wrapBundledDevClientSend(clients) {
-	if (!clients) return;
+	if (!clients || typeof clients.setupIfNeeded != "function") return;
 	const setupIfNeeded = clients.setupIfNeeded.bind(clients);
 	clients.setupIfNeeded = (client, clientId) => {
 		if (!client[isManualRefreshWrappedClient]) {
@@ -581,12 +482,12 @@ function wrapBundledDevClientSend(clients) {
 		return setupIfNeeded(client, clientId);
 	};
 }
-function wrapBundledDevFullReloads(clientEnvironment) {
-	if (!clientEnvironment.handleHmrOutput) return;
-	const handleHmrOutput = clientEnvironment.handleHmrOutput.bind(clientEnvironment);
-	clientEnvironment.handleHmrOutput = (client, files, hmrOutput, invalidateInformation) => {
+function wrapBundledDevFullReloads(bundledDev) {
+	if (typeof bundledDev.handleHmrOutput != "function") return;
+	const handleHmrOutput = bundledDev.handleHmrOutput.bind(bundledDev);
+	bundledDev.handleHmrOutput = (client, files, hmrOutput, invalidateInformation) => {
 		if (hmrOutput.type == "FullReload" && shouldShowManualRefreshPromptForFiles(files)) {
-			clientEnvironment.devEngine?.ensureLatestBuildOutput().catch(() => {});
+			ensureLatestBuildOutput(bundledDev);
 			client.send({
 				type: "custom",
 				event: MANUAL_REFRESH_EVENT_NAME
@@ -596,6 +497,11 @@ function wrapBundledDevFullReloads(clientEnvironment) {
 		return handleHmrOutput(client, files, hmrOutput, invalidateInformation);
 	};
 }
+function ensureLatestBuildOutput(bundledDev) {
+	try {
+		bundledDev.devEngine?.ensureLatestBuildOutput().catch(() => {});
+	} catch {}
+}
 function sendManualRefreshPayload(payload, send) {
 	if (shouldShowManualRefreshPrompt(payload)) {
 		send({
@@ -619,42 +525,27 @@ function shouldShowManualRefreshPromptForFiles(files) {
 	return files.some((file) => !file.endsWith(".css") && !file.endsWith(".html"));
 }
 //#endregion
-//#region src/raw-plugin/plugin.ts
+//#region src/svg-plugin/plugin.ts
 /**
 * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
 * For licensing, see LICENSE.md.
 */
-const RAW_QUERY = "?ckeditor5-raw";
-function rawHtmlPlugin() {
+function rawSvgPlugin() {
 	return {
-		name: "ckeditor5-raw",
+		name: "ckeditor5-raw-svg",
 		enforce: "pre",
-		resolveId(source, importer) {
-			if (!importer || source.includes("?")) return null;
-			if (path.extname(source) != ".html") return null;
-			const filePath = resolveHtmlFilePath(source, importer);
-			if (filePath) return `${filePath}${RAW_QUERY}`;
-			return null;
-		},
-		async load(id) {
-			if (!id.endsWith(RAW_QUERY)) return null;
-			const source = await readFile(id.slice(0, -14), "utf8");
-			return {
-				code: `export default ${JSON.stringify(source)};`,
-				map: null
-			};
+		load: {
+			filter: { id: { include: /\.svg$/ } },
+			handler(id) {
+				const content = readFileSync(id, "utf-8");
+				return {
+					code: `export default ${JSON.stringify(content)};`,
+					map: null
+				};
+			}
 		}
 	};
 }
-function resolveHtmlFilePath(source, importer) {
-	if (!source.startsWith(".")) return null;
-	const filePath = path.resolve(path.dirname(getFilePathFromId(importer)), source);
-	return existsSync(filePath) ? toPosixPath(filePath) : null;
-}
-function getFilePathFromId(id) {
-	const queryIndex = id.indexOf("?");
-	return queryIndex >= 0 ? id.slice(0, queryIndex) : id;
-}
 //#endregion
 //#region src/index.ts
 /**
@@ -662,4 +553,4 @@ function getFilePathFromId(id) {
 * For licensing, see LICENSE.md.
 */
 //#endregion
-export { ckDebugPlugin, manualTestsPlugin, rawHtmlPlugin, refreshPlugin, stringifyValues };
+export { ckDebugPlugin, manualStaticAssetsPlugin, manualTestsPlugin, rawSvgPlugin, refreshPlugin, stringifyValues };