kirbyup 4.0.0-alpha.5 → 4.0.0-alpha.7

package/README.md

@@ -2,25 +2,31 @@
 
 # kirbyup
 
-[![npm version](https://img.shields.io/npm/v/kirbyup?color=a1b858&label=)](https://www.npmjs.com/package/kirbyup)
-
-The official bundler for Kirby Panel plugins with zero-config usage and built-in HMR.
+The official bundler for Kirby Panel plugins. Zero-config, built-in HMR.
 
 - [✨  Release Notes](https://github.com/johannschopplich/kirbyup/releases)
 - [📖  Read the documentation](https://kirbyup.getkirby.com)
 
 ## Key Features
 
-- 🔄 [Hot module replacement](https://kirbyup.getkirby.com/guide/getting-started.html#development)
-- 🎒 PostCSS support
-- 🧭 Add custom path aliases
-- 🔌 Run actions based on environment variables
-- 🦔 [Extends Vite with `kirbyup.config.js`](https://kirbyup.getkirby.com/guide/config-file)
+- 🔄 [Hot Module Replacement](https://kirbyup.getkirby.com/guide/getting-started.html#development)
+- 🎒 [PostCSS & Sass](https://kirbyup.getkirby.com/guide/postcss)
+- 🧩 [kirbyuse Integration](https://kirbyup.getkirby.com/guide/kirbyuse)
+- 🔌 [Environment Variables](https://kirbyup.getkirby.com/guide/environment-variables)
+- 🦔 [Configuration File](https://kirbyup.getkirby.com/guide/config-file)
+- 🧭 [Path Aliases](https://kirbyup.getkirby.com/guide/path-aliases)
+
+## Requirements
+
+- **Node.js 24+**: paired with a package manager (pnpm, npm, or yarn).
+- **Kirby 6 or newer**: kirbyup 4.x targets the Vue 3-based Panel runtime introduced in Kirby 6. For Kirby 4 or 5 plugins, use kirbyup 3.x.
 
 ## Setup
 
 > [!TIP]
-> [📖 Read the documentation](https://kirbyup.getkirby.com)
+> Skip starting from scratch and pick one of the following starters:
+> - [`eslint`](./examples/eslint)
+> - [`unocss`](./examples/unocss)
 
 ```bash
 # pnpm
@@ -28,16 +34,12 @@ pnpm add -D kirbyup
 
 # npm
 npm i -D kirbyup
-```
 
-## Basic Usage
-
-> [!TIP]
-> [📖 Read the documentation](https://kirbyup.getkirby.com) or skip starting from scratch and pick one of the following starters:
-> - [`eslint`](./examples/eslint)
-> - [`tailwindcss`](./examples/tailwindcss)
+# yarn
+yarn add -D kirbyup
+```
 
-Having installed kirbyup, you can add the following scripts as shortcuts to the commands you will use most often:
+After installation, add these scripts to your `package.json`:
 
 ```json
 {
@@ -46,18 +48,18 @@ Having installed kirbyup, you can add the following scripts as shortcuts to the
     "build": "kirbyup src/index.js"
   },
   "devDependencies": {
-    "kirbyup": "^3.4.0"
+    "kirbyup": "^4.0.0-alpha.6"
   }
 }
 ```
 
-## 💻 Development
+## Development
 
 1. Clone this repository
 2. Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable`
 3. Install dependencies using `pnpm install`
-4. Run `pnpm run dev:prepare`
-5. Start development server using `pnpm run dev`
+4. Build with `pnpm run build`
+5. Run tests with `pnpm test`
 
 ## License
 

package/dist/client/config.d.mts

@@ -1,4 +1,4 @@
-import { r as UserConfig } from "../types-CFhX3iS8.mjs";
+import { r as UserConfig } from "../types-3hN383nZ.mjs";
 
 //#region src/client/config.d.ts
 declare function defineConfig(config: UserConfig): UserConfig;

package/dist/client/config.mjs

@@ -2,6 +2,5 @@
 function defineConfig(config) {
 	return config;
 }
-
 //#endregion
-export { defineConfig };
+export { defineConfig };

package/dist/client/plugin.mjs

@@ -1,7 +1,15 @@
 //#region src/client/plugin.ts
-const kirbyup = Object.freeze({ import(glob) {
-	const modules = glob;
-	return Object.entries(modules).reduce((accumulator, [path, component]) => {
+const kirbyup = Object.freeze({ 
+/**
+* Auto-import Kirby Panel components, transformed by
+* kirbyup's glob-import plugin for Vite.
+*
+* @example
+* kirbyup.import('./components/blocks/*.vue')
+*/
+import(glob) {
+	if (typeof glob === "string") throw new TypeError("[kirbyup] kirbyup.import() requires the kirbyup build pipeline. The call must be transformed at build time by the kirbyup:glob-import plugin.");
+	return Object.entries(glob).reduce((accumulator, [path, component]) => {
 		accumulator[getComponentName(path)] = component.default;
 		return accumulator;
 	}, {});
@@ -9,6 +17,5 @@ const kirbyup = Object.freeze({ import(glob) {
 function getComponentName(path) {
 	return path.substring(path.lastIndexOf("/") + 1, path.lastIndexOf(".")).toLowerCase();
 }
-
 //#endregion
-export { kirbyup };
+export { kirbyup };

package/dist/node/cli.mjs

@@ -1,6 +1,5 @@
-import { a as version, i as name, n as serve, r as handleError, t as build } from "../node-B8aLFfzt.mjs";
+import { a as version, i as name, n as serve, r as handleError, t as build } from "../node-BAAmufwc.mjs";
 import { cac } from "cac";
-
 //#region src/node/cli-start.ts
 async function startCli(cwd = process.cwd(), argv = process.argv) {
 	const cli = cac(name);
@@ -36,10 +35,8 @@ async function startCli(cwd = process.cwd(), argv = process.argv) {
 	cli.parse(argv, { run: false });
 	await cli.runMatchedCommand();
 }
-
 //#endregion
 //#region src/node/cli.ts
 startCli().catch(handleError);
-
 //#endregion
-export {  };
+export {};

package/dist/node/index.d.mts

@@ -1,4 +1,4 @@
-import { n as ServeOptions, t as BuildOptions } from "../types-CFhX3iS8.mjs";
+import { n as ServeOptions, t as BuildOptions } from "../types-3hN383nZ.mjs";
 import { ViteDevServer } from "vite";
 
 //#region src/node/index.d.ts

package/dist/node/index.mjs

@@ -1,3 +1,2 @@
-import { n as serve, t as build } from "../node-B8aLFfzt.mjs";
-
-export { build, serve };
+import { n as serve, t as build } from "../node-BAAmufwc.mjs";
+export { build, serve };

package/dist/node-BAAmufwc.mjs

@@ -0,0 +1,480 @@
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import vuePlugin from "@vitejs/plugin-vue";
+import vueJsxPlugin from "@vitejs/plugin-vue-jsx";
+import { consola } from "consola";
+import { colors } from "consola/utils";
+import { basename, dirname, normalize, relative, resolve } from "pathe";
+import { debounce } from "perfect-debounce";
+import { build, createFilter, createLogger, createServer, mergeConfig, normalizePath } from "vite";
+import * as vueCompilerSfc from "vue/compiler-sfc";
+import { loadConfig } from "c12";
+import postcssrcLoad from "postcss-load-config";
+import { gzipSync } from "node:zlib";
+import MagicString from "magic-string";
+import { stripLiteral } from "strip-literal";
+import { isIP } from "node:net";
+//#region package.json
+var name = "kirbyup";
+var version = "4.0.0-alpha.7";
+//#endregion
+//#region src/node/config.ts
+function loadConfig$1(cwd = process.cwd()) {
+	return loadConfig({
+		cwd,
+		name: "kirbyup",
+		rcFile: false,
+		packageJson: false
+	});
+}
+async function resolvePostCSSConfig(cwd) {
+	try {
+		return await postcssrcLoad(void 0, void 0, { stopDir: cwd });
+	} catch (error) {
+		if (!error.message.includes("No PostCSS Config found")) throw error;
+	}
+}
+//#endregion
+//#region src/node/errors.ts
+var PrettyError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = this.constructor.name;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+function handleError(error) {
+	consola.error(error.message);
+	process.exitCode = 1;
+}
+//#endregion
+//#region src/node/plugins/build-cleanup.ts
+function kirbyupBuildCleanupPlugin(options) {
+	let config;
+	let devIndexPath;
+	return {
+		name: "kirbyup:build-cleanup",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+			devIndexPath = resolve(config.root, options.outDir, "index.dev.js");
+		},
+		writeBundle() {
+			if (options.watch) return;
+			if (fs.existsSync(devIndexPath)) fs.unlinkSync(devIndexPath);
+		}
+	};
+}
+//#endregion
+//#region src/node/utils.ts
+function toArray(array) {
+	array ??= [];
+	return Array.isArray(array) ? array : [array];
+}
+async function printFileInfo({ root, outDir, filePath, content, type, maxLength }) {
+	const prettyOutDir = `${normalize(relative(root, outDir))}/`;
+	const kibs = content.length / 1024;
+	const compressedKibs = gzipSync(content).length / 1024;
+	const writeColor = type === "chunk" ? colors.cyan : colors.magenta;
+	consola.log(colors.white(colors.dim(prettyOutDir)) + writeColor(filePath.padEnd(maxLength + 2)) + colors.dim(`${kibs.toFixed(2)} kB / gzip: ${compressedKibs.toFixed(2)} KiB`));
+}
+//#endregion
+//#region src/node/plugins/full-reload.ts
+/**
+* Triggers a full browser reload when files matching the given globs change.
+* Vite forces chokidar's `disableGlobbing: true` by default; this plugin
+* resets it so glob strings passed to `watcher.add` are expanded by chokidar.
+*/
+function kirbyupFullReloadPlugin(paths) {
+	return {
+		name: "kirbyup:full-reload",
+		apply: "serve",
+		config() {
+			return { server: { watch: { disableGlobbing: false } } };
+		},
+		configureServer({ watcher, ws, config: { root, logger } }) {
+			const files = toArray(paths).map((p) => resolve(root, p));
+			const matches = createFilter(files);
+			watcher.add(files);
+			const reload = (path) => {
+				if (!matches(path)) return;
+				setTimeout(() => ws.send({
+					type: "full-reload",
+					path: "*"
+				}), 0);
+				logger.info(`${colors.green("full reload")} ${colors.dim(relative(root, path))}`, {
+					clear: true,
+					timestamp: true
+				});
+			};
+			watcher.on("add", reload);
+			watcher.on("change", reload);
+		}
+	};
+}
+//#endregion
+//#region src/node/plugins/glob-import.ts
+/**
+* Transforms `kirbyup.import(<path>)` to `kirbyup.import(import.meta.glob(<path>, { eager: true }))`.
+*
+* Must run before Vite's own `import.meta.glob` plugin (also `enforce: 'pre'`),
+* otherwise the emitted call is never expanded.
+*/
+function kirbyupGlobImportPlugin() {
+	let config;
+	return {
+		name: "kirbyup:glob-import",
+		enforce: "pre",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		},
+		transform(code) {
+			if (!code.includes("kirbyup.import")) return;
+			const kirbyupImportRE = /\bkirbyup\.import\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*\)/dg;
+			const cleanCode = stripLiteral(code);
+			let s;
+			for (const match of cleanCode.matchAll(kirbyupImportRE)) {
+				const { 0: exp, index } = match;
+				const [argStart, argEnd] = match.indices[1];
+				const rawPath = code.slice(argStart, argEnd);
+				if (!s) s = new MagicString(code);
+				s.overwrite(index, index + exp.length, `kirbyup.import(import.meta.glob(${rawPath}, { eager: true }))`);
+			}
+			if (s) return {
+				code: s.toString(),
+				map: config.build.sourcemap ? s.generateMap({ hires: true }) : void 0
+			};
+		}
+	};
+}
+//#endregion
+//#region src/node/utils/server.ts
+function resolveOriginFromServerOptions(serverOptions, port, fallbackHostname) {
+	const protocol = serverOptions?.https && (typeof serverOptions.https === "boolean" || Object.keys(serverOptions.https).length > 0) ? "https" : "http";
+	const configuredHost = normalizeHost(serverOptions?.host);
+	return `${protocol}://${formatHostname(configuredHost || fallbackHostname || "localhost")}${(configuredHost ? hostIncludesPort(configuredHost) : false) || protocol === "http" && port === 80 || protocol === "https" && port === 443 ? "" : `:${port}`}`;
+}
+function normalizeHost(host) {
+	if (host === false || host === void 0) return;
+	if (host === true) return "0.0.0.0";
+	return host;
+}
+function formatHostname(host) {
+	if (!host) return "localhost";
+	if (host.startsWith("[") && host.endsWith("]")) return host;
+	return isIP(host) === 6 ? `[${host}]` : host;
+}
+function hostIncludesPort(host) {
+	if (host.startsWith("[")) {
+		const closingIndex = host.indexOf("]");
+		return closingIndex > -1 && host.slice(closingIndex + 1).startsWith(":");
+	}
+	if (isIP(host) === 6) return false;
+	return host.includes(":");
+}
+//#endregion
+//#region src/node/plugins/runtime/hmr-shim.js?raw
+var hmr_shim_default = "/* eslint-disable no-undef */\nimport 'vue'\n\nif (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {\n  const originalReload = __VUE_HMR_RUNTIME__.reload\n\n  __VUE_HMR_RUNTIME__.reload = function (id, newComp) {\n    const plugins = window.panel && window.panel.plugins\n    const app = window.panel && window.panel.app\n\n    if (\n      plugins\n      && app\n      && plugins.components\n      && typeof plugins.resolveComponentExtension === 'function'\n      && typeof plugins.resolveComponentRender === 'function'\n      && typeof plugins.resolveComponentMixins === 'function'\n    ) {\n      for (const name in plugins.components) {\n        const pluginComp = plugins.components[name]\n        if (\n          pluginComp.__hmrId === id\n          || (newComp.__file && pluginComp.__file === newComp.__file)\n        ) {\n          plugins.resolveComponentExtension(app, name, newComp)\n          plugins.resolveComponentRender(newComp)\n          plugins.resolveComponentMixins(newComp)\n          break\n        }\n      }\n    }\n\n    return originalReload.call(this, id, newComp)\n  }\n}\nelse {\n  console.warn(\n    '[kirbyup] Vue HMR runtime not detected; component changes will fall back to full page reload. The Kirby Panel may be loading a production build of Vue.',\n  )\n}\n";
+//#endregion
+//#region src/node/plugins/runtime/vue-stub.js?raw
+var vue_stub_default = "const __kirbyupVueImportMapEl = typeof document !== 'undefined'\n  ? document.querySelector('script[type=\"importmap\"]')\n  : null\nconst __kirbyupVueImports = __kirbyupVueImportMapEl\n  ? (() => {\n      try {\n        return JSON.parse(__kirbyupVueImportMapEl.textContent || '{}').imports || {}\n      }\n      // eslint-disable-next-line unused-imports/no-unused-vars\n      catch (_) {\n        return {}\n      }\n    })()\n  : {}\nconst __kirbyupVueUrl = __kirbyupVueImports.vue\nif (!__kirbyupVueUrl) {\n  throw new Error(\n    '[kirbyup] No \"vue\" entry found in the page <script type=\"importmap\">. Ensure Kirby\\'s Panel is loaded with v6 import maps enabled.',\n  )\n}\n// eslint-disable-next-line no-unused-vars, antfu/no-top-level-await\nconst __kirbyupVueModule = await import(/* @vite-ignore */ __kirbyupVueUrl)\n";
+//#endregion
+//#region src/node/plugins/utils.ts
+/**
+* Vue's `reload` does `Object.assign(record.initialDef, newComp)`, which would
+* overwrite Kirby's in-place mutations on the stored definition. The shim
+* re-runs Kirby's plugin helpers on `newComp` first; see
+* https://github.com/getkirby/kirby/blob/v6/develop/panel/src/panel/plugins.ts
+* ("expose helper functions for kirbyup"). `rerender` is not wrapped: in Vue 3
+* it only swaps a render function, leaving Kirby's mutations untouched.
+*/
+const __HMR_SHIM_CODE__ = hmr_shim_default;
+/**
+* Reads Kirby's panel-vue URL at runtime from the page's
+* `<script type="importmap">` and dynamic-imports it; the browser's module
+* map dedups by URL, so plugin SFCs share Kirby's Vue instance (and
+* `__VUE_HMR_RUNTIME__`). Top-level await lets consumers keep using ordinary
+* `import { ... } from 'vue'` syntax.
+*/
+function buildVueStubCode(namedExports) {
+	if (namedExports.length === 0) return vue_stub_default;
+	return vue_stub_default + `\nexport const {\n${namedExports.map((name) => `  ${name},`).join("\n")}\n} = __kirbyupVueModule\n`;
+}
+//#endregion
+//#region src/node/plugins/hmr.ts
+const SHIM_ID = "\0kirbyup:hmr-shim";
+const SHIM_PUBLIC_ID = SHIM_ID.slice(1);
+const VUE_STUB_ID = "\0kirbyup:vue-stub";
+const VUE_STUB_PUBLIC_ID = VUE_STUB_ID.slice(1);
+const VUE_NOT_FOUND_STUB = `throw new Error('[kirbyup] Cannot resolve "vue" from the plugin project. Make sure "vue" is installed as a dependency.')\n`;
+function kirbyupHmrPlugin(options) {
+	let config;
+	let entry;
+	let entryId;
+	let devIndexPath;
+	let vueStubCode;
+	return {
+		name: "kirbyup:hmr",
+		apply: "serve",
+		enforce: "pre",
+		config() {
+			return {
+				optimizeDeps: { exclude: ["vue"] },
+				resolve: { alias: [{
+					find: /^vue$/,
+					replacement: VUE_STUB_ID
+				}] }
+			};
+		},
+		async configResolved(resolvedConfig) {
+			config = resolvedConfig;
+			entry = resolve(config.root, options.entry);
+			entryId = normalizePath(entry);
+			devIndexPath = resolve(config.root, options.outDir ?? "", "index.dev.js");
+			try {
+				const vueModule = await import("vue");
+				const namedExports = Object.keys(vueModule).filter((name) => name !== "default");
+				vueStubCode = namedExports.length > 0 ? buildVueStubCode(namedExports) : void 0;
+			} catch {
+				vueStubCode = void 0;
+			}
+		},
+		resolveId(source) {
+			if (source === SHIM_ID || source === SHIM_PUBLIC_ID) return SHIM_ID;
+			if (source === VUE_STUB_ID || source === VUE_STUB_PUBLIC_ID) return VUE_STUB_ID;
+		},
+		load(id) {
+			if (id === SHIM_ID) return {
+				code: __HMR_SHIM_CODE__,
+				map: null,
+				moduleType: "js"
+			};
+			if (id === VUE_STUB_ID) return {
+				code: vueStubCode ?? VUE_NOT_FOUND_STUB,
+				map: null,
+				moduleType: "js"
+			};
+		},
+		transform(code, id) {
+			if (normalizePath(id.split("?")[0]) !== entryId) return;
+			if (code.includes(SHIM_PUBLIC_ID)) return;
+			return {
+				code: `import ${JSON.stringify(SHIM_ID)}\n${code}`,
+				map: null
+			};
+		},
+		configureServer(server) {
+			if (!server.httpServer) return;
+			server.httpServer.once("listening", async () => {
+				const entryPath = entry.replace(`${config.root}/`, "");
+				const baseUrl = getDevBaseUrl(server, config);
+				const entryUrl = new URL(entryPath, baseUrl).href;
+				const pm = detectPackageManager(config.root);
+				await fsp.writeFile(devIndexPath, getViteProxyModule(entryUrl, pm));
+			});
+		},
+		async closeBundle() {
+			await fsp.rm(devIndexPath, { force: true });
+		}
+	};
+}
+function getViteProxyModule(entryUrl, packageManager) {
+	return `
+try {
+  await import("${entryUrl}");
+} catch (error) {
+  console.error(
+    "[kirbyup] Couldn't connect to the development server at ${entryUrl}. Run \`${packageManager} run serve\` to start Vite or build the plugin with \`${packageManager} run build\` so Kirby uses the production version."
+  );
+  throw error;
+}
+`.trimStart();
+}
+function getDevBaseUrl(server, config) {
+	const { address, port } = server.httpServer.address();
+	const origin = config.server?.origin ?? server.resolvedUrls?.local?.[0] ?? server.resolvedUrls?.network?.[0] ?? resolveOriginFromServerOptions(config.server, port, address);
+	const base = config.base ?? "/";
+	return new URL(base, origin).href;
+}
+function detectPackageManager(cwd) {
+	if (fs.existsSync(resolve(cwd, "pnpm-lock.yaml"))) return "pnpm";
+	if (fs.existsSync(resolve(cwd, "bun.lock")) || fs.existsSync(resolve(cwd, "bun.lockb"))) return "bun";
+	if (fs.existsSync(resolve(cwd, "yarn.lock"))) return "yarn";
+	if (fs.existsSync(resolve(cwd, "deno.lock"))) return "deno";
+	return "npm";
+}
+//#endregion
+//#region src/node/index.ts
+const DEV_OUTPUT_FILENAME = "index.dev.js";
+const SUPPRESSED_WARNING_PREFIX = "\n(!) build.outDir";
+const logLevel = "warn";
+function getViteConfig(command, options, { kirbyupConfig, postCssConfig, logger }) {
+	const aliasDir = resolve(options.cwd, dirname(options.entry));
+	const { alias = {}, vite } = kirbyupConfig;
+	const userConfig = vite ?? {};
+	const sharedConfig = {
+		resolve: { alias: {
+			"~/": `${aliasDir}/`,
+			"@/": `${aliasDir}/`,
+			...alias
+		} },
+		plugins: [
+			vuePlugin({ compiler: vueCompilerSfc }),
+			vueJsxPlugin(),
+			kirbyupGlobImportPlugin()
+		],
+		build: { copyPublicDir: false },
+		...postCssConfig && { css: { postcss: {
+			...postCssConfig.options,
+			plugins: postCssConfig.plugins
+		} } },
+		envDir: options.cwd,
+		envPrefix: ["VITE_", "KIRBYUP_"],
+		customLogger: logger,
+		logLevel
+	};
+	if (command === "serve") {
+		const { port, watch } = options;
+		const inferredOrigin = userConfig.server?.origin ?? resolveOriginFromServerOptions(userConfig.server, port, "localhost");
+		return mergeConfig(mergeConfig(sharedConfig, {
+			plugins: [kirbyupHmrPlugin(options), watch && kirbyupFullReloadPlugin(watch)].filter(Boolean),
+			build: { rollupOptions: { input: resolve(options.cwd, options.entry) } },
+			server: {
+				port,
+				strictPort: true,
+				origin: inferredOrigin,
+				cors: true
+			}
+		}), userConfig);
+	}
+	const mode = options.watch ? "development" : "production";
+	return mergeConfig(mergeConfig(sharedConfig, {
+		mode,
+		plugins: [kirbyupBuildCleanupPlugin(options)],
+		build: {
+			lib: {
+				entry: resolve(options.cwd, options.entry),
+				formats: ["es"],
+				fileName: () => options.watch ? DEV_OUTPUT_FILENAME : "index.js"
+			},
+			minify: mode === "production",
+			outDir: options.outDir,
+			emptyOutDir: false,
+			rollupOptions: {
+				external: ["vue"],
+				output: { assetFileNames: "index.[ext]" }
+			}
+		}
+	}), userConfig);
+}
+async function generate(options, context) {
+	const config = getViteConfig("build", options, context);
+	let result;
+	try {
+		result = await build(config);
+	} catch (error) {
+		if (!options.watch) throw error;
+		consola.error(error);
+	}
+	if (!result || options.watch) return;
+	const { output } = toArray(result)[0];
+	const maxLength = Math.max(0, ...output.map((item) => item.fileName.length));
+	for (const item of output) {
+		const content = item.type === "chunk" ? item.code : await fsp.readFile(resolve(options.outDir, item.fileName), "utf8");
+		await printFileInfo({
+			root: options.cwd,
+			outDir: options.outDir,
+			filePath: item.fileName,
+			content,
+			type: item.type,
+			maxLength
+		});
+	}
+}
+async function build$1(options) {
+	assertEntryExists(options);
+	const { cwd } = options;
+	const { config, configFile } = await loadConfig$1(cwd);
+	const postCssConfig = await resolvePostCSSConfig(cwd);
+	const context = {
+		kirbyupConfig: config ?? {},
+		postCssConfig,
+		logger: createKirbyupLogger()
+	};
+	consola.log(colors.green(`${name} v${version}`));
+	consola.start(`Building ${colors.cyan(options.entry)}`);
+	await generate(options, context);
+	consola.success("Build successful");
+	if (!options.watch) return;
+	const { watch } = await import("chokidar");
+	const debouncedBuild = debounce(() => {
+		generate(options, context).catch(handleError);
+	}, 100);
+	const ignored = [
+		"**/{.git,node_modules}/**",
+		"index.{css,js}",
+		DEV_OUTPUT_FILENAME
+	];
+	const watchPaths = options.watch === true ? dirname(options.entry) : toArray(options.watch);
+	consola.info(`Watching for changes in ${toArray(watchPaths).map((i) => colors.cyan(i)).join(", ")}`);
+	const watcher = watch(watchPaths, {
+		ignoreInitial: true,
+		ignorePermissionErrors: true,
+		ignored,
+		cwd
+	});
+	const devOutputPath = resolve(options.outDir, DEV_OUTPUT_FILENAME);
+	const cleanup = async () => {
+		await watcher.close().catch(() => {});
+		await fsp.rm(devOutputPath, { force: true }).catch(() => {});
+	};
+	process.once("exit", () => {
+		try {
+			fs.rmSync(devOutputPath, { force: true });
+		} catch {}
+	});
+	const onShutdown = () => {
+		cleanup().finally(() => process.exit(0));
+	};
+	process.once("SIGINT", onShutdown);
+	process.once("SIGTERM", onShutdown);
+	if (configFile) watcher.add(configFile);
+	watcher.on("all", async (type, file) => {
+		if (configFile === resolve(cwd, file)) {
+			context.kirbyupConfig = (await loadConfig$1(cwd)).config ?? {};
+			consola.info(`${colors.cyan(basename(file))} changed, setting new config`);
+		} else consola.log(`${colors.green(type)} ${colors.white(colors.dim(file))}`);
+		debouncedBuild();
+	});
+}
+async function serve(options) {
+	assertEntryExists(options);
+	const { cwd } = options;
+	const { config } = await loadConfig$1(cwd);
+	const postCssConfig = await resolvePostCSSConfig(cwd);
+	const context = {
+		kirbyupConfig: config ?? {},
+		postCssConfig,
+		logger: createKirbyupLogger()
+	};
+	consola.log(colors.green(`${name} v${version}`));
+	consola.info("Starting development server…");
+	const server = await createServer(getViteConfig("serve", options, context));
+	await server.listen();
+	consola.success(`Server is listening on :${server.config.server.port}`);
+	return server;
+}
+function createKirbyupLogger() {
+	const baseLogger = createLogger(logLevel);
+	return {
+		...baseLogger,
+		warn(msg, options) {
+			if (msg.startsWith(SUPPRESSED_WARNING_PREFIX)) return;
+			baseLogger.warn(msg, options);
+		}
+	};
+}
+function assertEntryExists(options) {
+	if (!fs.existsSync(resolve(options.cwd, options.entry))) throw new PrettyError(`Cannot find "${options.entry}"`);
+}
+//#endregion
+export { version as a, name as i, serve as n, handleError as r, build$1 as t };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "kirbyup",
   "type": "module",
-  "version": "4.0.0-alpha.5",
-  "packageManager": "pnpm@10.25.0",
+  "version": "4.0.0-alpha.7",
+  "packageManager": "pnpm@10.33.3",
   "description": "Zero-config bundler for Kirby Panel plugins",
   "author": {
     "name": "Johann Schopplich",
@@ -57,7 +57,7 @@
     "dist"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=24"
   },
   "scripts": {
     "build": "tsdown",
@@ -71,32 +71,32 @@
     "test:types": "tsc --noEmit"
   },
   "dependencies": {
-    "@vitejs/plugin-vue": "^6.0.2",
-    "@vitejs/plugin-vue-jsx": "^5.1.2",
-    "@vue/compiler-sfc": "^3.5.25",
-    "c12": "^3.3.2",
-    "cac": "^6.7.14",
+    "@vitejs/plugin-vue": "^6.0.6",
+    "@vitejs/plugin-vue-jsx": "^5.1.5",
+    "@vue/compiler-sfc": "^3.5.34",
+    "c12": "^4.0.0-beta.4",
+    "cac": "^7.0.0",
     "chokidar": "^5.0.0",
     "consola": "^3.4.2",
     "magic-string": "^0.30.21",
-    "nypm": "^0.6.2",
     "pathe": "^2.0.3",
-    "perfect-debounce": "^2.0.0",
-    "postcss": "^8.5.6",
+    "perfect-debounce": "^2.1.0",
+    "postcss": "^8.5.14",
     "postcss-load-config": "^6.0.1",
-    "sass": "^1.95.1",
-    "vite": "^7.2.7",
-    "vite-plugin-full-reload": "^1.2.0",
-    "vue": "^3.5.25"
+    "sass": "^1.99.0",
+    "strip-literal": "^3.1.0",
+    "vite": "^8.0.10",
+    "vue": "^3.5.34"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^6.6.1",
-    "@types/node": "^24.10.2",
-    "bumpp": "^10.3.2",
-    "eslint": "^9.39.1",
-    "tinyglobby": "^0.2.15",
-    "tsdown": "^0.17.2",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.15"
+    "@antfu/eslint-config": "^8.2.0",
+    "@types/node": "^24.12.2",
+    "bumpp": "^11.0.1",
+    "eslint": "^10.3.0",
+    "eslint-flat-config-utils": "^3.2.0",
+    "tsdown": "^0.21.10",
+    "typescript": "^6.0.3",
+    "unplugin-raw": "^0.7.0",
+    "vitest": "^4.1.5"
   }
 }

package/dist/node-B8aLFfzt.mjs

@@ -1,496 +0,0 @@
-import * as fs from "node:fs";
-import * as fsp from "node:fs/promises";
-import vuePlugin from "@vitejs/plugin-vue";
-import vueJsxPlugin from "@vitejs/plugin-vue-jsx";
-import { consola } from "consola";
-import { colors } from "consola/utils";
-import { basename, dirname, normalize, relative, resolve } from "pathe";
-import { debounce } from "perfect-debounce";
-import { build, createLogger, mergeConfig } from "vite";
-import fullReloadPlugin from "vite-plugin-full-reload";
-import * as vueCompilerSfc from "vue/compiler-sfc";
-import { loadConfig } from "c12";
-import postcssrc from "postcss-load-config";
-import { detectPackageManager } from "nypm";
-import { isIP } from "node:net";
-import { Buffer } from "node:buffer";
-import { promisify } from "node:util";
-import { gzip } from "node:zlib";
-
-//#region package.json
-var name = "kirbyup";
-var version = "4.0.0-alpha.5";
-
-//#endregion
-//#region src/node/config.ts
-function loadConfig$1(cwd = process.cwd()) {
-	return loadConfig({
-		cwd,
-		name: "kirbyup",
-		rcFile: false,
-		packageJson: false
-	});
-}
-async function resolvePostCSSConfig(cwd) {
-	try {
-		return await postcssrc(void 0, void 0, { stopDir: cwd });
-	} catch (error) {
-		if (!error.message.includes("No PostCSS Config found")) throw error;
-	}
-}
-
-//#endregion
-//#region src/node/errors.ts
-var PrettyError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = this.constructor.name;
-		if (typeof Error.captureStackTrace === "function") Error.captureStackTrace(this, this.constructor);
-		else this.stack = new Error(message).stack;
-	}
-};
-function handleError(error) {
-	consola.error(error.message);
-	process.exitCode = 1;
-}
-
-//#endregion
-//#region src/node/plugins/build-cleanup.ts
-function kirbyupBuildCleanupPlugin(options) {
-	let config;
-	let devIndexPath;
-	return {
-		name: "kirbyup:build-cleanup",
-		configResolved(resolvedConfig) {
-			config = resolvedConfig;
-			devIndexPath = resolve(config.root, options.outDir, "index.dev.mjs");
-		},
-		writeBundle() {
-			if (fs.existsSync(devIndexPath)) fs.unlinkSync(devIndexPath);
-		}
-	};
-}
-
-//#endregion
-//#region src/node/utils/server.ts
-function resolveOriginFromServerOptions(serverOptions, port, fallbackHostname) {
-	const protocol = serverOptions?.https && (typeof serverOptions.https === "boolean" || Object.keys(serverOptions.https).length > 0) ? "https" : "http";
-	const configuredHost = normalizeHost(serverOptions?.host);
-	return `${protocol}://${formatHostname(configuredHost || fallbackHostname || "localhost")}${(configuredHost ? hostIncludesPort(configuredHost) : false) || !needsExplicitPort(protocol, port) ? "" : `:${port}`}`;
-}
-function ensureTrailingSlash(url) {
-	return url.endsWith("/") ? url : `${url}/`;
-}
-function normalizeHost(host) {
-	if (host === false || host === void 0) return;
-	if (host === true) return "0.0.0.0";
-	return host;
-}
-function formatHostname(host) {
-	if (!host) return "localhost";
-	if (host.startsWith("[") && host.endsWith("]")) return host;
-	return isIP(host) === 6 ? `[${host}]` : host;
-}
-function hostIncludesPort(host) {
-	if (host.startsWith("[")) {
-		const closingIndex = host.indexOf("]");
-		return closingIndex > -1 && host.slice(closingIndex + 1).startsWith(":");
-	}
-	if (isIP(host) === 6) return false;
-	return host.includes(":");
-}
-function needsExplicitPort(protocol, port) {
-	if (protocol === "http") return port !== 80;
-	return port !== 443;
-}
-
-//#endregion
-//#region src/node/plugins/utils.ts
-/**
-* This code is injected into Vue 3 components to wrap the global HMR runtime.
-*
-* All `.vue` components register themselves with the HMR runtime (`__VUE_HMR_RUNTIME__`),
-* which stores their component definitions in a map. When a module is updated, the runtime
-* applies changes to the stored definition and re-renders component instances.
-*
-* In Vue 3, the HMR map structure is:
-* ```js
-* {
-*   [id]: { initialDef: ComponentDefinition, instances: Set<ComponentInstance> }
-* }
-* ```
-*
-* However, Kirby does not register the exact object exported from a `.vue` file.
-* Instead, it creates a new object and merges the definition in:
-* https://github.com/getkirby/kirby/blob/main/panel/public/js/plugins.js
-*
-* After HMR changes, the runtime updates the stored definition and re-renders instances,
-* but since they are derived from Kirby's modified object (not the stored definition),
-* updates may not apply correctly.
-*
-* To fix this, we wrap `__VUE_HMR_RUNTIME__.rerender()` and `__VUE_HMR_RUNTIME__.reload()`:
-*
-* 1. **Before updates**, we check if the component belongs to a Kirby plugin by matching
-*    the `__hmrId` or `__file` properties against registered plugin components.
-*
-* 2. **If matched**, we look up the actual component definition used by Kirby
-*    (`window.panel.app.config.globalProperties.$root.$options.components`)
-*    and update the HMR map's reference to point to it.
-*
-* 3. **For section components** (detected by `k-*-section` name pattern), we add a
-*    `$_isSection` flag for special treatment in `$_applyKirbyModifications()`.
-*
-* `$_applyKirbyModifications()`:
-*
-* Kirby modifies component definitions before registration:
-* - Adds the section mixin to section components
-* - Gives templates priority over render functions
-* - Resolves component names in `extends` to their definition objects
-*
-* When a module hot reloads, Vue 3 receives a fresh component definition missing
-* these modifications. We re-apply them to ensure the runtime doesn't prune them
-* when patching the stored definition with the updated one.
-*
-* This code uses a singleton pattern (`__KIRBYUP_HMR_WRAPPED__`) to ensure the
-* wrapper is installed only once, even though it's injected into every component.
-*/
-const __HMR_INJECTION_CODE__ = `
-/** - injected by kirbyup for Vue 3 HMR - */
-if (typeof __VUE_HMR_RUNTIME__ !== 'undefined' && !window.__KIRBYUP_HMR_WRAPPED__) {
-  window.__KIRBYUP_HMR_WRAPPED__ = true;
-
-  const originalRerender = __VUE_HMR_RUNTIME__.rerender;
-  const originalReload = __VUE_HMR_RUNTIME__.reload;
-
-  __VUE_HMR_RUNTIME__.rerender = function(id, newRender) {
-    $_syncKirbyComponent(id);
-    return originalRerender.call(this, id, newRender);
-  };
-
-  __VUE_HMR_RUNTIME__.reload = function(id, newComp) {
-    const record = $_getHmrRecord(id);
-    if (record) {
-      $_syncKirbyComponent(id, record.initialDef);
-      $_applyKirbyModifications(record.initialDef, newComp);
-    }
-    return originalReload.call(this, id, newComp);
-  };
-
-  function $_getHmrRecord(id) {
-    // Vue 3's HMR map is not exposed, so we maintain our own parallel map
-    // by wrapping \`createRecord\` to track component definitions
-    if (!window.__KIRBYUP_MAP__) {
-      window.__KIRBYUP_MAP__ = new Map();
-      const originalCreate = __VUE_HMR_RUNTIME__.createRecord;
-      __VUE_HMR_RUNTIME__.createRecord = function(id, initialDef) {
-        window.__KIRBYUP_MAP__.set(id, { initialDef });
-        return originalCreate.call(this, id, initialDef);
-      };
-    }
-    return window.__KIRBYUP_MAP__.get(id);
-  }
-
-  function $_syncKirbyComponent(id, activeDef) {
-    const pluginComponents = window.panel?.plugins?.components;
-    const usedComponentDefs = window.panel?.app?.config?.globalProperties?.$root?.$options?.components;
-
-    if (!pluginComponents || !usedComponentDefs) return;
-
-    const record = $_getHmrRecord(id);
-    if (!record) return;
-
-    for (const componentName in pluginComponents) {
-      const pluginComp = pluginComponents[componentName];
-
-      if (pluginComp.__hmrId === id || pluginComp.__file === record.initialDef?.__file) {
-        const usedDef = usedComponentDefs[componentName];
-
-        if (usedDef && record.initialDef !== usedDef) {
-          record.initialDef = usedDef;
-        }
-
-        if (activeDef && typeof activeDef.$_isSection !== 'boolean') {
-          activeDef.$_isSection = /^k-.*-section$/.test(componentName);
-        }
-
-        break;
-      }
-    }
-  }
-
-  function $_applyKirbyModifications(activeDef, newDef) {
-    const usedComponentDefs = window.panel?.app?.config?.globalProperties?.$root?.$options?.components;
-
-    if (!usedComponentDefs) return;
-
-    // Give templates priority over render functions
-    if (newDef.template) {
-      newDef.render = null;
-    }
-
-    // Re-apply section mixin for section components
-    if (activeDef.$_isSection) {
-      newDef.$_isSection = true;
-      if (!newDef.mixins?.[0]?.methods?.load) {
-        const sectionMixin = activeDef.mixins?.[0];
-        if (sectionMixin) {
-          newDef.mixins = [sectionMixin, ...(newDef.mixins || [])];
-        }
-      }
-    }
-
-    // Resolve component name in extends to definition object
-    if (typeof newDef.extends === 'string') {
-      if (newDef.extends === activeDef.extends?.name) {
-        newDef.extends = activeDef.extends;
-      } else if (usedComponentDefs[newDef.extends]) {
-        newDef.extends = usedComponentDefs[newDef.extends];
-      } else {
-        newDef.extends = null;
-      }
-    }
-  }
-}
-/** -- */
-`;
-
-//#endregion
-//#region src/node/plugins/hmr.ts
-function kirbyupHmrPlugin(options) {
-	let config;
-	let entry;
-	let devIndexPath;
-	return {
-		name: "kirbyup:hmr",
-		apply: "serve",
-		configResolved(resolvedConfig) {
-			config = resolvedConfig;
-			entry = resolve(config.root, options.entry);
-			devIndexPath = resolve(config.root, options.outDir ?? "", "index.dev.mjs");
-		},
-		transform(code, id) {
-			if (!id.endsWith(".vue")) return;
-			if (!code.includes("__VUE_HMR_RUNTIME__.createRecord")) return;
-			const injectionPoint = code.indexOf("import.meta.hot.accept");
-			if (injectionPoint === -1) return;
-			return {
-				code: `${code.slice(0, injectionPoint) + __HMR_INJECTION_CODE__}\n${code.slice(injectionPoint)}`,
-				map: null
-			};
-		},
-		configureServer(server) {
-			if (!server.httpServer) return;
-			server.httpServer.once("listening", async () => {
-				const entryPath = entry.replace(`${config.root}/`, "");
-				const baseUrl = getDevBaseUrl(server, config);
-				const entryUrl = new URL(entryPath, baseUrl).href;
-				const pm = await detectPackageManager(config.root);
-				await fsp.writeFile(devIndexPath, getViteProxyModule(entryUrl, pm));
-			});
-		},
-		async closeBundle() {
-			await fsp.rm(devIndexPath, { force: true });
-		}
-	};
-}
-/**
-* Proxy the JS file to "forward" the plugin script loaded by Kirby to the Vite server
-*/
-function getViteProxyModule(entryUrl, packageManager) {
-	const pm = packageManager?.name || "npm";
-	return `
-try {
-  await import("${entryUrl}");
-} catch (error) {
-  console.error(
-    "[kirbyup] Couldn't connect to the development server at ${entryUrl}. Run \`${pm} run serve\` to start Vite or build the plugin with \`${pm} run build\` so Kirby uses the production version."
-  );
-  throw error;
-}
-`.trimStart();
-}
-function getDevBaseUrl(server, config) {
-	const { address, port } = server.httpServer.address();
-	const normalizedOrigin = ensureTrailingSlash(config.server?.origin ?? server.resolvedUrls?.local?.[0] ?? server.resolvedUrls?.network?.[0] ?? resolveOriginFromServerOptions(config.server, port, address));
-	const base = config.base ?? "/";
-	return new URL(base, normalizedOrigin).href;
-}
-
-//#endregion
-//#region src/node/utils.ts
-const compress = promisify(gzip);
-function toArray(array) {
-	array ??= [];
-	return Array.isArray(array) ? array : [array];
-}
-async function getCompressedSize(code) {
-	return ` / gzip: ${((await compress(typeof code === "string" ? code : Buffer.from(code))).length / 1024).toFixed(2)} KiB`;
-}
-async function printFileInfo({ root, outDir, filePath, content, type, maxLength }) {
-	const prettyOutDir = `${normalize(relative(root, resolve(root, outDir)))}/`;
-	const kibs = content.length / 1024;
-	const compressedSize = await getCompressedSize(content);
-	const writeColor = type === "chunk" ? colors.cyan : colors.magenta;
-	consola.log(colors.white(colors.dim(prettyOutDir)) + writeColor(filePath.padEnd(maxLength + 2)) + colors.dim(`${kibs.toFixed(2)} kB${compressedSize}`));
-}
-
-//#endregion
-//#region src/node/index.ts
-const DEV_OUTPUT_FILENAME = "index.dev.js";
-let resolvedKirbyupConfig;
-let resolvedPostCssConfig;
-const logLevel = "warn";
-const logger = createLogger(logLevel);
-const loggerWarn = logger.warn;
-logger.warn = (msg, options) => {
-	if (msg.includes("(!) build.outDir")) return;
-	loggerWarn(msg, options);
-};
-function getViteConfig(command, options) {
-	const aliasDir = resolve(options.cwd, dirname(options.entry));
-	const { alias = {}, vite } = resolvedKirbyupConfig;
-	const userConfig = vite ?? {};
-	const sharedConfig = {
-		resolve: { alias: {
-			"~/": `${aliasDir}/`,
-			"@/": `${aliasDir}/`,
-			...alias
-		} },
-		plugins: [vuePlugin({ compiler: vueCompilerSfc }), vueJsxPlugin()],
-		build: { copyPublicDir: false },
-		...resolvedPostCssConfig && { css: { postcss: resolvedPostCssConfig } },
-		envDir: options.cwd,
-		envPrefix: ["VITE_", "KIRBYUP_"],
-		customLogger: logger,
-		logLevel
-	};
-	if (command === "serve") {
-		const { port, watch } = options;
-		const inferredOrigin = userConfig.server?.origin ?? resolveOriginFromServerOptions(userConfig.server, port, "localhost");
-		return mergeConfig(mergeConfig(sharedConfig, {
-			plugins: [kirbyupHmrPlugin(options), watch && fullReloadPlugin(watch)].filter(Boolean),
-			build: { rollupOptions: { input: resolve(options.cwd, options.entry) } },
-			server: {
-				port,
-				strictPort: true,
-				origin: inferredOrigin
-			}
-		}), userConfig);
-	}
-	const mode = options.watch ? "development" : "production";
-	return mergeConfig(mergeConfig(sharedConfig, {
-		mode,
-		plugins: [kirbyupBuildCleanupPlugin(options)],
-		build: {
-			lib: {
-				entry: resolve(options.cwd, options.entry),
-				formats: ["es"],
-				fileName: () => options.watch ? DEV_OUTPUT_FILENAME : "index.js"
-			},
-			minify: mode === "production",
-			outDir: options.outDir,
-			emptyOutDir: false,
-			rollupOptions: {
-				external: ["vue"],
-				output: { assetFileNames: "index.[ext]" }
-			}
-		}
-	}), userConfig);
-}
-async function generate(options) {
-	const config = getViteConfig("build", options);
-	let result;
-	try {
-		result = await build(config);
-	} catch (error) {
-		if (config.mode === "production") throw error;
-		else consola.error(error);
-	}
-	if (result && !options.watch) {
-		const { output } = toArray(result)[0];
-		let maxLength = 0;
-		for (const chunkFile in output) {
-			const fileNameLength = output[chunkFile].fileName.length;
-			if (fileNameLength > maxLength) maxLength = fileNameLength;
-		}
-		for (const { fileName, type, code } of output) {
-			const content = code || await fsp.readFile(resolve(options.outDir, fileName), "utf8");
-			await printFileInfo({
-				root: options.cwd,
-				outDir: options.outDir,
-				filePath: fileName,
-				content,
-				type,
-				maxLength
-			});
-		}
-	}
-	return result;
-}
-async function build$1(options) {
-	assertEntryExists(options);
-	const { cwd } = options;
-	const { config, configFile } = await loadConfig$1(cwd);
-	resolvedKirbyupConfig = config ?? {};
-	resolvedPostCssConfig = await resolvePostCSSConfig(cwd);
-	consola.log(colors.green(`${name} v${version}`));
-	consola.start(`Building ${colors.cyan(options.entry)}`);
-	if (options.watch) consola.info("Running in watch mode");
-	await generate(options);
-	consola.success("Build successful");
-	if (!options.watch) return;
-	const { watch } = await import("chokidar");
-	const debouncedBuild = debounce(async () => {
-		generate(options).catch(handleError);
-	}, 100);
-	const ignored = [
-		"**/{.git,node_modules}/**",
-		"index.{css,js}",
-		DEV_OUTPUT_FILENAME
-	];
-	const watchPaths = typeof options.watch === "boolean" ? dirname(options.entry) : Array.isArray(options.watch) ? options.watch.filter((path) => typeof path === "string") : options.watch;
-	consola.info(`Watching for changes in ${toArray(watchPaths).map((i) => colors.cyan(i)).join(", ")}`);
-	const watcher = watch(watchPaths, {
-		ignoreInitial: true,
-		ignorePermissionErrors: true,
-		ignored,
-		cwd
-	});
-	const devOutputPath = resolve(options.outDir, DEV_OUTPUT_FILENAME);
-	const cleanup = async () => {
-		await watcher.close().catch(() => {});
-		await fsp.rm(devOutputPath, { force: true }).catch(() => {});
-	};
-	process.once("exit", () => {
-		try {
-			fs.rmSync(devOutputPath, { force: true });
-		} catch {}
-	});
-	const onShutdown = () => void cleanup().finally(() => process.exit(0));
-	process.once("SIGINT", onShutdown);
-	process.once("SIGTERM", onShutdown);
-	if (configFile) watcher.add(configFile);
-	watcher.on("all", async (type, file) => {
-		if (configFile === resolve(cwd, file)) {
-			resolvedKirbyupConfig = (await loadConfig$1(cwd)).config ?? {};
-			consola.info(`${colors.cyan(basename(file))} changed, setting new config`);
-		} else consola.log(`${colors.green(type)} ${colors.white(colors.dim(file))}`);
-		debouncedBuild();
-	});
-}
-async function serve(options) {
-	assertEntryExists(options);
-	const { cwd } = options;
-	const { config } = await loadConfig$1(cwd);
-	resolvedKirbyupConfig = config ?? {};
-	resolvedPostCssConfig = await resolvePostCSSConfig(cwd);
-	consola.log(colors.green(`${name} v${version}`));
-	consola.info(`Development server unavailable. Use watch mode for now: ${colors.cyan(`kirbyup build ${options.entry} --watch`)}`);
-	throw new PrettyError("HMR is not yet implemented for Kirby 6 plugins. Please use watch mode instead.");
-}
-function assertEntryExists(options) {
-	if (!fs.existsSync(resolve(options.cwd, options.entry))) throw new PrettyError(`Cannot find "${options.entry}"`);
-}
-
-//#endregion
-export { version as a, name as i, serve as n, handleError as r, build$1 as t };