kirbyup 4.0.0-alpha.8 → 4.0.0-alpha.9

package/README.md

@@ -18,13 +18,13 @@ The official bundler for Kirby Panel plugins. Zero-config, built-in HMR.
 
 ## 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.
+- **Node.js 24 or newer** with pnpm, npm or yarn.
+- **Kirby 6 or newer.** kirbyup 4 builds for the Vue 3 Panel. Plugins for Kirby 4 and 5 stay on kirbyup 3.x, documented at the [last 3.x release](https://github.com/johannschopplich/kirbyup/tree/v3.5.0/docs). Upgrading? Read the [migration guide](https://kirbyup.getkirby.com/guide/migration).
 
 ## Setup
 
 > [!TIP]
-> Skip starting from scratch and pick one of the following starters:
+> Skip the setup with one of the starters:
 > - [`eslint`](./examples/eslint)
 > - [`unocss`](./examples/unocss)
 
@@ -39,16 +39,16 @@ npm i -D kirbyup
 yarn add -D kirbyup
 ```
 
-After installation, add these scripts to your `package.json`:
+Add the two scripts to `package.json`:
 
 ```json
 {
   "scripts": {
-    "dev": "kirbyup serve src/index.js",
+    "dev": "kirbyup dev src/index.js",
     "build": "kirbyup src/index.js"
   },
   "devDependencies": {
-    "kirbyup": "^4.0.0-alpha.6"
+    "kirbyup": "^4.0.0"
   }
 }
 ```

package/bin/kirbyup.mjs

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
-'use strict'
-import('../dist/node/cli.mjs')
+import('../dist/node/entry.mjs')

package/dist/client/config.d.mts

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

package/dist/client/plugin.mjs

@@ -1,8 +1,7 @@
 //#region src/client/plugin.ts
 const kirbyup = Object.freeze({ 
 /**
-* Auto-import Kirby Panel components, transformed by
-* kirbyup's glob-import plugin for Vite.
+* Auto-imports the Kirby Panel components matching a glob.
 *
 * @example
 * kirbyup.import('./components/blocks/*.vue')

package/dist/node/entry.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/node/entry.mjs

@@ -0,0 +1,400 @@
+import { a as version, c as reportFailure, i as name, l as log_exports, n as serve, o as ArgumentError, r as description, s as CliError, t as build, u as paint } from "../node-noo8EBlY.mjs";
+import { parseArgs, stripVTControlCharacters } from "node:util";
+import process from "node:process";
+//#region node_modules/.pnpm/utilful@3.3.0_vitest@4.1.11_@types+node@26.4.0_vite@8.2.2_@types+node@26.4.0_jiti@2.7.0_sass@1.103.1_yaml@2.9.0__/node_modules/utilful/dist/cli/args.mjs
+const commonArgs = { verbose: {
+	type: "boolean",
+	description: "Print the cause chain and stack trace on failure"
+} };
+/** Parses `argv` against a definition. An absent boolean reads as `false`, and `--no-<name>` turns one off. */
+function parseArgs$1(argv, argsDef, { allowExtraPositionals = false } = {}) {
+	let parseResult;
+	try {
+		parseResult = parseArgs({
+			args: joinNegativeValues(splitShortOptionValues(argv), argsDef),
+			options: toNodeOptions(argsDef),
+			strict: true,
+			allowPositionals: true,
+			allowNegative: true
+		});
+	} catch (error) {
+		if (isNodeArgumentError(error)) throw new ArgumentError(error.message.split(". ")[0]);
+		throw error;
+	}
+	const args = { _: parseResult.positionals };
+	const positionalNames = [];
+	for (const [name, definition] of Object.entries(argsDef)) {
+		if (definition.type === "positional") {
+			positionalNames.push(name);
+			continue;
+		}
+		const value = parseResult.values[name];
+		if (definition.type === "boolean") args[name] = value ?? false;
+		else if (value === void 0 && definition.required === true) throw new ArgumentError(`Missing required argument: --${name}`);
+		else args[name] = value;
+	}
+	positionalNames.forEach((name, index) => {
+		const definition = argsDef[name];
+		const value = parseResult.positionals[index];
+		if (value === void 0 && definition.required === true) throw new ArgumentError(`Missing required positional argument: ${name.toUpperCase()}`);
+		args[name] = value;
+	});
+	if (!allowExtraPositionals && parseResult.positionals.length > positionalNames.length) throw new ArgumentError(`Unexpected argument: ${JSON.stringify(parseResult.positionals[positionalNames.length])}`);
+	return args;
+}
+function toNodeOptions(argsDef) {
+	const options = {};
+	for (const [name, definition] of Object.entries(argsDef)) {
+		if (definition.type === "positional") continue;
+		const option = { type: definition.type };
+		if (definition.alias !== void 0) option.short = definition.alias;
+		if (definition.default !== void 0) option.default = definition.default;
+		options[name] = option;
+	}
+	return options;
+}
+/**
+* Splits an inline value off a short option. Node's `parseArgs` splits
+* `--name=value` but leaves `-n=value` whole, so `-o=report.json` would write to
+* a file named `=report.json`. Past `--` every token is an operand and stays as
+* it was written.
+*/
+function splitShortOptionValues(argv) {
+	const splitArguments = [];
+	let isTerminated = false;
+	for (const argument of argv) {
+		const match = /^(-[^-])=(.*)$/.exec(argument);
+		if (isTerminated || match === null) {
+			splitArguments.push(argument);
+			isTerminated ||= argument === "--";
+			continue;
+		}
+		splitArguments.push(match[1], match[2]);
+	}
+	return splitArguments;
+}
+/**
+* Joins a negative number onto the value-taking option before it, as
+* `--start=-3`. Node refuses `--start -3` as ambiguous, but a token that starts
+* with a digit after its dash is a number wherever a value is due.
+*/
+function joinNegativeValues(argv, argsDef) {
+	const optionNamesBySpelling = /* @__PURE__ */ new Map();
+	for (const [name, definition] of Object.entries(argsDef)) {
+		if (definition.type !== "string") continue;
+		optionNamesBySpelling.set(`--${name}`, name);
+		if (definition.alias !== void 0) optionNamesBySpelling.set(`-${definition.alias}`, name);
+	}
+	const joinedArguments = [];
+	for (let index = 0; index < argv.length; index++) {
+		const argument = argv[index];
+		const next = argv[index + 1];
+		const name = optionNamesBySpelling.get(argument);
+		if (argument === "--") {
+			joinedArguments.push(...argv.slice(index));
+			break;
+		}
+		if (name !== void 0 && next !== void 0 && /^-\d/.test(next)) {
+			joinedArguments.push(`--${name}=${next}`);
+			index++;
+			continue;
+		}
+		joinedArguments.push(argument);
+	}
+	return joinedArguments;
+}
+function isNodeArgumentError(error) {
+	return error instanceof Error && String(error.code).startsWith("ERR_PARSE_ARGS");
+}
+//#endregion
+//#region node_modules/.pnpm/utilful@3.3.0_vitest@4.1.11_@types+node@26.4.0_vite@8.2.2_@types+node@26.4.0_jiti@2.7.0_sass@1.103.1_yaml@2.9.0__/node_modules/utilful/dist/cli/usage.mjs
+function renderUsage(command, { parent, stream = process.stdout } = {}) {
+	const color = (style, text) => paint(style, text, stream);
+	const heading = (title) => color("bold", title);
+	const meta = command.meta ?? {};
+	const parentMeta = parent?.meta ?? {};
+	const commandName = [parentMeta.name, meta.name].filter((name) => name !== void 0).join(" ");
+	const version = meta.version ?? parentMeta.version;
+	const positionalLines = [];
+	const optionLines = [];
+	const commandLines = [];
+	const usageLine = [];
+	for (const [name, definition] of Object.entries(command.args ?? {})) {
+		const isRequired = definition.type !== "boolean" && definition.required === true;
+		const hasDefault = definition.type !== "positional" && definition.default !== void 0 && definition.default !== false;
+		const hints = [
+			definition.description,
+			isRequired ? color("gray", "(Required)") : void 0,
+			hasDefault ? color("gray", `(Default: ${definition.default})`) : void 0
+		].filter((hint) => hint !== void 0).join(" ");
+		if (definition.type === "positional") {
+			const label = name.toUpperCase();
+			positionalLines.push([color("cyan", label), hints]);
+			usageLine.push(isRequired ? `<${label}>` : `[${label}]`);
+			continue;
+		}
+		const spellings = [definition.alias === void 0 ? void 0 : `-${definition.alias}`, `--${name}`].filter((spelling) => spelling !== void 0).join(", ");
+		const value = definition.type === "string" ? `<${definition.valueHint ?? name}>` : void 0;
+		optionLines.push([color("cyan", spellings) + (value === void 0 ? "" : color("dim", `=${value}`)), hints]);
+		if (definition.type === "boolean" && definition.default === true) optionLines.push([color("cyan", `--no-${name}`), ""]);
+		if (isRequired) usageLine.push(`--${name}=${value}`);
+	}
+	for (const [name, subCommand] of Object.entries(command.subCommands ?? {})) commandLines.push([color("cyan", name), subCommand.meta?.description ?? ""]);
+	const hasArguments = positionalLines.length > 0 || optionLines.length > 0;
+	if (commandLines.length > 0 && !hasArguments) usageLine.push(Object.keys(command.subCommands).join("|"));
+	const lines = [
+		color("bold", version === void 0 ? commandName : `${commandName} v${version}`),
+		...meta.description === void 0 ? [] : [meta.description],
+		"",
+		`${heading("USAGE")}  ${color("cyan", [
+			commandName,
+			hasArguments ? "[OPTIONS]" : void 0,
+			...usageLine
+		].filter((part) => part !== void 0).join(" "))}`,
+		""
+	];
+	for (const [title, rows] of [
+		["ARGUMENTS", positionalLines],
+		["OPTIONS", optionLines],
+		["COMMANDS", commandLines]
+	]) if (rows.length > 0) lines.push(heading(title), "", formatColumns(rows), "");
+	if (commandLines.length > 0) lines.push(`Use ${color("cyan", `${commandName} <command> --help`)} for more information about a command.`);
+	return lines.join("\n").trimEnd();
+}
+function formatColumns(rows) {
+	const widths = rows[0].map((_, column) => Math.max(...rows.map((row) => visibleLength(row[column]))));
+	return rows.map((row) => row.map((cell, column) => `  ${cell}${" ".repeat(widths[column] - visibleLength(cell))}`).join("").trimEnd()).join("\n");
+}
+function visibleLength(text) {
+	return stripVTControlCharacters(text).length;
+}
+//#endregion
+//#region node_modules/.pnpm/utilful@3.3.0_vitest@4.1.11_@types+node@26.4.0_vite@8.2.2_@types+node@26.4.0_jiti@2.7.0_sass@1.103.1_yaml@2.9.0__/node_modules/utilful/dist/cli/command.mjs
+const HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
+const VERSION_FLAGS = /* @__PURE__ */ new Set(["--version", "-v"]);
+function defineCommand(command) {
+	return command;
+}
+/**
+* Runs the command tree and reports whatever it throws. Help someone asked for
+* is the result of the run and goes to stdout; usage that follows a wrong
+* argument is diagnostics and joins its message on stderr.
+*/
+async function runMain(command, options = {}) {
+	const argv = options.argv ?? process.argv.slice(2);
+	const beforeTerminator = argv.slice(0, argv.includes("--") ? argv.indexOf("--") : void 0);
+	const hasFlag = (flags) => beforeTerminator.some((argument) => flags.has(argument));
+	try {
+		if (hasFlag(HELP_FLAGS)) process.stdout.write(`${usageFor(command, argv, process.stdout)}\n`);
+		else if (hasFlag(VERSION_FLAGS)) process.stdout.write(`${command.meta?.version ?? ""}\n`);
+		else await runCommand(command, argv);
+	} catch (error) {
+		if (error instanceof ArgumentError) process.stderr.write(`${usageFor(command, argv, process.stderr)}\n\n`);
+		const verbose = !(error instanceof ArgumentError) && beforeTerminator.includes("--verbose");
+		reportFailure(error, {
+			...options,
+			verbose
+		});
+	}
+}
+/** Runs like `runMain`, but without the error boundary. */
+async function runCommand(command, argv) {
+	const { name, firstOperand, rest } = findSubCommand(command, argv);
+	if (name !== void 0) return runCommand(command.subCommands[name], rest);
+	if (command.subCommands !== void 0 && command.run === void 0) throw new ArgumentError(firstOperand === void 0 ? "Missing command" : `Unknown command: ${firstOperand}`);
+	const args = parseArgs$1(rest, command.args ?? {}, { allowExtraPositionals: command.allowExtraPositionals });
+	await command.run?.({ args });
+}
+function usageFor(command, argv, stream) {
+	const { name } = findSubCommand(command, argv);
+	return name === void 0 ? renderUsage(command, { stream }) : renderUsage(command.subCommands[name], {
+		parent: command,
+		stream
+	});
+}
+/**
+* Finds the sub-command the first operand names, wherever it stands among the
+* options. Telling an operand from the value of an option needs every
+* value-taking option of every sub-command, since the command is still unknown.
+*/
+function findSubCommand(command, argv) {
+	if (command.subCommands === void 0) return { rest: [...argv] };
+	const options = Object.assign(toNodeOptions(command.args ?? {}), ...Object.values(command.subCommands).map((subCommand) => toNodeOptions(subCommand.args ?? {})));
+	const { tokens } = parseArgs({
+		args: [...argv],
+		options,
+		strict: false,
+		allowPositionals: true,
+		tokens: true
+	});
+	const firstOperand = tokens.find((token) => token.kind === "positional" || token.kind === "option-terminator");
+	if (firstOperand?.kind !== "positional") return { rest: [...argv] };
+	if (Object.hasOwn(command.subCommands, firstOperand.value)) return {
+		name: firstOperand.value,
+		rest: argv.toSpliced(firstOperand.index, 1)
+	};
+	return {
+		firstOperand: firstOperand.value,
+		rest: [...argv]
+	};
+}
+//#endregion
+//#region src/node/commands/watch-paths.ts
+const GLOB_CHARACTERS = /[*?[\]{}]/;
+/**
+* Splits a comma-separated `--watch-path` value.
+*
+* `build` hands its paths to chokidar, which has expanded no globs since v4, so
+* a pattern there would watch nothing at all – it is rejected rather than
+* silently ignored. `serve` matches through Vite's own watcher, where globs work.
+*/
+function resolveWatchPaths(value, { allowGlobs }) {
+	const paths = (value ?? "").split(",").map((path) => path.trim()).filter((path) => path !== "");
+	if (!allowGlobs) {
+		const pattern = paths.find((path) => GLOB_CHARACTERS.test(path));
+		if (pattern !== void 0) throw new CliError(`--watch-path takes files and folders, not patterns: ${pattern}\nName the folder instead – it is watched recursively.`);
+	}
+	return paths;
+}
+//#endregion
+//#region src/node/commands/build.ts
+const buildArgs = {
+	...commonArgs,
+	"file": {
+		type: "positional",
+		description: "Entry file of the plugin",
+		required: true
+	},
+	"out-dir": {
+		type: "string",
+		alias: "d",
+		description: "Output directory",
+		valueHint: "dir"
+	},
+	"watch": {
+		type: "boolean",
+		alias: "w",
+		description: "Rebuild when the folder of the entry file changes"
+	},
+	"watch-path": {
+		type: "string",
+		description: "Comma-separated files and folders to watch instead",
+		valueHint: "paths"
+	}
+};
+const buildCommand = defineCommand({
+	meta: {
+		name: "build",
+		description: "Compile the Kirby Panel plugin to index.js and index.css"
+	},
+	args: buildArgs,
+	async run({ args }) {
+		const cwd = process.cwd();
+		const paths = resolveWatchPaths(args["watch-path"], { allowGlobs: false });
+		const watch = paths.length > 0 ? paths : args.watch;
+		process.env.NODE_ENV ||= watch === false ? "production" : "development";
+		await build({
+			cwd,
+			entry: args.file,
+			outDir: args["out-dir"] ?? cwd,
+			watch
+		});
+	}
+});
+//#endregion
+//#region src/node/commands/dev.ts
+const DEFAULT_PORT = 5177;
+const DEFAULT_WATCH = "./**/*.php";
+const devArgs = {
+	...commonArgs,
+	"file": {
+		type: "positional",
+		description: "Entry file of the plugin",
+		required: true
+	},
+	"out-dir": {
+		type: "string",
+		alias: "d",
+		description: "Output directory",
+		valueHint: "dir"
+	},
+	"watch": {
+		type: "boolean",
+		alias: "w",
+		default: true,
+		description: "Reload the Panel when a watched file changes"
+	},
+	"watch-path": {
+		type: "string",
+		default: DEFAULT_WATCH,
+		description: "Comma-separated files, folders and globs to watch",
+		valueHint: "paths"
+	},
+	"port": {
+		type: "string",
+		alias: "p",
+		default: String(DEFAULT_PORT),
+		description: "Port for the development server"
+	}
+};
+async function run({ args }) {
+	process.env.NODE_ENV ||= "development";
+	const paths = resolveWatchPaths(args["watch-path"], { allowGlobs: true });
+	const server = await serve({
+		cwd: process.cwd(),
+		entry: args.file,
+		outDir: args["out-dir"] ?? process.cwd(),
+		watch: args.watch && paths.length > 0 ? paths : false,
+		port: parsePort(args.port)
+	});
+	process.once("SIGINT", async () => {
+		try {
+			await server.close();
+		} finally {
+			process.exit();
+		}
+	});
+}
+const devCommand = defineCommand({
+	meta: {
+		name: "dev",
+		description: "Start a development server with live reload"
+	},
+	args: devArgs,
+	run
+});
+const serveCommand = defineCommand({
+	meta: {
+		name: "serve",
+		description: "Former name of dev, kept so existing scripts keep working"
+	},
+	args: devArgs,
+	async run(context) {
+		log_exports.info("`kirbyup serve` is now `kirbyup dev`.");
+		await run(context);
+	}
+});
+/** The parser knows strings and booleans only, so the port arrives as a string. */
+function parsePort(value) {
+	const port = Number(value);
+	if (!Number.isInteger(port) || port < 1 || port > 65535) throw new CliError(`Not a usable port: ${JSON.stringify(value)}`);
+	return port;
+}
+//#endregion
+//#region src/node/entry.ts
+runMain(defineCommand({
+	meta: {
+		name,
+		version,
+		description: `${description}. An entry file on its own builds it: kirbyup src/index.js`
+	},
+	args: buildArgs,
+	subCommands: {
+		build: buildCommand,
+		dev: devCommand,
+		serve: serveCommand
+	},
+	run: buildCommand.run
+}));
+//#endregion
+export {};

package/dist/node/index.d.mts

@@ -1,6 +1,5 @@
-import { n as ServeOptions, t as BuildOptions } from "../types-3hN383nZ.mjs";
+import { n as ServeOptions, t as BuildOptions } from "../types-Dh8QpeYt.mjs";
 import { ViteDevServer } from "vite";
-
 //#region src/node/index.d.ts
 declare function build(options: BuildOptions): Promise<void>;
 declare function serve(options: ServeOptions): Promise<ViteDevServer>;

package/dist/node/index.mjs

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

package/dist/{node-DFNV7EsB.mjs → node-noo8EBlY.mjs}

@@ -3,19 +3,97 @@ import * as fsp from "node:fs/promises";
 import { basename, dirname, relative, resolve } from "node:path";
 import vuePlugin from "@vitejs/plugin-vue";
 import vueJsxPlugin from "@vitejs/plugin-vue-jsx";
-import { consola } from "consola";
-import { colors } from "consola/utils";
 import { debounce } from "perfect-debounce";
+import { styleText } from "node:util";
+import process$1 from "node:process";
 import { build, createFilter, createLogger, createServer, mergeConfig, normalizePath } from "vite";
 import { loadConfig } from "c12";
-import postcssrcLoad from "postcss-load-config";
+import { WriteStream } from "node:tty";
 import { gzipSync } from "node:zlib";
+import { Ansis } from "ansis";
 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.8";
+//#region node_modules/.pnpm/utilful@3.3.0_vitest@4.1.11_@types+node@26.4.0_vite@8.2.2_@types+node@26.4.0_jiti@2.7.0_sass@1.103.1_yaml@2.9.0__/node_modules/utilful/dist/_virtual/_rolldown/runtime.mjs
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region node_modules/.pnpm/utilful@3.3.0_vitest@4.1.11_@types+node@26.4.0_vite@8.2.2_@types+node@26.4.0_jiti@2.7.0_sass@1.103.1_yaml@2.9.0__/node_modules/utilful/dist/cli/style.mjs
+function paint(style, text, stream) {
+	return styleText(style, text, { stream });
+}
+//#endregion
+//#region node_modules/.pnpm/utilful@3.3.0_vitest@4.1.11_@types+node@26.4.0_vite@8.2.2_@types+node@26.4.0_jiti@2.7.0_sass@1.103.1_yaml@2.9.0__/node_modules/utilful/dist/cli/log.mjs
+var log_exports = /* @__PURE__ */ __exportAll({
+	blankLine: () => blankLine$1,
+	error: () => error,
+	info: () => info,
+	success: () => success,
+	warn: () => warn
+});
+function error(message) {
+	console.error(`${paint("red", "✖", process$1.stderr)} ${message}`);
+}
+function warn(message) {
+	console.error(`${paint("yellow", "⚠", process$1.stderr)} ${message}`);
+}
+function info(message) {
+	console.error(`${paint("cyan", "●", process$1.stderr)} ${message}`);
+}
+function success(message) {
+	console.error(`${paint("green", "✔", process$1.stderr)} ${message}`);
+}
+function blankLine$1() {
+	console.error("");
+}
+//#endregion
+//#region node_modules/.pnpm/utilful@3.3.0_vitest@4.1.11_@types+node@26.4.0_vite@8.2.2_@types+node@26.4.0_jiti@2.7.0_sass@1.103.1_yaml@2.9.0__/node_modules/utilful/dist/cli/errors.mjs
+/**
+* A condition the CLI recognized and phrased for a human. Anything else
+* reaching the boundary is a defect in the tool and prints its stack unasked.
+*/
+var CliError = class extends Error {};
+/** Gets usage printed alongside its message. */
+var ArgumentError = class extends CliError {};
+/** Reports a failure the way the boundary does, for one that outlives `run`, such as a watch rebuild. */
+function reportFailure(error$1, { verbose = false, expectedErrors = [], describe } = {}) {
+	const sections = [error$1 instanceof Error ? describe?.(error$1) ?? error$1.message : String(error$1)];
+	if (verbose || !isExpected(error$1, expectedErrors)) {
+		const causeChain = formatCauseChain(error$1);
+		if (causeChain) sections.push(causeChain);
+		if (error$1 instanceof Error && error$1.stack) sections.push(error$1.stack);
+	}
+	error(sections.join("\n\n"));
+	process$1.exitCode = 1;
+}
+/**
+* Reports whether the CLI raised this error deliberately rather than tripping
+* over it. A system error such as `ENOENT` reaches the boundary as the honest
+* answer to what the user asked for, so it reads as deliberate too, while an
+* `ERR_*` error from a Node API is a wrong call and stays a defect.
+*/
+function isExpected(error, expectedErrors) {
+	if (error instanceof CliError) return true;
+	if (expectedErrors.some((expectedError) => error instanceof expectedError)) return true;
+	return error instanceof Error && /^E[A-Z0-9]+$/.test(String(error.code));
+}
+function formatCauseChain(error) {
+	const causeLines = [];
+	let current = error instanceof Error ? error.cause : void 0;
+	while (current instanceof Error) {
+		causeLines.push(`Caused by: ${current.name || "Error"}: ${current.message}`);
+		current = current.cause;
+	}
+	return causeLines.join("\n");
+}
 //#endregion
 //#region src/node/config.ts
 function loadConfig$1(cwd = process.cwd()) {
@@ -26,37 +104,91 @@ function loadConfig$1(cwd = process.cwd()) {
 		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;
+//#region package.json
+var name = "kirbyup";
+var version = "4.0.0-alpha.9";
+var description = "Zero-config bundler for Kirby Panel plugins";
+//#endregion
+//#region src/node/output.ts
+/**
+* Follows the rule `styleText` applies, so this output and utilful's `log`
+* agree: a terminal or `FORCE_COLOR`, never `NO_COLOR`. On its own, ansis
+* would color a pipe as soon as `COLORTERM` is set.
+*/
+function colorLevel(stream) {
+	if (!stream.isTTY && process$1.env.FORCE_COLOR === void 0) return 0;
+	const depth = WriteStream.prototype.getColorDepth.call(stream);
+	return depth >= 24 ? 3 : depth >= 8 ? 2 : depth >= 4 ? 1 : 0;
+}
+const ansis = new Ansis(colorLevel(process$1.stderr));
+const brand = ansis.hex("#f67f2f");
+const badge = ansis.bgHex("#f67f2f").black;
+/** U+279C. */
+const ARROW = "➜";
+const INDENT = "  ";
+function banner(action, subject) {
+	const status = subject === void 0 ? ansis.dim(action) : `${ansis.dim(action)} ${ansis.cyan(subject)}`;
+	console.error(`${badge(` ${name} `)} ${brand(`v${version}`)}  ${status}`);
+}
+function blankLine() {
+	console.error("");
+}
+function aside(message) {
+	console.error(`${INDENT}${ansis.dim(message)}`);
+}
+function fileWritten({ root, outDir, filePath, content, type, maxLength }) {
+	const prettyOutDir = `${normalizePath(relative(root, outDir))}/`;
+	const kibs = content.length / 1024;
+	const compressedKibs = gzipSync(content).length / 1024;
+	const paint = type === "chunk" ? ansis.cyan : ansis.magenta;
+	console.error(`${INDENT}${ansis.green(ARROW)}  ${ansis.dim(prettyOutDir)}${ansis.bold(paint(filePath.padEnd(maxLength + 2)))}${ansis.dim(`${kibs.toFixed(2)} kB`)} ${ansis.gray("·")} ${ansis.dim(`gzip ${compressedKibs.toFixed(2)} kB`)}`);
+}
+function serverReady({ root, url, outDir, devFilename, watchPaths, startedAt }) {
+	const devIndex = normalizePath(relative(root, resolve(root, outDir ?? "", devFilename)));
+	const labelWidth = 8;
+	row("Server", ansis.cyan(ansis.link(url)), labelWidth);
+	row("Plugin", ansis.dim(devIndex), labelWidth);
+	if (watchPaths.length > 0) row("Watching", ansis.dim(watchPaths.join(", ")), labelWidth);
+	blankLine();
+	aside(`ready in ${elapsed(startedAt)} – open the Panel and your changes appear as you save`);
+	aside(`stop with ${ansis.bold("Ctrl-C")}`);
+}
+function watching(paths) {
+	row("Watching", ansis.dim(paths.join(", ")), 8);
+}
+function fileChanged(event, file) {
+	console.error(`${INDENT}${ansis.green(ARROW)}  ${ansis.bold(file)} ${ansis.dim(event)}`);
+}
+function fullReload(file) {
+	console.error(`${INDENT}${ansis.green(ARROW)}  ${ansis.bold(file)} ${ansis.dim("changed, reloading the Panel")}`);
+}
+function configChanged(file) {
+	console.error(`${INDENT}${ansis.green(ARROW)}  ${ansis.bold(file)} ${ansis.dim("changed, reloading the config")}`);
+}
+function elapsed(startedAt) {
+	const milliseconds = Math.round(performance.now() - startedAt);
+	return milliseconds < 1e3 ? `${milliseconds} ms` : `${(milliseconds / 1e3).toFixed(2)} s`;
+}
+function row(label, value, labelWidth) {
+	console.error(`${INDENT}${ansis.green(ARROW)}  ${ansis.bold(`${label}:`.padEnd(labelWidth + 1))} ${value}`);
 }
 //#endregion
 //#region src/node/plugins/build-cleanup.ts
+const VITE_HASH_UPDATE_MARKER_RE = /\/\*\$vite\$:\d+\*\/\s*$/;
 function kirbyupBuildCleanupPlugin(options) {
 	let config;
 	let devIndexPath;
 	return {
 		name: "kirbyup:build-cleanup",
+		enforce: "post",
 		configResolved(resolvedConfig) {
 			config = resolvedConfig;
 			devIndexPath = resolve(config.root, options.outDir, "index.dev.js");
 		},
+		generateBundle(_outputOptions, bundle) {
+			for (const item of Object.values(bundle)) if (item.type === "asset" && typeof item.source === "string") item.source = item.source.replace(VITE_HASH_UPDATE_MARKER_RE, "");
+		},
 		writeBundle() {
 			if (options.watch) return;
 			if (fs.existsSync(devIndexPath)) fs.unlinkSync(devIndexPath);
@@ -69,41 +201,26 @@ function toArray(array) {
 	array ??= [];
 	return Array.isArray(array) ? array : [array];
 }
-async function printFileInfo({ root, outDir, filePath, content, type, maxLength }) {
-	const prettyOutDir = `${normalizePath(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.
+* Triggers a full browser reload when a watched file changes. The matching is
+* `createFilter`, not the watcher: Vite already watches the project root, and
+* chokidar has expanded no globs since v4, so adding a pattern to it does nothing.
 */
 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);
+		configureServer({ watcher, ws, config: { root } }) {
+			const matches = createFilter(toArray(paths).map((path) => resolve(root, path)));
 			const reload = (path) => {
 				if (!matches(path)) return;
 				setTimeout(() => ws.send({
 					type: "full-reload",
 					path: "*"
 				}), 0);
-				logger.info(`${colors.green("full reload")} ${colors.dim(normalizePath(relative(root, path)))}`, {
-					clear: true,
-					timestamp: true
-				});
+				fullReload(normalizePath(relative(root, path)));
 			};
 			watcher.on("add", reload);
 			watcher.on("change", reload);
@@ -175,7 +292,7 @@ function hostIncludesPort(host) {
 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, app } = window.panel ?? {}\n\n    if (plugins?.components) {\n      for (const [name, pluginComp] of Object.entries(plugins.components)) {\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(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";
+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 the Kirby 6 Panel is loaded.',\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
 /**
@@ -215,10 +332,17 @@ function kirbyupHmrPlugin(options) {
 	let entryId;
 	let devIndexPath;
 	let vueStubCode;
+	let markWritten;
+	let markFailed;
+	const devIndexWritten = new Promise((resolve, reject) => {
+		markWritten = resolve;
+		markFailed = reject;
+	});
 	return {
 		name: "kirbyup:hmr",
 		apply: "serve",
 		enforce: "pre",
+		api: { devIndexWritten },
 		config() {
 			return {
 				optimizeDeps: { exclude: ["vue"] },
@@ -266,16 +390,25 @@ function kirbyupHmrPlugin(options) {
 			};
 		},
 		configureServer(server) {
-			if (!server.httpServer) return;
+			if (!server.httpServer) {
+				markWritten();
+				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));
+				try {
+					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));
+					markWritten();
+				} catch (error) {
+					markFailed(error);
+				}
 			});
 		},
 		async closeBundle() {
+			await devIndexWritten.catch(() => {});
 			await fsp.rm(devIndexPath, { force: true });
 		}
 	};
@@ -286,9 +419,9 @@ 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."
+    "[kirbyup] Couldn't connect to the development server at ${entryUrl}. Run \`${packageManager} run dev\` to start Vite or build the plugin with \`${packageManager} run build\` so Kirby uses the production version.",
+    error
   );
-  throw error;
 }
 `.trimStart();
 }
@@ -308,9 +441,9 @@ function detectPackageManager(cwd) {
 //#endregion
 //#region src/node/index.ts
 const DEV_OUTPUT_FILENAME = "index.dev.js";
-const SUPPRESSED_WARNING_PREFIX = "\n(!) build.outDir";
+const SUPPRESSED_WARNING = "(!) build.outDir";
 const logLevel = "warn";
-function getViteConfig(command, options, { kirbyupConfig, postCssConfig, logger }) {
+function getViteConfig(command, options, { kirbyupConfig, logger }) {
 	const aliasDir = resolve(options.cwd, dirname(options.entry));
 	const { alias = {}, vite } = kirbyupConfig;
 	const userConfig = vite ?? {};
@@ -326,10 +459,6 @@ function getViteConfig(command, options, { kirbyupConfig, postCssConfig, logger
 			kirbyupGlobImportPlugin()
 		],
 		build: { copyPublicDir: false },
-		...postCssConfig && { css: { postcss: {
-			...postCssConfig.options,
-			plugins: postCssConfig.plugins
-		} } },
 		envDir: options.cwd,
 		envPrefix: ["VITE_", "KIRBYUP_"],
 		customLogger: logger,
@@ -337,26 +466,29 @@ function getViteConfig(command, options, { kirbyupConfig, postCssConfig, logger
 	};
 	if (command === "serve") {
 		const { port, watch } = options;
-		const inferredOrigin = userConfig.server?.origin ?? resolveOriginFromServerOptions(userConfig.server, port, "localhost");
-		return mergeConfig(mergeConfig(sharedConfig, {
+		const resolvedPort = userConfig.server?.port ?? port;
+		const inferredOrigin = userConfig.server?.origin ?? resolveOriginFromServerOptions(userConfig.server, resolvedPort, "localhost");
+		const serveConfig = mergeConfig(sharedConfig, {
 			plugins: [kirbyupHmrPlugin(options), watch && kirbyupFullReloadPlugin(watch)].filter(Boolean),
 			build: { rollupOptions: { input: resolve(options.cwd, options.entry) } },
 			server: {
-				port,
+				port: resolvedPort,
 				strictPort: true,
 				origin: inferredOrigin,
 				cors: true
 			}
-		}), userConfig);
+		});
+		return mergeConfig(serveConfig, userConfig);
 	}
 	const mode = options.watch ? "development" : "production";
-	return mergeConfig(mergeConfig(sharedConfig, {
+	const buildConfig = mergeConfig(sharedConfig, {
 		mode,
 		plugins: [kirbyupBuildCleanupPlugin(options)],
 		build: {
 			lib: {
 				entry: resolve(options.cwd, options.entry),
-				formats: ["es"],
+				formats: ["iife"],
+				name: "kirbyupPlugin",
 				fileName: () => options.watch ? DEV_OUTPUT_FILENAME : "index.js"
 			},
 			minify: mode === "production",
@@ -364,10 +496,15 @@ function getViteConfig(command, options, { kirbyupConfig, postCssConfig, logger
 			emptyOutDir: false,
 			rollupOptions: {
 				external: ["vue"],
-				output: { assetFileNames: "index.[ext]" }
+				output: {
+					assetFileNames: "index.[ext]",
+					exports: "none",
+					globals: (id) => `await import(${JSON.stringify(id)})`
+				}
 			}
 		}
-	}), userConfig);
+	});
+	return mergeConfig(buildConfig, userConfig);
 }
 async function generate(options, context) {
 	const config = getViteConfig("build", options, context);
@@ -375,15 +512,16 @@ async function generate(options, context) {
 	try {
 		result = await build(config);
 	} catch (error) {
-		if (!options.watch) throw error;
-		consola.error(error);
+		const buildError = new CliError(error instanceof Error ? error.message : String(error), { cause: error });
+		if (!options.watch) throw buildError;
+		reportFailure(buildError);
 	}
 	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 { output: bundle } = toArray(result)[0];
+	const maxLength = Math.max(0, ...bundle.map((item) => item.fileName.length));
+	for (const item of bundle) {
 		const content = item.type === "chunk" ? item.code : await fsp.readFile(resolve(options.outDir, item.fileName), "utf8");
-		await printFileInfo({
+		fileWritten({
 			root: options.cwd,
 			outDir: options.outDir,
 			filePath: item.fileName,
@@ -397,20 +535,19 @@ 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)}`);
+	const startedAt = performance.now();
+	banner("building", options.entry);
+	blankLine();
 	await generate(options, context);
-	consola.success("Build successful");
+	aside(`built in ${elapsed(startedAt)}`);
 	if (!options.watch) return;
 	const { watch } = await import("chokidar");
 	const debouncedBuild = debounce(() => {
-		generate(options, context).catch(handleError);
+		generate(options, context).catch(reportFailure);
 	}, 100);
 	const ignored = [
 		"**/{.git,node_modules}/**",
@@ -418,7 +555,7 @@ async function build$1(options) {
 		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(", ")}`);
+	watching(toArray(watchPaths));
 	const watcher = watch(watchPaths, {
 		ignoreInitial: true,
 		ignorePermissionErrors: true,
@@ -442,10 +579,11 @@ async function build$1(options) {
 	process.once("SIGTERM", onShutdown);
 	if (configFile) watcher.add(configFile);
 	watcher.on("all", async (type, file) => {
-		if (configFile === resolve(cwd, file)) {
+		const absolutePath = resolve(cwd, file);
+		if (configFile === absolutePath) {
 			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))}`);
+			configChanged(basename(file));
+		} else fileChanged(type, file);
 		debouncedBuild();
 	});
 }
@@ -453,17 +591,25 @@ 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 startedAt = performance.now();
+	banner("starting the development server");
+	blankLine();
 	const server = await createServer(getViteConfig("serve", options, context));
 	await server.listen();
-	consola.success(`Server is listening on :${server.config.server.port}`);
+	await (server.config.plugins.find((plugin) => plugin.name === "kirbyup:hmr")?.api)?.devIndexWritten;
+	const port = server.config.server.port ?? options.port;
+	serverReady({
+		root: cwd,
+		url: server.config.server.origin ?? resolveOriginFromServerOptions(server.config.server, port, "localhost"),
+		outDir: options.outDir,
+		devFilename: DEV_OUTPUT_FILENAME,
+		watchPaths: options.watch === false ? [] : toArray(options.watch),
+		startedAt
+	});
 	return server;
 }
 function createKirbyupLogger() {
@@ -471,13 +617,13 @@ function createKirbyupLogger() {
 	return {
 		...baseLogger,
 		warn(msg, options) {
-			if (msg.startsWith(SUPPRESSED_WARNING_PREFIX)) return;
+			if (msg.includes(SUPPRESSED_WARNING)) return;
 			baseLogger.warn(msg, options);
 		}
 	};
 }
 function assertEntryExists(options) {
-	if (!fs.existsSync(resolve(options.cwd, options.entry))) throw new PrettyError(`Cannot find "${options.entry}"`);
+	if (!fs.existsSync(resolve(options.cwd, options.entry))) throw new CliError(`Cannot find "${options.entry}"`);
 }
 //#endregion
-export { version as a, name as i, serve as n, handleError as r, build$1 as t };
+export { version as a, reportFailure as c, name as i, log_exports as l, serve as n, ArgumentError as o, description as r, CliError as s, build$1 as t, paint as u };

package/dist/types-Dh8QpeYt.d.mts

@@ -0,0 +1,38 @@
+import { AliasOptions, InlineConfig } from "vite";
+//#region src/node/types.d.ts
+interface BaseOptions {
+  cwd: string;
+  entry: string;
+}
+interface ServeOptions extends BaseOptions {
+  watch: false | string | string[];
+  port: number;
+  outDir?: string;
+}
+interface BuildOptions extends BaseOptions {
+  outDir: string;
+  watch: boolean | string | string[];
+}
+interface UserConfig {
+  /**
+   * Object or array of objects defining aliases that replace values in
+   * `import` statements. With either format, the order of the entries
+   * matters: the first defined rules are applied first.
+   */
+  alias?: AliasOptions;
+  /**
+   * Additional Vite configuration, merged into kirbyup's defaults – for
+   * example, to define global constant replacements.
+   *
+   * @example
+   * export default defineConfig({
+   *   vite: {
+   *    define: {
+   *     __TEST__: JSON.stringify(process.env.TEST === 'true'),
+   *   },
+   * })
+   */
+  vite?: InlineConfig;
+}
+//#endregion
+export { ServeOptions as n, UserConfig as r, BuildOptions as t };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "kirbyup",
   "type": "module",
-  "version": "4.0.0-alpha.8",
-  "packageManager": "pnpm@10.33.3",
+  "version": "4.0.0-alpha.9",
+  "packageManager": "pnpm@11.25.0",
   "description": "Zero-config bundler for Kirby Panel plugins",
   "author": {
     "name": "Johann Schopplich",
@@ -51,9 +51,9 @@
   },
   "scripts": {
     "build": "tsdown",
-    "docs:dev": "vitepress dev docs",
-    "docs:build": "vitepress build docs",
-    "docs:preview": "vitepress preview docs",
+    "docs:dev": "pnpm --filter docs run dev",
+    "docs:build": "pnpm --filter docs run build",
+    "docs:preview": "pnpm --filter docs run preview",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "release": "bumpp",
@@ -61,30 +61,28 @@
     "test:types": "tsc --noEmit"
   },
   "dependencies": {
-    "@vitejs/plugin-vue": "^6.0.6",
-    "@vitejs/plugin-vue-jsx": "^5.1.5",
-    "c12": "^4.0.0-beta.4",
-    "cac": "^7.0.0",
+    "@vitejs/plugin-vue": "^6.0.8",
+    "@vitejs/plugin-vue-jsx": "^5.1.6",
+    "ansis": "^4.3.1",
+    "c12": "^4.0.0-beta.5",
     "chokidar": "^5.0.0",
-    "consola": "^3.4.2",
-    "magic-string": "^0.30.21",
+    "magic-string": "^1.2.3",
     "perfect-debounce": "^2.1.0",
-    "postcss": "^8.5.14",
-    "postcss-load-config": "^6.0.1",
-    "sass": "^1.99.0",
-    "strip-literal": "^3.1.0",
-    "vite": "^8.0.10",
-    "vue": "^3.5.34"
+    "sass": "^1.103.1",
+    "strip-literal": "^4.0.0",
+    "vite": "^8.2.2",
+    "vue": "^3.5.42"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^8.2.0",
-    "@types/node": "^24.12.2",
-    "bumpp": "^11.0.1",
-    "eslint": "^10.3.0",
+    "@antfu/eslint-config": "^9.3.0",
+    "@types/node": "^26.4.0",
+    "bumpp": "^12.2.2",
+    "eslint": "^10.9.1",
     "eslint-flat-config-utils": "^3.2.0",
-    "tsdown": "^0.21.10",
+    "tsdown": "^0.22.14",
     "typescript": "^6.0.3",
-    "unplugin-raw": "^0.7.0",
-    "vitest": "^4.1.5"
+    "unplugin-raw": "^0.8.0",
+    "utilful": "^3.3.0",
+    "vitest": "^4.1.11"
   }
 }

package/dist/node/cli.d.mts

@@ -1 +0,0 @@
-export { };

package/dist/node/cli.mjs

@@ -1,42 +0,0 @@
-import { a as version, i as name, n as serve, r as handleError, t as build } from "../node-DFNV7EsB.mjs";
-import { cac } from "cac";
-//#region src/node/cli-start.ts
-async function startCli(cwd = process.cwd(), argv = process.argv) {
-	const cli = cac(name);
-	cli.command("<file>", "Compile the Kirby Panel plugin to index.js and index.css").option("-d, --out-dir <dir>", "Output directory", { default: cwd }).option("-w, --watch [path]", "Watch for file changes. If no path is specified, the folder of the input file will be watched", { default: false }).example("kirbyup src/index.js").example("kirbyup src/index.js --out-dir ~/kirby-site/site/plugins/demo").example("kirbyup src/index.js --watch src/**/*.{js,css} --watch assets/*\n").action(async (file, options) => {
-		process.env.NODE_ENV ||= options.watch ? "development" : "production";
-		await build({
-			cwd,
-			entry: file,
-			...options
-		});
-	});
-	cli.command("serve <file>", "Start development server with live reload").option("--no-watch", "Don't watch .php files for changes", { default: "\0" }).option("-w, --watch <path>", "Watch additional files", { default: "./**/*.php" }).option("-p, --port <number>", "Port for the development server", { default: 5177 }).option("-d, --out-dir <dir>", "Output directory").example("kirbyup serve src/index.js").example("kirbyup serve src/index.js --no-watch --port 3003").example("kirbyup serve src/index.js --watch snippets/*.php --watch templates/*.php\n").action(async (file, options) => {
-		process.env.NODE_ENV ||= "development";
-		const server = await serve({
-			cwd,
-			entry: file,
-			...options
-		});
-		const exitProcess = async () => {
-			try {
-				await server.close();
-			} finally {
-				process.exit();
-			}
-		};
-		process.once("SIGINT", exitProcess);
-	});
-	cli.help((s) => s.map((msg) => ({
-		...msg,
-		body: msg.body.replace(" (default: \0)", "")
-	})));
-	cli.version(version);
-	cli.parse(argv, { run: false });
-	await cli.runMatchedCommand();
-}
-//#endregion
-//#region src/node/cli.ts
-startCli().catch(handleError);
-//#endregion
-export {};

package/dist/types-3hN383nZ.d.mts

@@ -1,40 +0,0 @@
-import { AliasOptions, InlineConfig } from "vite";
-
-//#region src/node/types.d.ts
-interface BaseOptions {
-  cwd: string;
-  entry: string;
-}
-interface ServeOptions extends BaseOptions {
-  watch: false | string | string[];
-  port: number;
-  outDir?: string;
-}
-interface BuildOptions extends BaseOptions {
-  outDir: string;
-  watch: boolean | string | string[];
-}
-interface UserConfig {
-  /**
-  * Specifies an object or an array of objects, which defines aliases
-  * used to replace values in `import` statements.
-  * With either format, the order of the entries is important,
-  * in that the first defined rules are applied first.
-  */
-  alias?: AliasOptions;
-  /**
-  * Extends Vite's configuration. Will be merged with kirbyup's
-  * default configuration. For example, you can define global constant replacements.
-  *
-  * @example
-  * export default defineConfig({
-  *   vite: {
-  *    define: {
-  *     __TEST__: JSON.stringify(process.env.TEST === 'true'),
-  *   },
-  * })
-  */
-  vite?: InlineConfig;
-}
-//#endregion
-export { ServeOptions as n, UserConfig as r, BuildOptions as t };