kirbyup 4.0.0-alpha.3 → 4.0.0-alpha.5

package/dist/node/cli.mjs

@@ -1,4 +1,4 @@
-import { a as version, i as name, n as serve, r as handleError, t as build } from "../node-DxNmVk8V.mjs";
+import { a as version, i as name, n as serve, r as handleError, t as build } from "../node-B8aLFfzt.mjs";
 import { cac } from "cac";
 
 //#region src/node/cli-start.ts

package/dist/node/index.mjs

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

package/dist/node-B8aLFfzt.mjs

@@ -0,0 +1,496 @@
+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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kirbyup",
   "type": "module",
-  "version": "4.0.0-alpha.3",
+  "version": "4.0.0-alpha.5",
   "packageManager": "pnpm@10.25.0",
   "description": "Zero-config bundler for Kirby Panel plugins",
   "author": {
@@ -84,7 +84,6 @@
     "perfect-debounce": "^2.0.0",
     "postcss": "^8.5.6",
     "postcss-load-config": "^6.0.1",
-    "rollup-plugin-external-globals": "^0.13.0",
     "sass": "^1.95.1",
     "vite": "^7.2.7",
     "vite-plugin-full-reload": "^1.2.0",

package/dist/node-DxNmVk8V.mjs

@@ -1,491 +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 { 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.3";
-
-//#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/plugins/utils.ts
-const HMR_RUNTIME_ID = "\0plugin-vue2:hmr-runtime";
-const JSX_HMR_RUNTIME_ID = "plugin-vue2-jsx:hmr-runtime";
-function isHmrRuntimeId(id) {
-	return id === HMR_RUNTIME_ID || id === JSX_HMR_RUNTIME_ID;
-}
-/**
-* This code is injected into the HMR runtime of plugin-vue2(-jsx).
-*
-* All `.vue` components register themselves once with the HMR runtime, so their exported
-* component definitions can be stored in a map, alongside the rendered component instances
-* that are based off this definition. When a module is updated, the runtime applies all
-* changes from the updated module to the stored definition, then re-renders the instances.
-*
-* ```js
-* {
-*   [id]: { options: ComponentDefinition, instances: [...] }
-* }
-* ```
-*
-* However, in some cases (sections and blocks) Kirby does not actually register the
-* object that is exported from a `.vue` file (and stored as definition) as component,
-* instead it creates a new object and merges the definition from the `.vue` file in:
-* https://github.com/getkirby/kirby/blob/main/panel/public/js/plugins.js#L22-L25
-* After changes, the runtime updates the definition and re-renders the instances, but since
-* they are derived from the object created by Kirby, not the stored definition, nothing happens.
-* To fix that, we wrap `rerender()` and `reload()` so that before applying the updates, we first check
-* if the updated definition belongs to a component added by a Kirby plugin. To do so, we can check
-* whether the `__file` (added by plugin-vue2) or `__hmrId` (added by plugin-vue2-jsx) properties of the
-* updated module and the plugin component match. If so, we look up the component definition that is
-* _actually_ used by component instances rendered on the page (`window.panel.app.$options.components`)
-* and if it differs from the one stored in the HMR runtime's map, we updates the map's reference.
-*
-* We also check the component name and add a `$_isSection` flag if it's `k-something-section`, because
-* section components are hard to detect and need special treatment in `$_applyKirbyModifications`.
-*
-* `$_applyKirbyModifications`:
-*
-* Kirby modifies component definitions before registering components.
-* This includes adding the section mixin to section components,
-* giving templates priority over render functions if both exist
-* and resolving component names in `extends` to their definition object:
-* https://github.com/getkirby/kirby/blob/2965c3124e3b141072a2d46c798a327dda710060/panel/src/panel/plugins.js
-* When a module is reloaded, Vue receives a fresh component definition that is
-* missing these modifications. We need to re-apply them, else the runtime will
-* prune them when patching the stored definition to match the newer one.
-*
-* The call to `$_applyKirbyModifications()` is injected into `__VUE_HMR_RUNTIME__.reload()`
-* at the appropriate position using a RegExp in the Vite plugin's transform method.
-*/
-const __INJECTED_HMR_CODE__ = `
-/** - injected by kirbyup - */
-for (const methodName of ['rerender', 'reload']) {
-  const original = __VUE_HMR_RUNTIME__[methodName]
-
-  __VUE_HMR_RUNTIME__[methodName] = function (id, updatedDef) {
-    const key = updatedDef?.__file ? '__file' : updatedDef?.__hmrId ? '__hmrId' : null
-
-    if (key) {
-      const pluginComponents = window.panel.plugins.components
-      // const usedComponentDefs = window.panel.app.$options.components
-      const usedComponentDefs = window.panel.app._vnode.componentInstance.$options.components // #33
-
-      for (const componentName in pluginComponents) {
-        if (updatedDef[key] === pluginComponents[componentName][key]) {
-          const usedDefinition = usedComponentDefs[componentName].options
-
-          if (map[id].options !== usedDefinition)
-            map[id].options = usedDefinition
-
-          if (typeof map[id].options.$_isSection !== 'boolean')
-            map[id].options.$_isSection = /^k-.*-section$/.test(componentName)
-
-          break
-        }
-      }
-    }
-
-    return original.apply(this, arguments)
-  }
-}
-
-function $_applyKirbyModifications(activeDef, newDef) {
-  const usedComponentDefs = window.panel.app.$options.components
-
-  if (newDef.template)
-    newDef.render = null
-
-  if (activeDef.$_isSection)
-    newDef.$_isSection = true
-  if (newDef.$_isSection && !newDef.mixins?.[0]?.methods?.load)
-    newDef.mixins = [activeDef.mixins[0], ...(newDef.mixins || [])]
-
-  if (typeof newDef.extends === 'string') {
-    if (newDef.extends === activeDef.extends?.options?.name) {
-      newDef.extends = activeDef.extends
-    }
-    else if (usedComponentDefs[newDef.extends]) {
-      newDef.extends = usedComponentDefs[newDef.extends].extend({
-        options: newDef,
-        components: { ...usedComponentDefs, ...(newDef.components || {}) },
-      })
-    }
-    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 (isHmrRuntimeId(id)) return code.replace(/^.*=\s*record\.Ctor\.super\.extend\(options\)/m, "$_applyKirbyModifications(record.Ctor.options, options) // injected by kirbyup\n$&") + __INJECTED_HMR_CODE__;
-		},
-		configureServer(server) {
-			if (!server.httpServer) return;
-			server.httpServer.once("listening", async () => {
-				const entryPath = entry.replace(`${config.root}/`, "");
-				const { address, family, port } = server.httpServer.address();
-				const baseUrl = `http://${family === "IPv6" ? `[${address}]` : address}:${port}${config.base}`;
-				const entryUrl = new URL(entryPath, baseUrl).href;
-				const pm = await detectPackageManager(config.root);
-				await fsp.writeFile(devIndexPath, getViteProxyModule(entryUrl, pm));
-			});
-		},
-		closeBundle() {
-			if (fs.existsSync(devIndexPath)) fs.unlinkSync(devIndexPath);
-		}
-	};
-}
-/**
-* 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 (err) {
-  console.error(
-    "[kirbyup] Couldn't connect to the development server. Run \`${pm} run serve\` to start Vite or build the plugin with \`${pm} run build\` so Kirby uses the production version."
-  );
-  throw err;
-}
-`.trimStart();
-}
-
-//#endregion
-//#region src/node/plugins/vite-running.ts
-const VITE_RUNNING_FILENAME = ".vite-running";
-function kirbyupRunningMarkerPlugin(options = {}) {
-	let config;
-	let pluginDir;
-	let markerPath;
-	let exitCleanupRegistered = false;
-	const ensureMarker = async () => {
-		if (markerPath) return;
-		try {
-			const resolvedPath = await ensureViteRunningMarker(pluginDir);
-			if (resolvedPath) markerPath = resolvedPath;
-		} catch (error) {
-			config.logger.warn(`[kirbyup] Failed to write ${VITE_RUNNING_FILENAME}: ${error.message}`);
-		}
-	};
-	const cleanupMarker = async () => {
-		if (!markerPath) return;
-		try {
-			await removeViteRunningMarker(markerPath);
-		} catch (error) {
-			config.logger.warn(`[kirbyup] Failed to remove ${VITE_RUNNING_FILENAME}: ${error.message}`);
-		} finally {
-			markerPath = void 0;
-		}
-	};
-	const registerProcessCleanup = () => {
-		if (exitCleanupRegistered) return;
-		exitCleanupRegistered = true;
-		process.once("exit", () => {
-			if (markerPath && fs.existsSync(markerPath)) try {
-				fs.rmSync(markerPath, { force: true });
-			} catch {}
-		});
-	};
-	return {
-		name: "kirbyup:vite-running",
-		configResolved(resolved) {
-			config = resolved;
-			pluginDir = resolve(resolved.root, options.outDir || "");
-			registerProcessCleanup();
-		},
-		configureServer(server) {
-			server.httpServer?.once("listening", () => ensureMarker());
-			server.httpServer?.once("close", () => cleanupMarker());
-		},
-		buildStart() {
-			if (config.command !== "build" || !config.build.watch) return;
-			ensureMarker();
-		}
-	};
-}
-/**
-* Creates the `.vite-running` marker file if the directory is inside `site/plugins/`.
-* Returns `undefined` if the directory is not a Kirby plugin directory.
-*/
-async function ensureViteRunningMarker(targetDir) {
-	if (!isInsideKirbyPlugins(targetDir)) return;
-	const markerPath = resolve(targetDir, VITE_RUNNING_FILENAME);
-	await fsp.writeFile(markerPath, "", "utf8");
-	return markerPath;
-}
-/**
-* Removes the `.vite-running` marker file.
-*/
-async function removeViteRunningMarker(markerPath) {
-	if (!markerPath) return;
-	await fsp.rm(markerPath, { force: true });
-}
-/**
-* Checks if a directory is inside a Kirby plugin directory (`site/plugins/*`).
-* This is used to determine whether to create the `.vite-running` marker file,
-* which Kirby 6+ uses to detect development mode and load the development
-* build of Vue instead of the production build.
-*/
-function isInsideKirbyPlugins(targetDir) {
-	const initialDir = normalize(targetDir);
-	let currentDir = initialDir;
-	while (true) {
-		const parentDir = dirname(currentDir);
-		if (currentDir !== initialDir && isPathSegmentEqual(basename(currentDir), "plugins") && isPathSegmentEqual(basename(parentDir), "site")) return true;
-		if (currentDir === parentDir) return false;
-		currentDir = parentDir;
-	}
-}
-/**
-* Performs case-insensitive comparison of path segments.
-*/
-function isPathSegmentEqual(segment, expected) {
-	return segment.toLowerCase() === expected;
-}
-
-//#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
-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;
-		return mergeConfig(mergeConfig(sharedConfig, {
-			plugins: [
-				kirbyupHmrPlugin(options),
-				kirbyupRunningMarkerPlugin({ outDir: options.outDir }),
-				watch && fullReloadPlugin(watch)
-			].filter(Boolean),
-			build: { rollupOptions: { input: resolve(options.cwd, options.entry) } },
-			server: {
-				port,
-				strictPort: true,
-				origin: `http://localhost:${port}`
-			}
-		}), 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: () => "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) {
-		consola.error("Build failed");
-		if (config.mode === "production") throw 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");
-	const debouncedBuild = debounce(async () => {
-		generate(options).catch(handleError);
-	}, 100);
-	const startWatcher = async () => {
-		if (!options.watch) return;
-		const { watch } = await import("chokidar");
-		const ignored = ["**/{.git,node_modules}/**", "index.{css,js,mjs}"];
-		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
-		});
-		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();
-		});
-	};
-	await generate(options);
-	consola.success("Build successful");
-	startWatcher();
-}
-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 };