@mantaq/inspect 0.2.3 → 0.4.0

package/README.md

@@ -1,16 +1,12 @@
 # @mantaq/inspect
 
-Turns your Mantaq machine into a picture you can walk: one command, no config.
+Turns your Mantaq machine into a picture you can walk: add the Vite plugin, no other config.
 
-```sh
-mantaq-inspect src/cart.ts     # writes mantaq-viz.html and opens it
-```
-
-It finds every exported actor, or function that builds one, from the file's types. It reads handler explanations and sample payloads from the source, fuzzes each machine that runs on a `VirtualClock`, and writes one self-contained HTML page that works offline: commit it, attach it to a PR. The viewer is [`@mantaq/viz`](../viz/README.md).
+It finds every exported actor, or function that builds one, from the file's types. It reads handler explanations and sample payloads from the source, fuzzes each machine that runs on a `VirtualClock`, and shows them in a live page on your Vite dev server. The viewer is [`@mantaq/viz`](../viz/README.md).
 
-## Three ways in
+## Ways in
 
-**CLI**: `mantaq-inspect <file.ts>... [--out FILE] [--json] [--no-fuzz] [--iterations N] [--config FILE] [--mode MODE] [--no-open] [--check]`. `--config` loads the files with that Vite config (env, aliases, plugins) and `--mode` picks its mode; without `--config` no project config is read. `--check` exits 1 if a warning was printed or fuzzing found a handler error (printed as `error:`), so CI can gate on design errors. `--json` writes the viz document instead of the page. Seed: `MANTAQ_SEED` (default from `@mantaq/pbt`). Same seed → same output.
+**Gate in tests**: see the docs page "Design gate in vitest" for `expectNoDesignErrors`, `expectReached` and `expectAllStatesReached`.
 
 **Vite plugin**: a live page on your dev server that redraws, keeping your walk, when you save.
 
