@fuzdev/fuz_gitops 0.57.0

package/src/lib/gitops_publish.task.ts

@@ -0,0 +1,227 @@
+import type {Task} from '@ryanatkn/gro';
+import {z} from 'zod';
+import {createInterface} from 'node:readline/promises';
+import {styleText as st} from 'node:util';
+
+import {get_gitops_ready} from './gitops_task_helpers.js';
+import {
+	publish_repos,
+	type PublishingOptions,
+	type PublishingResult,
+} from './multi_repo_publisher.js';
+import {generate_publishing_plan, log_publishing_plan} from './publishing_plan.js';
+import {format_and_output, type OutputFormatters} from './output_helpers.js';
+
+/** @nodocs */
+export const Args = z.strictObject({
+	path: z
+		.string()
+		.meta({description: 'path to the gitops config file, absolute or relative to the cwd'})
+		.default('gitops.config.ts'),
+	dir: z
+		.string()
+		.meta({description: 'path containing the repos, defaults to the parent of the `path` dir'})
+		.optional(),
+	peer_strategy: z
+		.enum(['exact', 'caret', 'tilde'])
+		.meta({description: 'version strategy for peer dependencies'})
+		.default('caret' as const),
+	dry_run: z
+		.boolean()
+		.meta({description: 'perform a dry run without actually publishing'})
+		.default(false),
+	format: z
+		.enum(['stdout', 'json', 'markdown'])
+		.meta({description: 'output format'})
+		.default('stdout'),
+	deploy: z.boolean().meta({description: 'deploy all repos after publishing'}).default(false),
+	plan: z.boolean().meta({description: 'dual of no-plan'}).default(true),
+	'no-plan': z
+		.boolean()
+		.meta({description: 'skip plan confirmation before publishing'})
+		.default(false),
+	max_wait: z
+		.number()
+		.meta({description: 'max time to wait for npm propagation in ms'})
+		.default(600000), // 10 minutes
+	skip_install: z
+		.boolean()
+		.meta({description: 'skip npm install after dependency updates'})
+		.default(false),
+	outfile: z.string().meta({description: 'write output to file instead of logging'}).optional(),
+	verbose: z.boolean().meta({description: 'show additional details in plan output'}).default(false),
+});
+export type Args = z.infer<typeof Args>;
+
+/** @nodocs */
+export const task: Task<Args> = {
+	summary: 'publish all repos in dependency order',
+	Args,
+	run: async ({args, log}): Promise<void> => {
+		const {
+			path,
+			dir,
+			peer_strategy,
+			dry_run,
+			format,
+			deploy,
+			plan,
+			max_wait,
+			skip_install,
+			outfile,
+			verbose,
+		} = args;
+
+		// Load repos
+		const {local_repos: repos} = await get_gitops_ready({
+			path,
+			dir,
+			download: false, // Don't download if missing
+			log,
+		});
+
+		// Show plan if requested (skip for dry runs)
+		if (plan && !dry_run) {
+			log.info(st('cyan', 'Publishing Plan'));
+			const plan_result = await generate_publishing_plan(repos, {log, verbose});
+			log_publishing_plan(plan_result, log, {verbose});
+
+			if (plan_result.errors.length > 0) {
+				throw new Error('Cannot proceed with publishing due to errors');
+			}
+
+			// Ask for confirmation
+			log.info(st('yellow', '⚠️  This will publish the packages shown above.'));
+			process.stdout.write('Continue with publishing? (y/n): ');
+			const confirmed = await prompt_for_confirmation();
+			if (!confirmed) {
+				log.info('Publishing cancelled');
+				process.exit(0);
+			}
+		}
+
+		// Publishing options
+		const options: PublishingOptions = {
+			dry_run,
+			update_deps: true, // Always update dependencies
+			version_strategy: peer_strategy,
+			deploy,
+			max_wait,
+			skip_install,
+			log,
+		};
+
+		// Execute publishing (may throw on fatal errors like circular dependencies)
+		let result: PublishingResult;
+		let fatal_error: Error | null = null;
+
+		try {
+			result = await publish_repos(repos, options);
+		} catch (error) {
+			// Construct a failure result for fatal errors so output can still be generated
+			fatal_error = error instanceof Error ? error : new Error(String(error));
+			result = {
+				ok: false,
+				published: [],
+				// Note: FATAL_ERROR is a placeholder - only fatal_error.message is displayed in output
+				failed: [{name: 'FATAL_ERROR', error: fatal_error}],
+				duration: 0,
+			};
+		}
+
+		// Format and output result (always runs, even on fatal errors)
+		// Note: stdout format is handled by publish_repos function's logging
+		if (format !== 'stdout') {
+			await format_and_output({result, fatal_error}, create_publish_formatters(), {
+				format,
+				outfile,
+				log,
+			});
+		}
+
+		// Exit with error if failed
+		if (!result.ok || fatal_error) {
+			process.exit(1);
+		}
+	},
+};
+
+interface PublishResultData {
+	result: PublishingResult;
+	fatal_error: Error | null;
+}
+
+const create_publish_formatters = (): OutputFormatters<PublishResultData> => ({
+	json: (data) => JSON.stringify(data.result, null, 2),
+	markdown: (data) => format_result_markdown(data.result, data.fatal_error),
+	stdout: () => {
+		// stdout format is handled by publish_repos function's logging
+		// This should never be called due to early return in task
+	},
+});
+
+// Format the publishing result as markdown
+const format_result_markdown = (
+	result: PublishingResult,
+	fatal_error: Error | null,
+): Array<string> => {
+	const lines: Array<string> = [];
+
+	lines.push('# Publishing Result');
+	lines.push('');
+
+	// Show fatal error prominently if present
+	if (fatal_error) {
+		lines.push('## ❌ Fatal Error');
+		lines.push('');
+		lines.push(`**Error**: ${fatal_error.message}`);
+		lines.push('');
+		lines.push('Publishing could not proceed due to the error above.');
+		lines.push('');
+		return lines;
+	}
+
+	lines.push(`**Status**: ${result.ok ? '✅ Success' : '❌ Failed'}`);
+	lines.push(`**Duration**: ${(result.duration / 1000).toFixed(1)}s`);
+	lines.push(`**Published**: ${result.published.length} packages`);
+
+	if (result.failed.length > 0) {
+		lines.push(`**Failed**: ${result.failed.length} packages`);
+	}
+
+	if (result.published.length > 0) {
+		lines.push('');
+		lines.push('## Published Packages');
+		lines.push('');
+		for (const pkg of result.published) {
+			lines.push(`- \`${pkg.name}\`: ${pkg.old_version} → ${pkg.new_version}`);
+		}
+	}
+
+	if (result.failed.length > 0) {
+		lines.push('');
+		lines.push('## Failed Packages');
+		lines.push('');
+		for (const {name, error} of result.failed) {
+			lines.push(`- \`${name}\`: ${error.message}`);
+		}
+	}
+
+	return lines;
+};
+
+/**
+ * Prompts user for y/n confirmation.
+ * Returns true if user enters 'y', false otherwise.
+ */
+const prompt_for_confirmation = async (): Promise<boolean> => {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout,
+	});
+
+	const answer = await rl.question('');
+	rl.close();
+
+	return answer.toLowerCase() === 'y';
+};

