@mpis/monorepo 0.0.18 → 0.0.20

package/src/actions/cmd.dot.ts

@@ -0,0 +1,106 @@
+import { createWorkspace } from '@build-script/monorepo-lib';
+import { argv } from '@idlebox/args/default';
+import { logger } from '@idlebox/logger';
+import { shutdown } from '@idlebox/node';
+
+type NamePair = readonly [string, string];
+const outerScope: string[] = [];
+const scopes = new Map<string, string[]>();
+
+export async function runDot() {
+	const reverse = argv.flag(['--reverse', '-r']) > 0;
+	const prodOnly = argv.flag(['--prod', '-P']) > 0;
+	const devOnly = argv.flag(['--dev', '-D']) > 0;
+
+	// const packages = argv.range(0)
+
+	if (argv.unused().length) {
+		logger.error`Unknown arguments: ${argv.unused().join(', ')}`;
+		return shutdown(1);
+	}
+
+	const workspace = await createWorkspace();
+	await workspace.decoupleDependencies();
+
+	const projects = await workspace.listPackages();
+	logger.debug`workspace: ${projects.length} packages.`;
+	for (const project of projects) {
+		if (!project.name) continue;
+		if (ignoreName(project.name)) continue;
+
+		const [scopeName, nodeName] = split(project.name);
+
+		const all_deps = new Set<string>();
+		if (!devOnly) {
+			for (const [dep, version] of Object.entries(project.packageJson.dependencies ?? {})) {
+				if (!version.startsWith('workspace:') || ignoreName(dep)) continue;
+				all_deps.add(dep);
+			}
+		}
+		if (!prodOnly) {
+			for (const [dep, version] of Object.entries(project.packageJson.devDependencies ?? {})) {
+				if (!version.startsWith('workspace:') || ignoreName(dep)) continue;
+				all_deps.add(dep);
+			}
+		}
+
+		scope(scopeName).push(`  "${nodeName}" [label="${nodeName}\\n依赖: ${osize(project.packageJson.devDependencies)}+${osize(project.packageJson.dependencies)}"];`);
+		for (const dep of all_deps) {
+			const styles = [];
+			if (Object.hasOwn(project.packageJson.devDependencies ?? {}, dep)) {
+				styles.push('style=dashed', 'color=darkorange3');
+			} else {
+				styles.push('color=darkorchid3');
+			}
+
+			if (reverse) {
+				connect(split(dep), split(project.name), styles);
+			} else {
+				connect(split(project.name), split(dep), styles);
+			}
+		}
+	}
+
+	const output: string[] = ['digraph Tree {', 'splines=ortho;', 'node [shape=rect,style=filled,fillcolor=darkolivegreen3];'];
+	for (const lines of scopes.values()) {
+		output.push(...lines, '}');
+	}
+	output.push(...outerScope);
+	output.push('}');
+
+	console.log(output.join('\n'));
+}
+
+function split(name: string): NamePair {
+	name = name.replace(/-/g, '_');
+	if (name.startsWith('@')) {
+		const n = name.split('/');
+		return [n[0].slice(1), n[1]] as const;
+	} else {
+		return ['standalone', name] as const;
+	}
+}
+function scope(scopeName: string) {
+	const arr = scopes.get(scopeName);
+	if (arr) return arr;
+	const newArr: string[] = [`subgraph "cluster_${scopeName}" {`, `fillcolor=cornsilk;`, `style=filled;`, `label = "Scope @${scopeName}";`];
+	scopes.set(scopeName, newArr);
+	return newArr;
+}
+function connect(from: NamePair, to: NamePair, styles: string[] = []) {
+	if (from[0] === to[0]) {
+		scope(from[0]).push(`  "${from[1]}" -> "${to[1]}" [${styles.join(',')}];`);
+	} else {
+		styles.push(`ltail="cluster_${from[0]}"`, `lhead="cluster_${to[0]}"`);
+		outerScope.push(`  "${from[1]}" -> "${to[1]}" [${styles.join(',')}];`);
+	}
+}
+
+function ignoreName(_name: string) {
+	return false;
+}
+
+function osize(objects: object) {
+	if (!objects) return 0;
+	return Object.keys(objects).length;
+}

package/src/actions/cmd.list.ts

