@mantaq/inspect 0.3.0 → 0.5.0

package/dist/{vite-BBW0CmYr.mjs → inspect-B7ZQCNM2.mjs}

@@ -1,14 +1,12 @@
-import { i as execute, r as eventCatalog } from "./run-B5huYj_r.mjs";
-import { ANY_STATE, UPDATE_EVENT, VIZ_SCHEMA_VERSION, coveredByAny, isAnyState, livePageHtml, routingWarnings, serializeViz, unhandledSends } from "@mantaq/viz";
+import { i as execute, r as eventCatalog, t as applyStep } from "./run-B5huYj_r.mjs";
+import { ANY_STATE, VIZ_SCHEMA_VERSION, coveredByAny, isAnyState, routingWarnings, unhandledSends } from "@mantaq/viz";
 import { INITIAL_NODE_ID, buildGraph, parseInternalEventIds } from "@mantaq/traversal";
 import { Either } from "@mantaq/utils";
 import ts from "typescript";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, join, relative, sep } from "node:path";
 import { DEFAULT_SEED } from "@mantaq/pbt";
 import { VirtualClock } from "@mantaq/core";
-import { existsSync, globSync, readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { loadConfigFromFile, loadEnv, runnerImport, searchForWorkspaceRoot } from "vite";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 // src/structure.ts
 function byId$1(left, right) {
 	if (left.id < right.id) return -1;
@@ -126,7 +124,8 @@ function toVizMachine(input) {
 		states,
 		events,
 		edges,
-		fuzz: null
+		fuzz: null,
+		runs: []
 	};
 }
 function toViz(inputs) {
@@ -407,6 +406,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({
@@ -1556,6 +1556,107 @@ function annotateWith(machine, context) {
 		edges
 	};
 }
+// src/runs.ts
+/** Name of the folder, next to the test files, that holds recorded runs. */
+const RUNS_DIR = "__runs__";
+function dropOne(list, item) {
+	const at = list.indexOf(item);
+	if (at < 0) return false;
+	list.splice(at, 1);
+	return true;
+}
+/**
+* Replay a raw recording on a fresh actor and keep only the steps that cannot
+* be reproduced: an internal event the replay already produced (a timer after
+* its advance, a synchronous emit after its send) is dropped, one it did not
+* (a promise result) is kept. Left when the replay ends elsewhere than the
+* test did.
+*/
+function normalizeRun(target, run) {
+	const { actor, clock } = target.create();
+	const internal = new Set(eventCatalog(actor).internal);
+	let produced = [];
+	actor.on("transition", { fn: ({ event }) => void produced.push(event.type) });
+	const known = /* @__PURE__ */ new Set([...eventCatalog(actor).inputs, ...internal]);
+	const unknown = run.steps.find((step) => step.kind === "event" && !known.has(step.event));
+	if (unknown?.kind === "event") {
+		actor.dispose();
+		return Either.left(`unknown event "${unknown.event}"`);
+	}
+	const kept = [];
+	for (const step of run.steps) {
+		if (step.kind === "event" && internal.has(step.event) && dropOne(produced, step.event)) continue;
+		produced = [];
+		applyStep(actor, {
+			step,
+			clock,
+			internal
+		});
+		if (step.kind === "event" && internal.has(step.event)) dropOne(produced, step.event);
+		kept.push(step);
+	}
+	const ended = actor.state.name;
+	actor.dispose();
+	return ended === run.end ? Either.right(kept) : Either.left(`replays to ${ended}, the test ended in ${run.end}`);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJson(value) {
+	return Either.isRight(Either.from(() => JSON.stringify(value)));
+}
+function isStep(value) {
+	if (!isRecord(value)) return false;
+	if (value["kind"] === "advance") return typeof value["ms"] === "number" && value["ms"] >= 0;
+	return value["kind"] === "event" && typeof value["event"] === "string" && isJson(value["payload"]);
+}
+function isRecorded(value) {
+	return isRecord(value) && typeof value["name"] === "string" && typeof value["end"] === "string" && Array.isArray(value["steps"]) && value["steps"].every(isStep);
+}
+function readFile(file) {
+	const name = basename(file);
+	const text = Either.from(() => JSON.parse(readFileSync(file, "utf8")));
+	if (Either.isLeft(text) || !isRecord(text[1])) return {
+		runs: {},
+		warnings: [`${RUNS_DIR}/${name}: not a JSON object, ignored`]
+	};
+	const entries = Object.entries(text[1]).map(([id, runs]) => {
+		const list = Array.isArray(runs) ? runs : [];
+		const valid = list.filter(isRecorded);
+		return {
+			id,
+			valid,
+			bad: Array.isArray(runs) ? list.length - valid.length : 1
+		};
+	});
+	return {
+		runs: Object.fromEntries(entries.map(({ id, valid }) => [id, valid])),
+		warnings: entries.filter(({ bad }) => bad > 0).map(({ id, bad }) => `${RUNS_DIR}/${name}: ${bad} malformed run(s) for "${id}" ignored`)
+	};
+}
+/**
+* Every run recorded for the test files in `dir`: the `__runs__/*.json` files
+* next to them, merged by machine id in file-name order, and a warning for
+* each file or run that could not be read.
+*/
+function readRuns(dir) {
+	const listing = Either.from(() => readdirSync(join(dir, RUNS_DIR)).sort());
+	if (Either.isLeft(listing)) return {
+		runs: {},
+		warnings: []
+	};
+	const merged = {};
+	const warnings = [];
+	for (const name of listing[1].filter((each) => each.endsWith(".json"))) {
+		const read = readFile(join(dir, RUNS_DIR, name));
+		warnings.push(...read.warnings);
+		for (const [id, runs] of Object.entries(read.runs)) merged[id] = [...merged[id] ?? [], ...runs];
+	}
+	return {
+		runs: merged,
+		warnings
+	};
+}
 // src/inspect.ts
 const DEFAULT_ITERATIONS = 2e3;
 function isVirtualClock(clock) {
@@ -1600,10 +1701,11 @@ 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.map((run) => run.steps) },
 		...guidance(structure)
 	}));
 	return {
-		machine: target.tests === void 0 ? fuzzed : withTestCoverage(run[1], fuzzed, target.tests),
+		machine: target.tests === void 0 ? fuzzed : withTestCoverage(run[1], fuzzed, target.tests.map((each) => each.steps)),
 		skipped: []
 	};
 }
