@master/internal-site 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Aoyue Design LLC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -1,3 +1,69 @@
-# Temporary Holding Version
+# @master/internal-site
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+First-party Astro and Svelte 5 website framework for Master websites. This package is public for installation; it is an internal platform, not a supported general-purpose product. Consumers pin an exact version and upgrade deliberately.
+
+## Ownership
+
+Master maintains document layouts, navigation, search, localization, MDX components, interface tokens, shared styles, artwork, demonstration primitives and design-system specimens here. Master CSS maintains its homepage composition, guide/reference content and adapters that read its product data. The organization blog, brand pages and design-system handbook live in the Master website, outside this package. Drafts are never packaged.
+
+The package imports Master CSS rather than duplicating its compiler or maintaining a parallel CSS implementation. Install the matching Astro, Svelte, Vite and Master CSS toolchain versions declared by your site's lockfile. During RC development, use the exact source-pinned `site` snapshot and its dependency closure; never depend on a moving Git branch.
+
+This initial release targets the CSS-first `site` snapshots, starting with `df48b35846c1`. Older npm RC releases do not provide that contract. The `0.0.0` peer alternative allows the product's unversioned development workspaces; published consumers must pin a validated snapshot of the complete toolchain.
+
+## Configure a consumer
+
+```ts
+// astro.config.ts
+import { defineConfig } from 'astro/config'
+import masterSite from '@master/internal-site/astro'
+import site from './site.config'
+
+export default defineConfig({ integrations: [masterSite(site)] })
+```
+
+`site.config.ts` exports `defineSite(...)` from `@master/internal-site/config`. It declares the site's origin, content directory, app module, locale policy and section module URLs. Optional document layouts, category sources, styles and a server-only highlighter are also URLs. Keep route content lazy: do not import a complete page or specimen catalog into the configuration.
+
+Optional `header.communityNavs` selects the links shown beside search without removing community links from the compact menu or footer. Set `header.searchOnHome` to show search in the desktop homepage header. When available, the language switch follows the community links and a divider.
+
+The app module exports its logo component, navigation, version links and source/feedback URLs using the `SiteApp` contract. Consumers retain their own content and homepage composition. Ordinary documents use `content/<section>/<slug>/content.mdx` and `metadata.ts`; a local `page.astro` can override the generated entry. Dynamic routes enumerate params from lightweight `params.ts` files. The integration owns generated routes, page asset collection and the Astro/Svelte renderer setup.
+
+```css
+/* styles/globals.css */
+@import '@master/css';
+@reference '@master/internal-site/styles/foundation.css';
+@import '@master/internal-site/styles/foundation.css';
+```
+
+The reference supplies definitions to headless tooling; the import delivers native styles. Import this stylesheet from the module configured as `styles.site`. Use the package's document/interface boundaries where the corresponding layouts need them. Do not combine every gallery stylesheet into a site-wide bundle.
+
+The route loader delivers that foundation once for every page, including bare iframe examples. A bare section must not import a second global entry; it only opts out of the interface and document boundaries.
+
+```astro
+---
+import Callout from '@master/internal-site/components/Callout.astro'
+---
+<Callout tone="info">Content remains in the product repository.</Callout>
+```
+
+Import individual component subpaths, including `.astro` and `.svelte` extensions. Interactive Svelte islands use the consumer's Astro hydration directive. Shared theme/context data remains scoped to the rendered request. Components are distributed as source for the consumer's Astro and Svelte compilers; `astro` and `config` entrypoints are built Node ESM and include declarations.
+
+## Subpaths
+
+| Subpath | Purpose |
+| --- | --- |
+| `astro`, `config` | Integration and typed configuration |
+| `components/*`, `layouts/*`, `contexts/*` | Document shell and reusable interface components |
+| `styles/*` | Foundation, document, interface and component styles |
+| `assets/*` | Shared fonts, icons and brand artwork |
+| `home/*`, `blog/*` | Reusable homepage and article presentation |
+| `demo/*`, `benchmarks/*`, `examples/*` | Presentation primitives and isolated example pages |
+| `css/*` | Server-only Master CSS compiler/highlighter adapters and preset demonstrations |
+| `env` | Virtual module declarations for a consumer's `env.d.ts` |
+
+The CSS-specific subpaths require the matching optional compiler, tooling, schema, preset and language-service peers. Keep them out of browser-only imports. Shared public assets are served in development and copied into build output; consumer public files take precedence. No install hook writes consumer source files.
+
+## Development and releases
+
+From the Master repository, run `bun run build:packages`, `bun run --cwd packages/internal-site type-check` and `bun run --cwd packages/internal-site test`. Astro checks `.astro` implementations and Svelte checks interactive components separately. The root `build` builds the Node entrypoints before the site.
+
+Before publishing, inspect the tarball, install it in the Master CSS consumer and validate both sites, including local CSS imports, themes, mobile navigation and lazy page styles. Publish an immutable version, update exact consumer pins and lockfiles, then deploy preview builds. Roll back by restoring the previous dependency version and deployment; do not unpublish a release in use.

