nx 20.0.0-beta.1 → 20.0.0-beta.2

package/src/daemon/server/sync-generators.d.ts

@@ -3,7 +3,10 @@ import { type FlushSyncGeneratorChangesResult, type SyncGeneratorRunResult } fro
 export declare function getCachedSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorRunResult[]>;
 export declare function flushSyncGeneratorChangesToDisk(generators: string[]): Promise<FlushSyncGeneratorChangesResult>;
 export declare function collectAndScheduleSyncGenerators(projectGraph: ProjectGraph): void;
-export declare function getCachedRegisteredSyncGenerators(): Promise<string[]>;
+export declare function getCachedRegisteredSyncGenerators(): Promise<{
+    globalGenerators: string[];
+    taskGenerators: string[];
+}>;
 /**
  * @internal
  */

package/src/daemon/server/sync-generators.js

@@ -72,11 +72,16 @@ function collectAndScheduleSyncGenerators(projectGraph) {
     // a change imply we need to re-run all the generators
     // make sure to schedule all the collected generators
     scheduledGenerators.clear();
-    if (!registeredSyncGenerators.size) {
+    if (!registeredSyncGenerators.globalGenerators.size &&
+        !registeredSyncGenerators.taskGenerators.size) {
         // there are no generators to run
         return;
     }
-    for (const generator of registeredSyncGenerators) {
+    const uniqueSyncGenerators = new Set([
+        ...registeredSyncGenerators.globalGenerators,
+        ...registeredSyncGenerators.taskGenerators,
+    ]);
+    for (const generator of uniqueSyncGenerators) {
         scheduledGenerators.add(generator);
     }
     log('scheduling:', [...scheduledGenerators]);
@@ -102,7 +107,7 @@ function collectAndScheduleSyncGenerators(projectGraph) {
 }
 async function getCachedRegisteredSyncGenerators() {
     log('get registered sync generators');
-    if (!registeredSyncGenerators) {
+    if (!registeredGlobalSyncGenerators && !registeredTaskSyncGenerators) {
         log('no registered sync generators, collecting them');
         const { projectGraph } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
         collectAllRegisteredSyncGenerators(projectGraph);
@@ -110,7 +115,10 @@ async function getCachedRegisteredSyncGenerators() {
     else {
         log('registered sync generators already collected, returning them');
     }
-    return [...registeredSyncGenerators];
+    return {
+        globalGenerators: [...registeredGlobalSyncGenerators],
+        taskGenerators: [...registeredTaskSyncGenerators],
+    };
 }
 async function getFromCacheOrRunGenerators(generators) {
     let projects;
@@ -296,23 +304,33 @@ function collectAllRegisteredSyncGenerators(projectGraph) {
     else {
         log('nx.json hash is the same, not collecting global sync generators');
     }
-    const generators = new Set([
-        ...registeredTaskSyncGenerators,
-        ...registeredGlobalSyncGenerators,
-    ]);
     if (!registeredSyncGenerators) {
-        registeredSyncGenerators = generators;
+        registeredSyncGenerators = {
+            globalGenerators: registeredGlobalSyncGenerators,
+            taskGenerators: registeredTaskSyncGenerators,
+        };
         return;
     }
-    for (const generator of registeredSyncGenerators) {
-        if (!generators.has(generator)) {
-            registeredSyncGenerators.delete(generator);
+    for (const generator of registeredSyncGenerators.globalGenerators) {
+        if (!registeredGlobalSyncGenerators.has(generator)) {
+            registeredSyncGenerators.globalGenerators.delete(generator);
             syncGeneratorsCacheResultPromises.delete(generator);
         }
     }
-    for (const generator of generators) {
-        if (!registeredSyncGenerators.has(generator)) {
-            registeredSyncGenerators.add(generator);
+    for (const generator of registeredSyncGenerators.taskGenerators) {
+        if (!registeredTaskSyncGenerators.has(generator)) {
+            registeredSyncGenerators.taskGenerators.delete(generator);
+            syncGeneratorsCacheResultPromises.delete(generator);
+        }
+    }
+    for (const generator of registeredGlobalSyncGenerators) {
+        if (!registeredSyncGenerators.globalGenerators.has(generator)) {
+            registeredSyncGenerators.globalGenerators.add(generator);
+        }
+    }
+    for (const generator of registeredTaskSyncGenerators) {
+        if (!registeredSyncGenerators.taskGenerators.has(generator)) {
+            registeredSyncGenerators.taskGenerators.add(generator);
         }
     }
 }

package/src/executors/run-commands/run-commands.impl.js

@@ -231,6 +231,7 @@ function nodeProcess(commandConfig, cwd, env, readyWhenStatus, streamOutput = tr
             maxBuffer: exports.LARGE_BUFFER,
             env,
             cwd,
+            windowsHide: true,
         });
         childProcesses.add(childProcess);
         childProcess.stdout.on('data', (data) => {

package/src/executors/run-script/run-script.impl.js

@@ -35,6 +35,7 @@ function nodeProcess(command, cwd, env) {
         stdio: ['inherit', 'inherit', 'inherit'],
         cwd,
         env,
+        windowsHide: true,
     });
 }
 async function ptyProcess(command, cwd, env) {

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.js

@@ -32,7 +32,7 @@ function getRootPackageName(tree) {
 }
 function getNxInitDate() {
     try {
-        const nxInitIso = (0, child_process_1.execSync)('git log --diff-filter=A --follow --format=%aI -- nx.json | tail -1', { stdio: 'pipe' })
+        const nxInitIso = (0, child_process_1.execSync)('git log --diff-filter=A --follow --format=%aI -- nx.json | tail -1', { stdio: 'pipe', windowsHide: true })
             .toString()
             .trim();
         const nxInitDate = new Date(nxInitIso);

package/src/project-graph/file-utils.js

@@ -91,6 +91,7 @@ function defaultReadFileAtRevision(file, revision) {
             : (0, child_process_1.execSync)(`git show ${revision}:${filePathInGitRepository}`, {
                 maxBuffer: exports.TEN_MEGABYTES,
                 stdio: ['pipe', 'pipe', 'ignore'],
+                windowsHide: true,
             })
                 .toString()
                 .trim();

package/src/tasks-runner/cache.d.ts

@@ -1,5 +1,6 @@
 import { DefaultTasksRunnerOptions, RemoteCache } from './default-tasks-runner';
 import { Task } from '../config/task-graph';
+import { NxJsonConfiguration } from '../config/nx-json';
 export type CachedResult = {
     terminalOutput: string;
     outputsPath: string;
@@ -10,7 +11,7 @@ export type TaskWithCachedResult = {
     task: Task;
     cachedResult: CachedResult;
 };
-export declare function getCache(options: DefaultTasksRunnerOptions): DbCache | Cache;
+export declare function getCache(nxJson: NxJsonConfiguration, options: DefaultTasksRunnerOptions): DbCache | Cache;
 export declare class DbCache {
     private readonly options;
     private cache;
@@ -30,6 +31,7 @@ export declare class DbCache {
     private _getRemoteCache;
     private getPowerpackS3Cache;
     private getPowerpackSharedCache;
+    private getPowerpackCache;
     private resolvePackage;
     private assertCacheIsValid;
 }

package/src/tasks-runner/cache.js

@@ -18,9 +18,9 @@ const update_manager_1 = require("../nx-cloud/update-manager");
 const get_cloud_options_1 = require("../nx-cloud/utilities/get-cloud-options");
 const is_ci_1 = require("../utils/is-ci");
 const output_1 = require("../utils/output");
-function getCache(options) {
+function getCache(nxJson, options) {
     return process.env.NX_DISABLE_DB !== 'true' &&
-        process.env.NX_DB_CACHE === 'true'
+        (nxJson.enableDbCache === true || process.env.NX_DB_CACHE === 'true')
         ? new DbCache({
             // Remove this in Nx 21
             nxCloudRemoteCache: (0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())
@@ -114,23 +114,21 @@ class DbCache {
                 null);
         }
     }
-    async getPowerpackS3Cache() {
-        try {
-            const { getRemoteCache } = await Promise.resolve(`${this.resolvePackage('@nx/powerpack-s3-cache')}`).then(s => require(s));
-            return getRemoteCache();
-        }
-        catch {
-            return null;
-        }
+    getPowerpackS3Cache() {
+        return this.getPowerpackCache('@nx/powerpack-s3-cache');
+    }
+    getPowerpackSharedCache() {
+        return this.getPowerpackCache('@nx/powerpack-shared-fs-cache');
     }
-    async getPowerpackSharedCache() {
+    async getPowerpackCache(pkg) {
+        let getRemoteCache = null;
         try {
-            const { getRemoteCache } = await Promise.resolve(`${this.resolvePackage('@nx/powerpack-shared-fs-cache')}`).then(s => require(s));
-            return getRemoteCache();
+            getRemoteCache = (await Promise.resolve(`${this.resolvePackage(pkg)}`).then(s => require(s))).getRemoteCache;
         }
         catch {
             return null;
         }
+        return getRemoteCache();
     }
     resolvePackage(pkg) {
         return require.resolve(pkg, {
@@ -183,6 +181,7 @@ class Cache {
                     stdio: 'ignore',
                     detached: true,
                     shell: false,
+                    windowsHide: true,
                 });
                 p.unref();
             }

package/src/tasks-runner/default-tasks-runner.js

@@ -56,7 +56,7 @@ const defaultTasksRunner = async (tasks, options, context) => {
 };
 exports.defaultTasksRunner = defaultTasksRunner;
 async function runAllTasks(tasks, options, context) {
-    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.projectGraph, context.taskGraph, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.outputStyle);
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.outputStyle);
     return orchestrator.run();
 }
 exports.default = exports.defaultTasksRunner;

package/src/tasks-runner/life-cycles/task-history-life-cycle.js

@@ -31,6 +31,9 @@ class TaskHistoryLifeCycle {
     }
     async endCommand() {
         const entries = Array.from(this.taskRuns);
+        if (!this.taskHistory) {
+            return;
+        }
         await this.taskHistory.recordTaskRuns(entries.map(([_, v]) => v));
         const flakyTasks = await this.taskHistory.getFlakyTasks(entries.map(([hash]) => hash));
         if (flakyTasks.length > 0) {

package/src/tasks-runner/task-orchestrator.d.ts

@@ -4,11 +4,13 @@ import { TaskStatus } from './tasks-runner';
 import { ProjectGraph } from '../config/project-graph';
 import { TaskGraph } from '../config/task-graph';
 import { DaemonClient } from '../daemon/client/client';
+import { NxJsonConfiguration } from '../config/nx-json';
 export declare class TaskOrchestrator {
     private readonly hasher;
     private readonly initiatingProject;
     private readonly projectGraph;
     private readonly taskGraph;
+    private readonly nxJson;
     private readonly options;
     private readonly bail;
     private readonly daemon;
@@ -24,7 +26,7 @@ export declare class TaskOrchestrator {
     private waitingForTasks;
     private groups;
     private bailed;
-    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string);
+    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string);
     run(): Promise<{
         [id: string]: TaskStatus;
     }>;

package/src/tasks-runner/task-orchestrator.js

@@ -17,16 +17,17 @@ const output_1 = require("../utils/output");
 const params_1 = require("../utils/params");
 class TaskOrchestrator {
     // endregion internal state
-    constructor(hasher, initiatingProject, projectGraph, taskGraph, options, bail, daemon, outputStyle) {
+    constructor(hasher, initiatingProject, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle) {
         this.hasher = hasher;
         this.initiatingProject = initiatingProject;
         this.projectGraph = projectGraph;
         this.taskGraph = taskGraph;
+        this.nxJson = nxJson;
         this.options = options;
         this.bail = bail;
         this.daemon = daemon;
         this.outputStyle = outputStyle;
-        this.cache = (0, cache_1.getCache)(this.options);
+        this.cache = (0, cache_1.getCache)(this.nxJson, this.options);
         this.forkedProcessTaskRunner = new forked_process_task_runner_1.ForkedProcessTaskRunner(this.options);
         this.tasksSchedule = new tasks_schedule_1.TasksSchedule(this.projectGraph, this.taskGraph, this.options);
         // region internal state

package/src/tasks-runner/tasks-schedule.js

@@ -13,7 +13,7 @@ class TasksSchedule {
         this.notScheduledTaskGraph = this.taskGraph;
         this.reverseTaskDeps = (0, utils_1.calculateReverseDeps)(this.taskGraph);
         this.reverseProjectGraph = (0, operators_1.reverse)(this.projectGraph);
-        this.taskHistory = process.env.NX_DISABLE_DB !== 'true' ? (0, task_history_1.getTaskHistory)() : null;
+        this.taskHistory = (0, task_history_1.getTaskHistory)();
         this.scheduledBatches = [];
         this.scheduledTasks = [];
         this.runningTasks = new Set();

package/src/utils/ab-testing.js

@@ -97,7 +97,10 @@ function shouldRecordStats() {
         return true;
     }
     try {
-        const stdout = (0, node_child_process_1.execSync)(pmc.getRegistryUrl, { encoding: 'utf-8' });
+        const stdout = (0, node_child_process_1.execSync)(pmc.getRegistryUrl, {
+            encoding: 'utf-8',
+            windowsHide: true,
+        });
         const url = new URL(stdout.trim());
         // don't record stats when testing locally
         return url.hostname !== 'localhost';

package/src/utils/child-process.js

@@ -16,6 +16,7 @@ function runNxSync(cmd, options) {
     else {
         options ??= {};
         options.cwd ??= process.cwd();
+        options.windowsHide ??= true;
         const offsetFromRoot = (0, path_1.relative)(options.cwd, (0, workspace_root_1.workspaceRootInner)(options.cwd, null));
         if (process.platform === 'win32') {
             baseCmd = '.\\' + (0, path_1.join)(`${offsetFromRoot}`, 'nx.bat');
@@ -34,6 +35,7 @@ async function runNxAsync(cmd, options) {
     else {
         options ??= {};
         options.cwd ??= process.cwd();
+        options.windowsHide ??= true;
         const offsetFromRoot = (0, path_1.relative)(options.cwd, (0, workspace_root_1.workspaceRootInner)(options.cwd, null));
         if (process.platform === 'win32') {
             baseCmd = '.\\' + (0, path_1.join)(`${offsetFromRoot}`, 'nx.bat');
@@ -46,13 +48,13 @@ async function runNxAsync(cmd, options) {
     if (options?.silent) {
         delete options.silent;
     }
-    await new Promise((resolve, reject) => {
+    return new Promise((resolve, reject) => {
         const child = (0, child_process_1.exec)(`${baseCmd} ${cmd}`, options, (error, stdout, stderr) => {
             if (error) {
-                reject(error);
+                reject(stderr || stdout || error.message);
             }
             else {
-                resolve(stdout);
+                resolve();
             }
         });
         if (!silent) {

package/src/utils/command-line-utils.js

@@ -222,6 +222,7 @@ function getMergeBase(base, head = 'HEAD') {
             maxBuffer: file_utils_1.TEN_MEGABYTES,
             cwd: workspace_root_1.workspaceRoot,
             stdio: 'pipe',
+            windowsHide: true,
         })
             .toString()
             .trim();
@@ -232,6 +233,7 @@ function getMergeBase(base, head = 'HEAD') {
                 maxBuffer: file_utils_1.TEN_MEGABYTES,
                 cwd: workspace_root_1.workspaceRoot,
                 stdio: 'pipe',
+                windowsHide: true,
             })
                 .toString()
                 .trim();
@@ -245,7 +247,11 @@ function getFilesUsingBaseAndHead(base, head) {
     return parseGitOutput(`git diff --name-only --no-renames --relative "${base}" "${head}"`);
 }
 function parseGitOutput(command) {
-    return (0, child_process_1.execSync)(command, { maxBuffer: file_utils_1.TEN_MEGABYTES, cwd: workspace_root_1.workspaceRoot })
+    return (0, child_process_1.execSync)(command, {
+        maxBuffer: file_utils_1.TEN_MEGABYTES,
+        cwd: workspace_root_1.workspaceRoot,
+        windowsHide: true,
+    })
         .toString('utf-8')
         .split('\n')
         .map((a) => a.trim())

package/src/utils/default-base.js

@@ -5,8 +5,11 @@ const child_process_1 = require("child_process");
 function deduceDefaultBase() {
     const nxDefaultBase = 'main';
     try {
-        return ((0, child_process_1.execSync)('git config --get init.defaultBranch').toString().trim() ||
-            nxDefaultBase);
+        return ((0, child_process_1.execSync)('git config --get init.defaultBranch', {
+            windowsHide: true,
+        })
+            .toString()
+            .trim() || nxDefaultBase);
     }
     catch {
         return nxDefaultBase;

package/src/utils/git-utils.index-filter.js

@@ -9,9 +9,10 @@ try {
     const { execSync } = require('child_process');
     // NOTE: Using env vars because Windows PowerShell has its own handling of quotes (") messes up quotes in args, even if escaped.
     const src = process.env.NX_IMPORT_SOURCE;
-    execSync('git read-tree --empty', { stdio: 'inherit' });
+    execSync('git read-tree --empty', { stdio: 'inherit', windowsHide: true });
     execSync(`git reset ${process.env.GIT_COMMIT} -- "${src}"`, {
         stdio: 'inherit',
+        windowsHide: true,
     });
 }
 catch (error) {

package/src/utils/git-utils.js

@@ -36,6 +36,7 @@ class GitRepository {
     getGitRootPath(cwd) {
         return (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
             cwd,
+            windowsHide: true,
         })
             .toString()
             .trim();
@@ -176,6 +177,7 @@ function getGithubSlugOrNull() {
     try {
         const gitRemote = (0, child_process_1.execSync)('git remote -v', {
             stdio: 'pipe',
+            windowsHide: true,
         }).toString();
         // If there are no remotes, we default to github
         if (!gitRemote || gitRemote.length === 0) {
@@ -226,6 +228,7 @@ function commitChanges(commitMessage, directory) {
             stdio: 'pipe',
             input: commitMessage,
             cwd: directory,
+            windowsHide: true,
         });
     }
     catch (err) {
@@ -247,6 +250,7 @@ function getLatestCommitSha() {
         return (0, child_process_1.execSync)('git rev-parse HEAD', {
             encoding: 'utf8',
             stdio: 'pipe',
+            windowsHide: true,
         }).trim();
     }
     catch {

package/src/utils/git-utils.tree-filter.js

@@ -14,7 +14,9 @@ try {
     // NOTE: Using env vars because Windows PowerShell has its own handling of quotes (") messes up quotes in args, even if escaped.
     const src = process.env.NX_IMPORT_SOURCE;
     const dest = process.env.NX_IMPORT_DESTINATION;
-    const files = execSync(`git ls-files -z ${src}`)
+    const files = execSync(`git ls-files -z ${src}`, {
+        windowsHide: true,
+    })
         .toString()
         .trim()
         .split('\x00')

package/src/utils/powerpack.d.ts

@@ -1,5 +1,5 @@
 export declare function printPowerpackLicense(): Promise<void>;
-export declare function getPowerpackLicenseInformation(): Promise<any>;
+export declare function getPowerpackLicenseInformation(): Promise<import("@nx/powerpack-license").PowerpackLicense>;
 export declare class NxPowerpackNotInstalledError extends Error {
     constructor(e: Error);
 }

package/src/utils/powerpack.js

@@ -9,22 +9,17 @@ const workspace_root_1 = require("./workspace-root");
 async function printPowerpackLicense() {
     try {
         const { organizationName, seatCount, workspaceCount } = await getPowerpackLicenseInformation();
-        logger_1.logger.log(`Nx Powerpack Licensed to ${organizationName} for ${seatCount} user${seatCount > 1 ? '' : 's'} in ${workspaceCount} workspace${workspaceCount > 1 ? '' : 's'}`);
+        logger_1.logger.log(`Nx Powerpack Licensed to ${organizationName} for ${seatCount} user${seatCount > 1 ? '' : 's'} in ${workspaceCount === 9999 ? 'an unlimited number of' : workspaceCount} workspace${workspaceCount > 1 ? '' : 's'}`);
     }
     catch { }
 }
 async function getPowerpackLicenseInformation() {
     try {
-        const { getPowerpackLicenseInformation } = (await Promise.resolve().then(() => require(
-        // @ts-ignore
-        '@nx/powerpack-license'
-        // TODO(@FrozenPandaz): Provide the right type here.
-        )));
-        // )) as typeof import('@nx/powerpack-license');
+        const { getPowerpackLicenseInformation } = (await Promise.resolve().then(() => require('@nx/powerpack-license')));
         return getPowerpackLicenseInformation(workspace_root_1.workspaceRoot);
     }
     catch (e) {
-        if ('code' in e && e.code === 'ERR_MODULE_NOT_FOUND') {
+        if ('code' in e && e.code === 'MODULE_NOT_FOUND') {
             throw new NxPowerpackNotInstalledError(e);
         }
         throw e;

package/src/utils/sync-generators.d.ts

@@ -18,6 +18,8 @@ export type SyncGeneratorRunSuccessResult = {
 type SerializableSimpleError = {
     message: string;
     stack: string | undefined;
+    title?: string;
+    bodyLines?: string[];
 };
 export type SyncGeneratorRunErrorResult = {
     generatorName: string;
@@ -36,16 +38,24 @@ type FlushSyncGeneratorChangesFailure = {
     generalFailure?: SerializableSimpleError;
 };
 export type FlushSyncGeneratorChangesResult = FlushSyncGeneratorChangesSuccess | FlushSyncGeneratorChangesFailure;
+export declare class SyncError extends Error {
+    title: string;
+    bodyLines?: string[];
+    constructor(title: string, bodyLines?: string[]);
+}
 export declare function getSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorRunResult[]>;
 export declare function flushSyncGeneratorChanges(results: SyncGeneratorRunResult[]): Promise<FlushSyncGeneratorChangesResult>;
-export declare function collectAllRegisteredSyncGenerators(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Promise<string[]>;
+export declare function collectAllRegisteredSyncGenerators(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Promise<{
+    globalGenerators: string[];
+    taskGenerators: string[];
+}>;
 export declare function runSyncGenerator(tree: Tree, generatorSpecifier: string, projects: Record<string, ProjectConfiguration>): Promise<SyncGeneratorRunResult>;
 export declare function collectEnabledTaskSyncGeneratorsFromProjectGraph(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Set<string>;
 export declare function collectEnabledTaskSyncGeneratorsFromTaskGraph(taskGraph: TaskGraph, projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Set<string>;
 export declare function collectRegisteredGlobalSyncGenerators(nxJson?: NxJsonConfiguration<string[] | "*">): Set<string>;
 export declare function getSyncGeneratorSuccessResultsMessageLines(results: SyncGeneratorRunResult[]): string[];
-export declare function getFailedSyncGeneratorsFixMessageLines(results: SyncGeneratorRunResult[], verbose: boolean): string[];
-export declare function getFlushFailureMessageLines(result: FlushSyncGeneratorChangesFailure, verbose: boolean): string[];
+export declare function getFailedSyncGeneratorsFixMessageLines(results: SyncGeneratorRunResult[], verbose: boolean, globalGeneratorSet?: Set<string>): string[];
+export declare function getFlushFailureMessageLines(result: FlushSyncGeneratorChangesFailure, verbose: boolean, globalGeneratorSet?: Set<string>): string[];
 export declare function processSyncGeneratorResultErrors(results: SyncGeneratorRunResult[]): {
     failedGeneratorsCount: number;
     areAllResultsFailures: boolean;