@@ -1622,7 +1724,10 @@ function inspectWith(target, analysis) {
 	});
 	const quiet = target.fuzz === false && target.tests === void 0;
 	const unanalyzed = analysis === null ? [] : [Either.getLeft(analysis)].filter((each) => each !== void 0);
-	const annotated = annotate(machine);
+	const annotated = annotate({
+		...machine,
+		runs: [...target.tests ?? []]
+	});
 	return {
 		machine: annotated,
 		warnings: [
@@ -1676,6 +1781,33 @@ function actorFactory(found, value) {
 		return isActor(actor) ? actor : sample;
 	};
 }
+/** The recorded runs of one machine that replay faithfully, and a warning for each that does not. */
+function replayedRuns(id, create, recorded) {
+	const found = recorded[id] ?? [];
+	if (found.length === 0) return {
+		runs: [],
+		warnings: []
+	};
+	const run = runner({
+		id,
+		create
+	}, {});
+	if (Either.isLeft(run)) return {
+		runs: [],
+		warnings: [`runs not shown: ${run[0]}`]
+	};
+	const results = found.map((each) => ({
+		each,
+		result: normalizeRun(run[1], each)
+	}));
+	return {
+		runs: results.flatMap(({ each, result }) => Either.isRight(result) ? [{
+			name: each.name,
+			steps: result[1]
+		}] : []),
+		warnings: results.flatMap(({ each, result }) => Either.isLeft(result) ? [`run "${each.name}" dropped: ${result[0]}`] : [])
+	};
+}
 /**
 * Every machine a file exports, found from its types: actors, and functions
 * that build one (optionally taking a clock or `{ clock }`). When a file has
@@ -1701,6 +1833,7 @@ async function inspectModule(file, options) {
 		warnings: [`${file}: no exported actor or actor factory found`]
 	};
 	const exports = await options.load(file);
+	const { runs: recorded, warnings: runWarnings } = readRuns(dirname(file));
 	const results = chosen.map((each) => {
 		const id = machineId(each.name);
 		const create = actorFactory(each, exports[each.name]);
@@ -1709,21 +1842,30 @@ async function inspectModule(file, options) {
 			warnings: [`${id}: ${each.name} did not return an actor`]
 		};
 		const fuzzSettings = each.call === "instance" ? false : options.fuzz ?? {};
+		const replayed = each.call === "instance" ? {
+			runs: [],
+			warnings: (recorded[id] ?? []).length === 0 ? [] : ["runs not shown: exported as one actor, so they cannot be replayed safely"]
+		} : replayedRuns(id, create, recorded);
 		const inspected = inspectWith({
 			id,
 			create,
 			source,
-			fuzz: fuzzSettings
+			fuzz: fuzzSettings,
+			...replayed.runs.length === 0 ? {} : { tests: replayed.runs }
 		}, analysis);
 		const instance = each.call === "instance" ? ["not fuzzed: exported as one actor, not a factory"] : [];
 		return {
 			machine: inspected.machine,
-			warnings: [...instance, ...inspected.warnings].map((warning) => `${id}: ${warning}`)
+			warnings: [
+				...instance,
+				...replayed.warnings,
+				...inspected.warnings
+			].map((warning) => `${id}: ${warning}`)
 		};
 	});
 	return {
 		machines: results.flatMap((result) => result.machine === null ? [] : [result.machine]),
-		warnings: results.flatMap((result) => result.warnings)
+		warnings: [...runWarnings.map((warning) => `${file}: ${warning}`), ...results.flatMap((result) => result.warnings)]
 	};
 }
 /** Machines as a document, ready for `serializeViz`. */
@@ -1733,280 +1875,4 @@ function vizDocument(machines) {
 		machines: [...machines]
 	};
 }