package/dist/astro.d.mts

@@ -0,0 +1,3 @@
+import { SiteConfig } from "./config.mjs";
+import { AstroIntegration } from "astro";
+export default function masterSite(site: SiteConfig): AstroIntegration;

package/dist/astro.mjs

@@ -0,0 +1,510 @@
+import { svgoOptimizer } from "astro/config";
+import svelte from "@astrojs/svelte";
+import mdx from "@astrojs/mdx";
+import { unified } from "@astrojs/markdown-remark";
+import masterCSS from "@master/css-astro";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { dirname, extname, join, relative, resolve, sep } from "node:path";
+import { cp, mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import { createReadStream, existsSync } from "node:fs";
+import { isCSSRequest, searchForWorkspaceRoot, transformWithOxc } from "vite";
+import { optimize } from "svgo";
+import Slugger from "github-slugger";
+import { SKIP, visit } from "unist-util-visit";
+import { parse, parseExpressionAt } from "acorn";
+// src/astro/module-id.ts
+/** A Vite module id without its query or hash. */
+function cleanId(id) {
+	return id.replace(/[?#].*$/, "");
+}
+// src/astro/source-url.ts
+const sourcePattern = /\.(?:[cm]?[jt]sx?|mdx|astro|svelte)$/;
+/**
+* Server chunks only run on the machine that builds the static site. Keep each
+* module's source `import.meta.url` so site code and bundled dependencies resolve
+* repository files, data files and native bindings relative to their sources.
+*/
+function sourceURL() {
+	return {
+		name: "master-css-site:source-url",
+		applyToEnvironment: (environment) => environment.config.consumer === "server",
+		transform(code, id) {
+			const file = cleanId(id);
+			if (id.startsWith("\0") || !file.startsWith("/") || !sourcePattern.test(file) || !code.includes("import.meta.url")) return;
+			return {
+				code: code.replaceAll("import.meta.url", JSON.stringify(pathToFileURL(file).href)),
+				map: null
+			};
+		}
+	};
+}
+// src/astro/content-pages.ts
+async function contentFiles(directory) {
+	const files = [];
+	for (const entry of await readdir(directory, { withFileTypes: true })) {
+		const path = join(directory, entry.name);
+		if (entry.isDirectory()) files.push(...await contentFiles(path));
+		else if (entry.isFile()) files.push(path);
+	}
+	return files;
+}
+const specifier = (url) => JSON.stringify("/@fs/" + fileURLToPath(url));
+/** Generate only ordinary MDX wrappers; content and metadata remain statically imported. */
+async function prepareContentPages(site, root, contentPrefix) {
+	const content = fileURLToPath(site.content);
+	const files = new Set(await contentFiles(content));
+	const destination = join(root, ".astro/master-site/pages");
+	const pages = {};
+	const wanted = /* @__PURE__ */ new Set();
+	for (const file of files) {
+		if (!file.endsWith("/content.mdx")) continue;
+		const directory = dirname(file);
+		if (files.has(join(directory, "page.astro"))) continue;
+		const metadata = join(directory, "metadata.ts");
+		if (!files.has(metadata)) throw new Error(`${file} requires metadata.ts or an explicit page.astro`);
+		const route = relative(content, directory).replaceAll("\\", "/");
+		const section = route.split("/").find((segment) => !/^\(.+\)$/.test(segment)) ?? "home";
+		const config = site.documents?.[section];
+		if (!config) throw new Error(`${file} requires documents.${section} configuration or an explicit page.astro`);
+		const output = join(destination, route, "page.astro");
+		const source = `---
+// Generated by @master/internal-site; edit the content or site config.
+import Page from '@master/internal-site/factories/Page.astro'
+import { createPageMetadata } from '@master/internal-site/factories/create-page'
+import Layout from ${specifier(config.layout)}
+import dictionaries from ${specifier(config.dictionaries)}
+import metadata from ${specifier(pathToFileURL(metadata))}
+import * as content from ${specifier(pathToFileURL(file))}
+${config.categories ? `import categories from ${specifier(config.categories)}` : "const categories = undefined"}
+export const generateMetadata = createPageMetadata(metadata, dictionaries)
+---
+<Page {...Astro.props} {metadata} {dictionaries} {categories} {content} {Layout} />
+`;
+		await mkdir(dirname(output), { recursive: true });
+		if (await readFile(output, "utf8").catch(() => "") !== source) await writeFile(output, source);
+		wanted.add(output);
+		pages[`${contentPrefix}/${route ? route + "/" : ""}page.astro`] = pathToFileURL(output);
+	}
+	for (const stale of await contentFiles(destination).catch(() => [])) if (stale.endsWith("/page.astro") && !wanted.has(stale)) await unlink(stale);
+	const availableLocales = {};
+	for (const file of files) {
+		if (!file.endsWith("/content.mdx")) continue;
+		const directory = dirname(file);
+		const route = relative(content, directory).replaceAll("\\", "/");
+		const section = route.split("/").find((segment) => !/^\(.+\)$/.test(segment)) ?? "home";
+		if (!site.i18n.translatedOnly?.includes(section)) continue;
+		availableLocales[`${contentPrefix}/${route ? route + "/" : ""}page.astro`] = site.i18n.locales.filter((locale) => locale === site.i18n.defaultLocale || files.has(join(directory, `content.${locale}.mdx`)));
+	}
+	for (const section of site.i18n.translatedOnly ?? []) {
+		const key = `${contentPrefix}/${section}/page.astro`;
+		if (!files.has(join(content, section, "page.astro"))) continue;
+		const published = Object.entries(availableLocales).filter(([page]) => page.startsWith(`${contentPrefix}/${section}/`));
+		availableLocales[key] = site.i18n.locales.filter((locale) => locale === site.i18n.defaultLocale || published.some(([, locales]) => locales.includes(locale)));
+	}
+	return {
+		pages,
+		availableLocales
+	};
+}
+// src/astro/server-styles.ts
+const empty = "\0site-server-style";
+/**
+* Pages link the stylesheets of every module they render on the server. Hydrated
+* modules repeat those imports in the browser bundle, where Astro would attach
+* them to every page of the route, so the client build omits site stylesheets.
+* Development keeps them for Vite's CSS hot updates.
+*/
+function serverStyles(roots) {
+	return {
+		name: "master-css-site:server-styles",
+		enforce: "pre",
+		apply: "build",
+		applyToEnvironment: (environment) => environment.config.consumer === "client",
+		resolveId(source, importer) {
+			if (!importer || importer.startsWith("\0") || !roots.some((root) => cleanId(importer).startsWith(root.replace(/\/$/, "") + "/")) || isCSSRequest(cleanId(importer))) return;
+			if (isCSSRequest(source) && !/[?&](?:inline|raw|url)\b/.test(source)) return empty;
+		},
+		load(id) {
+			if (id === empty) return "export default undefined";
+		}
+	};
+}
+// src/docs-shell/common/svgo.config.js
+var svgo_config_default = { plugins: [
+	{ name: "preset-default" },
+	"removeTitle",
+	"prefixIds"
+] };
+// src/astro/svg-markup.ts
+/**
+* `.svg?raw` imports give Svelte components inline SVG markup. Optimize it like Astro's SVG
+* components, with the same configuration, so both render the same markup and file-prefixed ids.
+*/
+function svgMarkup() {
+	return {
+		name: "master-css-site:svg-markup",
+		enforce: "pre",
+		async load(id) {
+			if (!/\.svg\?raw$/.test(id)) return;
+			const file = cleanId(id);
+			this.addWatchFile(file);
+			const { data } = optimize(await readFile(file, "utf8"), {
+				...svgo_config_default,
+				path: file
+			});
+			return `export default ${JSON.stringify(data)}`;
+		}
+	};
+}
+// src/docs-shell/utils/resolve-heading.js
+function resolveHeading(title, id) {
+	const explicit = typeof title === "string" && title.match(/\s+\{#([\w-]+)\}$/);
+	if (explicit) {
+		title = title.slice(0, explicit.index);
+		id = explicit[1];
+	}
+	const words = title?.split?.(" ");
+	if (words?.pop() === "[sr-only]") return {
+		title: words.join(" "),
+		id: id?.replace("-sr-only", "")?.replace("-[sr-only]", ""),
+		className: "sr-only"
+	};
+	return {
+		title,
+		id
+	};
+}
+// src/docs-shell/remark/slug-and-toc.js
+function remarkSlugAndTOC() {
+	return (tree) => {
+		const slugs = new Slugger();
+		const toc = [];
+		visit(tree, "heading", (node) => {
+			const depth = node.depth;
+			if (depth !== 2 && depth !== 3) return;
+			const title = node.children.filter((n) => n.type === "text" || n.type === "inlineCode").map((n) => n.value).join(" ").trim();
+			const resolved = resolveHeading(title, slugs.slug(title));
+			const lastText = node.children.findLast((child) => child.type === "text");
+			if (lastText) lastText.value = lastText.value.replace(/\s+\{#[\w-]+\}$/, "");
+			node.data ??= {};
+			node.data.hProperties ??= {};
+			node.data.id = resolved.id;
+			node.data.hProperties.id = resolved.id;
+			toc.push({
+				id: resolved.id,
+				title: resolved.title,
+				level: depth
+			});
+		});
+		const tocCode = `export const toc = ${JSON.stringify(toc, null, 2)};`;
+		tree.children.unshift({
+			type: "mdxjsEsm",
+			value: tocCode,
+			data: { estree: parse(tocCode, {
+				ecmaVersion: "latest",
+				sourceType: "module"
+			}) }
+		});
+	};
+}
+// src/docs-shell/remark/markdown-components.js
+/** Paragraph markers that turn a Markdown paragraph into a callout or a gesture hint. */
+const paragraphMarkers = [
+	["(o) ", "Do"],
+	["(x) ", "DoNot"],
+	["(i) ", "Info"],
+	["(!) ", "Warn"],
+	[
+		"(!|) ",
+		"Warn",
+		{ leaded: true }
+	],
+	[
+		"(hover) ",
+		"InteractingIndicator",
+		{ icon: "hover" }
+	],
+	[
+		"(resize) ",
+		"InteractingIndicator",
+		{ icon: "resize" }
+	],
+	[
+		"(click) ",
+		"InteractingIndicator",
+		{ icon: "click" }
+	],
+	[
+		"(type) ",
+		"InteractingIndicator",
+		{ icon: "type" }
+	],
+	[
+		"(wand) ",
+		"InteractingIndicator",
+		{ icon: "wand" }
+	]
+];
+/** Inline code may lead with its grammar, as in `html <div>`. */
+const inlineLanguages = /* @__PURE__ */ new Set([
+	"html",
+	"js",
+	"ts",
+	"css",
+	"json",
+	"mcss"
+]);
+function attribute(name, value) {
+	if (typeof value === "string") return {
+		type: "mdxJsxAttribute",
+		name,
+		value
+	};
+	const source = JSON.stringify(value);
+	return {
+		type: "mdxJsxAttribute",
+		name,
+		value: {
+			type: "mdxJsxAttributeValueExpression",
+			value: source,
+			data: { estree: {
+				type: "Program",
+				sourceType: "module",
+				body: [{
+					type: "ExpressionStatement",
+					expression: parseExpressionAt(source, 0, { ecmaVersion: "latest" })
+				}]
+			} }
+		}
+	};
+}
+function element(type, name, props, children = []) {
+	return {
+		type,
+		name,
+		attributes: Object.entries(props).filter(([, value]) => value !== void 0).map(([key, value]) => attribute(key, value)),
+		children
+	};
+}
+/** Fence meta reads as URL parameters whose values may be JSON, as in ```html name=index.html beautify=true. */
+function fenceProps(node) {
+	const props = {
+		name: "",
+		lang: "",
+		dedent: "block"
+	};
+	if (node.meta) for (const [key, value] of new URLSearchParams(node.meta.trim())) try {
+		props[key] = JSON.parse(value);
+	} catch {
+		props[key] = value;
+	}
+	if (!props.lang) props.lang = node.lang ?? "";
+	return props;
+}
+const componentsExport = `import { markdownComponents as __markdownComponents } from '@master/internal-site/components/markdown-components'
+export const components = __markdownComponents`;
+/**
+* Markdown constructs that render through site components: fences become `Code` (or a
+* package-manager `PMAction`), inline code becomes `InlineCode`, and marked paragraphs become
+* callouts. Every MDX module exports the site's `components`, so imported MDX renders the same way.
+*/
+function remarkMarkdownComponents() {
+	return (tree) => {
+		tree.children.unshift({
+			type: "mdxjsEsm",
+			value: componentsExport,
+			data: { estree: parse(componentsExport, {
+				ecmaVersion: "latest",
+				sourceType: "module"
+			}) }
+		});
+		visit(tree, (node, index, parent) => {
+			if (!parent || index === void 0) return;
+			if (node.type === "code") {
+				const props = fenceProps(node);
+				const code = node.value ? node.value + "\n" : "";
+				parent.children[index] = props.lang === "bash" && props.action ? element("mdxJsxFlowElement", "PMAction", {
+					action: props.action,
+					code: node.value
+				}) : element("mdxJsxFlowElement", "Code", {
+					...props,
+					code
+				});
+				return SKIP;
+			}
+			if (node.type === "inlineCode") {
+				const [first, ...rest] = node.value.split(" ");
+				const lang = rest.length && inlineLanguages.has(first) ? first : "";
+				parent.children[index] = element("mdxJsxTextElement", "InlineCode", {
+					lang,
+					code: lang ? rest.join(" ") : node.value
+				});
+				return SKIP;
+			}
+			if (node.type === "paragraph") {
+				const first = node.children[0];
+				if (first?.type !== "text") return;
+				const marker = paragraphMarkers.find(([prefix]) => first.value.startsWith(prefix));
+				if (!marker) return;
+				const [prefix, name, props = {}] = marker;
+				first.value = first.value.slice(prefix.length);
+				parent.children[index] = element("mdxJsxFlowElement", name, props, node.children);
+				return index;
+			}
+		});
+	};
+}
+// src/astro/index.ts
+const packageSource = fileURLToPath(new URL("..", new URL("../src/astro/index.ts", import.meta.url).href));
+const fsImport = (url) => "/@fs/" + fileURLToPath(url);
+const moduleImport = (url) => `export { default } from ${JSON.stringify(fsImport(url))}`;
+const propagated = (url) => `() => import(${JSON.stringify(fsImport(url) + "?astroPropagatedAssets")}).then(m => m.default)`;
+function masterSite(site) {
+	let output;
+	return {
+		name: "@master/internal-site",
+		hooks: {
+			"astro:config:setup": async ({ config, updateConfig, addRenderer, injectRoute }) => {
+				const root = fileURLToPath(config.root);
+				const contentRelative = relative(root, fileURLToPath(site.content)).split(sep).join("/");
+				if (contentRelative.startsWith("..")) throw new Error("Site content must be inside the Astro project root");
+				const contentPrefix = "/" + contentRelative.replace(/\/$/, "");
+				const prepared = await prepareContentPages(site, root, contentPrefix);
+				const routeOptions = {
+					contentRoot: contentPrefix + "/",
+					defaultLocale: site.i18n.defaultLocale,
+					locales: site.i18n.locales,
+					sectionLocales: site.i18n.sectionLocales,
+					availableLocales: prepared.availableLocales
+				};
+				const imports = {
+					"virtual:master-site/navigation": Object.entries(site.navigation ?? {}).map(([key, url], index) => `import data${index} from ${JSON.stringify(fsImport(url))}`).join("\n") + `\nexport default {${Object.keys(site.navigation ?? {}).map((key, index) => `${JSON.stringify(key)}: data${index}`).join(",")}}`,
+					"virtual:master-site/config": `export default ${JSON.stringify(site)}`,
+					"virtual:master-site/app": moduleImport(site.app),
+					"virtual:master-site/highlight": moduleImport(site.highlighter ?? new URL("../docs-shell/utils/highlight-code-core.ts", new URL("../src/astro/index.ts", import.meta.url).href)),
+					"virtual:master-site/translations": `export default import.meta.glob(${JSON.stringify(`${contentPrefix}/**/content.*.mdx`)})`
+				};
+				const plugin = {
+					name: "@master/internal-site:modules",
+					resolveId(id) {
+						if (id === "virtual:master-site/routes") return "\0" + id + ".ts";
+						if (id in imports) return "\0" + id;
+					},
+					async load(id) {
+						if (id.slice(1) in imports) return imports[id.slice(1)];
+						if (id !== "\0virtual:master-site/routes.ts") return;
+						let source = await readFile(new URL("./routes.template.ts", new URL("../src/astro/index.ts", import.meta.url).href), "utf8");
+						source = source.replaceAll("__CONTENT_PREFIX__", contentPrefix);
+						source = source.replace("__ROUTE_OPTIONS__", JSON.stringify(routeOptions));
+						source = source.replace("__GENERATED_PAGES__", `{${Object.entries(prepared.pages).map(([name, url]) => `${JSON.stringify(name)}: ${propagated(url)}`).join(",\n")}}`);
+						const sections = Object.entries(site.sections).map(([name, url]) => `${JSON.stringify(`/sections/${name}.astro`)}: ${propagated(url)}`).join(",\n");
+						source = source.replace("__SECTION_IMPORTS__", `{${sections}}`);
+						for (const boundary of [
+							"site",
+							"interface",
+							"documents"
+						]) {
+							const url = site.styles?.[boundary] ?? new URL(`../styles/${boundary}.ts`, new URL("../src/astro/index.ts", import.meta.url).href);
+							source = source.replace(`__${boundary.toUpperCase()}_IMPORT__`, `{${JSON.stringify(`/styles/${boundary}.ts`)}: ${propagated(url)}}`);
+						}
+						source = source.replace("__SECTION_SHELLS__", JSON.stringify(Object.fromEntries(Object.keys(site.sections).map((key) => [key, key]))));
+						return transformWithOxc(source, "master-site-routes.ts");
+					},
+					configureServer(server) {
+						const routeFile = /(?:^|\/)(?:content(?:\.[^/]+)?\.mdx|metadata\.ts|page\.astro|params\.ts|layout\.astro)$/;
+						let restart;
+						const refresh = (file) => {
+							if (!file.startsWith(fileURLToPath(site.content)) || !routeFile.test(file.replaceAll("\\", "/"))) return;
+							clearTimeout(restart);
+							restart = setTimeout(() => {
+								server.restart();
+							}, 100);
+						};
+						server.watcher.on("add", refresh).on("unlink", refresh);
+						server.httpServer?.once("close", () => {
+							clearTimeout(restart);
+							server.watcher.off("add", refresh).off("unlink", refresh);
+						});
+						server.middlewares.use((request, response, next) => {
+							let pathname;
+							try {
+								pathname = decodeURIComponent(new URL(request.url ?? "/", "http://localhost").pathname);
+							} catch {
+								return next();
+							}
+							if (!/^\/(fonts|icons|images|brand|demo)\//.test(pathname)) return next();
+							const directory = resolve(packageSource, "public") + sep;
+							const file = resolve(directory, "." + pathname);
+							if (!file.startsWith(directory) || !existsSync(file) || existsSync(resolve(root, "public", "." + pathname))) return next();
+							const type = {
+								".woff2": "font/woff2",
+								".ttf": "font/ttf",
+								".css": "text/css",
+								".svg": "image/svg+xml",
+								".png": "image/png",
+								".jpg": "image/jpeg",
+								".webp": "image/webp",
+								".ico": "image/x-icon",
+								".json": "application/json"
+							}[extname(file)];
+							if (!type) return next();
+							response.setHeader("Content-Type", type);
+							createReadStream(file).pipe(response);
+						});
+					}
+				};
+				addRenderer({
+					name: "@master/internal-site:svelte",
+					serverEntrypoint: fileURLToPath(new URL("./svelte-renderer.ts", new URL("../src/astro/index.ts", import.meta.url).href)),
+					clientEntrypoint: "@astrojs/svelte/client.js"
+				});
+				injectRoute({
+					pattern: "/[...path]",
+					entrypoint: new URL("./Page.astro", new URL("../src/astro/index.ts", import.meta.url).href),
+					prerender: true
+				});
+				updateConfig({
+					site: site.origin,
+					trailingSlash: "never",
+					build: { format: "file" },
+					markdown: {
+						processor: unified({
+							remarkPlugins: [remarkSlugAndTOC, remarkMarkdownComponents],
+							gfm: true,
+							smartypants: false
+						}),
+						syntaxHighlight: false
+					},
+					experimental: { svgOptimizer: svgoOptimizer(svgo_config_default) },
+					vite: {
+						plugins: [
+							plugin,
+							sourceURL(),
+							serverStyles([root, packageSource]),
+							svgMarkup()
+						],
+						resolve: { dedupe: ["svelte"] },
+						server: { fs: { allow: [searchForWorkspaceRoot(root), packageSource] } }
+					},
+					integrations: [
+						svelte(),
+						mdx(),
+						masterCSS({ mode: "progressive" })
+					]
+				});
+			},
+			"astro:config:done": ({ config }) => {
+				output = config.outDir;
+			},
+			"astro:build:done": async () => {
+				const destination = output;
+				await mkdir(destination, { recursive: true });
+				await cp(new URL("../public/", new URL("../src/astro/index.ts", import.meta.url).href), destination, {
+					recursive: true,
+					force: false
+				});
+			}
+		}
+	};
+}
+export { masterSite as default };

package/dist/config.d.mts

@@ -0,0 +1,69 @@
+import { Component } from "svelte";
+export interface AppNavItem {
+  name: string;
+  href?: string;
+  fullName?: string;
+  date?: string;
+  disabled?: boolean;
+  Icon?: Component<any>;
+}
+export interface SiteApp {
+  name: string;
+  brandURL: string;
+  Logotype: Component<any>;
+  navs: AppNavItem[];
+  communityNavs?: AppNavItem[];
+  /** Header controls can be quieter than the full community menu and footer. */
+  header?: {
+    communityNavs?: AppNavItem[];
+    searchOnHome?: boolean;
+  };
+  sourceBaseURL?: string;
+  feedbackURL?: string;
+  versions: {
+    name: string;
+    href: string;
+  }[];
+}
+export interface SiteI18nConfig {
+  defaultLocale: string;
+  locales: readonly string[];
+  hreflangOfLocale: Record<string, string>;
+  nameOfLocale: Record<string, string>;
+  localizablePathnameRoots: string[];
+  translations: Record<string, Record<string, string>>;
+  sectionLocales?: Record<string, readonly string[]>;
+  /** These sections emit translated URLs only when translated MDX exists. */
+  translatedOnly?: readonly string[];
+}
+export interface DocumentConfig {
+  layout: URL;
+  dictionaries: URL;
+  categories?: URL;
+}
+/** Configuration contains module URLs, not imported page components, to preserve lazy routes. */
+export interface SiteConfig {
+  id: string;
+  name: string;
+  origin: string;
+  content: URL;
+  app: URL;
+  i18n: SiteI18nConfig;
+  sections: Record<string, URL>;
+  feeds?: {
+    title: string;
+    type: 'application/rss+xml' | 'application/atom+xml';
+    href: string;
+  }[];
+  documents?: Record<string, DocumentConfig>;
+  /** Server-only category sources, keyed by section. */
+  navigation?: Record<string, URL>;
+  /** Server module exporting a highlighter. Product semantic integrations live here. */
+  highlighter?: URL;
+  styles?: {
+    site?: URL;
+    interface?: URL;
+    documents?: URL;
+  };
+}
+export declare function defineSite(config: SiteConfig): SiteConfig;