@axerity/cli 0.1.0

package/bin/axerity.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+import { spawn, spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import {
+	cpSync,
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	readdirSync,
+	rmSync,
+	symlinkSync,
+	writeFileSync
+} from 'node:fs';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const engineRoot = resolve(here, '..');
+const userRoot = process.cwd();
+const isEngineRepo = userRoot === engineRoot;
+
+const symlinkType = process.platform === 'win32' ? 'junction' : 'dir';
+
+// The engine runs in place, from its own install with its real node_modules. The
+// user's project is mounted into a handful of gitignored paths for a single run,
+// so nothing the engine tracks is ever touched — clean exit, Ctrl-C, or crash.
+const ENGINE_DOCS = join(engineRoot, 'src', 'content', 'docs');
+const ENGINE_CONFIG = join(engineRoot, 'axerity.json');
+const ENGINE_STATIC = join(engineRoot, 'static');
+const ENGINE_BUILD = join(engineRoot, 'build');
+const SPECS_DIR = join(engineRoot, '.axerity-specs');
+const ASSETS_DIR = join(engineRoot, '.axerity-assets');
+
+function findContentDir() {
+	for (const candidate of ['docs', join('content', 'docs'), 'content']) {
+		const dir = join(userRoot, candidate);
+		if (existsSync(dir)) return dir;
+	}
+	return null;
+}
+
+/** Reset the engine's own demo site into the mount points (for `axerity` runs
+ *  from inside the engine repo). `pnpm dev` does this via its pre-scripts. */
+function prepareEngine() {
+	spawnSync(process.execPath, [join(engineRoot, 'scripts', 'prepare-engine.mjs')], {
+		stdio: 'inherit'
+	});
+}
+
+/** Copy local specs into a gitignored folder and rewrite the config to point at
+ *  them, so the user's spec paths resolve without touching the engine tree. */
+function mountSpecs(config) {
+	const rewrite = (source) => {
+		const spec = typeof source === 'string' ? source : source.spec;
+		if (!spec || /^https?:\/\//.test(spec) || !existsSync(join(userRoot, spec))) return source;
+		const local = `.axerity-specs/${basename(spec)}`;
+		cpSync(join(userRoot, spec), join(engineRoot, local));
+		return typeof source === 'string' ? local : { ...source, spec: local };
+	};
+
+	if (!config.openapi) return config;
+	mkdirSync(SPECS_DIR, { recursive: true });
+	const openapi = Array.isArray(config.openapi)
+		? config.openapi.map(rewrite)
+		: rewrite(config.openapi);
+	return { ...config, openapi };
+}
+
+function mount(contentDir) {
+	// Content -> the path the engine globs, as symlinks so generated pages (an API
+	// reference) can sit alongside without touching the user's repo.
+	rmSync(ENGINE_DOCS, { recursive: true, force: true });
+	mkdirSync(ENGINE_DOCS, { recursive: true });
+	for (const entry of readdirSync(contentDir)) {
+		symlinkSync(join(contentDir, entry), join(ENGINE_DOCS, entry), symlinkType);
+	}
+
+	// Config (with local spec paths rewritten into the gitignored specs folder).
+	const config = JSON.parse(readFileSync(join(userRoot, 'axerity.json'), 'utf8'));
+	writeFileSync(ENGINE_CONFIG, JSON.stringify(mountSpecs(config), null, '\t'));
+
+	// Assets: engine defaults overlaid with the user's public/ folder.
+	rmSync(ASSETS_DIR, { recursive: true, force: true });
+	cpSync(ENGINE_STATIC, ASSETS_DIR, { recursive: true });
+	const userPublic = join(userRoot, 'public');
+	if (existsSync(userPublic)) cpSync(userPublic, ASSETS_DIR, { recursive: true });
+}
+
+function tidy() {
+	rmSync(SPECS_DIR, { recursive: true, force: true });
+	rmSync(ASSETS_DIR, { recursive: true, force: true });
+	rmSync(ENGINE_BUILD, { recursive: true, force: true });
+}
+
+const tty = process.stdout.isTTY;
+const paint = (code) => (s) => (tty ? `\x1b[${code}m${s}\x1b[0m` : s);
+const dim = paint('2');
+const bold = paint('1');
+const red = paint('31');
+const green = paint('32');
+const brand = (s) => (tty ? `\x1b[38;2;124;108;246m${s}\x1b[0m` : s);
+const mark = brand('◆');
+const strip = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+
+const banner = (sub) => process.stdout.write(`\n  ${mark} ${bold('axerity')} ${dim(sub)}\n\n`);
+
+const NOISE =
+	/^\s*(VITE v|➜|press h|ready in|Local:|Network:|\[vite\].*(optimiz|dependencies)|\[optimizer\]|Forced re-opt|watching for file changes|use --host)/i;
+
+function streamServer(child, sub) {
+	let shown = false;
+	let buffer = '';
+	const onData = (chunk) => {
+		buffer += chunk;
+		const lines = buffer.split('\n');
+		buffer = lines.pop() ?? '';
+		for (const line of lines) {
+			const clean = strip(line);
+			const url = clean.match(/Local:\s*(http:\/\/\S+)/);
+			if (url && !shown) {
+				shown = true;
+				process.stdout.write(`  ${dim('ready at')}  ${brand(url[1])}\n`);
+				process.stdout.write(`  ${dim('Ctrl+C to stop')}\n\n`);
+				continue;
+			}
+			if (!clean.trim() || NOISE.test(clean.trim())) continue;
+			process.stdout.write(`  ${line}\n`);
+		}
+	};
+	child.stdout.on('data', onData);
+	child.stderr.on('data', onData);
+}
+
+/** A build: silent spinner on success, full captured output only on failure. */
+function streamBuild(child) {
+	const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+	let i = 0;
+	let log = '';
+	child.stdout.on('data', (d) => (log += d));
+	child.stderr.on('data', (d) => (log += d));
+	const timer = tty
+		? setInterval(() => {
+				process.stdout.write(`\r  ${brand(frames[(i = ++i % frames.length)])} ${dim('building…')}`);
+			}, 80)
+		: null;
+	return {
+		stop(ok) {
+			if (timer) clearInterval(timer);
+			if (tty) process.stdout.write('\r\x1b[K');
+			if (!ok) process.stdout.write(log);
+		}
+	};
+}
+
+function runEngine(sub, extra, { mounted, onSuccess }) {
+	const viteEntry = join(engineRoot, 'node_modules', 'vite', 'bin', 'vite.js');
+	const child = spawn(process.execPath, [viteEntry, sub, ...extra], {
+		cwd: engineRoot,
+		stdio: ['inherit', 'pipe', 'pipe'],
+		env: {
+			...process.env,
+			...(mounted
+				? { AXERITY_FS_ALLOW: userRoot, AXERITY_MOUNTED: '1', AXERITY_ASSETS: ASSETS_DIR }
+				: {})
+		}
+	});
+
+	banner(sub);
+	const build = sub === 'build' ? streamBuild(child) : (streamServer(child, sub), null);
+
+	let cleaned = false;
+	const cleanup = () => {
+		if (cleaned || !mounted) return;
+		cleaned = true;
+		tidy();
+	};
+
+	child.on('exit', (code) => {
+		const ok = code === 0;
+		if (build) build.stop(ok);
+		if (ok && onSuccess) onSuccess();
+		else if (!ok && sub !== 'build')
+			process.stdout.write(`\n  ${red('✗')} exited with code ${code}\n`);
+		cleanup();
+		process.exit(code ?? 0);
+	});
+
+	process.on('SIGINT', () => child.kill('SIGINT'));
+	process.on('SIGTERM', () => child.kill('SIGINT'));
+	process.on('exit', cleanup);
+}
+
+function run(sub, extra) {
+	// Inside the engine repo: serve its own demo site.
+	if (isEngineRepo) {
+		prepareEngine();
+		return runEngine(sub, extra, { mounted: false });
+	}
+
+	if (!existsSync(join(userRoot, 'axerity.json'))) {
+		console.error('No axerity.json found here. Run `axerity init` to create a starter site.');
+		process.exit(1);
+	}
+	const contentDir = findContentDir();
+	if (!contentDir) {
+		console.error('No content found. Create a `docs/` folder with your Markdown.');
+		process.exit(1);
+	}
+
+	mount(contentDir);
+
+	if (sub === 'preview') {
+		const built = join(userRoot, 'build');
+		if (!existsSync(built)) {
+			tidy();
+			console.error('No build found. Run `axerity build` first.');
+			process.exit(1);
+		}
+		cpSync(built, ENGINE_BUILD, { recursive: true });
+	}
+
+	const onSuccess =
+		sub === 'build'
+			? () => {
+					const out = join(userRoot, 'build');
+					rmSync(out, { recursive: true, force: true });
+					cpSync(ENGINE_BUILD, out, { recursive: true });
+					process.stdout.write(`  ${green('✓')} built ${dim('→')} ./build\n\n`);
+				}
+			: undefined;
+
+	runEngine(sub, extra, { mounted: true, onSuccess });
+}
+
+function init() {
+	const target = process.argv[3] ? resolve(userRoot, process.argv[3]) : userRoot;
+	mkdirSync(join(target, 'docs'), { recursive: true });
+
+	const files = {
+		'axerity.json': `${JSON.stringify(
+			{
+				$schema: 'https://axerity.com/axerity.schema.json',
+				name: 'My Docs',
+				description: 'Documentation built with Axerity.',
+				theme: 'neutral',
+				topNav: [{ title: 'Docs', href: '/' }]
+			},
+			null,
+			'\t'
+		)}\n`,
+		'docs/meta.json': `${JSON.stringify(
+			{ title: 'Getting Started', icon: 'rocket', pages: ['index', 'quickstart'] },
+			null,
+			'\t'
+		)}\n`,
+		'docs/index.md': `---\ntitle: Introduction\ndescription: Welcome to your docs.\nicon: book-open\n---\n\n# Introduction\n\nWelcome to your new Axerity site. Edit \`docs/index.md\` to change this page.\n`,
+		'docs/quickstart.md': `---\ntitle: Quick Start\ndescription: Get going in a minute.\nicon: rocket\n---\n\n# Quick Start\n\nRun \`axerity dev\` and start writing Markdown in the \`docs/\` folder.\n`,
+		'.gitignore': `build\n`
+	};
+
+	for (const [file, content] of Object.entries(files)) {
+		const path = join(target, file);
+		if (existsSync(path)) continue;
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, content);
+	}
+
+	const where = relative(userRoot, target) || '.';
+	console.log(`Created an Axerity site in ${where}.\n`);
+	console.log('Next:');
+	if (where !== '.') console.log(`  cd ${where}`);
+	console.log('  axerity dev');
+}
+
+function help() {
+	const { version } = JSON.parse(readFileSync(join(engineRoot, 'package.json'), 'utf8'));
+	console.log(`Axerity ${version} — a documentation site generator\n`);
+	console.log('Usage: axerity <command>\n');
+	console.log('Commands:');
+	console.log('  init [dir]   Scaffold a new docs site');
+	console.log('  dev          Start the dev server');
+	console.log('  build        Build the static site');
+	console.log('  preview      Preview the production build');
+	console.log('\nWrite Markdown in docs/ and configure the site in axerity.json.');
+}
+
+const command = process.argv[2];
+const extra = process.argv.slice(3);
+
+switch (command) {
+	case 'init':
+		init();
+		break;
+	case 'dev':
+		run('dev', extra);
+		break;
+	case 'build':
+		run('build', extra);
+		break;
+	case 'preview':
+		run('preview', extra);
+		break;
+	default:
+		help();
+		process.exit(command ? 1 : 0);
+}

package/mdsvex.config.js

@@ -0,0 +1,261 @@
+import { readFileSync } from 'node:fs';
+import { defineMDSveXConfig } from 'mdsvex';
+import { escapeSvelte } from 'mdsvex';
+import rehypeSlug from 'rehype-slug';
+import { createHighlighter } from 'shiki';
+import { transformerTwoslash } from '@shikijs/twoslash';
+
+let basePath = '';
+try {
+	basePath = JSON.parse(readFileSync('./axerity.json', 'utf8')).basePath ?? '';
+} catch {
+	// no config
+}
+
+function rehypeBasePath() {
+	return (tree) => {
+		const walk = (node) => {
+			if (node.type === 'element' && node.tagName === 'a') {
+				const href = node.properties?.href;
+				if (
+					typeof href === 'string' &&
+					href.startsWith('/') &&
+					!href.startsWith('//') &&
+					!href.startsWith(`${basePath}/`)
+				) {
+					node.properties.href = basePath + href;
+				}
+			}
+			node.children?.forEach(walk);
+		};
+		if (basePath) walk(tree);
+	};
+}
+
+/**
+ * Wrap every `<table>` in a `<div class="table-wrapper">` so it can be a rounded,
+ * horizontally-scrollable card (a bare table can't clip rounded corners while
+ * also scrolling on overflow).
+ */
+function rehypeTableWrapper() {
+	return (tree) => {
+		const walk = (node) => {
+			if (!node.children) return;
+			node.children = node.children.map((child) => {
+				if (child.type === 'element' && child.tagName === 'table') {
+					return {
+						type: 'element',
+						tagName: 'div',
+						properties: { className: ['table-wrapper'] },
+						children: [child]
+					};
+				}
+				walk(child);
+				return child;
+			});
+		};
+		walk(tree);
+	};
+}
+
+function rehypeExternalLinks() {
+	return (tree) => {
+		const walk = (node) => {
+			if (node.type === 'element' && node.tagName === 'a') {
+				const href = node.properties?.href;
+				if (typeof href === 'string' && /^https?:\/\//.test(href)) {
+					node.properties.target = '_blank';
+					node.properties.rel = 'noreferrer noopener';
+				}
+			}
+			node.children?.forEach(walk);
+		};
+		walk(tree);
+	};
+}
+
+// Dual theme: light tokens are inlined, dark tokens exposed as CSS vars that
+// `layout.css` switches on under `.dark`.
+const themes = { light: 'github-light', dark: 'vesper' };
+
+// Languages preloaded into the highlighter. Anything else falls back to plain
+// text (see the try/catch below).
+const langs = [
+	'svelte',
+	'typescript',
+	'javascript',
+	'json',
+	'yaml',
+	'bash',
+	'shell',
+	'html',
+	'css',
+	'markdown'
+];
+
+// Lazily create a single shared highlighter (loading grammars + themes is
+// expensive, so do it once).
+let highlighterPromise;
+function getHighlighter() {
+	if (!highlighterPromise) {
+		highlighterPromise = createHighlighter({ themes: Object.values(themes), langs });
+	}
+	return highlighterPromise;
+}
+
+/** Escape HTML special chars for safe interpolation into the title bar. */
+function escapeHtml(str) {
+	return str
+		.replace(/&/g, '&amp;')
+		.replace(/</g, '&lt;')
+		.replace(/>/g, '&gt;')
+		.replace(/"/g, '&quot;');
+}
+
+/** Pull `title="…"` (or single-quoted) out of a fence's meta string. */
+function parseTitle(meta) {
+	const match = meta.match(/title=(?:"([^"]*)"|'([^']*)')/);
+	return match ? (match[1] ?? match[2]) : null;
+}
+
+/**
+ * Parse a `{1,3-5}` line-range expression from a fence's meta into a Set of
+ * 1-based line numbers to highlight.
+ */
+function parseHighlightLines(meta) {
+	const match = meta.match(/\{([\d,\s-]+)\}/);
+	const lines = new Set();
+	if (!match) return lines;
+	for (const part of match[1].split(',')) {
+		const range = part.trim();
+		if (!range) continue;
+		const [start, end] = range.split('-').map((n) => parseInt(n, 10));
+		for (let i = start; i <= (end ?? start); i++) lines.add(i);
+	}
+	return lines;
+}
+
+/** Whether the fence asked for line numbers (```ts showLineNumbers). */
+function hasLineNumbers(meta) {
+	return /\bshowLineNumbers\b/.test(meta);
+}
+
+/** Whether the fence asked for Twoslash type annotations (```ts twoslash). */
+function hasTwoslash(meta) {
+	return /\btwoslash\b/.test(meta);
+}
+
+const twoslash = transformerTwoslash({ explicitTrigger: true });
+
+/**
+ * The YAML grammar gives the `---` document markers no scope, so they inherit
+ * the bright default foreground and read as unhighlighted. Dim them to a subtle
+ * token that adapts to both themes.
+ */
+function transformerDimYamlMarkers() {
+	return {
+		name: 'axerity:dim-yaml-markers',
+		span(node) {
+			const text = node.children?.[0];
+			if (text && text.type === 'text' && text.value.trim() === '---') {
+				node.properties = { ...node.properties, style: 'color:var(--fg-subtle)' };
+			}
+		}
+	};
+}
+
+/** Shiki transformer: tag the requested lines with a `highlighted` class. */
+function transformerHighlightLines(lines) {
+	return {
+		name: 'axerity:highlight-lines',
+		line(node, lineNumber) {
+			if (lines.has(lineNumber)) this.addClassToHast(node, 'highlighted');
+		}
+	};
+}
+
+/**
+ * Shiki separates lines with literal "\n" text nodes. With block-level lines
+ * (needed for full-width highlights) those render as blank lines, so strip
+ * them — the copy handler rejoins lines with newlines itself.
+ */
+function transformerRemoveLineBreaks() {
+	return {
+		name: 'axerity:remove-line-breaks',
+		code(node) {
+			node.children = node.children.filter(
+				(child) => !(child.type === 'text' && child.value === '\n')
+			);
+		}
+	};
+}
+
+/** Shiki transformer: flag the block so CSS counters can number the lines. */
+function transformerLineNumbers() {
+	return {
+		name: 'axerity:line-numbers',
+		pre(node) {
+			this.addClassToHast(node, 'has-line-numbers');
+		}
+	};
+}
+
+// Static copy button injected into every code block; clicks are handled by a
+// delegated listener in DocsLayout (the markup carries no state itself).
+const COPY_BUTTON =
+	'<button class="copy-button" type="button" aria-label="Copy code">' +
+	'<svg class="icon-copy" xmlns="http://www.w3.org/2000/svg" width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect width="14" height="14" x="8" y="8" rx="2"/><path d="M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"/></svg>' +
+	'<svg class="icon-check" xmlns="http://www.w3.org/2000/svg" width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><path d="M20 6 9 17l-5-5"/></svg>' +
+	'</button>';
+
+export default defineMDSveXConfig({
+	extensions: ['.svx', '.md'],
+	// Give every heading a stable id so the TOC can anchor + scroll-spy to it.
+	rehypePlugins: [rehypeSlug, rehypeTableWrapper, rehypeExternalLinks, rehypeBasePath],
+	highlight: {
+		highlighter: async (code, lang, meta) => {
+			if (lang === 'mermaid') {
+				const graph = escapeSvelte(
+					code.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+				);
+				return `{@html \`<pre class="mermaid">${graph}</pre>\`}`;
+			}
+
+			const highlighter = await getHighlighter();
+			const language = (lang && highlighter.getLoadedLanguages().includes(lang) && lang) || 'text';
+			meta = meta || '';
+
+			const title = parseTitle(meta);
+			const highlightLines = parseHighlightLines(meta);
+			const twoslashEnabled = hasTwoslash(meta);
+
+			const transformers = [];
+			if (twoslashEnabled) transformers.push(twoslash);
+			if (language === 'yaml') transformers.push(transformerDimYamlMarkers());
+			transformers.push(transformerRemoveLineBreaks());
+			if (highlightLines.size) transformers.push(transformerHighlightLines(highlightLines));
+			if (hasLineNumbers(meta)) transformers.push(transformerLineNumbers());
+
+			const html = highlighter.codeToHtml(code, {
+				lang: language,
+				meta: { __raw: meta },
+				themes,
+				defaultColor: 'light',
+				transformers
+			});
+
+			// With a title, the copy button lives in the header bar; otherwise it
+			// floats in the top-right corner of the block.
+			const header = title
+				? `<div class="code-header"><span class="code-title">${escapeHtml(title)}</span>${COPY_BUTTON}</div>`
+				: '';
+			const blockClass =
+				(title ? 'code-block has-header' : 'code-block') + (twoslashEnabled ? ' has-twoslash' : '');
+			const floatingButton = title ? '' : COPY_BUTTON;
+			const wrapped = `<div class="${blockClass}">${header}${floatingButton}${html}</div>`;
+
+			// Escape so Svelte doesn't try to parse `{`, `}`, or backticks in the code.
+			return `{@html \`${escapeSvelte(wrapped)}\`}`;
+		}
+	}
+});

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@axerity/cli",
+  "version": "0.1.0",
+  "description": "A documentation site generator built with Svelte.",
+  "type": "module",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "aelpxy",
+  "homepage": "https://axerity.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/axerity/axerity.git"
+  },
+  "bugs": {
+    "url": "https://github.com/axerity/axerity/issues"
+  },
+  "keywords": [
+    "documentation",
+    "docs",
+    "static-site-generator",
+    "ssg",
+    "sveltekit",
+    "svelte",
+    "markdown",
+    "mdsvex",
+    "openapi"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "bin": {
+    "axerity": "./bin/axerity.js"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "src",
+    "static",
+    "svelte.config.js",
+    "vite.config.ts",
+    "mdsvex.config.js",
+    "tsconfig.json",
+    "axerity.default.json",
+    "axerity.schema.json",
+    "README.md"
+  ],
+  "dependencies": {
+    "@fontsource-variable/geist": "^5.2.9",
+    "@fontsource-variable/geist-mono": "^5.2.8",
+    "@lucide/svelte": "^1.17.0",
+    "@orama/orama": "^3.1.18",
+    "@resvg/resvg-js": "^2.6.2",
+    "@shikijs/twoslash": "^4.1.0",
+    "@sveltejs/adapter-static": "^3.0.10",
+    "@sveltejs/kit": "^2.61.1",
+    "@sveltejs/vite-plugin-svelte": "^7.1.2",
+    "@tailwindcss/forms": "^0.5.11",
+    "@tailwindcss/typography": "^0.5.19",
+    "@tailwindcss/vite": "^4.3.0",
+    "mdsvex": "^0.12.7",
+    "mermaid": "^11.15.0",
+    "rehype-slug": "^6.0.0",
+    "satori": "^0.26.0",
+    "shiki": "^4.1.0",
+    "svelte": "^5.56.0",
+    "tailwindcss": "^4.3.0",
+    "twoslash": "^0.3.8",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.14",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^2.1.0",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.9.1",
+    "eslint": "^10.4.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-svelte": "^3.19.0",
+    "globals": "^17.6.0",
+    "prettier": "^3.8.3",
+    "prettier-plugin-svelte": "^4.0.1",
+    "prettier-plugin-tailwindcss": "^0.8.0",
+    "svelte-check": "^4.4.8",
+    "typescript-eslint": "^8.60.0"
+  },
+  "scripts": {
+    "axerity": "node ./bin/axerity.js",
+    "postversion": "git push --follow-tags",
+    "prepare-engine": "node scripts/prepare-engine.mjs",
+    "predev": "node scripts/prepare-engine.mjs",
+    "dev": "vite dev",
+    "prebuild": "node scripts/prepare-engine.mjs",
+    "build": "vite build",
+    "prepreview": "node scripts/prepare-engine.mjs",
+    "preview": "vite preview",
+    "check": "node scripts/prepare-engine.mjs && svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "lint": "prettier --check . --ignore-path .gitignore --ignore-path .prettierignore && eslint .",
+    "format": "prettier --write . --ignore-path .gitignore --ignore-path .prettierignore"
+  }
+}

package/scripts/prepare-engine.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { cpSync, existsSync, mkdirSync, readdirSync, rmSync, symlinkSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const symlinkType = process.platform === 'win32' ? 'junction' : 'dir';
+
+const demo = join(root, 'src', 'content', 'demo');
+const docs = join(root, 'src', 'content', 'docs');
+const defaultConfig = join(root, 'axerity.default.json');
+const config = join(root, 'axerity.json');
+
+rmSync(docs, { recursive: true, force: true });
+mkdirSync(docs, { recursive: true });
+for (const entry of readdirSync(demo)) {
+	symlinkSync(join(demo, entry), join(docs, entry), symlinkType);
+}
+
+if (existsSync(defaultConfig)) cpSync(defaultConfig, config);