@@ -43,13 +39,14 @@ const { machine, warnings } = inspect({
 const json = serializeViz(vizDocument([machine]));
 ```
 
-`inspectFile(file)` / `inspectModule(file, { load })` do the discovery the CLI does. The building blocks (`toVizMachine`, `annotateMachine`, `fuzz`, `fuzzedMachine`, `withTestCoverage`, `guidance`) stay exported for custom pipelines.
+`inspectFile(file)` / `inspectModule(file, { load })` do the discovery the Vite plugin does. The building blocks (`toVizMachine`, `annotateMachine`, `fuzz`, `fuzzedMachine`, `withTestCoverage`, `guidance`) stay exported for custom pipelines.
 
 ## What it needs from your file
 
 - **Exports.** An actor, or a function that returns one (or `{ actor }`). Functions are called with no arguments, with a `VirtualClock` when the first parameter is a clock, or with `{ clock }` when it is an options object with a `clock`. Functions with other required parameters are skipped. Discovery reads types only; nothing is called to find out.
 - **A fresh actor per call**, to fuzz. A file that only exports one actor instance is drawn, not fuzzed. When a file has factories, its actor instances are skipped.
 - **Exported factories.** Export a factory that takes ports and a clock, not only a built instance. See [Machines in an application](https://anderscan.github.io/mantaq/guides/machines-in-an-app/).
+- **A factory, for the live page.** The page recreates the actor on every step, so it needs an exported factory; a file that only exports an instance stays a static walk, with the usual warning.
 - **A `VirtualClock`**, to fuzz. An actor on the real clock is drawn, with a warning.
 
 Every part that cannot run is skipped with a warning, never guessed.
@@ -58,6 +55,7 @@ Every part that cannot run is skipped with a warning, never guessed.
 
 The viewer's "Coverage from" picker dims elements with zero hits. What dimmed means depends on the source:
 
+- **examples + fuzz** (`reached`): neither an example nor fuzzing reached this. The default when both sources are present, and the same merge `expectReached` uses. Fix a miss by adding an example to `tests`.
 - **example tests** (`tested`): no test exercises this. Collected by replaying the event sequences you pass as `tests`, each on a fresh actor.
 - **fuzz runs** (`coverage`): no fuzz run produced this. Fuzzing reaches almost everything, so little is dimmed. What does stay dimmed is usually a **declared but unreached edge**: the handler lists the target in `to`, but its guards may never allow it. Saga's `compensatingRefund -REFUND_DONE-> failed` is an example. The edge panel calls these out. Fuzzing is not proof, so check the handler.
 

package/dist/index.d.mts

@@ -37,6 +37,8 @@ interface FuzzOptions {
    * the run in the corpus as a stepping stone even without new coverage.
    */
   guide?: (trace: Trace) => boolean;
+  /** Known-good sequences (e.g. example tests) the corpus starts from, before any mutation. */
+  initial?: ReadonlyArray<ReadonlyArray<VizStep>>;
 }
 interface CorpusEntry {
   steps: VizStep[];
@@ -148,6 +150,40 @@ interface LoadOptions {
 }
 /** Load `file` with Vite (TS, tsconfig paths, extensionless imports) and inspect its machines. */
 export declare function inspectFile(file: string, options?: FileOptions, load?: LoadOptions): Promise<LoadedFile>;
-/** A self-contained HTML page for `document`: open it from disk, attach it, commit it. */
-export declare function htmlPage(document: VizDocument, title: string): Promise<string>;
-export { type AnalysisSource, type CorpusEntry, type FileOptions, type FuzzOptions, type FuzzResult, type FuzzSettings, type FuzzTarget, type HandlerSite, type InspectTarget, type Inspected, type InspectedModule, type LiteralPool, type MachineExport, type ModuleAnalysis, type ModuleOptions, type Observation, type RunError, type Trace, type VizInput, eventCatalog, execute, inspect, inspectModule, machineId, vizDocument };
+/**
+ * States no edge path leads to from the initial state. Empty when an undetermined
+ * edge hides the answer. Region states are never reported: the graph does not
+ * record where a region starts.
+ */
+export declare function unreachableStates(machine: VizMachine): string[];
+/** Design errors of an inspected machine, one line each. Unreached edges and routing warnings are not errors. */
+export declare function designErrors(machine: VizMachine): string[];
+/**
+ * Call from a test: throws when fuzzing finds a handler or effect that throws,
+ * an effect sends an event its state does not handle, or a declared state has
+ * no path from the initial state. Runs are seeded, so the result is stable.
+ */
+export declare function expectNoDesignErrors(target: InspectTarget): void;
+interface ReachTransition {
+  from: string;
+  event: string;
+  /** Omit to accept any target. */
+  to?: string;
+}
+interface ReachExpectation {
+  states?: ReadonlyArray<string>;
+  transitions?: ReadonlyArray<ReachTransition>;
+}
+/** Ids of the states a fuzz run or the supplied test sequences visited. */
+export declare function reachedStates(machine: VizMachine): string[];
+/** What the expectation asks for and the machine did not reach, one line each. */
+export declare function missedReach(machine: VizMachine, expected: ReachExpectation): string[];
+/**
+ * Call from a test: throws unless fuzzing or the target's `tests` visited every
+ * listed state and took every listed transition. Reaching is proof; a miss only
+ * says nothing got there yet.
+ */
+export declare function expectReached(target: InspectTarget, expected: ReachExpectation): void;
+/** Call from a test: throws unless fuzzing or the target's `tests` visited every declared state. */
+export declare function expectAllStatesReached(target: InspectTarget): void;
+export { type AnalysisSource, type CorpusEntry, type FileOptions, type FuzzOptions, type FuzzResult, type FuzzSettings, type FuzzTarget, type HandlerSite, type InspectTarget, type Inspected, type InspectedModule, type LiteralPool, type MachineExport, type ModuleAnalysis, type ModuleOptions, type Observation, type ReachExpectation, type ReachTransition, type RunError, type Trace, type VizInput, eventCatalog, execute, inspect, inspectModule, machineId, vizDocument };

package/dist/index.mjs

@@ -1,4 +1,98 @@
-import { S as toVizMachine, _ as fuzzedMachine, a as inspect, b as shrink, d as analyzeSource, f as annotateMachine, g as literalPool, h as guidance, l as vizDocument, m as branchDistanceGuide, o as inspectModule, p as branchDistance, r as inspectFile, s as machineId, u as analyzeModule, v as withTestCoverage, x as toViz, y as fuzz } from "./load-Dw5KOFuM.mjs";
+import { S as toVizMachine, _ as fuzzedMachine, a as inspect, b as shrink, d as analyzeSource, f as annotateMachine, g as literalPool, h as guidance, l as vizDocument, m as branchDistanceGuide, o as inspectModule, p as branchDistance, r as inspectFile, s as machineId, u as analyzeModule, v as withTestCoverage, x as toViz, y as fuzz } from "./load-D0_Jl6Wr.mjs";
 import { i as execute, r as eventCatalog } from "./run-B5huYj_r.mjs";
-import { t as htmlPage } from "./page-rr9IQ-4k.mjs";
-export { analyzeModule, analyzeSource, annotateMachine, branchDistance, branchDistanceGuide, eventCatalog, execute, fuzz, fuzzedMachine, guidance, htmlPage, inspect, inspectFile, inspectModule, literalPool, machineId, shrink, toViz, toVizMachine, vizDocument, withTestCoverage };
+import { coveredByAny, unhandledSends } from "@mantaq/viz";
+// src/gate.ts
+/**
+* States no edge path leads to from the initial state. Empty when an undetermined
+* edge hides the answer. Region states are never reported: the graph does not
+* record where a region starts.
+*/
+function unreachableStates(machine) {
+	const reached = new Set(machine.states.filter((state) => state.initial || state.region !== null).map((state) => state.id));
+	const queue = [...reached];
+	let undetermined = false;
+	for (let next = queue.shift(); next !== void 0; next = queue.shift()) {
+		const from = next;
+		for (const edge of machine.edges) {
+			if (edge.kind === "effect" || edge.from !== from && !coveredByAny(edge.from, from)) continue;
+			if (edge.to === null) {
+				undetermined = true;
+				continue;
+			}
+			if (reached.has(edge.to)) continue;
+			reached.add(edge.to);
+			queue.push(edge.to);
+		}
+	}
+	if (undetermined) return [];
+	return machine.states.map((state) => state.id).filter((id) => !reached.has(id));
+}
+/** Design errors of an inspected machine, one line each. Unreached edges and routing warnings are not errors. */
+function designErrors(machine) {
+	const thrown = (machine.fuzz?.errors ?? []).map((error) => `${error.event} in ${error.from} throws: ${error.message}`);
+	const sends = machine.states.flatMap((state) => unhandledSends(machine, state.id).map(({ effect, event }) => `effect ${effect} in ${state.id} sends ${event}, but ${state.id} has no handler for it`));
+	const orphans = unreachableStates(machine).map((id) => `state ${id} is declared but no path leads to it from the initial state`);
+	return [
+		...thrown,
+		...sends,
+		...orphans
+	];
+}
+/**
+* Call from a test: throws when fuzzing finds a handler or effect that throws,
+* an effect sends an event its state does not handle, or a declared state has
+* no path from the initial state. Runs are seeded, so the result is stable.
+*/
+function expectNoDesignErrors(target) {
+	const { machine } = inspect(target);
+	const errors = designErrors(machine);
+	if (errors.length === 0) return;
+	throw new Error(`${machine.id} has ${errors.length} design error${errors.length === 1 ? "" : "s"}:\n${errors.map((each) => `  - ${each}`).join("\n")}`);
+}
+// src/reach.ts
+function hitCount(coverage) {
+	return coverage?.hits ?? 0;
+}
+/** Ids of the states a fuzz run or the supplied test sequences visited. */
+function reachedStates(machine) {
+	return machine.states.filter((state) => hitCount(state.coverage) + hitCount(state.tested) > 0).map((state) => state.id);
+}
+function isTaken(edge) {
+	return hitCount(edge.coverage) + hitCount(edge.tested) > 0;
+}
+function describeTransition({ from, event, to }) {
+	return to === void 0 ? `${from} --${event}-->` : `${from} --${event}--> ${to}`;
+}
+/** What the expectation asks for and the machine did not reach, one line each. */
+function missedReach(machine, expected) {
+	const reached = new Set(reachedStates(machine));
+	const states = (expected.states ?? []).map((id) => {
+		if (!machine.states.some((state) => state.id === id)) return `state ${id} does not exist`;
+		return reached.has(id) ? null : `state ${id} was not reached`;
+	});
+	const transitions = (expected.transitions ?? []).map((wanted) => {
+		const matching = machine.edges.filter((edge) => edge.kind !== "effect" && edge.kind !== "initial" && edge.from === wanted.from && edge.event === wanted.event && (wanted.to === void 0 || edge.to === wanted.to));
+		if (matching.length === 0) return `transition ${describeTransition(wanted)} does not exist`;
+		return matching.some(isTaken) ? null : `transition ${describeTransition(wanted)} was not taken`;
+	});
+	return [...states, ...transitions].filter((line) => line !== null);
+}
+function failOnMiss(machine, misses) {
+	if (misses.length === 0) return;
+	throw new Error(`${machine.id} missed ${misses.length} expected ${misses.length === 1 ? "reach" : "reaches"}:\n${misses.map((each) => `  - ${each}`).join("\n")}\nAdd an example run to \`tests\`, or raise \`fuzz.iterations\`, to cover it.`);
+}
+/**
+* Call from a test: throws unless fuzzing or the target's `tests` visited every
+* listed state and took every listed transition. Reaching is proof; a miss only
+* says nothing got there yet.
+*/
+function expectReached(target, expected) {
+	const { machine } = inspect(target);
+	failOnMiss(machine, missedReach(machine, expected));
+}
+/** Call from a test: throws unless fuzzing or the target's `tests` visited every declared state. */
+function expectAllStatesReached(target) {
+	const { machine } = inspect(target);
+	failOnMiss(machine, missedReach(machine, { states: machine.states.map((state) => state.id) }));
+}
+export { analyzeModule, analyzeSource, annotateMachine, branchDistance, branchDistanceGuide, designErrors, eventCatalog, execute, expectAllStatesReached, expectNoDesignErrors, expectReached, fuzz, fuzzedMachine, guidance, inspect, inspectFile, inspectModule, literalPool, machineId, missedReach, reachedStates, shrink, toViz, toVizMachine, unreachableStates, vizDocument, withTestCoverage };

