@mantaq/inspect 0.3.0 → 0.5.0

package/dist/load-CWubcSZU.mjs

@@ -0,0 +1,131 @@
+import { Either } from "@mantaq/utils";
+import { dirname, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { loadConfigFromFile, loadEnv, runnerImport } from "vite";
+// src/load.ts
+const ANSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+const ENTRY = "virtual:mantaq-inspect";
+const RESOLVED = `\0${ENTRY}`;
+/**
+* A module that imports the machine file and the inspector side by side. Run
+* through one module graph, both see the same `@mantaq/core` instance: core
+* recognizes its state refs by a module-level registry, so a machine loaded
+* through a bundler and inspected from plain Node would look stateless.
+*/
+function entrySource(file) {
+	const inspect = fileURLToPath(import.meta.resolve("@mantaq/inspect"));
+	return [
+		`import * as machines from ${JSON.stringify(file)};`,
+		`import { inspectModule } from ${JSON.stringify(inspect)};`,
+		`export function run(options) {`,
+		`  return inspectModule(${JSON.stringify(file)}, { ...options, load: async () => machines });`,
+		`}`
+	].join("\n");
+}
+/** Vite plugin serving the entry for each `virtual:mantaq-inspect?file=<path>` id. */
+function inspectEntry() {
+	return {
+		name: "mantaq-inspect-entry",
+		resolveId: (id) => id.startsWith(ENTRY) ? `\0${id}` : null,
+		load: (id) => {
+			if (!id.startsWith(RESOLVED)) return null;
+			const file = new URLSearchParams(id.slice(id.indexOf("?") + 1)).get("file");
+			return file === null ? null : entrySource(file);
+		}
+	};
+}
+function entryId(file) {
+	return `${ENTRY}?${new URLSearchParams({ file }).toString()}`;
+}
+/** The `run` export of an entry module, checked: module objects are untyped. */
+function runOf(module) {
+	const run = typeof module === "object" && module !== null ? Reflect.get(module, "run") : void 0;
+	if (typeof run !== "function") return null;
+	return async (options) => Reflect.apply(run, void 0, [options]);
+}
+const ENV_ACCESS = [
+	"import",
+	"meta",
+	"env"
+].join(".");
+/**
+* Replaces the env object with the project's env: `runnerImport` never reads
+* env files, so `VITE_*` variables would otherwise be missing. A textual
+* replace: it also rewrites matches in strings and comments, and a frozen
+* snapshot replaces Vite's own `import.meta.env`, so assigning to it fails.
+*/
+function projectEnv(env, mode) {
+	const value = JSON.stringify({
+		...env,
+		BASE_URL: "/",
+		MODE: mode,
+		DEV: true,
+		PROD: false,
+		SSR: true
+	});
+	return {
+		name: "mantaq-inspect-env",
+		enforce: "pre",
+		transform: (code, id) => id.includes("/node_modules/") || !code.includes(ENV_ACCESS) ? null : {
+			code: code.replaceAll(ENV_ACCESS, `(${value})`),
+			map: null
+		}
+	};
+}
+/**
+* The inline config for a load: empty without `--config`; otherwise the
+* project's Vite config (plugins, aliases, define) plus its env files.
+*/
+async function inlineConfig({ config, mode }) {
+	const base = {
+		configFile: false,
+		logLevel: "silent"
+	};
+	if (config === void 0) return {
+		...base,
+		...mode === void 0 ? {} : { mode }
+	};
+	const chosen = mode ?? "development";
+	const user = (await loadConfigFromFile({
+		command: "serve",
+		mode: chosen
+	}, config))?.config ?? {};
+	const envDir = resolve(dirname(config), user.envDir === false ? "." : user.envDir ?? ".");
+	const env = user.envDir === false ? {} : loadEnv(chosen, envDir, user.envPrefix ?? "VITE_");
+	return {
+		...user,
+		...base,
+		mode: chosen,
+		plugins: [...user.plugins ?? [], projectEnv(env, chosen)]
+	};
+}
+/** Load `file` with Vite (TS, tsconfig paths, extensionless imports) and inspect its machines. */
+async function inspectFile(file, options = {}, load = {}) {
+	if (load.config !== void 0 && !existsSync(load.config)) return {
+		machines: [],
+		warnings: [`${file}: Vite config not found: ${load.config}`],
+		failed: true
+	};
+	const loaded = await inlineConfig(load).then((inline) => runnerImport(entryId(file), {
+		...inline,
+		plugins: [...inline.plugins ?? [], inspectEntry()]
+	})).then((value) => Either.right(value), (error) => Either.left((error instanceof Error ? error.message : String(error)).replace(ANSI, "")));
+	if (Either.isLeft(loaded)) return {
+		machines: [],
+		warnings: [`${file}: ${loaded[0]}`],
+		failed: true
+	};
+	const { module } = loaded[1];
+	const run = runOf(module);
+	if (run === null) return {
+		machines: [],
+		warnings: [`${file}: could not load the inspector`],
+		failed: true
+	};
+	return {
+		...await run(options),
+		failed: false
+	};
+}
+export { runOf as i, inspectEntry as n, inspectFile as r, entryId as t };

package/dist/record.d.mts

@@ -0,0 +1,14 @@
+import { AnyActor } from "@mantaq/core";
+type Made = AnyActor<unknown> | {
+  actor: AnyActor<unknown>;
+};
+/**
+ * Wrap a machine factory in a vitest test file so every passing test that
+ * builds an actor with it is recorded to `__runs__/<test file>.json` next to
+ * the test: the events it handled and how far its clock moved. Run the whole
+ * file to refresh it; with `CI` set a stale file fails the test instead.
+ * The factory may be called in the test or in `beforeEach`. A retried test is
+ * recorded once, from the attempt that passed.
+ */
+export declare function recordRuns<F extends (...args: never[]) => Made>(factory: F): F;
+export {};

package/dist/record.mjs

@@ -0,0 +1,154 @@
+import { r as machineId } from "./inspect-B7ZQCNM2.mjs";
+import { Either } from "@mantaq/utils";
+import { basename, dirname, join } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+// \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+// ../../node_modules/.pnpm/vite-plus@1.4.0_@types+node@26.2.0_@typescript+native-preview@7.0.0-dev.20260707.2_@vit_594a0913d1d55d70a26e6ccc5f2ebd7d/node_modules/vite-plus/dist/test/index.js
+var test_exports = /* @__PURE__ */ __exportAll({});
+import * as import_vitest from "vitest";
+__reExport(test_exports, import_vitest);
+// src/record.ts
+/** Actors built during the running test attempt, flushed when it ends. */
+let pending = [];
+/** Runs recorded so far, per test file, per machine id. */
+const files = /* @__PURE__ */ new Map();
+function actorOf(made) {
+	return "actor" in made ? made.actor : made;
+}
+function isJson(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (Array.isArray(value)) return value.every(isJson);
+	if (typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return false;
+	return Object.values(value).every((each) => each === void 0 || isJson(each));
+}
+function jsonPayload(payload) {
+	if (payload !== void 0 && !isJson(payload)) return Either.left("payload is not JSON");
+	const text = Either.from(() => JSON.stringify(payload ?? null));
+	if (Either.isLeft(text)) return Either.left("payload is not JSON");
+	return Either.right(JSON.parse(text[1]));
+}
+function textOf(runs) {
+	const body = [...runs].sort(([a], [b]) => a.localeCompare(b)).map(([id, list]) => [id, [...list].sort((a, b) => a.name.localeCompare(b.name))]);
+	return `${JSON.stringify(Object.fromEntries(body), null, 2)}\n`;
+}
+function sidecarOf(testPath) {
+	return join(dirname(testPath), "__runs__", `${basename(testPath).replace(/\.[cm]?[jt]sx?$/, "")}.json`);
+}
+function check(file, id, run) {
+	const committed = Either.from(() => JSON.parse(readFileSync(file, "utf8")));
+	const list = Either.isRight(committed) ? committed[1]?.[id] : void 0;
+	const found = Array.isArray(list) ? list.find((each) => each?.name === run.name) : void 0;
+	if (JSON.stringify(found) !== JSON.stringify(run)) throw new Error(`recordRuns: ${file} is out of date for "${run.name}". Run the tests locally without CI set and commit the result.`);
+}
+function flush(testPath, id, run, runs) {
+	const file = sidecarOf(testPath);
+	if (process.env["CI"]) return check(file, id, run);
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(file, textOf(runs));
+}
+function finish(attempt, passed) {
+	if (!passed) return;
+	const counts = /* @__PURE__ */ new Map();
+	for (const each of attempt) {
+		if (each.problem !== "") {
+			console.warn(`recordRuns: "${each.name}" not recorded, ${each.problem}`);
+			continue;
+		}
+		const now = each.actor.clock.now();
+		if (now > each.seen) each.steps.push({
+			kind: "advance",
+			ms: now - each.seen
+		});
+		const count = (counts.get(each.name) ?? 0) + 1;
+		counts.set(each.name, count);
+		const name = count === 1 ? each.name : `${each.name} #${count}`;
+		const runs = files.get(each.testPath) ?? /* @__PURE__ */ new Map();
+		files.set(each.testPath, runs);
+		const list = runs.get(each.id) ?? [];
+		runs.set(each.id, list);
+		const run = {
+			name,
+			end: each.actor.state.name,
+			steps: each.steps
+		};
+		list.push(run);
+		flush(each.testPath, each.id, run, runs);
+	}
+}
+(0, test_exports.afterEach)(({ task }) => {
+	const attempt = pending;
+	pending = [];
+	finish(attempt, task.result?.state !== "fail");
+});
+/**
+* Wrap a machine factory in a vitest test file so every passing test that
+* builds an actor with it is recorded to `__runs__/<test file>.json` next to
+* the test: the events it handled and how far its clock moved. Run the whole
+* file to refresh it; with `CI` set a stale file fails the test instead.
+* The factory may be called in the test or in `beforeEach`. A retried test is
+* recorded once, from the attempt that passed.
+*/
+function recordRuns(factory) {
+	const id = machineId(factory.name);
+	const wrapped = (...args) => {
+		const made = factory(...args);
+		const actor = actorOf(made);
+		const { testPath = "", currentTestName = "" } = test_exports.expect.getState();
+		const entry = {
+			actor,
+			id,
+			name: currentTestName,
+			testPath,
+			steps: [],
+			problem: "",
+			seen: actor.clock.now()
+		};
+		pending.push(entry);
+		actor.on("transition", { fn: ({ event }) => {
+			const now = actor.clock.now();
+			if (now > entry.seen) entry.steps.push({
+				kind: "advance",
+				ms: now - entry.seen
+			});
+			entry.seen = now;
+			const payload = jsonPayload(event.payload);
+			if (Either.isLeft(payload)) entry.problem = payload[0];
+			else entry.steps.push({
+				kind: "event",
+				event: event.type,
+				payload: payload[1]
+			});
+		} });
+		return made;
+	};
+	Object.defineProperty(wrapped, "name", { value: factory.name });
+	return wrapped;
+}
+export { recordRuns };

package/dist/vite.d.mts

@@ -1,4 +1,4 @@
-import { t as FuzzSettings } from "./inspect-DvQtAcwv.mjs";
+import { t as FuzzSettings } from "./inspect-vSdt2qtL.mjs";
 import { Plugin } from "vite";
 export declare const STYLESHEETS: string[];
 export interface MantaqVizOptions {

package/dist/vite.mjs

@@ -1 +1,233 @@
-export { t as STYLESHEETS, n as TARGETS, r as TARGETS_RESOLVED, i as mantaqViz, a as targetsSource } from "./vite-BBW0CmYr.mjs";
+import { a as vizDocument, i as projectRoot, o as analyzeModule, r as machineId } from "./inspect-B7ZQCNM2.mjs";
+import { i as runOf, n as inspectEntry, r as inspectFile, t as entryId } from "./load-CWubcSZU.mjs";
+import { UPDATE_EVENT, livePageHtml, serializeViz } from "@mantaq/viz";
+import { Either } from "@mantaq/utils";
+import { dirname, isAbsolute, posix, resolve } from "node:path";
+import { existsSync, globSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { searchForWorkspaceRoot } from "vite";
+// src/vite.ts
+/**
+* Vite plugin: a live page of your machines on your own dev server.
+*
+*   // vite.config.ts
+*   import { mantaqViz } from "@mantaq/inspect/vite";
+*   export default defineConfig({ plugins: [mantaqViz({ machines: "src/**\/*.machine.ts" })] });
+*
+* `vite build` with the plugin also writes the page as a static site
+* (`index.html`, `viz.json`, a script) under `base`.
+*
+* Open `/__mantaq/` while the dev server runs. Machines load through your own
+* Vite config (aliases, tsconfig paths), are inspected on the server, and the
+* page redraws, keeping the walk, when you save a file.
+*/
+const STYLESHEETS = ["@mantaq/viz/viewer.css", "@mantaq/viz/page.css"];
+const DEV_ITERATIONS = 500;
+const TARGETS = "virtual:mantaq/targets";
+const TARGETS_RESOLVED = `\0${TARGETS}`;
+function createExpression(found, index) {
+	const callee = `m${index}[${JSON.stringify(found.name)}]`;
+	const call = found.call === "clock" ? `${callee}(VirtualClock())` : found.call === "options" ? `${callee}({ clock: VirtualClock() })` : `${callee}()`;
+	return found.unwrap === "actor" ? `${call}.actor` : call;
+}
+/**
+* Source of `virtual:mantaq/targets`: one factory per exported actor factory,
+* shaped by its type (`call`, `clock`, `options`). A bare actor export cannot
+* be recreated, so it gets none. Like the server-side inspection, plain actors
+* are skipped when a file has factories.
+*/
+function targetsSource(files) {
+	const core = fileURLToPath(import.meta.resolve("@mantaq/core"));
+	const imports = [];
+	const entries = [];
+	files.forEach((file, index) => {
+		const analysis = analyzeModule({
+			file,
+			root: projectRoot(file)
+		});
+		if (Either.isLeft(analysis)) return;
+		const factories = analysis[1].machines.filter((found) => found.call !== "instance");
+		if (factories.length === 0) return;
+		imports.push(`import * as m${index} from ${JSON.stringify(file)};`);
+		for (const found of factories) entries.push(`  ${JSON.stringify(machineId(found.name))}: () => { const actor = ${createExpression(found, index)}; return { actor, clock: actor.clock }; },`);
+	});
+	return [
+		`import { VirtualClock } from ${JSON.stringify(core)};`,
+		...imports,
+		"export const targets = {",
+		...entries,
+		"};"
+	].join("\n");
+}
+function machineFiles(root, patterns) {
+	const files = patterns.flatMap((pattern) => globSync(pattern, { cwd: root }));
+	return [...new Set(files.map((file) => isAbsolute(file) ? file : resolve(root, file)))].sort();
+}
+async function documentText(server, context) {
+	const results = [];
+	for (const file of context.files) {
+		const run = runOf(await server.ssrLoadModule(entryId(file)));
+		results.push(run === null ? {
+			machines: [],
+			warnings: [`${file}: could not load the inspector`]
+		} : await run({ fuzz: context.fuzz }));
+	}
+	return {
+		text: serializeViz(vizDocument(results.flatMap((result) => result.machines))),
+		warnings: results.flatMap((result) => result.warnings)
+	};
+}
+function stylesheets() {
+	return STYLESHEETS.map((id) => readFileSync(fileURLToPath(import.meta.resolve(id)), "utf8")).join("\n");
+}
+/** Build mode: write the page, `viz.json` and the viewer script under `base`. */
+function siteBuild(context) {
+	let standalone = false;
+	return {
+		name: "mantaq-viz-build",
+		apply: "build",
+		config: (config) => {
+			const input = config.build?.rollupOptions?.input;
+			const root = resolve(config.root ?? process.cwd());
+			standalone = input === void 0 && !existsSync(resolve(root, "index.html"));
+			return standalone ? { build: { rollupOptions: { input: { "mantaq-live": context.live } } } } : {};
+		},
+		buildStart() {
+			if (!standalone) this.emitFile({
+				type: "chunk",
+				id: context.live,
+				name: "mantaq-live"
+			});
+		},
+		async generateBundle(_options, bundle) {
+			const results = [];
+			for (const file of machineFiles(context.root(), context.patterns)) {
+				const load = { config: context.project.configFile };
+				try {
+					results.push(await inspectFile(file, { fuzz: context.fuzz }, load));
+				} catch (error) {
+					this.warn(`[mantaq-viz] ${file}: could not inspect (${String(error)})`);
+				}
+			}
+			for (const warning of results.flatMap((result) => result.warnings)) this.warn(`[mantaq-viz] ${warning}`);
+			const text = serializeViz(vizDocument(results.flatMap((result) => result.machines)));
+			const dir = context.base.replace(/^\//, "");
+			const entry = Object.values(bundle).find((chunk) => chunk.type === "chunk" && chunk.isEntry && chunk.name === "mantaq-live");
+			if (entry === void 0) {
+				this.error("[mantaq-viz] the live page entry was not bundled");
+				return;
+			}
+			this.emitFile({
+				type: "asset",
+				fileName: `${dir}viz.json`,
+				source: text
+			});
+			this.emitFile({
+				type: "asset",
+				fileName: `${dir}index.html`,
+				source: livePageHtml({
+					title: "mantaq viz",
+					source: "viz.json",
+					entry: posix.relative(dir === "" ? "." : dir, entry.fileName),
+					css: stylesheets()
+				})
+			});
+		}
+	};
+}
+function mantaqViz(options) {
+	const base = (options.base ?? "/__mantaq/").replace(/\/?$/, "/");
+	const patterns = Array.isArray(options.machines) ? options.machines : [options.machines];
+	const fuzz = options.fuzz ?? { iterations: DEV_ITERATIONS };
+	const live = fileURLToPath(import.meta.resolve(import.meta.url.endsWith(".ts") ? "./live-entry.ts" : "./live-entry.mjs"));
+	const viz = dirname(dirname(fileURLToPath(import.meta.resolve("@mantaq/viz/live"))));
+	let root = process.cwd();
+	const project = { configFile: void 0 };
+	const targets = {
+		name: "mantaq-viz-targets",
+		configResolved: (config) => {
+			root = config.root;
+			project.configFile = config.configFile;
+		},
+		resolveId: (id) => id === "virtual:mantaq/targets" ? TARGETS_RESOLVED : null,
+		load: (id) => id === "\0virtual:mantaq/targets" ? targetsSource(machineFiles(root, patterns)) : null
+	};
+	const plugin = {
+		name: "mantaq-viz",
+		apply: "serve",
+		config: (config) => ({ server: { fs: { allow: [
+			searchForWorkspaceRoot(config.root ?? process.cwd()),
+			dirname(dirname(live)),
+			viz
+		] } } }),
+		configureServer(server) {
+			let cached = null;
+			const build = async () => {
+				const { text, warnings } = await documentText(server, {
+					files: machineFiles(server.config.root, patterns),
+					fuzz
+				});
+				for (const warning of warnings) server.config.logger.warn(`[mantaq-viz] ${warning}`);
+				return text;
+			};
+			server.watcher.on("all", (_event, path) => {
+				if (!/\.[cm]?[jt]sx?$/.test(path)) return;
+				cached = null;
+				const generated = server.moduleGraph.getModuleById(TARGETS_RESOLVED);
+				if (generated !== void 0) server.moduleGraph.invalidateModule(generated);
+				server.environments.ssr.moduleGraph.invalidateAll();
+				server.ws.send({
+					type: "custom",
+					event: UPDATE_EVENT
+				});
+			});
+			server.middlewares.use((request, response, next) => {
+				const path = request.url?.split("?")[0];
+				if (path === `${base}viz.json`) {
+					cached ??= build();
+					cached.then((text) => {
+						response.setHeader("content-type", "application/json");
+						response.end(text);
+					}, (error) => {
+						cached = null;
+						response.statusCode = 500;
+						response.end(String(error));
+					});
+					return;
+				}
+				if (path !== base && path !== base.slice(0, -1)) {
+					next();
+					return;
+				}
+				const html = livePageHtml({
+					title: "mantaq viz",
+					source: `${base}viz.json`,
+					entry: `/@fs${live}`,
+					css: stylesheets()
+				});
+				server.transformIndexHtml(request.url ?? base, html).then((page) => {
+					response.setHeader("content-type", "text/html");
+					response.end(page);
+				});
+			});
+			server.httpServer?.once("listening", () => {
+				server.config.logger.info(`  mantaq viz: ${base}`);
+			});
+		}
+	};
+	const site = siteBuild({
+		base,
+		patterns,
+		fuzz,
+		live,
+		project,
+		root: () => root
+	});
+	return [
+		inspectEntry(),
+		targets,
+		site,
+		plugin
+	];
+}
+export { STYLESHEETS, TARGETS, TARGETS_RESOLVED, mantaqViz, targetsSource };

package/package.json

@@ -1,16 +1,13 @@
 {
   "name": "@mantaq/inspect",
-  "version": "0.3.0",
-  "description": "Turn a Mantaq machine into a viz document: structure, handler explanations (AST), fuzz and test coverage. CLI and Vite plugin included.",
+  "version": "0.5.0",
+  "description": "Turn a Mantaq machine into a viz document: structure, handler explanations (AST), fuzz and test coverage. Vite plugin included.",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/AndersCan/mantaq",
     "directory": "packages/inspect"
   },
-  "bin": {
-    "mantaq-inspect": "./dist/cli.mjs"
-  },
   "files": [
     "dist"
   ],
@@ -18,8 +15,8 @@
   "exports": {
     ".": "./dist/index.mjs",
     "./drive": "./dist/drive.mjs",
-    "./live-embedded": "./dist/live-embedded.mjs",
     "./live-entry": "./dist/live-entry.mjs",
+    "./record": "./dist/record.mjs",
     "./vite": "./dist/vite.mjs",
     "./package.json": "./package.json"
   },
@@ -28,11 +25,11 @@
   },
   "dependencies": {
     "typescript": "6.0.3",
-    "@mantaq/core": "0.5.3",
-    "@mantaq/traversal": "0.3.3",
-    "@mantaq/viz": "0.2.3",
+    "@mantaq/core": "0.5.4",
     "@mantaq/pbt": "0.0.4",
-    "@mantaq/utils": "0.0.5"
+    "@mantaq/traversal": "0.3.4",
+    "@mantaq/utils": "0.0.5",
+    "@mantaq/viz": "0.4.0"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
@@ -40,10 +37,20 @@
     "happy-dom": "^21.0.4",
     "vite": "npm:@voidzero-dev/vite-plus-core@1.4.0",
     "vite-plus": "1.4.0",
-    "@mantaq/sugar": "2.0.3"
+    "vitest": "5.0.5",
+    "@mantaq/sugar": "2.0.4"
   },
   "peerDependencies": {
-    "vite": "*"
+    "vite": "*",
+    "vitest": "*"
+  },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
+  },
+  "inlinedDependencies": {
+    "vite-plus": "1.4.0"
   },
   "scripts": {
     "build": "vp pack",

package/dist/cli.d.mts

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