-// 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
-	};
-}
-// 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" })] });
-*
-* 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 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();
-	return [
-		inspectEntry(),
-		{
-			name: "mantaq-viz-targets",
-			apply: "serve",
-			configResolved: (config) => {
-				root = config.root;
-			},
-			resolveId: (id) => id === "virtual:mantaq/targets" ? TARGETS_RESOLVED : null,
-			load: (id) => id === "\0virtual:mantaq/targets" ? targetsSource(machineFiles(root, patterns)) : null
-		},
-		{
-			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.map((id) => readFileSync(fileURLToPath(import.meta.resolve(id)), "utf8")).join("\n")
-					});
-					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}`);
-				});
-			}
-		}
-	];
-}
-export { toViz as C, shrink as S, guidance as _, targetsSource as a, withTestCoverage as b, inspect as c, vizDocument as d, analyzeModule as f, branchDistanceGuide as g, branchDistance as h, mantaqViz as i, inspectModule as l, annotateMachine as m, TARGETS as n, inlineConfig as o, analyzeSource as p, TARGETS_RESOLVED as r, inspectFile as s, STYLESHEETS as t, machineId as u, literalPool as v, toVizMachine as w, fuzz as x, fuzzedMachine as y };
+export { toViz as _, vizDocument as a, annotateMachine as c, guidance as d, literalPool as f, shrink as g, fuzz as h, projectRoot as i, branchDistance as l, withTestCoverage as m, inspectModule as n, analyzeModule as o, fuzzedMachine as p, machineId as r, analyzeSource as s, inspect as t, branchDistanceGuide as u, toVizMachine as v };

package/dist/{inspect-DvQtAcwv.d.mts → inspect-vSdt2qtL.d.mts}

@@ -1,4 +1,4 @@
-import { VizDocument, VizJson, VizMachine, VizStep } from "@mantaq/viz";
+import { VizDocument, VizJson, VizMachine, VizRun } from "@mantaq/viz";
 import { Either } from "@mantaq/utils";
 import ts from "typescript";
 import { AnyActor } from "@mantaq/core";
@@ -23,8 +23,8 @@ interface InspectTarget {
   source?: AnalysisSource;
   /** Sample payloads per event; replace the ones read from types. */
   payloads?: Readonly<Record<string, ReadonlyArray<VizJson>>>;
-  /** Event sequences your tests send, for "Coverage from: example tests". */
-  tests?: ReadonlyArray<ReadonlyArray<VizStep>>;
+  /** Named runs your tests take: "Coverage from: example tests", fuzz seeds, and the live page's Runs list. */
+  tests?: ReadonlyArray<VizRun>;
   /** `false` = structure only. */
   fuzz?: false | FuzzSettings;
 }

package/dist/live-entry.mjs

@@ -1,6 +1,88 @@
-import { n as mountLiveDriven } from "./live-page-DEDl_Nio.mjs";
-import { UPDATE_EVENT } from "@mantaq/viz";
+import { createDriver } from "./drive.mjs";
+import { UPDATE_EVENT, parseViz } from "@mantaq/viz";
+import { Either } from "@mantaq/utils";
 import { targets } from "virtual:mantaq/targets";
+import { mountViewer, showIssues } from "@mantaq/viz/viewer";
+import { linkOptions } from "@mantaq/viz/page";
+// src/live-page.ts
+/**
+* The live page of the Vite plugin: the served document, with each machine
+* that has a target running for real behind the viewer. The walk lives in the
+* address bar (`?machine=&step=`), so a redraw after a save replays it on the
+* new code.
+*/
+/** A document holding only `machine`, so the viewer shows the machine its driver runs. */
+function only(viz, machine) {
+	const chosen = viz.machines.find((each) => each.id === machine) ?? viz.machines[0];
+	return {
+		...viz,
+		machines: chosen === void 0 ? [] : [chosen]
+	};
+}
+/** Mount the document at `text`; machines with a target run live, the rest stay static walks. */
+function mountDriven(root, context) {
+	const parsed = parseViz(context.text);
+	if (Either.isLeft(parsed)) {
+		showIssues(root, {
+			source: context.source,
+			issues: parsed[0]
+		});
+		return;
+	}
+	const options = linkOptions();
+	const viz = parsed[1];
+	const shown = only(viz, options.machine ?? null);
+	const id = shown.machines[0]?.id ?? "";
+	const target = context.targets[id];
+	const create = target !== void 0 && typeof Reflect.get(target().clock, "advance") === "function" ? target : void 0;
+	const picker = viz.machines.length > 1;
+	const select = (machine) => {
+		const next = new URLSearchParams(location.search);
+		next.set("machine", machine);
+		next.delete("step");
+		history.replaceState(null, "", `?${next.toString()}`);
+		mountDriven(root, context);
+	};
+	const doc = root.ownerDocument;
+	const bar = doc.createElement("nav");
+	bar.className = "machines";
+	if (picker) for (const machine of viz.machines) {
+		const button = doc.createElement("button");
+		button.type = "button";
+		button.textContent = machine.id;
+		button.disabled = machine.id === id;
+		button.addEventListener("click", () => select(machine.id));
+		bar.append(button);
+	}
+	const viewer = doc.createElement("div");
+	root.replaceChildren(...picker ? [bar] : [], viewer);
+	mountViewer(viewer, shown, {
+		...options,
+		...create === void 0 ? {} : { driver: createDriver({
+			id,
+			create
+		}) }
+	});
+}
+/** Fetch the document from `source` and mount it; call again to redraw, keeping the walk. */
+async function mountLiveDriven(root, context) {
+	const response = await fetch(context.source).catch(() => null);
+	if (response === null || !response.ok) {
+		const status = response === null ? "network error" : `HTTP ${response.status}`;
+		showIssues(root, {
+			source: context.source,
+			issues: [{
+				path: "$",
+				message: status
+			}]
+		});
+		return;
+	}
+	mountDriven(root, {
+		...context,
+		text: await response.text()
+	});
+}
 // src/live-entry.ts
 /**
 * Entry of the page `@mantaq/inspect/vite` serves. Redraws when the dev