@@ -0,0 +1,41 @@
+import { argv } from '@idlebox/args/default';
+import { logger } from '@idlebox/logger';
+import { shutdown } from '@idlebox/node';
+import { spawn } from 'node:child_process';
+import { createMonorepoObject } from '../common/workspace.js';
+
+export async function runList() {
+	const reverse = argv.flag(['--reverse', '-r']) > 0;
+	const noPager = argv.flag(['--no-pager']) > 0 || !process.stdout.isTTY;
+	const depth = parseInt(argv.single(['--depth']) || '0', 10);
+	if (argv.unused().length) {
+		logger.error`Unknown arguments: ${argv.unused().join(', ')}`;
+		return shutdown(1);
+	}
+
+	const repo = await createMonorepoObject();
+	repo._finalize();
+
+	const text = repo.dump({
+		depth: depth,
+		reverse: reverse,
+		short: false,
+		summary: false,
+	});
+
+	if (noPager) {
+		console.log(text);
+	} else {
+		const less = spawnLess();
+		less.stdin.end(text);
+		await new Promise((resolve) => {
+			less.on('exit', resolve);
+		});
+	}
+}
+
+function spawnLess() {
+	return spawn('less', ['-r'], {
+		stdio: ['pipe', process.stdout, process.stderr],
+	});
+}

package/src/{common → actions}/cmd.watch.ts

