@ox-content/vite-plugin-svelte 3.1.2-beta.0 → 3.1.3

package/dist/index.mjs

@@ -1,7 +1,11 @@
-import * as fs from "fs";
-import * as path from "path";
-import { applyIslandSsrHtml, discoverDocumentMdxIslands, oxContent, oxContent as oxContent$1, renderHead, renderIslandComponentImports, resolveContentRootPath, resolveMdxForFilePath, transformMarkdown } from "@ox-content/vite-plugin";
+import { a as loadSvelteHtmlHostDomRuntime, i as createSvelteHtmlHostDomRenderer, n as initSvelteHtmlHost, r as readSvelteHtmlHostSlot, t as createSvelteHtmlHostLazyHydrate } from "./html-host-client2.mjs";
+import { applyIslandSsrHtml, buildCollectionManifest, collectMdxIslandNamesFromHtml, customHostOxContentOptions, discoverDocumentMdxIslands, intersectHydratableComponentNames, normalizeMarkdownExtensions, oxContent, oxContent as oxContent$1, renderHead, renderIslandComponentImports, renderMarkdown, resolveCascadeOptions, resolveCollectionsOptions, resolveContentRootPath, resolveDocumentComponentImports, resolveMdxForFilePath, resolvePermalinksOptions, stripViteQuery, transformMarkdown } from "@ox-content/vite-plugin";
 import { compile } from "svelte/compiler";
+import * as fs$1 from "fs";
+import * as path$1 from "path";
+import path from "node:path";
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
 //#region src/transform.ts
 const COMPONENT_REGEX = /<([A-Z][a-zA-Z0-9]*)\s*([^>]*?)\s*(?:\/>|>([\s\S]*?)<\/\1>)/g;
 const PROP_REGEX = /([a-zA-Z0-9-]+)(?:=(?:"([^"]*)"|'([^']*)'|{([^}]*)}|\[([^\]]*)\]))?/g;
@@ -91,8 +95,8 @@ async function transformMarkdownWithSvelte(code, id, options) {
 			}),
 			srcDir: options.srcDir
 		});
-		if (options.mdxDocumentProps) return compileSvelteResult(generateMdxDocumentPropsSvelteModule(transformed.html, discovered.usedComponents, frontmatter, options, id, discovered.localBindings, documentExpressions.expressions), id, discovered.usedComponents, frontmatter, options.ssr);
-		return compileSvelteResult(generateSvelteModule(options.renderIsland ? await applyIslandSsrHtml(transformed.html, options.renderIsland, id, discovered.usedComponents) : transformed.html, discovered.usedComponents, discovered.usedComponents, frontmatter, options, id, discovered.localBindings), id, discovered.usedComponents, frontmatter, options.ssr);
+		if (options.mdxDocumentProps) return compileSvelteResult(generateMdxDocumentPropsSvelteModule(transformed.html, discovered.usedComponents, frontmatter, options, id, discovered.localBindings, documentExpressions.expressions), id, discovered.usedComponents, frontmatter, options);
+		return compileSvelteResult(generateSvelteModule(options.renderIsland ? await applyIslandSsrHtml(transformed.html, options.renderIsland, id, discovered.usedComponents) : transformed.html, discovered.usedComponents, discovered.usedComponents, frontmatter, options, id, discovered.localBindings), id, discovered.usedComponents, frontmatter, options);
 	}
 	const usedComponents = [];
 	const islands = [];
@@ -126,20 +130,63 @@ async function transformMarkdownWithSvelte(code, id, options) {
 		lastIndex = matchEnd;
 	}
 	processedContent += markdownContent.slice(lastIndex);
-	return compileSvelteResult(generateSvelteModule(injectIslandMarkers((await transformMarkdown(processedContent, id, baseOptions)).html, islands), usedComponents, islands, frontmatter, options, id), id, usedComponents, frontmatter, options.ssr);
+	return compileSvelteResult(generateSvelteModule(injectIslandMarkers((await transformMarkdown(processedContent, id, baseOptions)).html, islands), usedComponents, islands, frontmatter, options, id), id, usedComponents, frontmatter, options);
 }