package/dist/{load-Dw5KOFuM.mjs → load-D0_Jl6Wr.mjs}

@@ -407,6 +407,7 @@ function fuzz(target, options) {
 		}
 	}
 	consider([], 0);
+	for (const steps of options.initial ?? []) consider([...steps], 0);
 	for (let iteration = 1; iteration <= options.iterations; iteration += 1) {
 		const at = context.rng.int(corpus.length);
 		consider(mutate({
@@ -1600,6 +1601,7 @@ function driven(target, context) {
 	const fuzzed = settings === false ? structure : fuzzedMachine(run[1], fuzz(run[1], {
 		seed: settings?.seed ?? DEFAULT_SEED,
 		iterations: settings?.iterations ?? DEFAULT_ITERATIONS,
+		...target.tests === void 0 ? {} : { initial: target.tests },
 		...guidance(structure)
 	}));
 	return {

package/dist/vite.d.mts

@@ -1,5 +1,6 @@
 import { t as FuzzSettings } from "./inspect-DvQtAcwv.mjs";
 import { Plugin } from "vite";
+export declare const STYLESHEETS: string[];
 export interface MantaqVizOptions {
   /** Files that export machines: paths or globs, relative to the Vite root. */
   machines: string | string[];
@@ -8,4 +9,13 @@ export interface MantaqVizOptions {
   /** `false` = structure only. Default: 500 iterations, so a save redraws quickly. */
   fuzz?: false | FuzzSettings;
 }
+export declare const TARGETS = "virtual:mantaq/targets";
+export declare const TARGETS_RESOLVED = "\0virtual:mantaq/targets";
+/**
+ * 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.
+ */
+export declare function targetsSource(files: ReadonlyArray<string>): string;
 export declare function mantaqViz(options: MantaqVizOptions): Plugin[];

package/dist/vite.mjs

@@ -1,4 +1,4 @@
-import { c as projectRoot, i as runOf, l as vizDocument, n as inspectEntry, s as machineId, t as entryId, u as analyzeModule } from "./load-Dw5KOFuM.mjs";
+import { c as projectRoot, i as runOf, l as vizDocument, n as inspectEntry, s as machineId, t as entryId, u as analyzeModule } from "./load-D0_Jl6Wr.mjs";
 import { UPDATE_EVENT, livePageHtml, serializeViz } from "@mantaq/viz";
 import { Either } from "@mantaq/utils";
 import { dirname, isAbsolute, resolve } from "node:path";
@@ -88,8 +88,8 @@ function mantaqViz(options) {
 			configResolved: (config) => {
 				root = config.root;
 			},
-			resolveId: (id) => id === TARGETS ? TARGETS_RESOLVED : null,
-			load: (id) => id === TARGETS_RESOLVED ? targetsSource(machineFiles(root, patterns)) : null
+			resolveId: (id) => id === "virtual:mantaq/targets" ? TARGETS_RESOLVED : null,
+			load: (id) => id === "\0virtual:mantaq/targets" ? targetsSource(machineFiles(root, patterns)) : null
 		},
 		{
 			name: "mantaq-viz",
@@ -156,4 +156,4 @@ function mantaqViz(options) {
 		}
 	];
 }
-export { mantaqViz };
+export { STYLESHEETS, TARGETS, TARGETS_RESOLVED, mantaqViz, targetsSource };

package/package.json

@@ -1,16 +1,13 @@
 {
   "name": "@mantaq/inspect",
-  "version": "0.2.3",
-  "description": "Turn a Mantaq machine into a viz document: structure, handler explanations (AST), fuzz and test coverage. CLI and Vite plugin included.",
+  "version": "0.4.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"
   ],
@@ -27,11 +24,11 @@
   },
   "dependencies": {
     "typescript": "6.0.3",
-    "@mantaq/core": "0.5.3",
-    "@mantaq/pbt": "0.0.4",
+    "@mantaq/core": "0.5.4",
+    "@mantaq/traversal": "0.3.4",
+    "@mantaq/viz": "0.3.0",
     "@mantaq/utils": "0.0.5",
-    "@mantaq/viz": "0.2.3",
-    "@mantaq/traversal": "0.3.3"
+    "@mantaq/pbt": "0.0.4"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
@@ -39,7 +36,7 @@
     "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"
+    "@mantaq/sugar": "2.0.4"
   },
   "peerDependencies": {
     "vite": "*"

package/dist/cli.d.mts

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

package/dist/cli.mjs

@@ -1,108 +0,0 @@
-#!/usr/bin/env node
-import { l as vizDocument, r as inspectFile } from "./load-Dw5KOFuM.mjs";
-import { t as htmlPage } from "./page-rr9IQ-4k.mjs";
-import { serializeViz } from "@mantaq/viz";
-import { Either } from "@mantaq/utils";
-import { basename, resolve } from "node:path";
-import { SEED_ENV, parseSeed } from "@mantaq/pbt";
-import { writeFileSync } from "node:fs";
-import { spawn } from "node:child_process";
-import { parseArgs } from "node:util";
-// src/cli.ts
-/**
-* mantaq-inspect: draw the machines a file exports.
-*
-*   mantaq-inspect <file.ts>... [--out FILE] [--json] [--no-fuzz] [--iterations N] [--config FILE]
-*                  [--mode MODE] [--no-open] [--check]
-*
-* Finds every exported actor or actor factory from the file's types, reads
-* handler explanations and sample payloads from the source, fuzzes each
-* machine that runs on a VirtualClock, and writes one self-contained HTML page
-* (default `mantaq-viz.html`) that opens without a server. `--json` writes the
-* viz document instead. `--config` loads the files with that Vite config (env,
-* aliases, plugins) and `--mode` picks its mode. `--check` exits 1 if any warning was printed or
-* fuzzing found a handler error (each printed as `error:`). Seed: MANTAQ_SEED (default from @mantaq/pbt).
-*/
-const USAGE = "usage: mantaq-inspect <file.ts>... [--out FILE] [--json] [--no-fuzz] [--iterations N] [--config FILE] [--mode MODE] [--no-open] [--check]\n";
-function loadOptions(config, mode) {
-	return {
-		...config === void 0 ? {} : { config: resolve(config) },
-		...mode === void 0 ? {} : { mode }
-	};
-}
-function parse() {
-	const parsed = Either.from(() => parseArgs({
-		allowPositionals: true,
-		options: {
-			out: { type: "string" },
-			json: { type: "boolean" },
-			iterations: { type: "string" },
-			config: { type: "string" },
-			mode: { type: "string" },
-			"no-fuzz": { type: "boolean" },
-			"no-open": { type: "boolean" },
-			check: { type: "boolean" }
-		}
-	}));
-	if (Either.isLeft(parsed)) return Either.left(String(parsed[0]));
-	const { positionals, values } = parsed[1];
-	if (positionals.length === 0) return Either.left("no file given");
-	const iterations = Number(values.iterations ?? 2e3);
-	if (!Number.isInteger(iterations) || iterations < 0) return Either.left("bad --iterations");
-	const seed = parseSeed(process.env[SEED_ENV]);
-	if (Either.isLeft(seed)) return Either.left(seed[0].message);
-	const json = values.json === true;
-	const fuzz = values["no-fuzz"] === true ? false : {
-		seed: seed[1],
-		iterations
-	};
-	return Either.right({
-		files: positionals.map((file) => resolve(file)),
-		out: resolve(values.out ?? (json ? "mantaq-viz.json" : "mantaq-viz.html")),
-		json,
-		fuzz,
-		check: values.check === true,
-		load: loadOptions(values.config, values.mode),
-		open: values["no-open"] !== true && !json && process.stdout.isTTY === true
-	});
-}
-function openInBrowser(path) {
-	const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer" : "xdg-open";
-	spawn(command, [path], {
-		stdio: "ignore",
-		detached: true
-	}).on("error", () => {}).unref();
-}
-function checkFails(results, machines) {
-	const errors = machines.flatMap((machine) => (machine.fuzz?.errors ?? []).map((error) => `${machine.id}: ${error.from} -${error.event}-> ${error.message}`));
-	for (const error of errors) process.stderr.write(`error: ${error}\n`);
-	return errors.length > 0 || results.some((result) => result.warnings.length > 0);
-}
-async function main() {
-	const options = parse();
-	if (Either.isLeft(options)) {
-		process.stderr.write(`${options[0]}\n${USAGE}`);
-		process.exitCode = 1;
-		return;
-	}
-	const { files, out, json, fuzz, open, check, load } = options[1];
-	const results = [];
-	for (const file of files) results.push(await inspectFile(file, { fuzz }, load));
-	for (const warning of results.flatMap((result) => result.warnings)) process.stderr.write(`warning: ${warning}\n`);
-	const failed = results.some((result) => result.failed);
-	if (failed) process.exitCode = 1;
-	const machines = results.flatMap((result) => result.machines);
-	if (check && checkFails(results, machines)) process.exitCode = 1;
-	if (machines.length === 0) {
-		if (!failed) process.stderr.write("no machines found\n");
-		process.exitCode = 1;
-		return;
-	}
-	const document = vizDocument(machines);
-	const title = `${files.map((file) => basename(file)).join(", ")} · mantaq viz`;
-	writeFileSync(out, json ? serializeViz(document) : await htmlPage(document, title));
-	process.stdout.write(`wrote ${out} (${machines.map((machine) => machine.id).join(", ")})\n`);
-	if (open) openInBrowser(out);
-}
-main();
-export {};

package/dist/page-rr9IQ-4k.mjs

@@ -1,38 +0,0 @@
-import { serializeViz, standaloneHtml } from "@mantaq/viz";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { build } from "vite";
-// src/page.ts
-/** The viewer as one classic script, built from `@mantaq/viz/standalone`, plus its stylesheets. */
-async function viewerBundle() {
-	const entry = fileURLToPath(import.meta.resolve("@mantaq/viz/standalone"));
-	const output = await build({
-		configFile: false,
-		logLevel: "silent",
-		build: {
-			write: false,
-			minify: true,
-			cssCodeSplit: false,
-			lib: {
-				entry,
-				formats: ["iife"],
-				name: "MantaqViz",
-				fileName: () => "viz.js"
-			}
-		}
-	});
-	return {
-		script: (Array.isArray(output) ? output : [output]).flatMap((each) => "output" in each ? each.output : []).flatMap((file) => file.type === "chunk" ? [file.code] : []).join("\n"),
-		css: ["@mantaq/viz/viewer.css", "@mantaq/viz/page.css"].map((id) => readFileSync(fileURLToPath(import.meta.resolve(id)), "utf8")).join("\n")
-	};
-}
-/** A self-contained HTML page for `document`: open it from disk, attach it, commit it. */
-async function htmlPage(document, title) {
-	const bundle = await viewerBundle();
-	return standaloneHtml({
-		title,
-		...bundle,
-		document: serializeViz(document)
-	});
-}
-export { htmlPage as t };