@@ -3,9 +3,9 @@ import { InterruptError, prettyPrintError, registerGlobalLifecycle, type IDispos
 import { logger } from '@idlebox/logger';
 import { registerNodejsGlobalTypedErrorHandlerWithInheritance, shutdown } from '@idlebox/node';
 import { terminal, type ITitleControl } from '@idlebox/terminal-control';
-import { debugMode } from './args.js';
-import { startUi } from './user-interactive.js';
-import { createMonorepoObject } from './workspace.js';
+import { debugMode } from '../common/args.js';
+import { startUi } from '../common/user-interactive.js';
+import { createMonorepoObject } from '../common/workspace.js';
 
 let titleControl: ITitleControl | undefined;
 function setTitle(title: string) {
@@ -17,18 +17,20 @@ function setTitle(title: string) {
 }
 
 export async function runWatch() {
+	const debugChild = argv.flag('--child-verbose') > 0;
+
 	if (argv.unused().length) {
 		logger.error`Unknown arguments: ${argv.unused().join(', ')}`;
 		return shutdown(1);
 	}
 
 	let statePrinterDisposable: IDisposable | undefined;
-	const repo = await createMonorepoObject();
+	const repo = await createMonorepoObject({ debugChildren: debugChild });
 	const term = process.stderr.isTTY && !debugMode;
 
-	registerGlobalLifecycle(repo);
+	const userControl = startUi(repo);
 
-	startUi(repo);
+	registerGlobalLifecycle(repo);
 
 	registerNodejsGlobalTypedErrorHandlerWithInheritance(InterruptError, () => {
 		console.error(' -- Interrupted.');
@@ -46,6 +48,8 @@ export async function runWatch() {
 
 	if (!debugMode) {
 		statePrinterDisposable = repo.onStateChange(() => {
+			if (userControl.pause) return;
+
 			if (!repo.disposed && term) {
 				terminal.reset();
 				const p = repo.getProgress();
@@ -73,7 +77,7 @@ export async function runWatch() {
 		if (term) setTitle('启动');
 		await repo.startup();
 	} catch (e: any) {
-		if (debugMode) {
+		if (debugMode && !userControl.pause) {
 			if (!repo.disposed && term) {
 				terminal.reset();
 			}
@@ -83,9 +87,11 @@ export async function runWatch() {
 		shutdown(1);
 	}
 
-	if (!repo.disposed && term) {
-		setTitle('监视');
-		terminal.reset();
+	if (!userControl.pause) {
+		if (!repo.disposed && term) {
+			setTitle('监视');
+			terminal.reset();
+		}
+		repo.printScreen();
 	}
-	repo.printScreen();
 }

package/src/bin.ts

@@ -1,7 +1,8 @@
+import { argv } from '@idlebox/args/default';
 import { humanDate, registerGlobalLifecycle, toDisposable } from '@idlebox/common';
 import { createRootLogger, EnableLogLevel, logger } from '@idlebox/logger';
-import { debuggerBreakUserEntrypoint, registerNodejsExitHandler, setExitCodeIfNot } from '@idlebox/node';
-import { currentCommand, debugMode, helpMode, printUsage, verboseMode } from './common/args.js';
+import { debuggerBreakUserEntrypoint, registerNodejsExitHandler, setExitCodeIfNot, shutdown } from '@idlebox/node';
+import { debugMode, helpMode, printUsage, verboseMode } from './common/args.js';
 
 debuggerBreakUserEntrypoint();
 registerNodejsExitHandler();
@@ -16,9 +17,17 @@ createRootLogger('', level);
 
 if (helpMode) {
 	printUsage();
-	process.exit(0);
+	shutdown(0);
 }
 
+const cmd = argv.command(['build', 'watch', 'clean', 'list', 'ls', 'dot', 'analyze']);
+if (!cmd) {
+	printUsage();
+	logger.error`No command specified`;
+	shutdown(1);
+}
+export const currentCommand = cmd.value;
+
 const start = Date.now();
 registerGlobalLifecycle(
 	toDisposable(() => {
@@ -32,14 +41,14 @@ logger.log`working directory: ${process.cwd()}`;
 switch (currentCommand) {
 	case 'build':
 		{
-			const { runBuild } = await import('./common/cmd.build.js');
+			const { runBuild } = await import('./actions/cmd.build.js');
 			await runBuild();
 			setExitCodeIfNot(0);
 		}
 		break;
 	case 'watch':
 		{
-			const { runWatch } = await import('./common/cmd.watch.js');
+			const { runWatch } = await import('./actions/cmd.watch.js');
 			await runWatch();
 			setExitCodeIfNot(0);
 		}
@@ -47,13 +56,27 @@ switch (currentCommand) {
 	case 'list':
 	case 'ls':
 		{
-			const { runList } = await import('./common/cmd.list.js');
+			const { runList } = await import('./actions/cmd.list.js');
 			await runList();
 			setExitCodeIfNot(0);
 		}
 		break;
 	case 'clean':
 		throw new Error('The "clean" command is not implemented yet.');
+	case 'dot':
+		{
+			const { runDot } = await import('./actions/cmd.dot.js');
+			await runDot();
+			setExitCodeIfNot(0);
+		}
+		break;
+	case 'analyze':
+		{
+			const { runAnalyze } = await import('./actions/cmd.analyze.js');
+			await runAnalyze(cmd);
+			setExitCodeIfNot(0);
+		}
+		break;
 	default:
 		throw new Error(`impossible: invalid command`);
 }

package/src/common/args.ts

@@ -1,5 +1,4 @@
 import { argv } from '@idlebox/args/default';
-import { logger } from '@idlebox/logger';
 
 export function printUsage() {
 	console.log('Usage: build-manager <command>');
@@ -8,17 +7,11 @@ export function printUsage() {
 	console.log('  build   run build');
 	console.log('  watch   start watch mode');
 	console.log('  clean   cleanup all projects');
-	console.log('  list/ls [--depth=0] list projects');
+	console.log('  list/ls [--depth=0] [--reverse] list projects');
+	console.log('  dot     [--reverse] generate dot graph');
+	console.log('  analyze <package name> analyze package dependencies');
 }
 
 export const verboseMode = argv.flag(['-d', '--debug']) > 1;
 export const debugMode = argv.flag(['-d', '--debug']) > 0;
 export const helpMode = argv.flag(['-h', '--help']) > 0;
-
-const cmd = argv.command(['build', 'watch', 'clean', 'list', 'ls']);
-if (!cmd) {
-	printUsage();
-	logger.fatal`No command specified.`;
-	process.exit(1);
-}
-export const currentCommand = cmd.value;

package/src/common/string-collect.ts

@@ -0,0 +1,20 @@
+export class StringCollect<T> {
+	private readonly buffers = new Map<T, string[]>();
+
+	append(id: T, str: string) {
+		const list = this.buffers.get(id);
+		if (!list) {
+			this.buffers.set(id, [str]);
+		} else {
+			list.push(str);
+		}
+	}
+
+	get(id: T) {
+		return this.buffers.get(id)?.join('') ?? '';
+	}
+
+	clear(id: T) {
+		this.buffers.set(id, []);
+	}
+}

package/src/common/user-interactive.ts

@@ -1,11 +1,167 @@
-import { registerGlobalLifecycle, toDisposable } from '@idlebox/common';
-import { logger } from '@idlebox/logger';
+import { convertCaughtError, InterruptError, prettyPrintError, registerGlobalLifecycle, toDisposable } from '@idlebox/common';
+import { createLogger, EnableLogLevel } from '@idlebox/logger';
+import { createInterface, type Interface } from 'node:readline/promises';
+import { inspect } from 'node:util';
 import type { IPnpmMonoRepo } from './workspace.js';
 
-export async function startUi(_repo: IPnpmMonoRepo) {
+const logger = createLogger('user', true);
+logger.enable(EnableLogLevel.verbose);
+
+class UserControl {
+	private _pause = false;
+	private _quit = false;
+
+	public setPause(pause: boolean) {
+		this._pause = pause;
+	}
+	public togglePause() {
+		this._pause = !this._pause;
+		logger.info`${this._pause ? '暂停' : '恢复'}状态输出`;
+	}
+
+	get pause() {
+		return this._pause;
+	}
+
+	get quit() {
+		return this._quit;
+	}
+
+	public setQuit() {
+		this._quit = true;
+	}
+}
+
+export function startUi(repo: IPnpmMonoRepo) {
+	const controller = new UserControl();
+	if (!process.stdin.isTTY) {
+		logger.info`非交互式环境，跳过用户界面`;
+		return controller;
+	}
+
+	const rl = createInterface(process.stdin, process.stderr);
+
 	registerGlobalLifecycle(
 		toDisposable(async () => {
-			logger.error`NotImpl: (this is not an error) Exiting...`;
+			controller.setQuit();
+			rl.close();
 		}),
 	);
+
+	messageLoop(repo, controller, rl).catch((e) => {
+		if (controller.quit) return;
+		if (e.code === 'ABORT_ERR') {
+			throw new InterruptError('SIGINT');
+		}
+		prettyPrintError('命令接口错误', e);
+	});
+	return controller;
+}
+
+async function messageLoop(repo: IPnpmMonoRepo, controller: UserControl, rl: Interface) {
+	rl.setPrompt('> ');
+	while (!controller.quit) {
+		const line = await rl.question(`${helpText()}\n> `);
+
+		const [cmd, ...args] = line.trim().split(/\s+/g);
+
+		let found = false;
+		for (const [name, fn] of Object.entries(commands)) {
+			if (name.startsWith(cmd)) {
+				try {
+					await fn(repo, controller, args);
+				} catch (e) {
+					prettyPrintError(`命令执行错误: ${name}`, convertCaughtError(e));
+				}
+				found = true;
+				break;
+			}
+		}
+		if (!found) {
+			console.error(`未知命令: ${cmd}`);
+		}
+	}
+}
+
+function helpText() {
+	return '*** 帮助信息';
+}
+
+type CommandFunction = (repo: IPnpmMonoRepo, controller: UserControl, args: string[]) => void;
+
+const commands: Record<string, CommandFunction> = {
+	help() {
+		console.error(helpText());
+	},
+	status(repo) {
+		repo.printScreen();
+	},
+	pause(_repo, controller) {
+		controller.togglePause();
+	},
+	async dump(repo, controller, [what]: string[]) {
+		const pkg = await singleProject(repo, what);
+		if (!pkg) return;
+
+		const worker = repo._debugWorker(pkg);
+		Object.assign(globalThis, { dumpWorker: worker });
+
+		console.error(inspect(worker, { customInspect: false, colors: true }));
+
+		logger.info`已将项目 ${pkg.name} 的 worker 对象暴露为全局变量 dumpWorker`;
+		controller.setPause(true);
+
+		// biome-ignore lint/suspicious/noDebugger: it's for debugging
+		debugger;
+	},
+	async print(repo, _controller, [what]: string[]) {
+		const pkg = await singleProject(repo, what);
+		if (!pkg) return;
+
+		const output = repo._debugGetOutput(pkg);
+		if (output) {
+			console.error('\n\n');
+			console.error(output);
+			console.error('\n\n');
+		} else {
+			logger.error`项目 ${pkg.name} 没有输出`;
+		}
+	},
+	async errors(repo, _controller, [what]: string[]) {
+		const errMap = repo.getErrors();
+		const pkg = await singleProject(repo, what);
+		if (!pkg) return;
+
+		const err = errMap.get(pkg);
+		if (err) {
+			console.error('\n\n');
+			console.error(err);
+			console.error('\n\n');
+		} else {
+			logger.success`项目 ${pkg.name} 没有错误`;
+		}
+	},
+};
+
+async function singleProject(repo: IPnpmMonoRepo, name: string) {
+	if (!name) {
+		logger.error`需要指定项目`;
+		return null;
+	}
+
+	const exactMatch = await repo.workspace.getPackage(name);
+	if (exactMatch) {
+		return exactMatch;
+	}
+
+	const packages = await repo.workspace.listPackages();
+	const pkgs = packages.filter((p) => p.name?.includes(name));
+	if (pkgs.length === 0) {
+		logger.error`没有找到匹配的项目: ${name}`;
+		return null;
+	} else if (pkgs.length > 1) {
+		logger.error`找到多个匹配的项目list<${pkgs.map((e) => e.name)}>`;
+		return null;
+	}
+	return pkgs[0];
 }

package/src/common/workspace.ts

@@ -6,13 +6,18 @@ import { CompileError, ModeKind, ProcessIPCClient, WorkerClientState, WorkersMan
 import { RigConfig, type IRigConfig } from '@rushstack/rig-package';
 import { dirname, resolve } from 'node:path';
 import { split as splitCmd } from 'split-cmd';
-import { currentCommand } from './args.js';
+import { currentCommand } from '../bin.js';
+import { StringCollect } from './string-collect.js';
 
-export async function createMonorepoObject() {
+interface IOptions {
+	readonly debugChildren?: boolean;
+}
+
+export async function createMonorepoObject(options?: IOptions) {
 	const workspace = await createWorkspace();
 	logger.debug`workspace: long<${workspace.root}>`;
 	const repo = new PnpmMonoRepo(logger, workspace);
-	await repo.initialize();
+	await repo.initialize(options);
 	return repo;
 }
 
@@ -20,11 +25,19 @@ export type IPnpmMonoRepo = PnpmMonoRepo;
 const colorReg = /\x1B\[[0-9;]+?m/g;
 const unclosedColorReg = /\x1B\[[^m]*$/g;
 
+interface IDumpOptions {
+	readonly depth?: number;
+	readonly summary?: boolean;
+	readonly short?: boolean;
+	readonly reverse?: boolean;
+}
+
 const firstEmptyLine = /^\s*\n/;
 class PnpmMonoRepo extends EnhancedAsyncDisposable {
-	private readonly workersManager: WorkersManager;
+	public readonly workersManager: WorkersManager;
 	private readonly pathvar: PathArray;
 	private readonly errorMessages = new Map<IPackageInfo, string>();
+	private readonly debugOutputs = new StringCollect<IPackageInfo>();
 	private readonly rigConfig = new Map<IPackageInfo, IRigConfig>(); // TODO: 太重了
 
 	private readonly _onStateChange = this._register(new Emitter<void>());
@@ -35,7 +48,7 @@ class PnpmMonoRepo extends EnhancedAsyncDisposable {
 
 	constructor(
 		public readonly logger: IMyLogger,
-		protected readonly workspace: MonorepoWorkspace,
+		public readonly workspace: MonorepoWorkspace,
 	) {
 		super('PnpmMonoRepo');
 
@@ -50,14 +63,20 @@ class PnpmMonoRepo extends EnhancedAsyncDisposable {
 		this.workersManager = new WorkersManager(this.mode, logger);
 	}
 
-	async initialize() {
+	async initialize({ debugChildren = false }: IOptions = {}) {
 		await this.workspace.decoupleDependencies();
 		const projects = await this.workspace.listPackages();
 		logger.debug`workspace: ${projects.length} packages.`;
 		for (const project of projects) {
 			if (!project.packageJson.name) continue;
 
-			const exec = this.makeExecuter(this.mode === ModeKind.Watch, project);
+			const addEnvs: Record<string, string> = {};
+			if (debugChildren) {
+				addEnvs['DEBUG_LEVEL'] = 'verbose';
+				addEnvs['DEBUG'] = '* -executer:* -dispose:*';
+			}
+
+			const exec = this.makeExecuter(this.mode === ModeKind.Watch, project, addEnvs);
 			if (exec) {
 				const all_deps = new Set<string>([...project.devDependencies, ...project.dependencies]);
 				this.workersManager.addWorker(exec, Array.from(all_deps));
@@ -78,7 +97,7 @@ class PnpmMonoRepo extends EnhancedAsyncDisposable {
 		await graph.startup();
 	}
 
-	private makeExecuter(watchMode: boolean, project: IPackageInfo): undefined | ProcessIPCClient {
+	private makeExecuter(watchMode: boolean, project: IPackageInfo, addEnvs: Record<string, string> = {}): undefined | ProcessIPCClient {
 		if (project.packageJson.scripts?.watch === undefined) {
 			this.logger.fatal`project ${project.packageJson.name} does not have a "watch" script. If it doesn't need, specify a empty string.`;
 		}
@@ -98,7 +117,7 @@ class PnpmMonoRepo extends EnhancedAsyncDisposable {
 		}
 		const logger = this.logger.extend(project.name);
 
-		const env: Record<string, string> = {};
+		const env: Record<string, string> = { ...addEnvs };
 		env[isWindows ? 'Path' : 'PATH'] = this.forkPath(project).toString();
 
 		const exec = new ProcessIPCClient(project.packageJson.name, cmds, project.absolute, env, logger); // TODO: env add Path
@@ -107,22 +126,29 @@ class PnpmMonoRepo extends EnhancedAsyncDisposable {
 		}
 
 		exec.onFailure((e) => {
+			const output = (e as CompileError).output ?? '## onFailure: no output from process ##';
+			this.debugOutputs.append(project, output);
 			if (e instanceof CompileError) {
-				this.errorMessages.set(project, `${e.message}\n${e.output ?? 'no output from process'}`);
+				this.errorMessages.set(project, `${e.message}\n${output}`);
 			} else {
 				this.errorMessages.set(project, e.stack || e.message);
 			}
 			this._onStateChange.fireNoError();
 		});
-		exec.onSuccess(() => {
+		exec.onSuccess((e) => {
+			const output = e.output ?? '## onSuccess: no output from process ##';
+			this.debugOutputs.append(project, output);
+
 			this.errorMessages.delete(project);
 			this._onStateChange.fireNoError();
 		});
 		exec.onStart(() => {
+			this.debugOutputs.clear(project);
 			this.errorMessages.delete(project);
 			this._onStateChange.fireNoError();
 		});
 		exec.onTerminate(() => {
+			this.debugOutputs.append(project, '## onTerminate: process terminated ##');
 			try {
 				this._onStateChange.fireNoError();
 			} catch (e) {
@@ -150,6 +176,25 @@ class PnpmMonoRepo extends EnhancedAsyncDisposable {
 		});
 	}
 
+	/**
+	 * @internal
+	 */
+	_debugWorker(project: IPackageInfo) {
+		return this.packageToWorker.get(project);
+	}
+
+	/**
+	 * @internal
+	 */
+	_debugGetOutput(project: IPackageInfo): string | undefined {
+		const worker = this.packageToWorker.get(project);
+		return worker?.outputStream.toString();
+	}
+
+	getErrors(): ReadonlyMap<IPackageInfo, string> {
+		return this.errorMessages;
+	}
+
 	formatErrors() {
 		if (this.errorMessages.size === 0) return '';
 		let output = '';
@@ -223,7 +268,7 @@ class PnpmMonoRepo extends EnhancedAsyncDisposable {
 		return Math.floor((100 * completed) / count);
 	}
 
-	dump(depth: number = 0, short = false) {
+	dump({ depth = 0, short = false, summary = true, reverse = false }: IDumpOptions = {}) {
 		const graph = this.workersManager.finalize();
 		let graphTxt: string;
 		if (depth <= 0) {
@@ -235,23 +280,25 @@ class PnpmMonoRepo extends EnhancedAsyncDisposable {
 						result.push(node.customInspect());
 					}
 				}
-				result.push(graph.debugFormatSummary());
+				if (summary) result.push(graph.debugFormatSummary());
 				return result.join('\n');
 			} else {
 				graphTxt = graph.debugFormatList();
 			}
 		} else {
-			graphTxt = graph.debugFormatGraph(depth);
+			graphTxt = graph.debugFormatGraph(depth, reverse);
 		}
+		if (!summary) return graphTxt;
+
 		return `${graphTxt}\n${graph.debugFormatSummary()}`;
 	}
 
 	printScreen(short = false, listAbove = false) {
 		let r = this.formatErrors();
 		if (listAbove) {
-			r = this.dump(0, short) + r;
+			r = this.dump({ short }) + r;
 		} else {
-			r += this.dump(0, short);
+			r += this.dump({ short });
 		}
 		console.error(r);
 	}