@cbnventures/nova 0.16.2 → 0.18.0

package/build/src/cli/generate/github/workflows.js

@@ -2,12 +2,12 @@ import { promises as fs } from 'fs';
 import { join } from 'path';
 import chalk from 'chalk';
 import { parse as parseYaml, stringify as stringifyYaml, } from 'yaml';
-import { LibNovaConfig } from '../../../lib/nova-config.js';
+import { Runner as LibNovaConfig } from '../../../lib/nova-config.js';
 import { LIB_REGEX_PATTERN_LEADING_DOT_SLASH, LIB_REGEX_PATTERN_TRAILING_NEWLINES, LIB_REGEX_PATTERN_TRAILING_NEWLINES_OR_NONE, LIB_REGEX_PATTERN_TRAILING_SLASH, LIB_REGEX_PATTERN_WORKFLOW_CONTEXT_EXPRESSION, LIB_REGEX_PATTERN_WORKFLOW_CONTEXT_SEPARATOR, LIB_REGEX_PATTERN_WORKFLOW_CONTEXT_WRAPPER_END, LIB_REGEX_PATTERN_WORKFLOW_CONTEXT_WRAPPER_START, LIB_REGEX_PATTERN_WORKFLOW_NAME, LIB_REGEX_PATTERN_WORKFLOW_RUN_NAME_CAPTURE, } from '../../../lib/regex.js';
 import { isProjectRoot, pathExists, renameFileWithDate, resolveTemplatePath, saveGeneratedFile, } from '../../../lib/utility.js';
 import { libWorkflowTemplatesMetadata } from '../../../lib/workflow-templates.js';
 import { Logger } from '../../../toolkit/index.js';