package/src/lib/gitops_sync.task.ts

@@ -0,0 +1,109 @@
+import {TaskError, type Task} from '@ryanatkn/gro';
+import {z} from 'zod';
+import {readFile, writeFile} from 'node:fs/promises';
+import {format_file} from '@ryanatkn/gro/format_file.js';
+import {basename, resolve} from 'node:path';
+import {print_path} from '@ryanatkn/gro/paths.js';
+import {load_from_env} from '@ryanatkn/gro/env.js';
+import {load_package_json} from '@ryanatkn/gro/package_json.js';
+import {existsSync} from 'node:fs';
+
+import {fetch_repo_data} from './fetch_repo_data.js';
+import {create_fs_fetch_value_cache} from './fs_fetch_value_cache.js';
+import {get_gitops_ready} from './gitops_task_helpers.js';
+
+// TODO add flag to ignore or invalidate cache -- no-cache? clean?
+
+/** @nodocs */
+export const Args = z.strictObject({
+	path: z
+		.string()
+		.meta({description: 'path to the gitops config file, absolute or relative to the cwd'})
+		.default('gitops.config.ts'),
+	dir: z
+		.string()
+		.meta({description: 'path containing the repos, defaults to the parent of the `path` dir'})
+		.optional(),
+	outdir: z
+		.string()
+		.meta({description: 'path to the directory for the generated files, defaults to $routes/'})
+		.optional(),
+	download: z.boolean().meta({description: 'download all missing local repos'}).default(false),
+	check: z
+		.boolean()
+		.meta({description: 'check repos are ready without fetching remote data'})
+		.default(false),
+});
+export type Args = z.infer<typeof Args>;
+
+/**
+ * This is a task not a `.gen.` file because it makes network calls.
+ *
+ * @nodocs
+ */
+export const task: Task<Args> = {
+	Args,
+	summary: 'syncs local repos and generates UI data from repo metadata',
+	run: async ({args, log, svelte_config, invoke_task}) => {
+		const {path, dir, outdir = svelte_config.routes_path, download, check} = args;
+
+		const {local_repos} = await get_gitops_ready({path, dir, download, log});
+
+		const outfile = resolve(outdir, 'repos.ts');
+
+		// This searches the parent directory for the env var, so we don't use SvelteKit's $env imports
+		const token = load_from_env('SECRET_GITHUB_API_TOKEN');
+		if (!token) {
+			throw new TaskError('the env var SECRET_GITHUB_API_TOKEN was not found');
+		}
+
+		// Exit early if only checking repo readiness
+		if (check) {
+			log.info('repos are ready');
+			return;
+		}
+
+		const cache = await create_fs_fetch_value_cache('repos');
+
+		log.info('fetching remote repo data');
+		const repos_json = await fetch_repo_data(local_repos, token, cache.data, log);
+
+		// TODO should package_json be provided in the Gro task/gen contexts? check if it's always loaded
+		const package_json = await load_package_json();
+		const repo_specifier =
+			package_json.name === '@fuzdev/fuz_gitops'
+				? '$lib/repo.svelte.js'
+				: '@fuzdev/fuz_gitops/repo.svelte.js';
+
+		log.info('generating ' + outfile);
+
+		// TODO the `basename` is used here because we don't have an `origin_id` like with gen,
+		// and this file gets re-exported,
+		// and we don't want the file to change based on where it's being generated,
+		// because for example linking to a local package would change the contents
+		const contents = `
+			// generated by ${basename(import.meta.filename)} !! do not edit directly or risk lost data
+			
+			import type {RepoJson} from '${repo_specifier}';
+
+			export const repos_json: Array<RepoJson> = ${JSON.stringify(repos_json, null, '\t')};
+		`;
+		// TODO think about possibly using the `gen` functionality in this task, not sure what the API design could look like
+		const formatted = await format_file(contents, {filepath: outfile});
+		const existing = existsSync(outfile) ? await readFile(outfile, 'utf8') : '';
+		if (existing === formatted) {
+			log.info(`no changes to ${print_path(outfile)}`);
+		} else {
+			log.info(`writing changes to ${print_path(outfile)}`);
+			await writeFile(outfile, formatted);
+			await invoke_task('gen');
+		}
+
+		const changed = await cache.save();
+		if (changed) {
+			log.info('repos cache updated');
+		} else {
+			log.info('repos cache did not change');
+		}
+	},
+};