-function compileSvelteResult(svelteCode, id, usedComponents, frontmatter, ssr = false) {
+async function compileSvelteResult(svelteCode, id, usedComponents, frontmatter, options) {
+	const compiled = normalizeSvelteCompilerResult(await resolveSvelteCompiler(options.compiler)(svelteCode, {
+		filename: id,
+		generate: options.ssr ? "server" : "client",
+		runes: options.runes
+	}), id);
 	return {
-		code: `${compile(svelteCode, {
-			filename: id,
-			generate: ssr ? "server" : "client",
-			runes: true
-		}).js.code}\nexport const frontmatter = ${JSON.stringify(frontmatter)};`,
-		map: null,
+		code: `${compiled.code}\nexport const frontmatter = ${JSON.stringify(frontmatter)};`,
+		map: compiled.map,
+		warnings: compiled.warnings,
 		usedComponents,
 		frontmatter
 	};
 }
+function resolveSvelteCompiler(compiler) {
+	if (!compiler) return compile;
+	if (typeof compiler === "function") return compiler;
+	return compiler.compile;
+}
+function normalizeSvelteCompilerResult(result, id) {
+	let value = result;
+	if (typeof value === "string") {
+		const source = value;
+		try {
+			value = JSON.parse(source);
+		} catch {
+			return {
+				code: source,
+				map: null,
+				warnings: []
+			};
+		}
+	}
+	if (!value || typeof value !== "object") throwUnsupportedCompilerResult(id);
+	const output = value;
+	const js = output.js;
+	const warnings = Array.isArray(output.warnings) ? output.warnings : [];
+	if (typeof js === "string") return {
+		code: js,
+		map: null,
+		warnings
+	};
+	if (js && typeof js === "object") {
+		const jsOutput = js;
+		if (typeof jsOutput.code === "string") return {
+			code: jsOutput.code,
+			map: jsOutput.map ?? null,
+			warnings
+		};
+	}
+	throwUnsupportedCompilerResult(id);
+}
+function throwUnsupportedCompilerResult(id) {
+	throw new Error(`[ox-content-svelte] Compiler for ${id} returned an unsupported result. Expected { js: { code } } or a compatible JSON string.`);
+}
 function createIslandMarker(islandId) {
 	return `${ISLAND_MARKER_PREFIX}${islandId}${ISLAND_MARKER_SUFFIX}`;
 }
@@ -719,7 +766,7 @@ function findMdxIslandRanges(html) {
 	let match;
 	while ((match = openRe.exec(html)) !== null) {
 		const tag = match[1];
-		const name = decodeHtmlAttr(match[3] ?? "");
+		const name = decodeHtmlAttr$1(match[3] ?? "");
 		if (!name) continue;
 		const openStart = match.index;
 		const openEnd = match.index + match[0].length;
@@ -774,7 +821,7 @@ function indexOfTagOpen(html, openNeedle, from) {
 }
 function matchAttr(attrs, name) {
 	const match = new RegExp(`\\b${name}="([^"]*)"`, "i").exec(attrs);
-	return match?.[1] === void 0 ? void 0 : decodeHtmlAttr(match[1]);
+	return match?.[1] === void 0 ? void 0 : decodeHtmlAttr$1(match[1]);
 }
 function readMdxIslandPayload(island) {
 	const fromAttr = island.propsAttr ? tryParseJson(island.propsAttr) : void 0;
@@ -819,7 +866,7 @@ function tryParseJson(value) {
 		return;
 	}
 }
-function decodeHtmlAttr(value) {
+function decodeHtmlAttr$1(value) {
 	return value.replaceAll("&quot;", "\"").replaceAll("&#39;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
 }
 function assertSvelteComponentName(name, filePath) {
@@ -940,18 +987,640 @@ function createSvelteMarkdownEnvironment(mode, options) {
 	};
 }
 //#endregion
-//#region src/index.ts
+//#region src/components.ts
 /**
-* Vite Plugin for Ox Content Svelte Integration
-*
-* Uses Vite's Environment API to enable embedding Svelte components in Markdown.
+* Resolves the `components` option into a name → path map, expanding glob
+* patterns against the Vite project root.
 */
+async function resolveComponentsGlob(componentsOption, root) {
+	if (typeof componentsOption === "object" && !Array.isArray(componentsOption)) return componentsOption;
+	const patterns = Array.isArray(componentsOption) ? componentsOption : [componentsOption];
+	const result = {};
+	for (const pattern of patterns) for (const file of await globFiles(pattern, root)) {
+		const baseName = path$1.basename(file, path$1.extname(file));
+		const relativePath = "./" + path$1.relative(root, file).replace(/\\/g, "/");
+		result[toPascalCase(baseName)] = relativePath;
+	}
+	return result;
+}
+async function globFiles(pattern, root) {
+	const files = [];
+	const normalized = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
+	if (!hasWildcard(normalized)) {
+		const fullPath = path$1.resolve(root, normalized);
+		if (fs$1.existsSync(fullPath)) files.push(fullPath);
+		return files;
+	}
+	const baseDir = path$1.resolve(root, staticPrefix(normalized));
+	if (!fs$1.existsSync(baseDir)) return files;
+	const segments = normalized.split("/");
+	const crossesDirectories = normalized.includes("**") || segments.slice(0, -1).some(hasWildcard);
+	const candidates = [];
+	if (crossesDirectories) await walkDir(baseDir, candidates);
+	else {
+		const entries = await fs$1.promises.readdir(baseDir, { withFileTypes: true });
+		for (const entry of entries) if (entry.isFile()) candidates.push(path$1.join(baseDir, entry.name));
+	}
+	const matcher = globToRegExp(normalized);
+	for (const candidate of candidates) if (matcher.test(path$1.relative(root, candidate).replace(/\\/g, "/"))) files.push(candidate);
+	return files;
+}
+/** Whether a pattern (or one segment of it) contains a wildcard `globToRegExp` expands. */
+function hasWildcard(pattern) {
+	return pattern.includes("*") || pattern.includes("?");
+}
+/** Leading path segments of a pattern that contain no wildcard. */
+function staticPrefix(pattern) {
+	const segments = [];
+	for (const segment of pattern.split("/")) {
+		if (hasWildcard(segment)) break;
+		segments.push(segment);
+	}
+	return segments.join("/");
+}
+/**
+* Translates a glob into an anchored `RegExp`: `**` crosses directory
+* boundaries, `*` and `?` stay within one segment.
+*/
+function globToRegExp(pattern) {
+	let source = "";
+	let index = 0;
+	while (index < pattern.length) {
+		const char = pattern[index];
+		if (char === "*") {
+			if (pattern[index + 1] === "*") {
+				index += 2;
+				if (pattern[index] === "/") {
+					index += 1;
+					source += "(?:[^/]+/)*";
+				} else source += ".*";
+				continue;
+			}
+			source += "[^/]*";
+		} else if (char === "?") source += "[^/]";
+		else source += char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		index += 1;
+	}
+	return new RegExp(`^${source}$`);
+}
+async function walkDir(dir, files) {
+	const entries = await fs$1.promises.readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = path$1.join(dir, entry.name);
+		if (entry.isDirectory()) await walkDir(fullPath, files);
+		else if (entry.isFile()) files.push(fullPath);
+	}
+}
+function toPascalCase(str) {
+	return str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toUpperCase());
+}
+//#endregion
+//#region src/html-host-default-renderer.ts
+const defaultRenderSvelteHtmlComponent = async (component, props, slotHtml) => {
+	const [{ render }, { createRawSnippet }] = await Promise.all([import("svelte/server"), import("svelte")]);
+	const rendered = render(component, { props: slotHtml ? {
+		...props,
+		children: createRawSnippet(() => ({ render: () => slotHtml }))
+	} : props });
+	return rendered.html ?? rendered.body ?? "";
+};
+//#endregion
+//#region src/html-host.ts
+const ISLAND_JSON_SCRIPT = /^\s*<script type="application\/json">[\s\S]*?<\/script>/;
+async function renderSvelteHtmlHost(input) {
+	const diagnostics = [];
+	const modules = resolveHostModules(input, diagnostics);
+	const byName = new Map(modules.map((module) => [module.name, module]));
+	const cache = /* @__PURE__ */ new Map();
+	const renderComponent = input.renderComponent ?? defaultRenderSvelteHtmlComponent;
+	return {
+		html: markClientModules(await applyIslandSsrHtml(input.html, async (name, props, _filePath, slotHtml) => {
+			const module = byName.get(name);
+			if (!module) {
+				diagnostics.push({
+					code: "missing-component",
+					message: `Svelte island "${name}" is not registered for this document.`,
+					documentPath: input.documentPath,
+					component: name
+				});
+				return slotHtml ?? "";
+			}
+			const component = await loadComponent(input, module, cache, diagnostics);
+			if (!component) return slotHtml ?? "";
+			try {
+				return await renderComponent(component, props, slotHtml || void 0, {
+					component: name,
+					moduleId: module.serverModuleId,
+					documentPath: input.documentPath
+				});
+			} catch (error) {
+				diagnostics.push({
+					code: "ssr-failed",
+					message: `Svelte island "${name}" failed to render: ${errorMessage(error)}`,
+					documentPath: input.documentPath,
+					component: name,
+					moduleId: module.serverModuleId
+				});
+				return slotHtml ?? "";
+			}
+		}, input.documentPath, modules.map((module) => module.name)), modules),
+		modules,
+		clientModules: modules.flatMap((module) => module.clientModuleId ? [{
+			name: module.name,
+			moduleId: module.clientModuleId,
+			exportName: module.exportName
+		}] : []),
+		diagnostics
+	};
+}
+function createSvelteHtmlHostHydrate(input) {
+	return (element, props) => {
+		const name = element.dataset.oxIsland;
+		if (!name) return;
+		const component = componentFromRegistry(input.components, name);
+		if (!component) return;
+		const slotHtml = readIslandSlotHtml(element);
+		element.innerHTML = "";
+		return input.render(component, props, element, slotHtml || void 0);
+	};
+}
+function resolveHostModules(input, diagnostics) {
+	const names = collectMdxIslandNamesFromHtml(input.html);
+	const local = resolveDocumentComponentImports({
+		imports: input.imports ?? [],
+		documentPath: input.documentPath,
+		contentRoot: input.contentRoot ?? resolveContentRootPath(input),
+		srcDir: input.srcDir
+	});
+	for (const diagnostic of local.diagnostics) diagnostics.push({
+		...diagnostic,
+		documentPath: input.documentPath
+	});
+	const localBindings = new Map(local.bindings.map((binding) => [binding.localName, binding]));
+	const modules = [];
+	for (const name of names) {
+		const localBinding = localBindings.get(name);
+		const serverModuleId = localBinding ? localBinding.resolvedPath : componentPath(input.components ?? {}, name, input.root);
+		if (!serverModuleId) {
+			diagnostics.push({
+				code: "missing-component",
+				message: `Svelte island "${name}" is not registered for this document.`,
+				documentPath: input.documentPath,
+				component: name
+			});
+			continue;
+		}
+		const module = {
+			name,
+			serverModuleId,
+			exportName: localBinding?.imported ?? "default",
+			source: localBinding ? "document" : "components"
+		};
+		const clientModuleId = input.resolveClientModule?.(module, { documentPath: input.documentPath });
+		modules.push(clientModuleId ? {
+			...module,
+			clientModuleId
+		} : module);
+	}
+	return modules;
+}
+async function loadComponent(input, module, cache, diagnostics) {
+	let pending = cache.get(module.serverModuleId);
+	if (!pending) {
+		pending = input.loadModule(module.serverModuleId);
+		cache.set(module.serverModuleId, pending);
+	}
+	let exports;
+	try {
+		exports = await pending;
+	} catch (error) {
+		diagnostics.push({
+			code: "module-load-failed",
+			message: `Svelte island module "${module.serverModuleId}" failed to load: ${errorMessage(error)}`,
+			documentPath: input.documentPath,
+			component: module.name,
+			moduleId: module.serverModuleId
+		});
+		return;
+	}
+	const component = exportedValue(exports, module.exportName);
+	if (!component) diagnostics.push({
+		code: "missing-export",
+		message: `Svelte island "${module.name}" could not find export "${module.exportName}".`,
+		documentPath: input.documentPath,
+		component: module.name,
+		moduleId: module.serverModuleId
+	});
+	return component == null ? void 0 : component;
+}
+function componentPath(components, name, root = process.cwd()) {
+	const specifier = components[name];
+	if (!specifier) return;
+	return path.resolve(root, specifier.replace(/^\.\//, ""));
+}
+function exportedValue(exports, exportName) {
+	if (!exports || typeof exports !== "object") return;
+	return exports[exportName];
+}
+function componentFromRegistry(registry, name) {
+	return isReadonlyMap(registry) ? registry.get(name) : registry[name];
+}
+function isReadonlyMap(value) {
+	return typeof value.get === "function";
+}
+function readIslandSlotHtml(element) {
+	const fromAttr = element.dataset.oxContent;
+	if (fromAttr) return fromAttr;
+	if (element.dataset.oxSsr === "true") return "";
+	return element.innerHTML.replace(ISLAND_JSON_SCRIPT, "");
+}
+function markClientModules(html, modules) {
+	const clientModules = new Map(modules.filter((module) => module.clientModuleId).map((module) => [module.name, module]));
+	if (clientModules.size === 0) return html;
+	return html.replace(/<(div|span)\b([^>]*\bdata-ox-island="([^"]+)"[^>]*)>/gi, (openTag, _tag, _attrs, encodedName) => {
+		const module = clientModules.get(decodeHtmlAttr(encodedName));
+		if (!module?.clientModuleId) return openTag;
+		const attrs = [];
+		if (!hasAttr(openTag, "data-ox-module")) attrs.push(`data-ox-module="${escapeDoubleQuotedAttr(module.clientModuleId)}"`);
+		if (!hasAttr(openTag, "data-ox-export")) attrs.push(`data-ox-export="${escapeDoubleQuotedAttr(module.exportName)}"`);
+		return attrs.length === 0 ? openTag : openTag.replace(/>$/, ` ${attrs.join(" ")}>`);
+	});
+}
+function escapeDoubleQuotedAttr(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function decodeHtmlAttr(value) {
+	return value.replaceAll("&quot;", "\"").replaceAll("&#39;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+}
+function hasAttr(openTag, name) {
+	return new RegExp(`\\s${name}(?:\\s*=|\\s|>|$)`, "i").test(openTag);
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/html-host-registry-paths.ts
+function toSvelteHtmlHostClientModuleId(moduleId, root = process.cwd()) {
+	const [pathname, suffix = ""] = splitModuleSuffix(moduleId);
+	if (isBareSpecifier(pathname) || pathname.startsWith("/@fs/")) return `${pathname}${suffix}`;
+	const rootPath = path.resolve(root);
+	const realRoot = existingRealpath(rootPath) ?? rootPath;
+	const absolute = path.isAbsolute(pathname) ? path.resolve(pathname) : path.resolve(rootPath, pathname);
+	const realAbsolute = existingRealpath(absolute);
+	const isInsideRealRoot = realAbsolute ? isInsideRoot(realAbsolute, realRoot) : false;
+	const isInsideLexicalRoot = isInsideRoot(absolute, rootPath);
+	if (path.isAbsolute(pathname) && !isInsideRealRoot && !isInsideLexicalRoot) return fsSync.existsSync(pathname) ? `/@fs${toPosixPath(pathname)}${suffix}` : `${toPosixPath(pathname)}${suffix}`;
+	const relativeRoot = isInsideRealRoot ? realRoot : rootPath;
+	const relativePath = isInsideRealRoot && realAbsolute ? realAbsolute : absolute;
+	return `/${path.relative(relativeRoot, relativePath).replace(/\\/g, "/")}${suffix}`;
+}
+function resolveDocumentPath(documentPath, root) {
+	return path.isAbsolute(documentPath) ? stripViteQuery(documentPath) : path.resolve(root, stripViteQuery(documentPath));
+}
+function resolveWatchFile(file, root) {
+	return path.isAbsolute(file) ? stripViteQuery(file) : path.resolve(root, stripViteQuery(file));
+}
+function shouldInvalidate(file, root, srcDir, watchFiles, extraWatchFiles) {
+	const changed = path.resolve(file);
+	if (watchFiles.some((watchFile) => changed === watchFile)) return true;
+	if (extraWatchFiles?.some((watchFile) => changed === resolveWatchFile(watchFile, root))) return true;
+	return isInsideRoot(changed, path.resolve(root, srcDir ?? "content"));
+}
+function splitModuleSuffix(moduleId) {
+	const match = /[?#]/u.exec(moduleId);
+	return match ? [moduleId.slice(0, match.index), moduleId.slice(match.index)] : [moduleId];
+}
+function isBareSpecifier(moduleId) {
+	return !moduleId.startsWith(".") && !moduleId.startsWith("/") && !moduleId.includes("\\");
+}
+function isInsideRoot(file, root) {
+	const relative = path.relative(path.resolve(root), path.resolve(file));
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function existingRealpath(file) {
+	try {
+		return fsSync.realpathSync.native(file);
+	} catch {
+		return;
+	}
+}
+function toPosixPath(file) {
+	return file.replace(/\\/g, "/");
+}
+//#endregion
+//#region src/html-host-renderer.ts
+var SvelteHtmlHostRenderError = class extends Error {
+	diagnostics;
+	constructor(diagnostics) {
+		super(formatSvelteHtmlHostDiagnostics(diagnostics));
+		this.name = "SvelteHtmlHostRenderError";
+		this.diagnostics = [...diagnostics];
+	}
+};
+function createSvelteHtmlHostRenderer(input) {
+	const policy = input.diagnostics ?? "throw";
+	return async (html, context) => {
+		const root = context.root ?? input.root;
+		const result = await renderSvelteHtmlHost({
+			html,
+			documentPath: context.documentPath,
+			root,
+			srcDir: context.srcDir ?? input.srcDir,
+			contentRoot: context.contentRoot ?? input.contentRoot,
+			imports: context.imports,
+			components: context.components ?? input.components,
+			loadModule: input.loadModule,
+			renderComponent: context.renderComponent ?? input.renderComponent,
+			resolveClientModule: context.resolveClientModule ?? input.resolveClientModule ?? ((module) => toSvelteHtmlHostClientModuleId(module.serverModuleId, root))
+		});
+		if (policy === "throw" && result.diagnostics.length > 0) throw new SvelteHtmlHostRenderError(result.diagnostics);
+		return result;
+	};
+}
+function formatSvelteHtmlHostDiagnostics(diagnostics) {
+	if (diagnostics.length === 0) return "Svelte HTML host rendering failed.";
+	return diagnostics.map((diagnostic) => {
+		const details = [
+			diagnostic.documentPath,
+			diagnostic.component && `component ${diagnostic.component}`,
+			diagnostic.moduleId && `module ${diagnostic.moduleId}`
+		].filter(Boolean);
+		return `${diagnostic.code}: ${diagnostic.message}${details.length > 0 ? ` (${details.join(", ")})` : ""}`;
+	}).join("\n");
+}
+//#endregion
+//#region src/html-host-collection-documents.ts
+function createSvelteHtmlHostCollectionDocuments(input = {}) {
+	return (context) => resolveSvelteHtmlHostCollectionDocuments(input, context);
+}
+async function resolveSvelteHtmlHostCollectionDocuments(input, context) {
+	const options = resolveCollectionManifestOptions(customHostOxContentOptions(input.oxContent ?? {}));
+	if (!options.collections.enabled) return [];
+	const manifest = await buildCollectionManifest(context.root, options);
+	const names = resolveCollectionNames(input.collections, options.collections);
+	const documents = /* @__PURE__ */ new Map();
+	for (const name of names) for (const entry of manifest.collections[name] ?? []) {
+		const document = await resolveCollectionDocument(context.root, options.srcDir, name, entry);
+		if (!document) continue;
+		if (input.select && !await input.select(document, context)) continue;
+		documents.set(document.documentPath, document);
+	}
+	return [...documents.values()];
+}
+function resolveCollectionManifestOptions(oxContent) {
+	const collections = withoutCollectionInclude(resolveCollectionsOptions(oxContent.collections));
+	return {
+		srcDir: oxContent.srcDir ?? "content",
+		outDir: oxContent.outDir ?? "dist",
+		base: oxContent.base ?? "/",
+		extensions: normalizeMarkdownExtensions(oxContent.extensions),
+		collections,
+		permalinks: resolvePermalinksOptions(oxContent.permalinks),
+		cascade: resolveCascadeOptions(oxContent.cascade),
+		gfm: oxContent.gfm ?? true,
+		mdx: oxContent.mdx,
+		footnotes: oxContent.footnotes ?? true,
+		semanticFootnotes: oxContent.semanticFootnotes ?? false,
+		taskLists: oxContent.taskLists ?? true,
+		tables: oxContent.tables ?? true,
+		strikethrough: oxContent.strikethrough ?? true,
+		autolinks: oxContent.autolinks ?? oxContent.gfm ?? true,
+		superscript: oxContent.superscript ?? false,
+		subscript: oxContent.subscript ?? false,
+		smartPunctuation: oxContent.smartPunctuation ?? false,
+		autolinkTargetBlank: oxContent.autolinkTargetBlank ?? true,
+		linkTargetBlank: oxContent.linkTargetBlank ?? true,
+		sourceSpans: oxContent.sourceSpans ?? false,
+		frontmatter: oxContent.frontmatter ?? true,
+		tocMaxDepth: oxContent.tocMaxDepth ?? 3,
+		cjkEmphasis: oxContent.cjkEmphasis ?? false
+	};
+}
+function withoutCollectionInclude(collections) {
+	return {
+		enabled: collections.enabled,
+		collections: Object.fromEntries(Object.entries(collections.collections).map(([name, collection]) => [name, {
+			...collection,
+			include: []
+		}]))
+	};
+}
+function resolveCollectionNames(input, collections) {
+	const available = Object.keys(collections.collections);
+	if (!input) return available;
+	const selected = new Set(Array.isArray(input) ? input : [input]);
+	return available.filter((name) => selected.has(name));
+}
+async function resolveCollectionDocument(root, srcDir, collection, entry) {
+	const candidate = path.resolve(root, srcDir, entry.source);
+	let source;
+	try {
+		source = await fs.readFile(candidate, "utf8");
+	} catch {
+		return;
+	}
+	return {
+		collection,
+		documentPath: candidate,
+		entry,
+		frontmatter: entry.frontmatter,
+		path: entry.path,
+		source
+	};
+}
+//#endregion
+//#region src/html-host-registry.ts
+const SVELTE_HTML_HOST_MODULES_VIRTUAL_ID = "virtual:ox-content-svelte/html-host/modules";
+function createSvelteHtmlHostIslandRegistry(input = {}) {
+	const virtualModuleId = input.virtualModuleId ?? "virtual:ox-content-svelte/html-host/modules";
+	const resolvedVirtualModuleId = `\0${virtualModuleId}`;
+	let config;
+	let command = "build";
+	let components;
+	let cache;
+	let resolved = {
+		modules: [],
+		watchFiles: []
+	};
+	const context = () => ({
+		root: config?.root ?? input.root ?? process.cwd(),
+		mode: config?.mode ?? "production",
+		command
+	});
+	const resolve = async () => {
+		cache ??= resolveSvelteHtmlHostIslandRegistry(input, context(), components).then((next) => {
+			resolved = next;
+			return next;
+		});
+		return cache;
+	};
+	const invalidate = () => {
+		cache = void 0;
+	};
+	return {
+		plugin: {
+			name: "ox-content:svelte-html-host-island-registry",
+			config(_config, env) {
+				command = env.command;
+			},
+			async configResolved(resolvedConfig) {
+				config = resolvedConfig;
+				components = input.components ? await resolveComponentsGlob(input.components, resolvedConfig.root) : {};
+				invalidate();
+			},
+			buildStart() {
+				invalidate();
+			},
+			resolveId(id) {
+				return id === virtualModuleId ? resolvedVirtualModuleId : null;
+			},
+			async load(id) {
+				if (id !== resolvedVirtualModuleId) return null;
+				return renderModulesVirtualModule(await resolve());
+			},
+			handleHotUpdate(ctx) {
+				if (!shouldInvalidate(ctx.file, context().root, input.oxContent?.srcDir, resolved.watchFiles, input.watch)) return;
+				invalidate();
+				invalidateVirtualModule(ctx.server, resolvedVirtualModuleId);
+				ctx.server.ws.send({ type: "full-reload" });
+				return [];
+			}
+		},
+		virtualModuleId,
+		resolve,
+		resolveClientModule(module) {
+			return toSvelteHtmlHostClientModuleId(module.serverModuleId, context().root);
+		}
+	};
+}
+async function resolveSvelteHtmlHostIslandRegistry(input, context, resolvedComponents) {
+	const components = resolvedComponents ?? (input.components ? await resolveComponentsGlob(input.components, context.root) : {});
+	const documents = [...await resolveMaybe(input.documents, context) ?? [], ...await resolveInputCollectionDocuments(input, context) ?? []];
+	const entries = await resolveMaybe(input.entries, context);
+	const modules = /* @__PURE__ */ new Map();
+	const watchFiles = /* @__PURE__ */ new Set();
+	for (const file of input.watch ?? []) watchFiles.add(resolveWatchFile(file, context.root));
+	for (const entry of entries ?? []) {
+		addModule(modules, {
+			name: entry.name ?? path.basename(stripViteQuery(entry.moduleId), path.extname(entry.moduleId)),
+			moduleId: toSvelteHtmlHostClientModuleId(entry.moduleId, context.root),
+			exportName: entry.exportName ?? "default"
+		});
+		if (entry.documentPath) watchFiles.add(resolveWatchFile(entry.documentPath, context.root));
+	}
+	const oxContent = customHostOxContentOptions({
+		...input.oxContent,
+		embeds: false
+	});
+	const srcDir = oxContent.srcDir ?? "content";
+	const contentRoot = resolveContentRootPath({
+		root: context.root,
+		srcDir
+	});
+	for (const document of documents) {
+		const documentPath = resolveDocumentPath(document.documentPath, context.root);
+		watchFiles.add(documentPath);
+		for (const dependency of document.dependencies ?? []) watchFiles.add(resolveWatchFile(dependency, context.root));
+		const materialized = await materializeDocument(document, documentPath, oxContent);
+		if (!materialized) continue;
+		const documentComponents = document.components ?? components;
+		const discovered = await discoverDocumentMdxIslands({
+			source: materialized.source,
+			html: materialized.html,
+			components: documentComponents,
+			imports: materialized.imports,
+			documentPath,
+			contentRoot,
+			srcDir,
+			root: context.root
+		});
+		const usedComponents = new Set(discovered.usedComponents);
+		if (materialized.html) for (const name of intersectHydratableComponentNames(collectMdxIslandNamesFromHtml(materialized.html), documentComponents, discovered.localBindings.keys())) usedComponents.add(name);
+		for (const name of usedComponents) {
+			const local = discovered.localBindings.get(name);
+			const serverModuleId = local ? local.resolvedPath : resolveComponentPath(documentComponents, name, context.root);
+			if (!serverModuleId) continue;
+			addModule(modules, {
+				name,
+				moduleId: toSvelteHtmlHostClientModuleId(serverModuleId, context.root),
+				exportName: local?.imported ?? "default"
+			});
+		}
+	}
+	return {
+		modules: [...modules.values()].sort((a, b) => `${a.moduleId}\0${a.exportName}\0${a.name}`.localeCompare(`${b.moduleId}\0${b.exportName}\0${b.name}`)),
+		watchFiles: [...watchFiles]
+	};
+}
+function resolveInputCollectionDocuments(input, context) {
+	if (!input.collectionDocuments) return void 0;
+	return resolveSvelteHtmlHostCollectionDocuments(input.collectionDocuments.oxContent === void 0 ? {
+		...input.collectionDocuments,
+		oxContent: input.oxContent
+	} : input.collectionDocuments, context);
+}
+function renderModulesVirtualModule(registry) {
+	return [
+		"export const modules = {",
+		...[...new Set(registry.modules.map((module) => module.moduleId))].sort().map((moduleId) => `  ${JSON.stringify(moduleId)}: () => import(${JSON.stringify(moduleId)}),`),
+		"};",
+		`export const clientModules = ${JSON.stringify(registry.modules, null, 2)};`,
+		"export default modules;",
+		""
+	].join("\n");
+}
+async function materializeDocument(document, documentPath, oxContent) {
+	const source = document.source ?? await readOptional(documentPath);
+	if (source === void 0 && document.html === void 0) return void 0;
+	if (document.imports && document.html !== void 0) return {
+		source: source ?? "",
+		html: document.html,
+		imports: document.imports
+	};
+	if (source === void 0) return {
+		source: "",
+		html: document.html,
+		imports: document.imports ?? []
+	};
+	const rendered = await renderMarkdown(source, documentPath, oxContent);
+	return {
+		source,
+		html: document.html ?? rendered.html,
+		imports: document.imports ?? rendered.imports
+	};
+}
+async function readOptional(file) {
+	try {
+		return await fs.readFile(file, "utf8");
+	} catch {
+		return;
+	}
+}
+function addModule(modules, module) {
+	modules.set(`${module.moduleId}\0${module.exportName}\0${module.name}`, module);
+}
+function resolveMaybe(value, context) {
+	return typeof value === "function" ? value(context) : value;
+}
+function resolveComponentPath(components, name, root) {
+	const specifier = components[name];
+	if (!specifier) return void 0;
+	if (isBareSpecifier(specifier) || specifier.startsWith("/@fs/")) return specifier;
+	if (specifier.startsWith("/") && !path.isAbsolute(specifier)) return specifier;
+	return path.isAbsolute(specifier) ? specifier : path.resolve(root, specifier);
+}
+function invalidateVirtualModule(server, resolvedVirtualModuleId) {
+	const mod = server.moduleGraph.getModuleById(resolvedVirtualModuleId);
+	if (mod) server.moduleGraph.invalidateModule(mod);
+}
+//#endregion
+//#region src/index.ts
 const DEFAULT_MARKDOWN_EXTENSIONS = [
 	".md",
 	".markdown",
 	".mdx"
 ];
-function normalizeMarkdownExtensions(extensions) {
+function normalizeMarkdownExtensions$1(extensions) {
 	const values = extensions?.length ? extensions : DEFAULT_MARKDOWN_EXTENSIONS;
 	return Array.from(new Map(values.map((extension) => {
 		const value = extension.startsWith(".") ? extension : `.${extension}`;
@@ -1029,6 +1698,7 @@ function oxContentSvelte(options = {}) {
 				renderIsland: options.renderIsland,
 				ssr: transformOptions?.ssr
 			});
+			for (const warning of result.warnings) this.warn(formatSvelteCompilerWarning(warning));
 			return {
 				code: result.code,
 				map: result.map
@@ -1093,7 +1763,7 @@ function resolveSvelteOptions(options) {
 		srcDir: options.srcDir ?? "docs",
 		outDir: options.outDir ?? "dist",
 		base: options.base ?? "/",
-		extensions: normalizeMarkdownExtensions(options.extensions),
+		extensions: normalizeMarkdownExtensions$1(options.extensions),
 		gfm: options.gfm ?? true,
 		autolinks: options.autolinks ?? options.gfm ?? true,
 		frontmatter: options.frontmatter ?? true,
@@ -1101,11 +1771,16 @@ function resolveSvelteOptions(options) {
 		tocMaxDepth: options.tocMaxDepth ?? 3,
 		codeAnnotations: resolveCodeAnnotationsOptions(options.codeAnnotations),
 		runes: options.runes ?? true,
+		compiler: options.compiler,
 		embeds: resolveBuiltinEmbedOptions(options.embeds),
 		mdx: options.mdx,
 		mdxDocumentProps: options.mdxDocumentProps ?? false
 	};
 }
+function formatSvelteCompilerWarning(warning) {
+	const message = `${warning.code ? `[${warning.code}] ` : ""}${warning.message}`;
+	return warning.frame ? `${message}\n${warning.frame}` : message;
+}
 function resolveCodeAnnotationsOptions(options) {
 	if (!options) return {
 		enabled: false,
@@ -1143,49 +1818,7 @@ ${exports.join("\n")}
 export default components;
 `;
 }
-async function resolveComponentsGlob(componentsOption, root) {
-	if (typeof componentsOption === "object" && !Array.isArray(componentsOption)) return componentsOption;
-	const patterns = Array.isArray(componentsOption) ? componentsOption : [componentsOption];
-	const result = {};
-	for (const pattern of patterns) {
-		const files = await globFiles(pattern, root);
-		for (const file of files) {
-			const componentName = toPascalCase(path.basename(file, path.extname(file)));
-			result[componentName] = "./" + path.relative(root, file).replace(/\\/g, "/");
-		}
-	}
-	return result;
-}
-async function globFiles(pattern, root) {
-	const files = [];
-	if (!pattern.includes("*")) {
-		const fullPath = path.resolve(root, pattern);
-		if (fs.existsSync(fullPath)) files.push(fullPath);
-		return files;
-	}
-	const parts = pattern.split("*");
-	const baseDir = path.resolve(root, parts[0]);
-	const ext = parts[1] || "";
-	if (!fs.existsSync(baseDir)) return files;
-	if (pattern.includes("**")) await walkDir(baseDir, files, ext);
-	else {
-		const entries = await fs.promises.readdir(baseDir, { withFileTypes: true });
-		for (const entry of entries) if (entry.isFile() && entry.name.endsWith(ext)) files.push(path.join(baseDir, entry.name));
-	}
-	return files;
-}
-async function walkDir(dir, files, ext) {
-	const entries = await fs.promises.readdir(dir, { withFileTypes: true });
-	for (const entry of entries) {
-		const fullPath = path.join(dir, entry.name);
-		if (entry.isDirectory()) await walkDir(fullPath, files, ext);
-		else if (entry.isFile() && entry.name.endsWith(ext)) files.push(fullPath);
-	}
-}
-function toPascalCase(str) {
-	return str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toUpperCase());
-}
 //#endregion
-export { oxContent, oxContentSvelte, renderHead };
+export { SVELTE_HTML_HOST_MODULES_VIRTUAL_ID, SvelteHtmlHostRenderError, createSvelteHtmlHostCollectionDocuments, createSvelteHtmlHostDomRenderer, createSvelteHtmlHostHydrate, createSvelteHtmlHostIslandRegistry, createSvelteHtmlHostLazyHydrate, createSvelteHtmlHostRenderer, initSvelteHtmlHost, loadSvelteHtmlHostDomRuntime, oxContent, oxContentSvelte, readSvelteHtmlHostSlot, renderHead, renderSvelteHtmlHost, resolveSvelteHtmlHostCollectionDocuments, resolveSvelteHtmlHostIslandRegistry, toSvelteHtmlHostClientModuleId };
 
 //# sourceMappingURL=index.mjs.map