-export class CliGenerateGithubWorkflows {
+export class Runner {
     static async run(options) {
         const currentDirectory = process.cwd();
         const isAtProjectRoot = await isProjectRoot(currentDirectory);
@@ -19,14 +19,14 @@ export class CliGenerateGithubWorkflows {
         const isReplaceFile = options['replaceFile'] === true;
         if (isDryRun === true) {
             Logger.customize({
-                name: 'CliGenerateGithubWorkflows.run',
+                name: 'Runner.run',
                 purpose: 'options',
             }).warn('Dry run enabled. File changes will not be made in this session.');
         }
         if (isReplaceFile === true) {
             const replaceFileNotice = (isDryRun === true) ? 'This option has no effect during a dry run session.' : 'Backup file will not be created.';
             Logger.customize({
-                name: 'CliGenerateGithubWorkflows.run',
+                name: 'Runner.run',
                 purpose: 'options',
             }).warn(`Replace file enabled. ${replaceFileNotice}`);
         }
@@ -34,7 +34,7 @@ export class CliGenerateGithubWorkflows {
         const workflows = config['workflows'];
         if (workflows === undefined || workflows.length === 0) {
             Logger.customize({
-                name: 'CliGenerateGithubWorkflows.run',
+                name: 'Runner.run',
                 purpose: 'skip',
             }).info('No workflows configured.');
             return 'completed';
@@ -47,7 +47,7 @@ export class CliGenerateGithubWorkflows {
             const duplicateKey = (entry['suffix'] !== undefined) ? `${entry['template']}-${entry['suffix']}` : entry['template'];
             if (duplicateSet.has(duplicateKey) === true) {
                 Logger.customize({
-                    name: 'CliGenerateGithubWorkflows.run',
+                    name: 'Runner.run',
                     purpose: 'validate',
                 }).error(`Duplicate workflow ${chalk.cyan(`"${duplicateKey}"`)}. Each template must have a unique suffix when used multiple times.`);
                 hasDuplicateError = true;
@@ -58,24 +58,160 @@ export class CliGenerateGithubWorkflows {
             process.exitCode = 1;
             return 'cancelled';
         }
-        if (CliGenerateGithubWorkflows.detectCircularDependsOn(workflows) === true) {
+        if (Runner.detectCircularDependsOn(workflows) === true) {
             Logger.customize({
-                name: 'CliGenerateGithubWorkflows.run',
+                name: 'Runner.run',
                 purpose: 'validate',
             }).error('Circular depends-on references detected. Aborting.');
             process.exitCode = 1;
             return 'cancelled';
         }
+        const skippedWorkflowKeys = new Set();
+        for (const literalWorkflowEntry of workflows) {
+            const literalEntry = literalWorkflowEntry;
+            const literalTemplateName = literalEntry['template'];
+            const literalSuffix = literalEntry['suffix'];
+            const literalWorkflowKey = (literalSuffix !== undefined) ? `${literalTemplateName}-${literalSuffix}` : literalTemplateName;
+            const literalMetadataEntry = libWorkflowTemplatesMetadata.find((m) => m['name'] === literalTemplateName);
+            if (literalMetadataEntry === undefined) {
+                continue;
+            }
+            const missingLiterals = [];
+            for (const variableEntry of Object.entries(literalMetadataEntry['variables'])) {
+                const templateVariableName = variableEntry[0];
+                const templateVariableMeta = variableEntry[1];
+                if (templateVariableMeta['format'] === 'literal') {
+                    const templateLiteralValue = (literalEntry['settings'] !== undefined) ? literalEntry['settings'][templateVariableName] : undefined;
+                    if (typeof templateLiteralValue !== 'string' || templateLiteralValue.trim() === '') {
+                        missingLiterals.push(templateVariableName);
+                    }
+                }
+            }
+            const targetsMetadataForValidation = literalMetadataEntry['targets'] ?? {};
+            const entryTargetsForValidation = literalEntry['targets'] ?? [];
+            for (const entryTargetForValidation of entryTargetsForValidation) {
+                const targetTypeForValidation = entryTargetForValidation['type'];
+                const targetMetadataForValidation = targetsMetadataForValidation[targetTypeForValidation];
+                if (targetMetadataForValidation === undefined) {
+                    continue;
+                }
+                for (const variableEntry of Object.entries(targetMetadataForValidation['variables'])) {
+                    const validationVariableName = variableEntry[0];
+                    const validationVariableMeta = variableEntry[1];
+                    if (validationVariableMeta['format'] === 'literal') {
+                        const validationLiteralValue = (literalEntry['settings'] !== undefined) ? literalEntry['settings'][validationVariableName] : undefined;
+                        if (typeof validationLiteralValue !== 'string' || validationLiteralValue.trim() === '') {
+                            if (missingLiterals.includes(validationVariableName) === false) {
+                                missingLiterals.push(validationVariableName);
+                            }
+                        }
+                    }
+                }
+            }
+            if (missingLiterals.length > 0) {
+                Logger.customize({
+                    name: 'Runner.run',
+                    purpose: 'validate',
+                }).error(`Workflow ${chalk.cyan(`"${literalWorkflowKey}"`)} is missing required literal settings: ${missingLiterals.join(', ')}. Skipping.`);
+                skippedWorkflowKeys.add(literalWorkflowKey);
+            }
+        }
+        const globalUniquenessMap = new Map();
+        const uniquenessErrors = [];
+        for (const uniquenessWorkflowEntry of workflows) {
+            const uniquenessEntry = uniquenessWorkflowEntry;
+            const uniquenessTemplateName = uniquenessEntry['template'];
+            const uniquenessSuffix = uniquenessEntry['suffix'];
+            const uniquenessWorkflowKey = (uniquenessSuffix !== undefined) ? `${uniquenessTemplateName}-${uniquenessSuffix}` : uniquenessTemplateName;
+            if (skippedWorkflowKeys.has(uniquenessWorkflowKey) === true) {
+                continue;
+            }
+            const uniquenessMetadataEntry = libWorkflowTemplatesMetadata.find((m) => m['name'] === uniquenessTemplateName);
+            if (uniquenessMetadataEntry === undefined) {
+                continue;
+            }
+            const uniquenessTargetsMetadata = uniquenessMetadataEntry['targets'] ?? {};
+            const uniquenessEntryTargets = uniquenessEntry['targets'] ?? [];
+            for (const uniquenessTarget of uniquenessEntryTargets) {
+                const entryTargetForUniqueness = uniquenessTarget;
+                const targetTypeForUniqueness = entryTargetForUniqueness['type'];
+                const targetMetadataForUniqueness = uniquenessTargetsMetadata[targetTypeForUniqueness];
+                if (targetMetadataForUniqueness === undefined) {
+                    continue;
+                }
+                const uniquenessKeyForTarget = targetMetadataForUniqueness['uniquenessKey'];
+                if (uniquenessKeyForTarget === undefined) {
+                    continue;
+                }
+                const uniquenessKeyResolvedValues = [];
+                const uniquenessKeyDetailEntries = [];
+                for (const uniquenessKeyVariableName of uniquenessKeyForTarget) {
+                    const variableName = uniquenessKeyVariableName;
+                    const variableMeta = targetMetadataForUniqueness['variables'][variableName];
+                    const settingValue = (uniquenessEntry['settings'] !== undefined) ? uniquenessEntry['settings'][variableName] : undefined;
+                    const resolvedValue = settingValue
+                        ?? (variableMeta !== undefined ? variableMeta['default'] : undefined)
+                        ?? variableName;
+                    const uniquenessKeyDetailEntry = `${variableName}=${resolvedValue}`;
+                    uniquenessKeyResolvedValues.push(resolvedValue);
+                    uniquenessKeyDetailEntries.push(uniquenessKeyDetailEntry);
+                }
+                const uniquenessKeyComposite = [
+                    targetTypeForUniqueness,
+                    ...uniquenessKeyResolvedValues,
+                ].join('::');
+                const uniquenessKeyExisting = globalUniquenessMap.get(uniquenessKeyComposite);
+                if (uniquenessKeyExisting !== undefined) {
+                    skippedWorkflowKeys.add(uniquenessKeyExisting['workflowKey']);
+                    skippedWorkflowKeys.add(uniquenessWorkflowKey);
+                    const isSameWorkflow = uniquenessKeyExisting['workflowKey'] === uniquenessWorkflowKey;
+                    if (uniquenessKeyDetailEntries.length === 0) {
+                        if (isSameWorkflow === true) {
+                            uniquenessErrors.push(`Singleton target violation: workflow "${uniquenessWorkflowKey}" declares multiple "${targetTypeForUniqueness}" targets, but only one is allowed.`);
+                        }
+                        else {
+                            uniquenessErrors.push(`Singleton target collision: only one "${targetTypeForUniqueness}" target may be declared across all workflows. Found in workflow "${uniquenessKeyExisting['workflowKey']}" and again in workflow "${uniquenessWorkflowKey}".`);
+                        }
+                    }
+                    else if (isSameWorkflow === true) {
+                        uniquenessErrors.push(`Destination collision in workflow "${uniquenessWorkflowKey}": multiple "${targetTypeForUniqueness}" targets declare the same destination (${uniquenessKeyDetailEntries.join(', ')}). Each destination must be declared in only one target.`);
+                    }
+                    else {
+                        uniquenessErrors.push(`Cross-workflow destination collision: target "${targetTypeForUniqueness}" with destination (${uniquenessKeyDetailEntries.join(', ')}) is declared in workflow "${uniquenessKeyExisting['workflowKey']}" and again in workflow "${uniquenessWorkflowKey}". Each destination must be declared in only one workflow.`);
+                    }
+                    continue;
+                }
+                const uniquenessKeyMapValue = {
+                    workflowKey: uniquenessWorkflowKey,
+                    targetType: targetTypeForUniqueness,
+                    detailEntries: uniquenessKeyDetailEntries,
+                };
+                globalUniquenessMap.set(uniquenessKeyComposite, uniquenessKeyMapValue);
+            }
+        }
+        if (uniquenessErrors.length > 0) {
+            for (const uniquenessError of uniquenessErrors) {
+                Logger.customize({
+                    name: 'Runner.run',
+                    purpose: 'validate',
+                }).error(uniquenessError);
+            }
+        }
         const generatedSet = new Set();
         const outputFileNames = new Set();
         const setupLines = [];
         for (const workflowEntry of workflows) {
             const entry = workflowEntry;
             const templateName = entry['template'];
+            const workflowSuffix = entry['suffix'];
+            const entryWorkflowKey = (workflowSuffix !== undefined) ? `${templateName}-${workflowSuffix}` : templateName;
+            if (skippedWorkflowKeys.has(entryWorkflowKey) === true) {
+                continue;
+            }
             const metadataEntry = libWorkflowTemplatesMetadata.find((m) => m['name'] === templateName);
             if (metadataEntry === undefined) {
                 Logger.customize({
-                    name: 'CliGenerateGithubWorkflows.run',
+                    name: 'Runner.run',
                     purpose: 'validate',
                 }).error(`Unknown template ${chalk.cyan(`"${templateName}"`)}. Skipping.`);
                 continue;
@@ -84,33 +220,15 @@ export class CliGenerateGithubWorkflows {
             const templateDirExists = await pathExists(templateDirPath);
             if (templateDirExists !== true) {
                 Logger.customize({
-                    name: 'CliGenerateGithubWorkflows.run',
+                    name: 'Runner.run',
                     purpose: 'validate',
                 }).error(`Template directory ${chalk.cyan(`"${templateName}"`)} not found. Skipping.`);
                 continue;
             }
-            const missingLiterals = [];
-            for (const variableEntry of Object.entries(metadataEntry['variables'])) {
-                const variableName = variableEntry[0];
-                const variableMeta = variableEntry[1];
-                if (variableMeta['format'] === 'literal') {
-                    if (entry['settings'] === undefined || entry['settings'][variableName] === undefined) {
-                        missingLiterals.push(variableName);
-                    }
-                }
-            }
-            if (missingLiterals.length > 0) {
-                Logger.customize({
-                    name: 'CliGenerateGithubWorkflows.run',
-                    purpose: 'validate',
-                }).error(`Template ${chalk.cyan(`"${templateName}"`)} is missing required literal settings: ${missingLiterals.join(', ')}. Skipping.`);
-                continue;
-            }
-            const workflowSuffix = entry['suffix'];
             const outputFileName = (workflowSuffix !== undefined) ? `nova-${templateName}-${workflowSuffix}.yml` : `nova-${templateName}.yml`;
             if (outputFileNames.has(outputFileName) === true) {
                 Logger.customize({
-                    name: 'CliGenerateGithubWorkflows.run',
+                    name: 'Runner.run',
                     purpose: 'validate',
                 }).error(`Duplicate output filename ${chalk.cyan(`"${outputFileName}"`)}. Skipping.`);
                 continue;
@@ -123,7 +241,7 @@ export class CliGenerateGithubWorkflows {
             }
             catch {
                 Logger.customize({
-                    name: 'CliGenerateGithubWorkflows.run',
+                    name: 'Runner.run',
                     purpose: 'read',
                 }).error(`Failed to read base template ${chalk.cyan(`"${templateName}/base.yml"`)}. Skipping.`);
                 continue;
@@ -140,7 +258,7 @@ export class CliGenerateGithubWorkflows {
                     const triggerFileExists = await pathExists(triggerFilePath);
                     if (triggerFileExists !== true) {
                         Logger.customize({
-                            name: 'CliGenerateGithubWorkflows.run',
+                            name: 'Runner.run',
                             purpose: 'validate',
                         }).error(`Trigger file ${chalk.cyan(`"${triggerFileName}"`)} not found for template ${chalk.cyan(`"${templateName}"`)}. Skipping workflow.`);
                         hasTriggerError = true;
@@ -152,7 +270,7 @@ export class CliGenerateGithubWorkflows {
                     }
                     catch {
                         Logger.customize({
-                            name: 'CliGenerateGithubWorkflows.run',
+                            name: 'Runner.run',
                             purpose: 'read',
                         }).error(`Failed to read trigger file ${chalk.cyan(`"${triggerFileName}"`)}. Skipping workflow.`);
                         hasTriggerError = true;
@@ -182,7 +300,7 @@ export class CliGenerateGithubWorkflows {
                     const entryLabel = (workflowSuffix !== undefined) ? `${templateName}-${workflowSuffix}` : templateName;
                     if (dependsOnEntries.length === 0) {
                         Logger.customize({
-                            name: 'CliGenerateGithubWorkflows.run',
+                            name: 'Runner.run',
                             purpose: 'validate',
                         }).error(`Workflow ${chalk.cyan(`"${entryLabel}"`)} uses a trigger that requires depends-on, but no depends-on value is configured. Skipping.`);
                         continue;
@@ -197,7 +315,7 @@ export class CliGenerateGithubWorkflows {
                         });
                         if (dependsOnTarget === undefined) {
                             Logger.customize({
-                                name: 'CliGenerateGithubWorkflows.run',
+                                name: 'Runner.run',
                                 purpose: 'validate',
                             }).error(`Workflow ${chalk.cyan(`"${entryLabel}"`)} depends on ${chalk.cyan(`"${entry2}"`)} which does not exist. Skipping.`);
                             hasDependsOnError = true;
@@ -216,7 +334,7 @@ export class CliGenerateGithubWorkflows {
                         }
                         catch {
                             Logger.customize({
-                                name: 'CliGenerateGithubWorkflows.run',
+                                name: 'Runner.run',
                                 purpose: 'read',
                             }).error(`Failed to resolve depends-on workflow name for ${chalk.cyan(`"${entry2}"`)}. Skipping.`);
                             hasDependsOnError = true;
@@ -250,9 +368,9 @@ export class CliGenerateGithubWorkflows {
                 const indentedTriggerLines = triggerYaml.split('\n').map((line) => (line.trim() === '') ? '' : `  ${line}`);
                 const indentedTriggerYaml = indentedTriggerLines.join('\n').replace(LIB_REGEX_PATTERN_TRAILING_NEWLINES, '');
                 const needsManuallyFallback = metadataEntry['needsManuallyFallback'] ?? true;
-                const mergedRunName = CliGenerateGithubWorkflows.buildMergedRunName(triggerDataList, needsManuallyFallback);
-                const mergedPublishCondition = CliGenerateGithubWorkflows.buildMergedPublishCondition(triggerDataList);
-                const mergedJobsCondition = CliGenerateGithubWorkflows.buildMergedJobsCondition(triggerDataList);
+                const mergedRunName = Runner.buildMergedRunName(triggerDataList, needsManuallyFallback);
+                const mergedPublishCondition = Runner.buildMergedPublishCondition(triggerDataList);
+                const mergedJobsCondition = Runner.buildMergedJobsCondition(triggerDataList);
                 const jobsConditionLine = (mergedJobsCondition !== '') ? `    if: "${mergedJobsCondition}"\n` : '';
                 content = content.replace('[__RUN_NAME__]', mergedRunName);
                 content = content.replace('[__TRIGGERS__]', indentedTriggerYaml);
@@ -265,14 +383,14 @@ export class CliGenerateGithubWorkflows {
                 let hasPublishValidationError = false;
                 if (supportsTargets !== true && entryTargets.length > 0) {
                     Logger.customize({
-                        name: 'CliGenerateGithubWorkflows.run',
+                        name: 'Runner.run',
                         purpose: 'validate',
                     }).error(`Template ${chalk.cyan(`"${templateName}"`)} does not support targets but the workflow entry declares targets. Skipping.`);
                     hasPublishValidationError = true;
                 }
                 if (supportsScopes !== true && entryScopes.length > 0) {
                     Logger.customize({
-                        name: 'CliGenerateGithubWorkflows.run',
+                        name: 'Runner.run',
                         purpose: 'validate',
                     }).error(`Template ${chalk.cyan(`"${templateName}"`)} does not support scopes but the workflow entry declares scopes. Skipping.`);
                     hasPublishValidationError = true;
@@ -289,7 +407,7 @@ export class CliGenerateGithubWorkflows {
                         const targetWorkingDir = entryTarget['workingDir'];
                         if (targetsMetadata[targetType] === undefined) {
                             Logger.customize({
-                                name: 'CliGenerateGithubWorkflows.run',
+                                name: 'Runner.run',
                                 purpose: 'validate',
                             }).error(`Target type ${chalk.cyan(`"${targetType}"`)} is not supported by template ${chalk.cyan(`"${templateName}"`)}. Skipping.`);
                             hasPublishValidationError = true;
@@ -298,7 +416,7 @@ export class CliGenerateGithubWorkflows {
                         const targetTupleKey = `${targetType}::${targetWorkingDir}`;
                         if (targetTupleSet.has(targetTupleKey) === true) {
                             Logger.customize({
-                                name: 'CliGenerateGithubWorkflows.run',
+                                name: 'Runner.run',
                                 purpose: 'validate',
                             }).error(`Duplicate target ${chalk.cyan(`"${targetType}"`)} at ${chalk.cyan(`"${targetWorkingDir}"`)}. Each target type and working directory pair must be unique. Skipping.`);
                             hasPublishValidationError = true;
@@ -307,7 +425,7 @@ export class CliGenerateGithubWorkflows {
                         targetTupleSet.add(targetTupleKey);
                         if (configWorkspaces[targetWorkingDir] === undefined) {
                             Logger.customize({
-                                name: 'CliGenerateGithubWorkflows.run',
+                                name: 'Runner.run',
                                 purpose: 'validate',
                             }).error(`Target working directory ${chalk.cyan(`"${targetWorkingDir}"`)} is not a registered workspace. Skipping.`);
                             hasPublishValidationError = true;
@@ -322,10 +440,10 @@ export class CliGenerateGithubWorkflows {
                 if (supportsScopes === true && entryScopes.length > 0) {
                     for (const entryScope of entryScopes) {
                         const scopePath = entryScope;
-                        const resolvedWorkspaceName = CliGenerateGithubWorkflows.resolveWorkspaceName(configWorkspaces, scopePath);
+                        const resolvedWorkspaceName = Runner.resolveWorkspaceName(configWorkspaces, scopePath);
                         if (resolvedWorkspaceName === undefined) {
                             Logger.customize({
-                                name: 'CliGenerateGithubWorkflows.run',
+                                name: 'Runner.run',
                                 purpose: 'validate',
                             }).error(`Scope ${chalk.cyan(`"${scopePath}"`)} is not a registered workspace. Skipping.`);
                             hasPublishValidationError = true;
@@ -339,39 +457,26 @@ export class CliGenerateGithubWorkflows {
                     continue;
                 }
                 if (supportsTargets === true) {
-                    const useTurbo = await CliGenerateGithubWorkflows.detectTurbo(currentDirectory);
-                    const checkCommand = CliGenerateGithubWorkflows.buildCommand('check', resolvedWorkspaceNames, useTurbo);
-                    const buildCommand = CliGenerateGithubWorkflows.buildCommand('build', resolvedWorkspaceNames, useTurbo);
+                    const useTurbo = await Runner.detectTurbo(currentDirectory);
+                    const checkCommand = Runner.buildCommand('check', resolvedWorkspaceNames, useTurbo);
+                    const buildCommand = Runner.buildCommand('build', resolvedWorkspaceNames, useTurbo);
                     content = content.replace('[__CHECK_COMMAND__]', checkCommand);
                     content = content.replace('[__BUILD_COMMAND__]', buildCommand);
-                    const artifactPathsBlock = CliGenerateGithubWorkflows.renderArtifactPaths(entryTargets, targetsMetadata);
-                    let uploadArtifactStep = '';
-                    if (artifactPathsBlock !== '') {
-                        const uploadArtifactStepLines = [
-                            '      - name: "Upload build artifacts"',
-                            '        uses: "actions/upload-artifact@v4"',
-                            '        with:',
-                            '          name: "build-output"',
-                            '          retention-days: 1',
-                            '          path: |',
-                            artifactPathsBlock,
-                        ];
-                        uploadArtifactStep = uploadArtifactStepLines.join('\n');
-                    }
+                    const uploadArtifactStep = Runner.renderUploadArtifactSteps(entryTargets, targetsMetadata);
                     content = content.replace('[__UPLOAD_ARTIFACT_STEP__]', uploadArtifactStep);
                     const resolvedTargetFragments = [];
                     let hasTargetFragmentError = false;
                     for (const entryTarget of entryTargets) {
                         const currentEntryTarget = entryTarget;
-                        const targetType = currentEntryTarget['type'];
-                        const targetWorkingDir = currentEntryTarget['workingDir'];
-                        const targetFragmentPath = join(templateDirPath, 'targets', `${targetType}.yml`);
+                        const fragmentTargetType = currentEntryTarget['type'];
+                        const fragmentTargetWorkingDir = currentEntryTarget['workingDir'];
+                        const targetFragmentPath = join(templateDirPath, 'targets', `${fragmentTargetType}.yml`);
                         const targetFragmentExists = await pathExists(targetFragmentPath);
                         if (targetFragmentExists !== true) {
                             Logger.customize({
-                                name: 'CliGenerateGithubWorkflows.run',
+                                name: 'Runner.run',
                                 purpose: 'validate',
-                            }).error(`Target fragment ${chalk.cyan(`"${targetType}.yml"`)} not found for template ${chalk.cyan(`"${templateName}"`)}. Skipping.`);
+                            }).error(`Target fragment ${chalk.cyan(`"${fragmentTargetType}.yml"`)} not found for template ${chalk.cyan(`"${templateName}"`)}. Skipping.`);
                             hasTargetFragmentError = true;
                             break;
                         }
@@ -381,36 +486,38 @@ export class CliGenerateGithubWorkflows {
                         }
                         catch {
                             Logger.customize({
-                                name: 'CliGenerateGithubWorkflows.run',
+                                name: 'Runner.run',
                                 purpose: 'read',
-                            }).error(`Failed to read target fragment ${chalk.cyan(`"${targetType}.yml"`)}. Skipping.`);
+                            }).error(`Failed to read target fragment ${chalk.cyan(`"${fragmentTargetType}.yml"`)}. Skipping.`);
                             hasTargetFragmentError = true;
                             break;
                         }
-                        const targetId = CliGenerateGithubWorkflows.slugifyWorkingDir(targetWorkingDir);
+                        const targetId = Runner.slugifyWorkingDir(fragmentTargetWorkingDir);
                         let targetFragmentResolvedContent = targetFragmentRawContent;
                         targetFragmentResolvedContent = targetFragmentResolvedContent.replaceAll('[__TARGET_ID__]', targetId);
-                        targetFragmentResolvedContent = targetFragmentResolvedContent.replaceAll('[__WORKING_DIR__]', targetWorkingDir);
+                        targetFragmentResolvedContent = targetFragmentResolvedContent.replaceAll('[__WORKING_DIR__]', fragmentTargetWorkingDir);
+                        const artifactName = Runner.buildArtifactName(fragmentTargetType, targetId);
+                        targetFragmentResolvedContent = targetFragmentResolvedContent.replaceAll('[__ARTIFACT_NAME__]', artifactName);
                         const targetNeeds = currentEntryTarget['needs'] ?? [];
-                        const targetNeedsJobIds = targetNeeds.map((targetNeedWorkingDir) => `publish-${targetType}-${CliGenerateGithubWorkflows.slugifyWorkingDir(targetNeedWorkingDir)}`);
+                        const targetNeedsJobIds = targetNeeds.map((targetNeedWorkingDir) => `publish-${fragmentTargetType}-${Runner.slugifyWorkingDir(targetNeedWorkingDir)}`);
                         const targetNeedsValue = (targetNeedsJobIds.length === 0) ? '"build"' : `["build", ${targetNeedsJobIds.map((targetNeedsJobId) => `"${targetNeedsJobId}"`).join(', ')}]`;
                         targetFragmentResolvedContent = targetFragmentResolvedContent.replace('[__NEEDS__]', targetNeedsValue);
                         const targetJobsConditionLine = (mergedJobsCondition !== '') ? `  if: "${mergedJobsCondition}"\n` : '';
                         targetFragmentResolvedContent = targetFragmentResolvedContent.replace('[__JOBS_CONDITION__]\n', targetJobsConditionLine);
-                        const targetMetadata = targetsMetadata[targetType];
+                        const targetMetadata = targetsMetadata[fragmentTargetType];
                         const mergedVariables = {
                             ...metadataEntry['variables'],
                             ...(targetMetadata !== undefined) ? targetMetadata['variables'] : {},
                         };
-                        targetFragmentResolvedContent = CliGenerateGithubWorkflows.substituteVariables(targetFragmentResolvedContent, mergedVariables, entry['settings']);
+                        targetFragmentResolvedContent = Runner.substituteVariables(targetFragmentResolvedContent, mergedVariables, entry['settings']);
                         try {
                             parseYaml(targetFragmentResolvedContent);
                         }
                         catch {
                             Logger.customize({
-                                name: 'CliGenerateGithubWorkflows.run',
+                                name: 'Runner.run',
                                 purpose: 'validate',
-                            }).error(`Target fragment ${chalk.cyan(`"${targetType}.yml"`)} produced invalid YAML. Skipping.`);
+                            }).error(`Target fragment ${chalk.cyan(`"${fragmentTargetType}.yml"`)} produced invalid YAML. Skipping.`);
                             hasTargetFragmentError = true;
                             break;
                         }
@@ -433,7 +540,7 @@ export class CliGenerateGithubWorkflows {
                         }
                         catch {
                             Logger.customize({
-                                name: 'CliGenerateGithubWorkflows.run',
+                                name: 'Runner.run',
                                 purpose: 'validate',
                             }).error(`Base template for ${chalk.cyan(`"${templateName}"`)} produced invalid YAML after target injection. Skipping.`);
                             continue;
@@ -442,30 +549,34 @@ export class CliGenerateGithubWorkflows {
                 }
             }
             content = content.replaceAll('[__WORKFLOW_ID__]', (workflowSuffix !== undefined) ? ` (${workflowSuffix})` : '');
-            const substituted = CliGenerateGithubWorkflows.substituteVariables(content, metadataEntry['variables'], entry['settings']);
+            const substituted = Runner.substituteVariables(content, metadataEntry['variables'], entry['settings']);
             try {
                 parseYaml(substituted);
             }
             catch {
                 Logger.customize({
-                    name: 'CliGenerateGithubWorkflows.run',
+                    name: 'Runner.run',
                     purpose: 'validate',
                 }).error(`Generated YAML for ${chalk.cyan(`"${outputFileName}"`)} is invalid. Skipping.`);
                 continue;
             }
             generatedSet.add(outputFileName);
-            const entrySetupLines = CliGenerateGithubWorkflows.buildEntrySetupLines(entry, metadataEntry, outputFileName);
+            const entrySetupLines = Runner.buildEntrySetupLines(entry, metadataEntry, outputFileName);
             setupLines.push(...entrySetupLines);
             if (isDryRun === true) {
                 const displayPath = `.github/workflows/${outputFileName}`;
                 Logger.customize({
-                    name: 'CliGenerateGithubWorkflows.run',
+                    name: 'Runner.run',
                     purpose: 'dry-run',
                 }).info(`Would generate ${chalk.cyan(`"${displayPath}"`)}.`);
                 continue;
             }
             const targetPath = join(workflowsDirectory, outputFileName);
-            await saveGeneratedFile(targetPath, substituted, isReplaceFile);
+            await saveGeneratedFile(targetPath, substituted, isReplaceFile, {
+                command: 'nova generate github workflows',
+                docsSlug: 'cli/generators/github/workflows',
+                mode: 'strict',
+            });
         }
         if (isDryRun !== true && await pathExists(workflowsDirectory) === true) {
             let existingEntries = [];
@@ -475,31 +586,31 @@ export class CliGenerateGithubWorkflows {
             catch {
             }
             for (const existingEntry of existingEntries) {
-                const entry = existingEntry;
-                if (entry.isFile() !== true) {
+                const existingDirent = existingEntry;
+                if (existingDirent.isFile() !== true) {
                     continue;
                 }
-                const isOrphan = entry.name.startsWith('nova-') === true
-                    && entry.name.endsWith('.yml') === true
-                    && generatedSet.has(entry.name) === false;
-                const isBackup = entry.name.includes('.nova-backup.') === true;
+                const isOrphan = existingDirent.name.startsWith('nova-') === true
+                    && existingDirent.name.endsWith('.yml') === true
+                    && generatedSet.has(existingDirent.name) === false;
+                const isBackup = existingDirent.name.includes('.nova-backup.') === true;
                 if (isOrphan !== true || isBackup === true) {
                     continue;
                 }
-                const orphanPath = join(workflowsDirectory, entry.name);
+                const orphanPath = join(workflowsDirectory, existingDirent.name);
                 if (isReplaceFile === true) {
                     await fs.unlink(orphanPath);
                     Logger.customize({
-                        name: 'CliGenerateGithubWorkflows.run',
+                        name: 'Runner.run',
                         purpose: 'cleanup',
-                    }).info(`Deleted orphan ${chalk.cyan(`"${entry.name}"`)}.`);
+                    }).info(`Deleted orphan ${chalk.cyan(`"${existingDirent.name}"`)}.`);
                 }
                 else {
                     await renameFileWithDate(orphanPath);
                     Logger.customize({
-                        name: 'CliGenerateGithubWorkflows.run',
+                        name: 'Runner.run',
                         purpose: 'cleanup',
-                    }).info(`Backed up orphan ${chalk.cyan(`"${entry.name}"`)}.`);
+                    }).info(`Backed up orphan ${chalk.cyan(`"${existingDirent.name}"`)}.`);
                 }
             }
         }
@@ -509,7 +620,7 @@ export class CliGenerateGithubWorkflows {
                 setupLines.join('\n'),
             ].join('\n');
             Logger.customize({
-                name: 'CliGenerateGithubWorkflows.run',
+                name: 'Runner.run',
                 purpose: 'setup',
                 padTop: 1,
             }).info(setupMessage);
@@ -617,12 +728,12 @@ export class CliGenerateGithubWorkflows {
                 continue;
             }
             if (variableMeta['format'] === 'secret') {
-                const resolvedName = (entry['settings'] !== undefined && entry['settings'][variableName] !== undefined) ? entry['settings'][variableName] : (variableMeta['default'] ?? variableName);
-                lines.push(` - ${chalk.cyan(outputFileName)}: Secret ${chalk.yellow(resolvedName)}`);
+                const secretResolvedName = (entry['settings'] !== undefined && entry['settings'][variableName] !== undefined) ? entry['settings'][variableName] : (variableMeta['default'] ?? variableName);
+                lines.push(` - ${chalk.cyan(outputFileName)}: Secret ${chalk.yellow(secretResolvedName)}`);
             }
             if (variableMeta['format'] === 'var') {
-                const resolvedName = (entry['settings'] !== undefined && entry['settings'][variableName] !== undefined) ? entry['settings'][variableName] : (variableMeta['default'] ?? variableName);
-                lines.push(` - ${chalk.cyan(outputFileName)}: Variable ${chalk.yellow(resolvedName)}`);
+                const varResolvedName = (entry['settings'] !== undefined && entry['settings'][variableName] !== undefined) ? entry['settings'][variableName] : (variableMeta['default'] ?? variableName);
+                lines.push(` - ${chalk.cyan(outputFileName)}: Variable ${chalk.yellow(varResolvedName)}`);
             }
         }
         if (entry['targets'] !== undefined && metadataEntry['targets'] !== undefined) {
@@ -640,12 +751,12 @@ export class CliGenerateGithubWorkflows {
                         continue;
                     }
                     if (targetVariableMeta['format'] === 'secret') {
-                        const targetResolvedName = (entry['settings'] !== undefined && entry['settings'][targetVariableName] !== undefined) ? entry['settings'][targetVariableName] : (targetVariableMeta['default'] ?? targetVariableName);
-                        lines.push(` - ${chalk.cyan(outputFileName)}: Secret ${chalk.yellow(targetResolvedName)}`);
+                        const targetSecretResolvedName = (entry['settings'] !== undefined && entry['settings'][targetVariableName] !== undefined) ? entry['settings'][targetVariableName] : (targetVariableMeta['default'] ?? targetVariableName);
+                        lines.push(` - ${chalk.cyan(outputFileName)}: Secret ${chalk.yellow(targetSecretResolvedName)}`);
                     }
                     if (targetVariableMeta['format'] === 'var') {
-                        const targetResolvedName = (entry['settings'] !== undefined && entry['settings'][targetVariableName] !== undefined) ? entry['settings'][targetVariableName] : (targetVariableMeta['default'] ?? targetVariableName);
-                        lines.push(` - ${chalk.cyan(outputFileName)}: Variable ${chalk.yellow(targetResolvedName)}`);
+                        const targetVarResolvedName = (entry['settings'] !== undefined && entry['settings'][targetVariableName] !== undefined) ? entry['settings'][targetVariableName] : (targetVariableMeta['default'] ?? targetVariableName);
+                        lines.push(` - ${chalk.cyan(outputFileName)}: Variable ${chalk.yellow(targetVarResolvedName)}`);
                     }
                 }
             }
@@ -660,26 +771,29 @@ export class CliGenerateGithubWorkflows {
             const regex = new RegExp(`\\$\\{\\{\\s*(?:secrets|vars)\\.${variableName}\\s*\\}\\}`, 'g');
             const settingValue = (settings !== undefined && settings[variableName] !== undefined) ? settings[variableName] : undefined;
             if (variableMeta['format'] === 'secret') {
-                const resolvedName = settingValue
+                const secretResolvedName = settingValue
                     ?? variableMeta['default']
                     ?? variableName;
-                const replacement = `\${{ secrets.${resolvedName} }}`;
-                result = result.replace(regex, replacement);
+                const secretReplacement = `\${{ secrets.${secretResolvedName} }}`;
+                result = result.replace(regex, secretReplacement);
             }
             if (variableMeta['format'] === 'var') {
-                const resolvedName = settingValue
+                const varResolvedName = settingValue
                     ?? variableMeta['default']
                     ?? variableName;
-                const replacement = `\${{ vars.${resolvedName} }}`;
-                result = result.replace(regex, replacement);
+                const varReplacement = `\${{ vars.${varResolvedName} }}`;
+                result = result.replace(regex, varReplacement);
             }
             if (variableMeta['format'] === 'literal') {
-                const replacement = (settingValue ?? '').replaceAll('\n', '\\n');
-                result = result.replace(regex, replacement);
+                const literalReplacement = (settingValue ?? '').replaceAll('\n', '\\n');
+                result = result.replace(regex, () => literalReplacement);
             }
         }
         return result;
     }
+    static buildArtifactName(targetType, targetId) {
+        return `build-${targetType}-${targetId}`;
+    }
     static slugifyWorkingDir(input) {
         const trimmed = input
             .replace(LIB_REGEX_PATTERN_LEADING_DOT_SLASH, '')
@@ -702,35 +816,41 @@ export class CliGenerateGithubWorkflows {
     }
     static buildCommand(scriptName, workspaceNames, useTurbo) {
         if (useTurbo === true) {
-            const flags = workspaceNames.map((name) => `--filter=${name}`);
-            return `npx turbo run ${scriptName} ${flags.join(' ')} --concurrency=2`;
+            const turboFlags = workspaceNames.map((name) => `--filter=${name}`);
+            return `npx turbo run ${scriptName} ${turboFlags.join(' ')} --concurrency=2`;
         }
-        const flags = workspaceNames.map((name) => `-w ${name}`);
-        return `npm run ${scriptName} ${flags.join(' ')}`;
+        const npmFlags = workspaceNames.map((name) => `-w ${name}`);
+        return `npm run ${scriptName} ${npmFlags.join(' ')}`;
     }
-    static renderArtifactPaths(targets, targetsMetadata) {
-        const seen = new Set();
-        const paths = [];
+    static renderUploadArtifactSteps(targets, targetsMetadata) {
+        const steps = [];
         for (const target of targets) {
-            const targetEntry = target;
-            const metadata = targetsMetadata[targetEntry['type']];
+            const metadata = targetsMetadata[target['type']];
             if (metadata === undefined) {
                 continue;
             }
-            const strippedDir = targetEntry['workingDir'].replace(LIB_REGEX_PATTERN_LEADING_DOT_SLASH, '');
-            for (const template of metadata['artifactPaths']) {
-                const resolved = template.replaceAll('{workingDir}', strippedDir);
-                if (seen.has(resolved) === false) {
-                    seen.add(resolved);
-                    paths.push(resolved);
-                }
+            if (metadata['artifactPaths'].length === 0) {
+                continue;
             }
+            const strippedDir = target['workingDir'].replace(LIB_REGEX_PATTERN_LEADING_DOT_SLASH, '');
+            const targetId = Runner.slugifyWorkingDir(target['workingDir']);
+            const artifactName = Runner.buildArtifactName(target['type'], targetId);
+            const pathLines = metadata['artifactPaths'].map((template) => `            ${template.replaceAll('{workingDir}', strippedDir)}`);
+            const stepLines = [
+                `      - name: "Upload build artifacts (${target['type']}/${targetId})"`,
+                '        uses: "actions/upload-artifact@v7"',
+                '        with:',
+                `          name: "${artifactName}"`,
+                '          retention-days: 1',
+                '          path: |',
+                ...pathLines,
+            ];
+            steps.push(stepLines.join('\n'));
         }
-        if (paths.length === 0) {
+        if (steps.length === 0) {
             return '';
         }
-        const lines = paths.map((path) => `            ${path}`);
-        return lines.join('\n');
+        return steps.join('\n\n');
     }
 }
 //# sourceMappingURL=workflows.js.map