@fuzdev/fuz_gitops 0.77.0 → 0.78.1

package/src/lib/local_repo.ts

@@ -1,26 +1,36 @@
-import {strip_end} from '@fuzdev/fuz_util/string.js';
-import type {LibraryJson} from '@fuzdev/fuz_util/library_json.js';
-import type {PackageJson} from '@fuzdev/fuz_util/package_json.js';
-import {Library} from '@fuzdev/fuz_ui/library.svelte.js';
-import {existsSync} from 'node:fs';
-import {join} from 'node:path';
-import {TaskError} from '@fuzdev/gro';
-import {library_load_from_repo} from '@fuzdev/gro/library_load.js';
-import type {Logger} from '@fuzdev/fuz_util/log.js';
-import {spawn_out} from '@fuzdev/fuz_util/process.js';
-import {map_concurrent_settled} from '@fuzdev/fuz_util/async.js';
-import type {GitOperations, NpmOperations} from './operations.js';
-import {default_git_operations, default_npm_operations} from './operations_defaults.js';
-
-import type {GitopsConfig, GitopsRepoConfig} from './gitops_config.js';
-import type {ResolvedGitopsConfig} from './resolved_gitops_config.js';
-import {GITOPS_CONCURRENCY_DEFAULT} from './gitops_constants.js';
+import { strip_end } from '@fuzdev/fuz_util/string.ts';
+import { to_error_message } from '@fuzdev/fuz_util/error.ts';
+import { library_json_from_modules, type LibraryJson } from '@fuzdev/fuz_util/library_json.ts';
+import type { PackageJson } from '@fuzdev/fuz_util/package_json.ts';
+import { Library } from '@fuzdev/fuz_ui/library.svelte.ts';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { TaskError } from '@fuzdev/gro';
+import { library_load_from_repo } from '@fuzdev/gro/library_load.ts';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { spawn_out } from '@fuzdev/fuz_util/process.ts';
+import { map_concurrent_settled } from '@fuzdev/fuz_util/async.ts';
+import type { GitOperations, NpmOperations } from './operations.ts';
+import { default_git_operations, default_npm_operations } from './operations_defaults.ts';
+
+import type { GitopsConfig, GitopsRepoConfig } from './gitops_config.ts';
+import type { ResolvedGitopsConfig } from './resolved_gitops_config.ts';
+import { GITOPS_CONCURRENCY_DEFAULT } from './gitops_constants.ts';
+import { cargo_toml_load } from './cargo_toml.ts';
 
 /**
  * Fully loaded local repo with `Library` and extracted dependency data.
  * Does not extend `LocalRepoPath` - `Library` is source of truth for name/repo_url/etc.
  */
 export interface LocalRepo {
+	/**
+	 * Which packaging ecosystem the repo belongs to. `npm` repos (with a
+	 * `package.json`) take part in the changeset publishing cascade; `cargo` repos
+	 * (a Rust `Cargo.toml`, no `package.json`) are dashboard-only — fetched and
+	 * rendered like any repo but excluded from publishing/analysis. See
+	 * `repo_is_npm`.
+	 */
+	kind: 'npm' | 'cargo';
 	library: Library;
 	/** The repo's full `package.json` (with `dependencies`/`devDependencies`). */
 	package_json: PackageJson;
@@ -87,7 +97,7 @@ export const local_repo_load = async ({
 	git_ops = default_git_operations,
 	npm_ops = default_npm_operations,
 	sync = true,
-	allow_dirty = false,
+	allow_dirty = false
 }: {
 	local_repo_path: LocalRepoPath;
 	log?: Logger;
@@ -96,20 +106,20 @@ export const local_repo_load = async ({
 	sync?: boolean;
 	allow_dirty?: boolean;
 }): Promise<LocalRepo> => {
-	const {repo_config, repo_dir, repo_name, repo_git_ssh_url} = local_repo_path;
+	const { repo_config, repo_dir, repo_name, repo_git_ssh_url } = local_repo_path;
 
 	if (sync) {
 		// Record commit hash before any changes
-		const commit_before_result = await git_ops.current_commit_hash({cwd: repo_dir});
+		const commit_before_result = await git_ops.current_commit_hash({ cwd: repo_dir });
 		if (!commit_before_result.ok) {
 			throw new TaskError(
-				`Failed to get commit hash in ${repo_dir}: ${commit_before_result.message}`,
+				`Failed to get commit hash in ${repo_dir}: ${commit_before_result.message}`
 			);
 		}
 		const commit_before = commit_before_result.value;
 
 		// Switch to target branch if needed
-		const branch_result = await git_ops.current_branch_name({cwd: repo_dir});
+		const branch_result = await git_ops.current_branch_name({ cwd: repo_dir });
 		if (!branch_result.ok) {
 			throw new TaskError(`Failed to get current branch in ${repo_dir}: ${branch_result.message}`);
 		}
@@ -119,28 +129,28 @@ export const local_repo_load = async ({
 			// Guard the switch on a clean workspace unless the caller opts into `allow_dirty`,
 			// in which case we let `git checkout` itself fail loudly if it can't proceed.
 			if (!allow_dirty) {
-				const clean_result = await git_ops.check_clean_workspace({cwd: repo_dir});
+				const clean_result = await git_ops.check_clean_workspace({ cwd: repo_dir });
 				if (!clean_result.ok) {
 					throw new TaskError(`Failed to check workspace in ${repo_dir}: ${clean_result.message}`);
 				}
 
 				if (!clean_result.value) {
 					throw new TaskError(
-						`Repo ${repo_dir} is not on branch "${repo_config.branch}" and the workspace is unclean, blocking switch`,
+						`Repo ${repo_dir} is not on branch "${repo_config.branch}" and the workspace is unclean, blocking switch`
 					);
 				}
 			}
 
-			const checkout_result = await git_ops.checkout({branch: repo_config.branch, cwd: repo_dir});
+			const checkout_result = await git_ops.checkout({ branch: repo_config.branch, cwd: repo_dir });
 			if (!checkout_result.ok) {
 				throw new TaskError(
-					`Failed to checkout branch "${repo_config.branch}" in ${repo_dir}: ${checkout_result.message}`,
+					`Failed to checkout branch "${repo_config.branch}" in ${repo_dir}: ${checkout_result.message}`
 				);
 			}
 		}
 
 		// Only pull if remote exists (skip for local-only repos, test fixtures)
-		const origin_result = await git_ops.has_remote({remote: 'origin', cwd: repo_dir});
+		const origin_result = await git_ops.has_remote({ remote: 'origin', cwd: repo_dir });
 		if (!origin_result.ok) {
 			throw new TaskError(`Failed to check for remote in ${repo_dir}: ${origin_result.message}`);
 		}
@@ -149,7 +159,7 @@ export const local_repo_load = async ({
 			// Pull the configured branch explicitly. Without a branch, `git pull origin`
 			// targets the remote's default branch (origin/HEAD), which for a repo checked
 			// out on a non-default branch rebases the wrong branch onto it.
-			const pull_result = await git_ops.pull({branch: repo_config.branch, cwd: repo_dir});
+			const pull_result = await git_ops.pull({ branch: repo_config.branch, cwd: repo_dir });
 			if (!pull_result.ok) {
 				throw new TaskError(`Failed to pull in ${repo_dir}: ${pull_result.message}`);
 			}
@@ -158,25 +168,25 @@ export const local_repo_load = async ({
 		// Check clean workspace after pull to ensure we're in a good state
 		// (skipped when `allow_dirty`, since uncommitted changes are expected then)
 		if (!allow_dirty) {
-			const clean_after_result = await git_ops.check_clean_workspace({cwd: repo_dir});
+			const clean_after_result = await git_ops.check_clean_workspace({ cwd: repo_dir });
 			if (!clean_after_result.ok) {
 				throw new TaskError(
-					`Failed to check workspace in ${repo_dir}: ${clean_after_result.message}`,
+					`Failed to check workspace in ${repo_dir}: ${clean_after_result.message}`
 				);
 			}
 
 			if (!clean_after_result.value) {
 				throw new TaskError(
-					`Workspace ${repo_dir} is unclean after pulling branch "${repo_config.branch}"`,
+					`Workspace ${repo_dir} is unclean after pulling branch "${repo_config.branch}"`
 				);
 			}
 		}
 
 		// Record commit hash after pull
-		const commit_after_result = await git_ops.current_commit_hash({cwd: repo_dir});
+		const commit_after_result = await git_ops.current_commit_hash({ cwd: repo_dir });
 		if (!commit_after_result.ok) {
 			throw new TaskError(
-				`Failed to get commit hash in ${repo_dir}: ${commit_after_result.message}`,
+				`Failed to get commit hash in ${repo_dir}: ${commit_after_result.message}`
 			);
 		}
 		const commit_after = commit_after_result.value;
@@ -190,48 +200,57 @@ export const local_repo_load = async ({
 				from_commit: commit_before,
 				to_commit: commit_after,
 				file_path: 'package.json',
-				cwd: repo_dir,
+				cwd: repo_dir
 			});
 
 			if (!changed_result.ok) {
 				throw new TaskError(
-					`Failed to check if package.json changed in ${repo_dir}: ${changed_result.message}`,
+					`Failed to check if package.json changed in ${repo_dir}: ${changed_result.message}`
 				);
 			}
 
 			if (changed_result.value) {
-				const install_result = await npm_ops.install({cwd: repo_dir});
+				const install_result = await npm_ops.install({ cwd: repo_dir });
 				if (!install_result.ok) {
 					throw new TaskError(
-						`Failed to install dependencies in ${repo_dir}: ${install_result.message}${install_result.stderr ? `\n${install_result.stderr}` : ''}`,
+						`Failed to install dependencies in ${repo_dir}: ${install_result.message}${install_result.stderr ? `\n${install_result.stderr}` : ''}`
 					);
 				}
 			}
 		}
 	}
 
+	// A repo with no `package.json` but a Rust `Cargo.toml` isn't an npm package and can't be
+	// analyzed as a library. Load it as a dashboard-only `cargo` repo (CI, PRs, identity) that
+	// publishing/analysis skips. Anything else falls through to the npm loader below, whose
+	// error covers a genuinely missing or unreadable manifest.
+	if (!existsSync(join(repo_dir, 'package.json')) && existsSync(join(repo_dir, 'Cargo.toml'))) {
+		return local_repo_load_cargo({ local_repo_path });
+	}
+
 	// Load library metadata via svelte-docinfo analysis (cached under `.gro/library.json`).
 	let library_json: LibraryJson;
 	let package_json: PackageJson;
 	try {
-		({library_json, package_json} = await library_load_from_repo(repo_dir, {log: _log}));
+		({ library_json, package_json } = await library_load_from_repo(repo_dir, { log: _log }));
 	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
+		const message = to_error_message(err);
 		_log?.warn(
-			`Failed to load library metadata for repo "${repo_name}" in ${repo_dir}: ${message}`,
+			`Failed to load library metadata for repo "${repo_name}" in ${repo_dir}: ${message}`
 		);
 		throw new TaskError(
-			`Failed to load library metadata for repo "${repo_name}" in ${repo_dir}: ${message}`,
+			`Failed to load library metadata for repo "${repo_name}" in ${repo_dir}: ${message}`
 		);
 	}
 	const library = new Library(library_json);
 
 	const local_repo: LocalRepo = {
+		kind: 'npm',
 		library,
 		package_json,
 		repo_dir,
 		repo_git_ssh_url,
-		repo_config,
+		repo_config
 	};
 
 	// Extract dependencies from the full package_json
@@ -248,13 +267,60 @@ export const local_repo_load = async ({
 	return local_repo;
 };
 
+/**
+ * Whether a repo is an npm package and so participates in publishing and
+ * dependency analysis. Non-npm repos (e.g. Rust `cargo` repos) are still synced
+ * and rendered on the dashboard, but excluded from the changeset cascade.
+ */
+export const repo_is_npm = (repo: LocalRepo): boolean => repo.kind === 'npm';
+
+/**
+ * Loads a non-npm Rust repo as a dashboard-only `LocalRepo`. It has no
+ * `package.json`, so there's no `svelte-docinfo` analysis and no npm dependency
+ * graph — a lightweight `Library` is synthesized from the repo's `Cargo.toml`
+ * (best-effort name/version/description) and its configured repo URL, which is
+ * what the dashboard renders (CI status, PRs, identity). Marked `private` so it
+ * never reads as an npm publish target, and tagged `cargo` so the publishing and
+ * analysis paths skip it (see `repo_is_npm`).
+ */
+const local_repo_load_cargo = async ({
+	local_repo_path
+}: {
+	local_repo_path: LocalRepoPath;
+}): Promise<LocalRepo> => {
+	const { repo_config, repo_dir, repo_name, repo_url, repo_git_ssh_url } = local_repo_path;
+
+	const cargo = await cargo_toml_load(repo_dir);
+
+	// A Cargo workspace root has no `name`, so fall back to the repo name parsed from
+	// the URL; the config's `repo_url` is the authoritative `repository`.
+	const package_json: PackageJson = {
+		name: cargo?.name ?? repo_name,
+		version: cargo?.version ?? '0.0.0',
+		repository: cargo?.repository ?? repo_url,
+		private: true,
+		...(cargo?.description ? { description: cargo.description } : null)
+	};
+
+	const library = new Library(library_json_from_modules(package_json, []));
+
+	return {
+		kind: 'cargo',
+		library,
+		package_json,
+		repo_dir,
+		repo_git_ssh_url,
+		repo_config
+	};
+};
+
 export const local_repos_ensure = async ({
 	resolved_config,
 	repos_dir,
 	gitops_config,
 	download,
 	log,
-	npm_ops = default_npm_operations,
+	npm_ops = default_npm_operations
 }: {
 	resolved_config: ResolvedGitopsConfig;
 	repos_dir: string;
@@ -273,19 +339,19 @@ export const local_repos_ensure = async ({
 				repos_dir,
 				local_repos_missing: resolved_config.local_repos_missing,
 				log,
-				npm_ops,
+				npm_ops
 			});
 			local_repo_paths = (resolved_config.local_repo_paths ?? [])
 				.concat(downloaded)
 				.sort(
 					(a, b) =>
 						gitops_config.repos.findIndex((r) => r.repo_url === a.repo_url) -
-						gitops_config.repos.findIndex((r) => r.repo_url === b.repo_url),
+						gitops_config.repos.findIndex((r) => r.repo_url === b.repo_url)
 				);
 		} else {
 			log?.error(
 				`Failed to resolve local repos in ${repos_dir} - do you need to pass \`--download\` or configure the directory?`, // TODO leaking task impl details
-				resolved_config.local_repos_missing.map((r) => r.repo_url),
+				resolved_config.local_repos_missing.map((r) => r.repo_url)
 			);
 			throw new TaskError('Failed to resolve local configs');
 		}
@@ -306,7 +372,7 @@ export const local_repos_load = async ({
 	parallel = true,
 	concurrency = GITOPS_CONCURRENCY_DEFAULT,
 	sync = true,
-	allow_dirty = false,
+	allow_dirty = false
 }: {
 	local_repo_paths: Array<LocalRepoPath>;
 	log?: Logger;
@@ -322,7 +388,7 @@ export const local_repos_load = async ({
 		const loaded: Array<LocalRepo> = [];
 		for (const local_repo_path of local_repo_paths) {
 			loaded.push(
-				await local_repo_load({local_repo_path, log, git_ops, npm_ops, sync, allow_dirty}),
+				await local_repo_load({ local_repo_path, log, git_ops, npm_ops, sync, allow_dirty })
 			);
 		}
 		return loaded;
@@ -333,13 +399,13 @@ export const local_repos_load = async ({
 		local_repo_paths,
 		concurrency,
 		async (local_repo_path) => {
-			return local_repo_load({local_repo_path, log, git_ops, npm_ops, sync, allow_dirty});
-		},
+			return local_repo_load({ local_repo_path, log, git_ops, npm_ops, sync, allow_dirty });
+		}
 	);
 
 	// Check for failures and collect successes
 	const loaded: Array<LocalRepo> = [];
-	const errors: Array<{repo_name: string; error: string}> = [];
+	const errors: Array<{ repo_name: string; error: string }> = [];
 
 	for (let i = 0; i < results.length; i++) {
 		const result = results[i]!;
@@ -349,7 +415,7 @@ export const local_repos_load = async ({
 			const repo_path = local_repo_paths[i]!;
 			errors.push({
 				repo_name: repo_path.repo_name,
-				error: String(result.reason),
+				error: String(result.reason)
 			});
 		}
 	}
@@ -365,12 +431,12 @@ export const local_repos_load = async ({
 
 export const local_repo_locate = ({
 	repo_config,
-	repos_dir,
+	repos_dir
 }: {
 	repo_config: GitopsRepoConfig;
 	repos_dir: string;
 }): LocalRepoPath | LocalRepoMissing => {
-	const {repo_url} = repo_config;
+	const { repo_url } = repo_config;
 	const repo_name = strip_end(repo_url, '/').split('/').at(-1);
 	if (!repo_name) throw Error('Invalid `repo_config.repo_url` ' + repo_url);
 
@@ -378,7 +444,7 @@ export const local_repo_locate = ({
 
 	const repo_dir = repo_config.repo_dir ?? join(repos_dir, repo_name);
 	if (!existsSync(repo_dir)) {
-		return {type: 'local_repo_missing', repo_name, repo_url, repo_git_ssh_url, repo_config};
+		return { type: 'local_repo_missing', repo_name, repo_url, repo_git_ssh_url, repo_config };
 	}
 
 	return {
@@ -387,7 +453,7 @@ export const local_repo_locate = ({
 		repo_dir,
 		repo_url,
 		repo_git_ssh_url,
-		repo_config,
+		repo_config
 	};
 };
 
@@ -400,7 +466,7 @@ const download_repos = async ({
 	repos_dir,
 	local_repos_missing,
 	log,
-	npm_ops = default_npm_operations,
+	npm_ops = default_npm_operations
 }: {
 	repos_dir: string;
 	local_repos_missing: Array<LocalRepoMissing>;
@@ -408,26 +474,26 @@ const download_repos = async ({
 	npm_ops?: NpmOperations;
 }): Promise<Array<LocalRepoPath>> => {
 	const resolved: Array<LocalRepoPath> = [];
-	for (const {repo_config, repo_git_ssh_url} of local_repos_missing) {
+	for (const { repo_config, repo_git_ssh_url } of local_repos_missing) {
 		log?.info(`cloning repo ${repo_git_ssh_url} to ${repos_dir}`);
-		const clone_result = await spawn_out('git', ['clone', repo_git_ssh_url], {cwd: repos_dir});
+		const clone_result = await spawn_out('git', ['clone', repo_git_ssh_url], { cwd: repos_dir });
 		if (!clone_result.result.ok) {
 			throw new TaskError(
-				`Failed to clone repo ${repo_git_ssh_url} to ${repos_dir}${clone_result.stderr ? ': ' + clone_result.stderr.trim() : ''}`,
+				`Failed to clone repo ${repo_git_ssh_url} to ${repos_dir}${clone_result.stderr ? ': ' + clone_result.stderr.trim() : ''}`
 			);
 		}
-		const local_repo = local_repo_locate({repo_config, repos_dir});
+		const local_repo = local_repo_locate({ repo_config, repos_dir });
 		if (local_repo.type === 'local_repo_missing') {
 			throw new TaskError(
-				`Failed to clone repo ${repo_git_ssh_url} to ${repos_dir}: directory not found after clone`,
+				`Failed to clone repo ${repo_git_ssh_url} to ${repos_dir}: directory not found after clone`
 			);
 		}
 		// Always install dependencies after cloning
 		log?.info(`installing dependencies for newly cloned repo ${local_repo.repo_dir}`);
-		const install_result = await npm_ops.install({cwd: local_repo.repo_dir});
+		const install_result = await npm_ops.install({ cwd: local_repo.repo_dir });
 		if (!install_result.ok) {
 			throw new TaskError(
-				`Failed to install dependencies in ${local_repo.repo_dir}: ${install_result.message}${install_result.stderr ? `\n${install_result.stderr}` : ''}`,
+				`Failed to install dependencies in ${local_repo.repo_dir}: ${install_result.message}${install_result.stderr ? `\n${install_result.stderr}` : ''}`
 			);
 		}
 		resolved.push(local_repo);

package/src/lib/log_helpers.ts

@@ -1,14 +1,14 @@
-import type {Logger} from '@fuzdev/fuz_util/log.js';
-import {styleText as st} from 'node:util';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { styleText as st } from 'node:util';
 
-import type {DependencyGraphBuilder} from './dependency_graph.js';
+import type { DependencyGraphBuilder } from './dependency_graph.ts';
 
 /**
  * Formats wildcard dependencies as styled strings.
  * Returns array of lines for inclusion in output.
  */
 export const format_wildcard_dependencies = (
-	analysis: ReturnType<DependencyGraphBuilder['analyze']>,
+	analysis: ReturnType<DependencyGraphBuilder['analyze']>
 ): Array<string> => {
 	if (analysis.wildcard_deps.length === 0) return [];
 
@@ -17,7 +17,7 @@ export const format_wildcard_dependencies = (
 	// a leading `\n` in the header would leave the header line unprefixed.
 	lines.push('');
 	lines.push(st('yellow', `⚠️  Found ${analysis.wildcard_deps.length} wildcard dependencies:`));
-	for (const {pkg, dep, version} of analysis.wildcard_deps) {
+	for (const { pkg, dep, version } of analysis.wildcard_deps) {
 		lines.push(`  ${pkg} → ${dep} ${st('red', version)}`);
 	}
 	return lines;
@@ -28,7 +28,7 @@ export const format_wildcard_dependencies = (
  * Returns array of lines for inclusion in output.
  */
 export const format_dev_cycles = (
-	analysis: ReturnType<DependencyGraphBuilder['analyze']>,
+	analysis: ReturnType<DependencyGraphBuilder['analyze']>
 ): Array<string> => {
 	if (analysis.dev_cycles.length === 0) return [];
 
@@ -37,8 +37,8 @@ export const format_dev_cycles = (
 	lines.push(
 		st(
 			'dim',
-			`ℹ️  Found ${analysis.dev_cycles.length} dev circular dependencies (normal, non-blocking):`,
-		),
+			`ℹ️  Found ${analysis.dev_cycles.length} dev circular dependencies (normal, non-blocking):`
+		)
 	);
 	for (const cycle of analysis.dev_cycles) {
 		lines.push(st('dim', `  ${cycle.join(' → ')}`));
@@ -51,7 +51,7 @@ export const format_dev_cycles = (
  * Returns array of lines for inclusion in output.
  */
 export const format_production_cycles = (
-	analysis: ReturnType<DependencyGraphBuilder['analyze']>,
+	analysis: ReturnType<DependencyGraphBuilder['analyze']>
 ): Array<string> => {
 	if (analysis.production_cycles.length === 0) return [];
 
@@ -60,8 +60,8 @@ export const format_production_cycles = (
 	lines.push(
 		st(
 			'red',
-			`❌ Found ${analysis.production_cycles.length} production/peer circular dependencies (blocks publishing):`,
-		),
+			`❌ Found ${analysis.production_cycles.length} production/peer circular dependencies (blocks publishing):`
+		)
 	);
 	for (const cycle of analysis.production_cycles) {
 		lines.push(`  ${st('red', cycle.join(' → '))}`);
@@ -76,7 +76,7 @@ export const format_production_cycles = (
 export const log_wildcard_dependencies = (
 	analysis: ReturnType<DependencyGraphBuilder['analyze']>,
 	log: Logger,
-	indent = '',
+	indent = ''
 ): void => {
 	const lines = format_wildcard_dependencies(analysis);
 	for (const line of lines) {
@@ -91,7 +91,7 @@ export const log_wildcard_dependencies = (
 export const log_dev_cycles = (
 	analysis: ReturnType<DependencyGraphBuilder['analyze']>,
 	log: Logger,
-	indent = '',
+	indent = ''
 ): void => {
 	const lines = format_dev_cycles(analysis);
 	for (const line of lines) {
@@ -106,7 +106,7 @@ export const log_dev_cycles = (
 export const log_production_cycles = (
 	analysis: ReturnType<DependencyGraphBuilder['analyze']>,
 	log: Logger,
-	indent = '',
+	indent = ''
 ): void => {
 	const lines = format_production_cycles(analysis);
 	for (const line of lines) {
@@ -121,7 +121,7 @@ export const log_production_cycles = (
 export const log_dependency_analysis = (
 	analysis: ReturnType<DependencyGraphBuilder['analyze']>,
 	log: Logger,
-	indent = '',
+	indent = ''
 ): void => {
 	log_wildcard_dependencies(analysis, log, indent);
 	log_production_cycles(analysis, log, indent);