package/src/lib/gitops_task_helpers.ts

@@ -0,0 +1,126 @@
+/**
+ * Shared initialization logic for all gitops tasks.
+ *
+ * Provides `get_gitops_ready()` which orchestrates:
+ * - Config loading and normalization
+ * - Repo resolution (local path discovery)
+ * - Branch switching and syncing
+ * - Dependency installation
+ *
+ * Used by: `gitops_sync.task.ts`, `gitops_analyze.task.ts`, `gitops_plan.task.ts`,
+ * `gitops_publish.task.ts`, and `gitops_validate.task.ts`.
+ *
+ * Accepts `git_ops` and `npm_ops` parameters to support testing via operations pattern
+ * (see `operations.ts` for dependency injection details).
+ */
+
+import {TaskError} from '@ryanatkn/gro';
+import {styleText as st} from 'node:util';
+import {resolve, dirname} from 'node:path';
+import {print_path} from '@ryanatkn/gro/paths.js';
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+
+import {load_gitops_config, type GitopsConfig} from './gitops_config.js';
+import {local_repos_load, local_repos_ensure, type LocalRepo} from './local_repo.js';
+import {resolve_gitops_config} from './resolved_gitops_config.js';
+import {DEFAULT_REPOS_DIR} from './paths.js';
+import type {GitOperations, NpmOperations} from './operations.js';
+
+export interface GetGitopsReadyOptions {
+	path: string;
+	dir?: string;
+	download: boolean;
+	log?: Logger;
+	git_ops?: GitOperations;
+	npm_ops?: NpmOperations;
+}
+
+/**
+ * Central initialization function for all gitops tasks.
+ *
+ * Initialization sequence:
+ * 1. Loads and normalizes config from `gitops.config.ts`
+ * 2. Resolves local repo paths (creates missing with `--download`)
+ * 3. Switches branches and pulls latest changes
+ * 4. Auto-installs deps if package.json changed during pull
+ *
+ * Priority for path resolution:
+ * - `dir` argument (explicit override)
+ * - Config `repos_dir` setting
+ * - `DEFAULT_REPOS_DIR` constant
+ *
+ * @param options.git_ops for testing (defaults to real git operations)
+ * @param options.npm_ops for testing (defaults to real npm operations)
+ * @returns initialized config and fully loaded repos ready for operations
+ * @throws {TaskError} if config loading or repo resolution fails
+ */
+export const get_gitops_ready = async (
+	options: GetGitopsReadyOptions,
+): Promise<{
+	config_path: string;
+	repos_dir: string;
+	gitops_config: GitopsConfig;
+	local_repos: Array<LocalRepo>;
+}> => {
+	const {path, dir, download, log, git_ops, npm_ops} = options;
+	const config_path = resolve(path);
+	const gitops_config = await import_gitops_config(config_path);
+
+	// Priority: explicit dir arg → config repos_dir → default (two dirs up from config)
+	const repos_dir = resolve_gitops_paths({
+		path,
+		dir,
+		config_repos_dir: gitops_config.repos_dir,
+	}).repos_dir;
+
+	log?.info(
+		`resolving gitops configs on the filesystem in ${repos_dir}`,
+		gitops_config.repos.map((r) => r.repo_url),
+	);
+	const resolved_config = resolve_gitops_config(gitops_config, repos_dir);
+
+	const local_repo_paths = await local_repos_ensure({
+		resolved_config,
+		repos_dir,
+		gitops_config,
+		download,
+		log,
+		npm_ops,
+	});
+
+	const local_repos = await local_repos_load({local_repo_paths, log, git_ops, npm_ops});
+
+	return {config_path, repos_dir, gitops_config, local_repos};
+};
+
+export interface ResolveGitopsPathsOptions {
+	path: string;
+	dir?: string;
+	config_repos_dir?: string;
+}
+
+export const resolve_gitops_paths = (
+	options: ResolveGitopsPathsOptions,
+): {config_path: string; repos_dir: string} => {
+	const {path, dir, config_repos_dir} = options;
+	const config_path = resolve(path);
+	const config_dir = dirname(config_path);
+
+	// Priority: explicit dir arg → config repos_dir → default (parent of config dir)
+	const repos_dir =
+		dir !== undefined
+			? resolve(dir)
+			: config_repos_dir !== undefined
+				? resolve(config_dir, config_repos_dir)
+				: resolve(config_dir, DEFAULT_REPOS_DIR);
+
+	return {config_path, repos_dir};
+};
+
+export const import_gitops_config = async (config_path: string): Promise<GitopsConfig> => {
+	const gitops_config = await load_gitops_config(config_path);
+	if (!gitops_config) {
+		throw new TaskError(st('red', `No gitops config found at ${print_path(config_path)}`));
+	}
+	return gitops_config;
+};

package/src/lib/gitops_validate.task.ts

@@ -0,0 +1,248 @@
+import type {Task} from '@ryanatkn/gro';
+import {z} from 'zod';
+import {styleText as st} from 'node:util';
+
+import {get_gitops_ready} from './gitops_task_helpers.js';
+import {validate_dependency_graph} from './graph_validation.js';
+import {DependencyGraphBuilder} from './dependency_graph.js';
+import {generate_publishing_plan, log_publishing_plan} from './publishing_plan.js';
+import {publish_repos, type PublishingOptions} from './multi_repo_publisher.js';
+import {log_dependency_analysis} from './log_helpers.js';
+
+/** @nodocs */
+export const Args = z.strictObject({
+	path: z
+		.string()
+		.meta({description: 'path to the gitops config file, absolute or relative to the cwd'})
+		.default('gitops.config.ts'),
+	dir: z
+		.string()
+		.meta({description: 'path containing the repos, defaults to the parent of the `path` dir'})
+		.optional(),
+	verbose: z.boolean().meta({description: 'show additional details'}).default(false),
+});
+export type Args = z.infer<typeof Args>;
+
+/** @nodocs */
+export const task: Task<Args> = {
+	Args,
+	summary:
+		'validate gitops configuration by running all read-only commands and checking for issues',
+	run: async ({args, log}) => {
+		const {path, dir, verbose} = args;
+
+		log.info(st('cyan', 'Running Gitops Validation Suite'));
+		log.info(st('dim', 'This runs all read-only commands and checks for consistency.'));
+
+		const results: Array<{
+			command: string;
+			success: boolean;
+			warnings: number;
+			errors: number;
+			duration: number;
+			warning_details?: Array<string>;
+			info_details?: Array<string>;
+			analysis?: ReturnType<DependencyGraphBuilder['analyze']>;
+		}> = [];
+
+		const start_time = Date.now();
+
+		// Load repos once (shared by all commands)
+		log.info(st('dim', 'Loading repositories...'));
+		const {local_repos} = await get_gitops_ready({path, dir, download: false, log});
+		log.info(st('dim', `   Found ${local_repos.length} local repos`));
+
+		// 1. Run gitops_analyze
+		log.info(st('yellow', 'Running gitops_analyze...'));
+		const analyze_start = Date.now();
+		try {
+			// Build dependency graph and validate (but don't throw on cycles for analyze)
+			const {graph} = validate_dependency_graph(local_repos, {
+				throw_on_prod_cycles: false, // Analyze should report, not throw
+				log_cycles: false, // We'll collect our own statistics
+				log_order: false,
+			});
+
+			// Perform additional analysis
+			const builder = new DependencyGraphBuilder();
+			const analysis = builder.analyze(graph);
+
+			const analyze_duration = Date.now() - analyze_start;
+
+			// Collect warnings, info, and errors
+			const warning_details: Array<string> = [];
+			const info_details: Array<string> = [];
+			if (analysis.wildcard_deps.length > 0) {
+				warning_details.push('wildcard dependencies');
+			}
+			if (analysis.dev_cycles.length > 0) {
+				info_details.push('dev circular dependencies');
+			}
+			const warnings = warning_details.length;
+			const errors = analysis.production_cycles.length > 0 ? 1 : 0;
+
+			results.push({
+				command: 'gitops_analyze',
+				success: true,
+				warnings,
+				errors,
+				duration: analyze_duration,
+				warning_details,
+				info_details,
+				analysis,
+			});
+
+			log.info(st('green', `  ✓ gitops_analyze completed in ${analyze_duration}ms`));
+
+			// Print detailed analysis
+			log_dependency_analysis(analysis, log, '  ');
+
+			if (errors > 0) {
+				log.error(st('red', `  ❌ Found ${errors} error(s)`));
+			}
+		} catch (error) {
+			const analyze_duration = Date.now() - analyze_start;
+			results.push({
+				command: 'gitops_analyze',
+				success: false,
+				warnings: 0,
+				errors: 1,
+				duration: analyze_duration,
+			});
+			log.error(st('red', `  ✗ gitops_analyze failed: ${error}`));
+		}
+
+		// 2. Run gitops_plan
+		log.info(st('yellow', 'Running gitops_plan...'));
+		const plan_start = Date.now();
+		try {
+			const plan = await generate_publishing_plan(local_repos, {log: undefined, verbose});
+			const plan_duration = Date.now() - plan_start;
+
+			const warnings = plan.warnings.length;
+			const errors = plan.errors.length;
+
+			results.push({
+				command: 'gitops_plan',
+				success: true,
+				warnings,
+				errors,
+				duration: plan_duration,
+			});
+
+			log.info(st('green', `  ✓ gitops_plan completed in ${plan_duration}ms`));
+			if (verbose) {
+				log_publishing_plan(plan, log, {verbose});
+			}
+			if (warnings > 0) {
+				log.warn(st('yellow', `  ⚠️  Found ${warnings} warning(s)`));
+			}
+			if (errors > 0) {
+				log.error(st('red', `  ❌ Found ${errors} error(s)`));
+			}
+		} catch (error) {
+			const plan_duration = Date.now() - plan_start;
+			results.push({
+				command: 'gitops_plan',
+				success: false,
+				warnings: 0,
+				errors: 1,
+				duration: plan_duration,
+			});
+			log.error(st('red', `  ✗ gitops_plan failed: ${error}`));
+		}
+
+		// 3. Run gitops_publish --dry_run
+		log.info(st('yellow', 'Running gitops_publish --dry_run...'));
+		const dry_start = Date.now();
+		try {
+			const options: PublishingOptions = {
+				dry_run: true,
+				update_deps: true,
+				log: undefined, // Silent for validation
+			};
+
+			const result = await publish_repos(local_repos, options);
+			const dry_duration = Date.now() - dry_start;
+
+			// Dry run doesn't have warnings/errors in the same format
+			// We'll just check if it succeeded
+			const errors = result.ok ? 0 : result.failed.length;
+
+			results.push({
+				command: 'gitops_publish --dry_run',
+				success: result.ok,
+				warnings: 0,
+				errors,
+				duration: dry_duration,
+			});
+
+			log.info(st('green', `  ✓ gitops_publish --dry_run completed in ${dry_duration}ms`));
+			if (errors > 0) {
+				log.error(st('red', `  ❌ Found ${errors} error(s)`));
+			}
+		} catch (error) {
+			const dry_duration = Date.now() - dry_start;
+			results.push({
+				command: 'gitops_publish --dry_run',
+				success: false,
+				warnings: 0,
+				errors: 1,
+				duration: dry_duration,
+			});
+			log.error(st('red', `  ✗ gitops_publish --dry_run failed: ${error}`));
+		}
+
+		// Summary
+		const total_duration = Date.now() - start_time;
+		const all_success = results.every((r) => r.success);
+		const total_warnings = results.reduce((sum, r) => sum + r.warnings, 0);
+		const total_errors = results.reduce((sum, r) => sum + r.errors, 0);
+
+		log.info(st('cyan', 'Validation Summary'));
+		log.info(`  Total duration: ${(total_duration / 1000).toFixed(1)}s`);
+		log.info(`  Commands run: ${results.length}`);
+		log.info(`  Commands succeeded: ${results.filter((r) => r.success).length}`);
+		log.info(`  Commands failed: ${results.filter((r) => !r.success).length}`);
+		log.info(`  Total warnings: ${total_warnings}`);
+		log.info(`  Total errors: ${total_errors}`);
+
+		// Individual command results
+		log.info(st('cyan', 'Command Results:'));
+		for (const result of results) {
+			const status_icon = result.success ? '✓' : '✗';
+			const status_color = result.success ? 'green' : 'red';
+			const duration = (result.duration / 1000).toFixed(1);
+
+			log.info(st(status_color, `  ${status_icon} ${result.command} (${duration}s)`));
+			if (result.warnings > 0) {
+				const details = result.warning_details?.length
+					? ` (${result.warning_details.join(', ')})`
+					: '';
+				log.info(st('yellow', `    ⚠️  ${result.warnings} warning(s)${details}`));
+			}
+			if (result.info_details && result.info_details.length > 0) {
+				log.info(st('dim', `    ℹ️  ${result.info_details.join(', ')}`));
+			}
+			if (result.errors > 0) {
+				log.info(st('red', `    ❌ ${result.errors} error(s)`));
+			}
+		}
+
+		// Final verdict
+		log.info('');
+		if (all_success && total_errors === 0) {
+			log.info(st('green', '✓ All validation checks passed'));
+			if (total_warnings > 0) {
+				log.warn(
+					st('yellow', `⚠️  Note: ${total_warnings} warning(s) found - review output above.`),
+				);
+			}
+		} else if (all_success && total_errors > 0) {
+			log.warn(st('yellow', '⚠️  Validation completed but found errors - review output above.'));
+		} else {
+			log.error(st('red', '❌ Validation failed - one or more commands did not complete.'));
+			throw new Error('Validation failed');
+		}
+	},
+};