diff --git a/docs/3-create-a-zarf-package/4-zarf-schema.md b/docs/3-create-a-zarf-package/4-zarf-schema.md
index 050539669f..0ca39289a3 100644
--- a/docs/3-create-a-zarf-package/4-zarf-schema.md
+++ b/docs/3-create-a-zarf-package/4-zarf-schema.md
@@ -1848,7 +1848,7 @@ Must be one of:
 | ------------------------- | -------------------------------------------------------------------------------------------------------- |
 | **Type**                  | `object`                                                                                                 |
 | **Additional properties** | [![Not allowed](https://img.shields.io/badge/Not%20allowed-red)](# "Additional Properties not allowed.") |
-| **Defined in**            | #/definitions/ZarfComponentActionShell                                                                   |
+| **Defined in**            | #/definitions/Shell                                                                                      |
 
 <details>
 <summary>
diff --git a/src/cmd/common/setup.go b/src/cmd/common/setup.go
index 8bde89e640..a3736a35ae 100644
--- a/src/cmd/common/setup.go
+++ b/src/cmd/common/setup.go
@@ -10,7 +10,6 @@ import (
 	"github.com/defenseunicorns/zarf/src/config"
 	"github.com/defenseunicorns/zarf/src/config/lang"
 	"github.com/defenseunicorns/zarf/src/pkg/message"
-	"github.com/defenseunicorns/zarf/src/pkg/utils/exec"
 )
 
 // LogLevelCLI holds the log level as input from a command
@@ -18,7 +17,7 @@ var LogLevelCLI string
 
 // SetupCLI sets up the CLI logging, interrupt functions, and more
 func SetupCLI() {
-	exec.ExitOnInterrupt()
+	ExitOnInterrupt()
 
 	match := map[string]message.LogLevel{
 		"warn":  message.WarnLevel,
diff --git a/src/cmd/common/utils.go b/src/cmd/common/utils.go
index 1da7e456ee..54113ee90f 100644
--- a/src/cmd/common/utils.go
+++ b/src/cmd/common/utils.go
@@ -4,6 +4,18 @@
 // Package common handles command configuration across all commands
 package common
 
+import (
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/defenseunicorns/zarf/src/config/lang"
+	"github.com/defenseunicorns/zarf/src/pkg/message"
+)
+
+// SuppressGlobalInterrupt suppresses the global error on an interrupt
+var SuppressGlobalInterrupt = false
+
 // SetBaseDirectory sets the base directory. This is a directory with a zarf.yaml.
 func SetBaseDirectory(args []string) string {
 	if len(args) > 0 {
@@ -11,3 +23,15 @@ func SetBaseDirectory(args []string) string {
 	}
 	return "."
 }
+
+// ExitOnInterrupt catches an interrupt and exits with fatal error
+func ExitOnInterrupt() {
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+	go func() {
+		<-c
+		if !SuppressGlobalInterrupt {
+			message.Fatal(lang.ErrInterrupt, lang.ErrInterrupt.Error())
+		}
+	}()
+}
diff --git a/src/cmd/connect.go b/src/cmd/connect.go
index fe3442e395..39b382cad3 100644
--- a/src/cmd/connect.go
+++ b/src/cmd/connect.go
@@ -10,6 +10,7 @@ import (
 	"os/signal"
 	"syscall"
 
+	"github.com/defenseunicorns/zarf/src/cmd/common"
 	"github.com/defenseunicorns/zarf/src/config/lang"
 	"github.com/defenseunicorns/zarf/src/pkg/cluster"
 	"github.com/defenseunicorns/zarf/src/pkg/k8s"
@@ -72,7 +73,7 @@ var (
 			// Keep this open until an interrupt signal is received.
 			interruptChan := make(chan os.Signal, 1)
 			signal.Notify(interruptChan, os.Interrupt, syscall.SIGTERM)
-			exec.SuppressGlobalInterrupt = true
+			common.SuppressGlobalInterrupt = true
 
 			// Wait for the interrupt signal or an error.
 			select {
diff --git a/src/cmd/destroy.go b/src/cmd/destroy.go
index 0a60d05503..b0825af632 100644
--- a/src/cmd/destroy.go
+++ b/src/cmd/destroy.go
@@ -14,8 +14,8 @@ import (
 	"github.com/defenseunicorns/zarf/src/internal/packager/helm"
 	"github.com/defenseunicorns/zarf/src/pkg/cluster"
 	"github.com/defenseunicorns/zarf/src/pkg/message"
-	"github.com/defenseunicorns/zarf/src/pkg/utils"
 	"github.com/defenseunicorns/zarf/src/pkg/utils/exec"
+	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 
 	"github.com/spf13/cobra"
 )
@@ -52,7 +52,7 @@ var destroyCmd = &cobra.Command{
 
 			// Run all the scripts!
 			pattern := regexp.MustCompile(`(?mi)zarf-clean-.+\.sh$`)
-			scripts, _ := utils.RecursiveFileList(config.ZarfCleanupScriptsPath, pattern, true)
+			scripts, _ := helpers.RecursiveFileList(config.ZarfCleanupScriptsPath, pattern, true)
 			// Iterate over all matching zarf-clean scripts and exec them
 			for _, script := range scripts {
 				// Run the matched script
diff --git a/src/cmd/initialize.go b/src/cmd/initialize.go
index 40f633ed41..db3f790466 100644
--- a/src/cmd/initialize.go
+++ b/src/cmd/initialize.go
@@ -77,7 +77,7 @@ var initCmd = &cobra.Command{
 
 func findInitPackage(initPackageName string) (string, error) {
 	// First, look for the init package in the current working directory
-	if !utils.InvalidPath(initPackageName) {
+	if !helpers.InvalidPath(initPackageName) {
 		return initPackageName, nil
 	}
 
@@ -87,19 +87,19 @@ func findInitPackage(initPackageName string) (string, error) {
 		return "", err
 	}
 	executableDir := path.Dir(binaryPath)
-	if !utils.InvalidPath(filepath.Join(executableDir, initPackageName)) {
+	if !helpers.InvalidPath(filepath.Join(executableDir, initPackageName)) {
 		return filepath.Join(executableDir, initPackageName), nil
 	}
 
 	// Create the cache directory if it doesn't exist
-	if utils.InvalidPath(config.GetAbsCachePath()) {
-		if err := utils.CreateDirectory(config.GetAbsCachePath(), helpers.ReadExecuteAllWriteUser); err != nil {
+	if helpers.InvalidPath(config.GetAbsCachePath()) {
+		if err := helpers.CreateDirectory(config.GetAbsCachePath(), helpers.ReadExecuteAllWriteUser); err != nil {
 			message.Fatalf(err, lang.CmdInitErrUnableCreateCache, config.GetAbsCachePath())
 		}
 	}
 
 	// Next, look in the cache directory
-	if !utils.InvalidPath(filepath.Join(config.GetAbsCachePath(), initPackageName)) {
+	if !helpers.InvalidPath(filepath.Join(config.GetAbsCachePath(), initPackageName)) {
 		return filepath.Join(config.GetAbsCachePath(), initPackageName), nil
 	}
 
diff --git a/src/cmd/package.go b/src/cmd/package.go
index f296684e7a..b113c94e67 100644
--- a/src/cmd/package.go
+++ b/src/cmd/package.go
@@ -14,7 +14,6 @@ import (
 	"github.com/defenseunicorns/zarf/src/config/lang"
 	"github.com/defenseunicorns/zarf/src/pkg/message"
 	"github.com/defenseunicorns/zarf/src/pkg/packager/sources"
-	"github.com/defenseunicorns/zarf/src/pkg/utils"
 	"github.com/defenseunicorns/zarf/src/types"
 
 	"oras.land/oras-go/v2/registry"
@@ -214,7 +213,7 @@ var packagePublishCmd = &cobra.Command{
 			message.Fatalf(nil, "%s", err.Error())
 		}
 
-		if utils.IsDir(pkgConfig.PkgOpts.PackageSource) {
+		if helpers.IsDir(pkgConfig.PkgOpts.PackageSource) {
 			pkgConfig.CreateOpts.BaseDir = pkgConfig.PkgOpts.PackageSource
 			pkgConfig.CreateOpts.IsSkeleton = true
 		}
diff --git a/src/cmd/tools/crane.go b/src/cmd/tools/crane.go
index b3ddd32e17..b6fd47e5a0 100644
--- a/src/cmd/tools/crane.go
+++ b/src/cmd/tools/crane.go
@@ -10,12 +10,12 @@ import (
 	"strings"
 
 	"github.com/AlecAivazis/survey/v2"
+	"github.com/defenseunicorns/zarf/src/cmd/common"
 	"github.com/defenseunicorns/zarf/src/config"
 	"github.com/defenseunicorns/zarf/src/config/lang"
 	"github.com/defenseunicorns/zarf/src/pkg/cluster"
 	"github.com/defenseunicorns/zarf/src/pkg/message"
 	"github.com/defenseunicorns/zarf/src/pkg/transform"
-	"github.com/defenseunicorns/zarf/src/pkg/utils/exec"
 	"github.com/defenseunicorns/zarf/src/types"
 	craneCmd "github.com/google/go-containerregistry/cmd/crane/cmd"
 	"github.com/google/go-containerregistry/pkg/crane"
@@ -39,7 +39,7 @@ func init() {
 		Short:   lang.CmdToolsRegistryShort,
 		PersistentPreRun: func(cmd *cobra.Command, _ []string) {
 
-			exec.ExitOnInterrupt()
+			common.ExitOnInterrupt()
 
 			// The crane options loading here comes from the rootCmd of crane
 			craneOptions = append(craneOptions, crane.WithContext(cmd.Context()))
diff --git a/src/extensions/bigbang/bigbang.go b/src/extensions/bigbang/bigbang.go
index 3f2025f787..50da7a9fe4 100644
--- a/src/extensions/bigbang/bigbang.go
+++ b/src/extensions/bigbang/bigbang.go
@@ -262,7 +262,7 @@ func Skeletonize(tmpPaths *layout.ComponentPaths, c types.ZarfComponent) (types.
 		rel := filepath.Join(layout.TempDir, skelName)
 		dst := filepath.Join(tmpPaths.Base, rel)
 
-		if err := utils.CreatePathAndCopy(valuesFile, dst); err != nil {
+		if err := helpers.CreatePathAndCopy(valuesFile, dst); err != nil {
 			return c, err
 		}
 
@@ -282,7 +282,7 @@ func Skeletonize(tmpPaths *layout.ComponentPaths, c types.ZarfComponent) (types.
 		rel := filepath.Join(layout.TempDir, skelName)
 		dst := filepath.Join(tmpPaths.Base, rel)
 
-		if err := utils.CreatePathAndCopy(fluxPatchFile, dst); err != nil {
+		if err := helpers.CreatePathAndCopy(fluxPatchFile, dst); err != nil {
 			return c, err
 		}
 
diff --git a/src/internal/packager/helm/repo.go b/src/internal/packager/helm/repo.go
index 4df052dbd8..459c6a3bd2 100644
--- a/src/internal/packager/helm/repo.go
+++ b/src/internal/packager/helm/repo.go
@@ -93,7 +93,7 @@ func (h *Helm) PackageChartFromLocalFiles(cosignKeyPath string) error {
 		saved, err = client.Run(h.chart.LocalPath, nil)
 	} else {
 		saved = filepath.Join(temp, filepath.Base(h.chart.LocalPath))
-		err = utils.CreatePathAndCopy(h.chart.LocalPath, saved)
+		err = helpers.CreatePathAndCopy(h.chart.LocalPath, saved)
 	}
 	defer os.RemoveAll(temp)
 
@@ -204,7 +204,7 @@ func (h *Helm) DownloadPublishedChart(cosignKeyPath string) error {
 
 	// Download the file into a temp directory since we don't control what name helm creates here
 	temp := filepath.Join(h.chartPath, "temp")
-	if err = utils.CreateDirectory(temp, helpers.ReadWriteExecuteUser); err != nil {
+	if err = helpers.CreateDirectory(temp, helpers.ReadWriteExecuteUser); err != nil {
 		return fmt.Errorf("unable to create helm chart temp directory: %w", err)
 	}
 	defer os.RemoveAll(temp)
@@ -269,7 +269,7 @@ func (h *Helm) packageValues(cosignKeyPath string) error {
 				return fmt.Errorf(lang.ErrDownloading, path, err.Error())
 			}
 		} else {
-			if err := utils.CreatePathAndCopy(path, dst); err != nil {
+			if err := helpers.CreatePathAndCopy(path, dst); err != nil {
 				return fmt.Errorf("unable to copy chart values file %s: %w", path, err)
 			}
 		}
diff --git a/src/internal/packager/images/pull.go b/src/internal/packager/images/pull.go
index f6cba2a980..8f38a27964 100644
--- a/src/internal/packager/images/pull.go
+++ b/src/internal/packager/images/pull.go
@@ -123,7 +123,7 @@ func (i *ImageConfig) PullAll() ([]ImgInfo, error) {
 	}
 
 	// Create the ImagePath directory
-	if err := utils.CreateDirectory(i.ImagesPath, helpers.ReadExecuteAllWriteUser); err != nil {
+	if err := helpers.CreateDirectory(i.ImagesPath, helpers.ReadExecuteAllWriteUser); err != nil {
 		return nil, fmt.Errorf("failed to create image path %s: %w", i.ImagesPath, err)
 	}
 
@@ -233,7 +233,7 @@ func (i *ImageConfig) PullAll() ([]ImgInfo, error) {
 
 			// Create the directory for the blob if it doesn't exist
 			dir := filepath.Join(string(cranePath), "blobs", digest.Algorithm)
-			if err := utils.CreateDirectory(dir, os.ModePerm); err != nil {
+			if err := helpers.CreateDirectory(dir, os.ModePerm); err != nil {
 				layerWritingConcurrency.ErrorChan <- err
 				return
 			}
diff --git a/src/internal/packager/sbom/catalog.go b/src/internal/packager/sbom/catalog.go
index 646f066a34..a2a6618622 100755
--- a/src/internal/packager/sbom/catalog.go
+++ b/src/internal/packager/sbom/catalog.go
@@ -60,7 +60,7 @@ func Catalog(componentSBOMs map[string]*layout.ComponentSBOM, imageList []transf
 	defer builder.spinner.Stop()
 
 	// Ensure the sbom directory exists
-	_ = utils.CreateDirectory(builder.outputDir, helpers.ReadWriteExecuteUser)
+	_ = helpers.CreateDirectory(builder.outputDir, helpers.ReadWriteExecuteUser)
 
 	// Generate a list of images and files for the sbom viewer
 	json, err := builder.generateJSONList(componentSBOMs, imageList)
@@ -152,7 +152,7 @@ func (b *Builder) createImageSBOM(img v1.Image, src string) ([]byte, error) {
 	imageCachePath := filepath.Join(b.cachePath, layout.ImagesDir)
 
 	// Ensure the image cache directory exists.
-	if err := utils.CreateDirectory(imageCachePath, helpers.ReadWriteExecuteUser); err != nil {
+	if err := helpers.CreateDirectory(imageCachePath, helpers.ReadWriteExecuteUser); err != nil {
 		return nil, err
 	}
 
diff --git a/src/internal/packager/template/template.go b/src/internal/packager/template/template.go
index 75882e6bdf..f7e669ef58 100644
--- a/src/internal/packager/template/template.go
+++ b/src/internal/packager/template/template.go
@@ -5,8 +5,11 @@
 package template
 
 import (
+	"bufio"
 	"encoding/base64"
 	"fmt"
+	"os"
+	"regexp"
 	"strings"
 
 	"github.com/defenseunicorns/zarf/src/types"
@@ -17,6 +20,14 @@ import (
 	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 )
 
+// TextTemplate represents a value to be templated into a text file.
+type TextTemplate struct {
+	Sensitive  bool
+	AutoIndent bool
+	Type       types.VariableType
+	Value      string
+}
+
 // Values contains the values to be used in the template.
 type Values struct {
 	config   *types.PackagerConfig
@@ -69,8 +80,8 @@ func (values *Values) SetState(state *types.ZarfState) {
 }
 
 // GetVariables returns the variables to be used in the template.
-func (values *Values) GetVariables(component types.ZarfComponent) (templateMap map[string]*utils.TextTemplate, deprecations map[string]string) {
-	templateMap = make(map[string]*utils.TextTemplate)
+func (values *Values) GetVariables(component types.ZarfComponent) (templateMap map[string]*TextTemplate, deprecations map[string]string) {
+	templateMap = make(map[string]*TextTemplate)
 
 	depMarkerOld := "DATA_INJECTON_MARKER"
 	depMarkerNew := "DATA_INJECTION_MARKER"
@@ -125,7 +136,7 @@ func (values *Values) GetVariables(component types.ZarfComponent) (templateMap m
 		// Iterate over any custom variables and add them to the mappings for templating
 		for key, value := range builtinMap {
 			// Builtin keys are always uppercase in the format ###ZARF_KEY###
-			templateMap[strings.ToUpper(fmt.Sprintf("###ZARF_%s###", key))] = &utils.TextTemplate{
+			templateMap[strings.ToUpper(fmt.Sprintf("###ZARF_%s###", key))] = &TextTemplate{
 				Value: value,
 			}
 
@@ -140,7 +151,7 @@ func (values *Values) GetVariables(component types.ZarfComponent) (templateMap m
 
 	for key, variable := range values.config.SetVariableMap {
 		// Variable keys are always uppercase in the format ###ZARF_VAR_KEY###
-		templateMap[strings.ToUpper(fmt.Sprintf("###ZARF_VAR_%s###", key))] = &utils.TextTemplate{
+		templateMap[strings.ToUpper(fmt.Sprintf("###ZARF_VAR_%s###", key))] = &TextTemplate{
 			Value:      variable.Value,
 			Sensitive:  variable.Sensitive,
 			AutoIndent: variable.AutoIndent,
@@ -150,7 +161,7 @@ func (values *Values) GetVariables(component types.ZarfComponent) (templateMap m
 
 	for _, constant := range values.config.Pkg.Constants {
 		// Constant keys are always uppercase in the format ###ZARF_CONST_KEY###
-		templateMap[strings.ToUpper(fmt.Sprintf("###ZARF_CONST_%s###", constant.Name))] = &utils.TextTemplate{
+		templateMap[strings.ToUpper(fmt.Sprintf("###ZARF_CONST_%s###", constant.Name))] = &TextTemplate{
 			Value:      constant.Value,
 			AutoIndent: constant.AutoIndent,
 		}
@@ -170,12 +181,99 @@ func (values *Values) Apply(component types.ZarfComponent, path string, ignoreRe
 	}
 
 	templateMap, deprecations := values.GetVariables(component)
-	err := utils.ReplaceTextTemplate(path, templateMap, deprecations, "###ZARF_[A-Z0-9_]+###")
+	err := ReplaceTextTemplate(path, templateMap, deprecations, "###ZARF_[A-Z0-9_]+###")
 
 	return err
 }
 
-func debugPrintTemplateMap(templateMap map[string]*utils.TextTemplate) {
+// ReplaceTextTemplate loads a file from a given path, replaces text in it and writes it back in place.
+func ReplaceTextTemplate(path string, mappings map[string]*TextTemplate, deprecations map[string]string, templateRegex string) error {
+	textFile, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+
+	// This regex takes a line and parses the text before and after a discovered template: https://regex101.com/r/ilUxAz/1
+	regexTemplateLine := regexp.MustCompile(fmt.Sprintf("(?P<preTemplate>.*?)(?P<template>%s)(?P<postTemplate>.*)", templateRegex))
+
+	fileScanner := bufio.NewScanner(textFile)
+
+	// Set the buffer to 1 MiB to handle long lines (i.e. base64 text in a secret)
+	// 1 MiB is around the documented maximum size for secrets and configmaps
+	const maxCapacity = 1024 * 1024
+	buf := make([]byte, maxCapacity)
+	fileScanner.Buffer(buf, maxCapacity)
+
+	// Set the scanner to split on new lines
+	fileScanner.Split(bufio.ScanLines)
+
+	text := ""
+
+	for fileScanner.Scan() {
+		line := fileScanner.Text()
+
+		for {
+			matches := regexTemplateLine.FindStringSubmatch(line)
+
+			// No template left on this line so move on
+			if len(matches) == 0 {
+				text += fmt.Sprintln(line)
+				break
+			}
+
+			preTemplate := matches[regexTemplateLine.SubexpIndex("preTemplate")]
+			templateKey := matches[regexTemplateLine.SubexpIndex("template")]
+
+			_, present := deprecations[templateKey]
+			if present {
+				message.Warnf("This Zarf Package uses a deprecated variable: '%s' changed to '%s'.  Please notify your package creator for an update.", templateKey, deprecations[templateKey])
+			}
+
+			template := mappings[templateKey]
+
+			// Check if the template is nil (present), use the original templateKey if not (so that it is not replaced).
+			value := templateKey
+			if template != nil {
+				value = template.Value
+
+				// Check if the value is a file type and load the value contents from the file
+				if template.Type == types.FileVariableType && value != "" {
+					if isText, err := helpers.IsTextFile(value); err != nil || !isText {
+						message.Warnf("Refusing to load a non-text file for templating %s", templateKey)
+						line = matches[regexTemplateLine.SubexpIndex("postTemplate")]
+						continue
+					}
+
+					contents, err := os.ReadFile(value)
+					if err != nil {
+						message.Warnf("Unable to read file for templating - skipping: %s", err.Error())
+						line = matches[regexTemplateLine.SubexpIndex("postTemplate")]
+						continue
+					}
+
+					value = string(contents)
+				}
+
+				// Check if the value is autoIndented and add the correct spacing
+				if template.AutoIndent {
+					indent := fmt.Sprintf("\n%s", strings.Repeat(" ", len(preTemplate)))
+					value = strings.ReplaceAll(value, "\n", indent)
+				}
+			}
+
+			// Add the processed text and continue processing the line
+			text += fmt.Sprintf("%s%s", preTemplate, value)
+			line = matches[regexTemplateLine.SubexpIndex("postTemplate")]
+		}
+	}
+
+	textFile.Close()
+
+	return os.WriteFile(path, []byte(text), helpers.ReadWriteUser)
+
+}
+
+func debugPrintTemplateMap(templateMap map[string]*TextTemplate) {
 	debugText := "templateMap = { "
 
 	for key, template := range templateMap {
diff --git a/src/internal/packager/template/yaml.go b/src/internal/packager/template/yaml.go
index 46321d7f4d..07fe500b38 100644
--- a/src/internal/packager/template/yaml.go
+++ b/src/internal/packager/template/yaml.go
@@ -7,7 +7,7 @@ package template
 import (
 	"regexp"
 
-	"github.com/defenseunicorns/zarf/src/pkg/utils"
+	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 	"github.com/defenseunicorns/zarf/src/types"
 )
 
@@ -15,7 +15,7 @@ import (
 func ProcessYamlFilesInPath(path string, component types.ZarfComponent, values Values) ([]string, error) {
 	// Only pull in yml and yaml files
 	pattern := regexp.MustCompile(`(?mi)\.ya?ml$`)
-	manifests, _ := utils.RecursiveFileList(path, pattern, false)
+	manifests, _ := helpers.RecursiveFileList(path, pattern, false)
 
 	for _, manifest := range manifests {
 		if err := values.Apply(component, manifest, false); err != nil {
diff --git a/src/pkg/cluster/data.go b/src/pkg/cluster/data.go
index e1239cdcfd..ec78cd2768 100644
--- a/src/pkg/cluster/data.go
+++ b/src/pkg/cluster/data.go
@@ -46,7 +46,7 @@ func (c *Cluster) HandleDataInjection(wg *sync.WaitGroup, data types.ZarfDataInj
 	}
 
 	// Get the OS shell to execute commands in
-	shell, shellArgs := exec.GetOSShell(types.ZarfComponentActionShell{Windows: "cmd"})
+	shell, shellArgs := exec.GetOSShell(exec.Shell{Windows: "cmd"})
 
 	if _, _, err := exec.Cmd(shell, append(shellArgs, "tar --version")...); err != nil {
 		message.WarnErr(err, "Unable to execute tar on this system.  Please ensure it is installed and on your $PATH.")
@@ -58,10 +58,10 @@ iterator:
 	for {
 		message.Debugf("Attempting to inject data into %s", data.Target)
 		source := filepath.Join(componentPath.DataInjections, filepath.Base(data.Target.Path))
-		if utils.InvalidPath(source) {
+		if helpers.InvalidPath(source) {
 			// The path is likely invalid because of how we compose OCI components, add an index suffix to the filename
 			source = filepath.Join(componentPath.DataInjections, strconv.Itoa(dataIdx), filepath.Base(data.Target.Path))
-			if utils.InvalidPath(source) {
+			if helpers.InvalidPath(source) {
 				message.Warnf("Unable to find the data injection source path %s", source)
 				return
 			}
diff --git a/src/pkg/cluster/injector.go b/src/pkg/cluster/injector.go
index b4c465ede3..b35f2f7f02 100644
--- a/src/pkg/cluster/injector.go
+++ b/src/pkg/cluster/injector.go
@@ -52,7 +52,7 @@ func (c *Cluster) StartInjectionMadness(tmpDir string, imagesDir string, injecto
 		InjectorPayloadTarGz: filepath.Join(tmpDir, "payload.tar.gz"),
 	}
 
-	if err := utils.CreateDirectory(tmp.SeedImagesDir, helpers.ReadWriteExecuteUser); err != nil {
+	if err := helpers.CreateDirectory(tmp.SeedImagesDir, helpers.ReadWriteExecuteUser); err != nil {
 		spinner.Fatalf(err, "Unable to create the seed images directory")
 	}
 
@@ -203,7 +203,7 @@ func (c *Cluster) createPayloadConfigmaps(seedImagesDir, tarPath string, spinner
 		return configMaps, "", err
 	}
 
-	chunks, sha256sum, err := utils.ReadFileByChunks(tarPath, payloadChunkSize)
+	chunks, sha256sum, err := helpers.ReadFileByChunks(tarPath, payloadChunkSize)
 	if err != nil {
 		return configMaps, "", err
 	}
diff --git a/src/pkg/layout/component.go b/src/pkg/layout/component.go
index 6a97a9dd47..383c8c48c3 100644
--- a/src/pkg/layout/component.go
+++ b/src/pkg/layout/component.go
@@ -11,7 +11,6 @@ import (
 	"path/filepath"
 
 	"github.com/defenseunicorns/zarf/src/pkg/message"
-	"github.com/defenseunicorns/zarf/src/pkg/utils"
 	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 	"github.com/defenseunicorns/zarf/src/types"
 	"github.com/mholt/archiver/v3"
@@ -59,14 +58,14 @@ func (c *Components) Archive(component types.ZarfComponent, cleanupTemp bool) (e
 	if cleanupTemp {
 		_ = os.RemoveAll(c.Dirs[name].Temp)
 	}
-	size, err := utils.GetDirSize(base)
+	size, err := helpers.GetDirSize(base)
 	if err != nil {
 		return err
 	}
 	if size > 0 {
 		tb := fmt.Sprintf("%s.tar", base)
 		message.Debugf("Archiving %q", name)
-		if err := utils.CreateReproducibleTarballFromDir(base, name, tb); err != nil {
+		if err := helpers.CreateReproducibleTarballFromDir(base, name, tb); err != nil {
 			return err
 		}
 		if c.Tarballs == nil {
@@ -93,7 +92,7 @@ func (c *Components) Unarchive(component types.ZarfComponent) (err error) {
 		}
 	}
 
-	if utils.InvalidPath(tb) {
+	if helpers.InvalidPath(tb) {
 		return &fs.PathError{
 			Op:   "stat",
 			Path: tb,
@@ -132,7 +131,7 @@ func (c *Components) Unarchive(component types.ZarfComponent) (err error) {
 	delete(c.Tarballs, name)
 
 	// if the component is already unarchived, skip
-	if !utils.InvalidPath(cs.Base) {
+	if !helpers.InvalidPath(cs.Base) {
 		message.Debugf("Component %q already unarchived", name)
 		return nil
 	}
@@ -157,13 +156,13 @@ func (c *Components) Create(component types.ZarfComponent) (cp *ComponentPaths,
 		}
 	}
 
-	if err = utils.CreateDirectory(c.Base, helpers.ReadWriteExecuteUser); err != nil {
+	if err = helpers.CreateDirectory(c.Base, helpers.ReadWriteExecuteUser); err != nil {
 		return nil, err
 	}
 
 	base := filepath.Join(c.Base, name)
 
-	if err = utils.CreateDirectory(base, helpers.ReadWriteExecuteUser); err != nil {
+	if err = helpers.CreateDirectory(base, helpers.ReadWriteExecuteUser); err != nil {
 		return nil, err
 	}
 
@@ -172,26 +171,26 @@ func (c *Components) Create(component types.ZarfComponent) (cp *ComponentPaths,
 	}
 
 	cp.Temp = filepath.Join(base, TempDir)
-	if err = utils.CreateDirectory(cp.Temp, helpers.ReadWriteExecuteUser); err != nil {
+	if err = helpers.CreateDirectory(cp.Temp, helpers.ReadWriteExecuteUser); err != nil {
 		return nil, err
 	}
 
 	if len(component.Files) > 0 {
 		cp.Files = filepath.Join(base, FilesDir)
-		if err = utils.CreateDirectory(cp.Files, helpers.ReadWriteExecuteUser); err != nil {
+		if err = helpers.CreateDirectory(cp.Files, helpers.ReadWriteExecuteUser); err != nil {
 			return nil, err
 		}
 	}
 
 	if len(component.Charts) > 0 {
 		cp.Charts = filepath.Join(base, ChartsDir)
-		if err = utils.CreateDirectory(cp.Charts, helpers.ReadWriteExecuteUser); err != nil {
+		if err = helpers.CreateDirectory(cp.Charts, helpers.ReadWriteExecuteUser); err != nil {
 			return nil, err
 		}
 		for _, chart := range component.Charts {
 			cp.Values = filepath.Join(base, ValuesDir)
 			if len(chart.ValuesFiles) > 0 {
-				if err = utils.CreateDirectory(cp.Values, helpers.ReadWriteExecuteUser); err != nil {
+				if err = helpers.CreateDirectory(cp.Values, helpers.ReadWriteExecuteUser); err != nil {
 					return nil, err
 				}
 				break
@@ -201,21 +200,21 @@ func (c *Components) Create(component types.ZarfComponent) (cp *ComponentPaths,
 
 	if len(component.Repos) > 0 {
 		cp.Repos = filepath.Join(base, ReposDir)
-		if err = utils.CreateDirectory(cp.Repos, helpers.ReadWriteExecuteUser); err != nil {
+		if err = helpers.CreateDirectory(cp.Repos, helpers.ReadWriteExecuteUser); err != nil {
 			return nil, err
 		}
 	}
 
 	if len(component.Manifests) > 0 {
 		cp.Manifests = filepath.Join(base, ManifestsDir)
-		if err = utils.CreateDirectory(cp.Manifests, helpers.ReadWriteExecuteUser); err != nil {
+		if err = helpers.CreateDirectory(cp.Manifests, helpers.ReadWriteExecuteUser); err != nil {
 			return nil, err
 		}
 	}
 
 	if len(component.DataInjections) > 0 {
 		cp.DataInjections = filepath.Join(base, DataInjectionsDir)
-		if err = utils.CreateDirectory(cp.DataInjections, helpers.ReadWriteExecuteUser); err != nil {
+		if err = helpers.CreateDirectory(cp.DataInjections, helpers.ReadWriteExecuteUser); err != nil {
 			return nil, err
 		}
 	}
diff --git a/src/pkg/layout/package.go b/src/pkg/layout/package.go
index 2683ebf603..eeb5637f5b 100644
--- a/src/pkg/layout/package.go
+++ b/src/pkg/layout/package.go
@@ -86,7 +86,7 @@ func (pp *PackagePaths) MigrateLegacy() (err error) {
 	base := pp.Base
 
 	// legacy layout does not contain a checksums file, nor a signature
-	if utils.InvalidPath(pp.Checksums) && pp.Signature == "" {
+	if helpers.InvalidPath(pp.Checksums) && pp.Signature == "" {
 		if err := utils.ReadYaml(pp.ZarfYAML, &pkg); err != nil {
 			return err
 		}
@@ -104,7 +104,7 @@ func (pp *PackagePaths) MigrateLegacy() (err error) {
 
 	// Migrate legacy sboms
 	legacySBOMs := filepath.Join(base, "sboms")
-	if !utils.InvalidPath(legacySBOMs) {
+	if !helpers.InvalidPath(legacySBOMs) {
 		pp = pp.AddSBOMs()
 		message.Debugf("Migrating %q to %q", legacySBOMs, pp.SBOMs.Path)
 		if err := os.Rename(legacySBOMs, pp.SBOMs.Path); err != nil {
@@ -114,7 +114,7 @@ func (pp *PackagePaths) MigrateLegacy() (err error) {
 
 	// Migrate legacy images
 	legacyImagesTar := filepath.Join(base, "images.tar")
-	if !utils.InvalidPath(legacyImagesTar) {
+	if !helpers.InvalidPath(legacyImagesTar) {
 		pp = pp.AddImages()
 		message.Debugf("Migrating %q to %q", legacyImagesTar, pp.Images.Base)
 		defer os.Remove(legacyImagesTar)
@@ -199,7 +199,7 @@ func (pp *PackagePaths) GenerateChecksums() (string, error) {
 			continue
 		}
 
-		sum, err := utils.GetSHA256OfFile(abs)
+		sum, err := helpers.GetSHA256OfFile(abs)
 		if err != nil {
 			return "", err
 		}
@@ -213,7 +213,7 @@ func (pp *PackagePaths) GenerateChecksums() (string, error) {
 	}
 
 	// Calculate the checksum of the checksum file
-	return utils.GetSHA256OfFile(pp.Checksums)
+	return helpers.GetSHA256OfFile(pp.Checksums)
 }
 
 // ArchivePackage creates an archive for a Zarf package.
diff --git a/src/pkg/layout/sbom.go b/src/pkg/layout/sbom.go
index fe7dcefd02..280da017b8 100644
--- a/src/pkg/layout/sbom.go
+++ b/src/pkg/layout/sbom.go
@@ -10,7 +10,7 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/defenseunicorns/zarf/src/pkg/utils"
+	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 	"github.com/mholt/archiver/v3"
 )
 
@@ -27,14 +27,14 @@ type SBOMs struct {
 
 // Unarchive unarchives the package's SBOMs.
 func (s *SBOMs) Unarchive() (err error) {
-	if s.Path == "" || utils.InvalidPath(s.Path) {
+	if s.Path == "" || helpers.InvalidPath(s.Path) {
 		return &fs.PathError{
 			Op:   "stat",
 			Path: s.Path,
 			Err:  fs.ErrNotExist,
 		}
 	}
-	if utils.IsDir(s.Path) {
+	if helpers.IsDir(s.Path) {
 		return nil
 	}
 	tb := s.Path
@@ -48,20 +48,20 @@ func (s *SBOMs) Unarchive() (err error) {
 
 // Archive archives the package's SBOMs.
 func (s *SBOMs) Archive() (err error) {
-	if s.Path == "" || utils.InvalidPath(s.Path) {
+	if s.Path == "" || helpers.InvalidPath(s.Path) {
 		return &fs.PathError{
 			Op:   "stat",
 			Path: s.Path,
 			Err:  fs.ErrNotExist,
 		}
 	}
-	if !utils.IsDir(s.Path) {
+	if !helpers.IsDir(s.Path) {
 		return nil
 	}
 	dir := s.Path
 	tb := filepath.Join(filepath.Dir(dir), SBOMTar)
 
-	if err := utils.CreateReproducibleTarballFromDir(dir, "", tb); err != nil {
+	if err := helpers.CreateReproducibleTarballFromDir(dir, "", tb); err != nil {
 		return err
 	}
 	s.Path = tb
@@ -75,7 +75,7 @@ func (s *SBOMs) StageSBOMViewFiles() (warnings []string, err error) {
 	}
 
 	// If SBOMs were loaded, temporarily place them in the deploy directory
-	if !utils.InvalidPath(s.Path) {
+	if !helpers.InvalidPath(s.Path) {
 		if _, err := filepath.Glob(filepath.Join(s.Path, "sbom-viewer-*")); err != nil {
 			return nil, err
 		}
@@ -98,14 +98,14 @@ func (s *SBOMs) OutputSBOMFiles(outputDir, packageName string) (string, error) {
 		return "", err
 	}
 
-	if err := utils.CreateDirectory(packagePath, 0700); err != nil {
+	if err := helpers.CreateDirectory(packagePath, 0700); err != nil {
 		return "", err
 	}
 
-	return packagePath, utils.CreatePathAndCopy(s.Path, packagePath)
+	return packagePath, helpers.CreatePathAndCopy(s.Path, packagePath)
 }
 
 // IsTarball returns true if the SBOMs are a tarball.
 func (s SBOMs) IsTarball() bool {
-	return !utils.IsDir(s.Path) && filepath.Ext(s.Path) == ".tar"
+	return !helpers.IsDir(s.Path) && filepath.Ext(s.Path) == ".tar"
 }
diff --git a/src/pkg/packager/actions/actions.go b/src/pkg/packager/actions/actions.go
index c6df1abc8d..2b3019b4cf 100644
--- a/src/pkg/packager/actions/actions.go
+++ b/src/pkg/packager/actions/actions.go
@@ -38,7 +38,7 @@ func runAction(cfg *types.PackagerConfig, defaultCfg types.ZarfComponentActionDe
 		cmdEscaped string
 		out        string
 		err        error
-		vars       map[string]*utils.TextTemplate
+		vars       map[string]*template.TextTemplate
 
 		cmd = action.Cmd
 	)
@@ -210,7 +210,7 @@ func convertWaitToCmd(wait types.ZarfComponentActionWait, timeout *int) (string,
 }
 
 // Perform some basic string mutations to make commands more useful.
-func actionCmdMutation(cmd string, shellPref types.ZarfComponentActionShell) (string, error) {
+func actionCmdMutation(cmd string, shellPref exec.Shell) (string, error) {
 	zarfCommand, err := utils.GetFinalExecutableCommand()
 	if err != nil {
 		return cmd, err
@@ -241,7 +241,7 @@ func actionCmdMutation(cmd string, shellPref types.ZarfComponentActionShell) (st
 }
 
 // Merge the ActionSet defaults with the action config.
-func actionGetCfg(cfg types.ZarfComponentActionDefaults, a types.ZarfComponentAction, vars map[string]*utils.TextTemplate) types.ZarfComponentActionDefaults {
+func actionGetCfg(cfg types.ZarfComponentActionDefaults, a types.ZarfComponentAction, vars map[string]*template.TextTemplate) types.ZarfComponentActionDefaults {
 	if a.Mute != nil {
 		cfg.Mute = *a.Mute
 	}
@@ -280,7 +280,7 @@ func actionGetCfg(cfg types.ZarfComponentActionDefaults, a types.ZarfComponentAc
 	return cfg
 }
 
-func actionRun(ctx context.Context, cfg types.ZarfComponentActionDefaults, cmd string, shellPref types.ZarfComponentActionShell, spinner *message.Spinner) (string, error) {
+func actionRun(ctx context.Context, cfg types.ZarfComponentActionDefaults, cmd string, shellPref exec.Shell, spinner *message.Spinner) (string, error) {
 	shell, shellArgs := exec.GetOSShell(shellPref)
 
 	message.Debugf("Running command in %s: %s", shell, cmd)
diff --git a/src/pkg/packager/composer/oci.go b/src/pkg/packager/composer/oci.go
index 9d0485ce52..d8e136a9f5 100644
--- a/src/pkg/packager/composer/oci.go
+++ b/src/pkg/packager/composer/oci.go
@@ -66,7 +66,7 @@ func (ic *ImportChain) fetchOCISkeleton() error {
 	componentDesc := manifest.Locate(filepath.Join(layout.ComponentsDir, fmt.Sprintf("%s.tar", name)))
 
 	cache := filepath.Join(config.GetAbsCachePath(), "oci")
-	if err := utils.CreateDirectory(cache, helpers.ReadWriteExecuteUser); err != nil {
+	if err := helpers.CreateDirectory(cache, helpers.ReadWriteExecuteUser); err != nil {
 		return err
 	}
 
@@ -110,7 +110,7 @@ func (ic *ImportChain) fetchOCISkeleton() error {
 		}
 	}
 
-	if err := utils.CreateDirectory(dir, helpers.ReadWriteExecuteUser); err != nil {
+	if err := helpers.CreateDirectory(dir, helpers.ReadWriteExecuteUser); err != nil {
 		return err
 	}
 
diff --git a/src/pkg/packager/composer/pathfixer.go b/src/pkg/packager/composer/pathfixer.go
index b52c2c3257..c3f7954fb8 100644
--- a/src/pkg/packager/composer/pathfixer.go
+++ b/src/pkg/packager/composer/pathfixer.go
@@ -7,7 +7,6 @@ package composer
 import (
 	"path/filepath"
 
-	"github.com/defenseunicorns/zarf/src/pkg/utils"
 	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 	"github.com/defenseunicorns/zarf/src/types"
 )
@@ -46,7 +45,7 @@ func fixPaths(child *types.ZarfComponent, relativeToHead string) {
 			composed := makePathRelativeTo(kustomization, relativeToHead)
 			// kustomizations can use non-standard urls, so we need to check if the composed path exists on the local filesystem
 			abs, _ := filepath.Abs(composed)
-			invalid := utils.InvalidPath(abs)
+			invalid := helpers.InvalidPath(abs)
 			if !invalid {
 				child.Manifests[manifestIdx].Kustomizations[kustomizeIdx] = composed
 			}
diff --git a/src/pkg/packager/creator/normal.go b/src/pkg/packager/creator/normal.go
index 36a86940ae..f7fd527a68 100644
--- a/src/pkg/packager/creator/normal.go
+++ b/src/pkg/packager/creator/normal.go
@@ -403,7 +403,7 @@ func (pc *PackageCreator) addComponent(component types.ZarfComponent, dst *layou
 					return fmt.Errorf(lang.ErrFileExtract, file.ExtractPath, file.Source, err.Error())
 				}
 			} else {
-				if err := utils.CreatePathAndCopy(file.Source, dst); err != nil {
+				if err := helpers.CreatePathAndCopy(file.Source, dst); err != nil {
 					return fmt.Errorf("unable to copy file %s: %w", file.Source, err)
 				}
 			}
@@ -421,12 +421,12 @@ func (pc *PackageCreator) addComponent(component types.ZarfComponent, dst *layou
 
 		// Abort packaging on invalid shasum (if one is specified).
 		if file.Shasum != "" {
-			if err := utils.SHAsMatch(dst, file.Shasum); err != nil {
+			if err := helpers.SHAsMatch(dst, file.Shasum); err != nil {
 				return err
 			}
 		}
 
-		if file.Executable || utils.IsDir(dst) {
+		if file.Executable || helpers.IsDir(dst) {
 			_ = os.Chmod(dst, helpers.ReadWriteExecuteUser)
 		} else {
 			_ = os.Chmod(dst, helpers.ReadWriteUser)
@@ -448,7 +448,7 @@ func (pc *PackageCreator) addComponent(component types.ZarfComponent, dst *layou
 					return fmt.Errorf(lang.ErrDownloading, data.Source, err.Error())
 				}
 			} else {
-				if err := utils.CreatePathAndCopy(data.Source, dst); err != nil {
+				if err := helpers.CreatePathAndCopy(data.Source, dst); err != nil {
 					return fmt.Errorf("unable to copy data injection %s: %s", data.Source, err.Error())
 				}
 			}
@@ -481,7 +481,7 @@ func (pc *PackageCreator) addComponent(component types.ZarfComponent, dst *layou
 						return fmt.Errorf(lang.ErrDownloading, path, err.Error())
 					}
 				} else {
-					if err := utils.CreatePathAndCopy(path, dst); err != nil {
+					if err := helpers.CreatePathAndCopy(path, dst); err != nil {
 						return fmt.Errorf("unable to copy manifest %s: %w", path, err)
 					}
 				}
@@ -537,8 +537,8 @@ func (pc *PackageCreator) getFilesToSBOM(component types.ZarfComponent, dst *lay
 	}
 
 	appendSBOMFiles := func(path string) {
-		if utils.IsDir(path) {
-			files, _ := utils.RecursiveFileList(path, nil, false)
+		if helpers.IsDir(path) {
+			files, _ := helpers.RecursiveFileList(path, nil, false)
 			componentSBOM.Files = append(componentSBOM.Files, files...)
 		} else {
 			componentSBOM.Files = append(componentSBOM.Files, path)
diff --git a/src/pkg/packager/creator/skeleton.go b/src/pkg/packager/creator/skeleton.go
index d23081f1a7..6e186af0c5 100644
--- a/src/pkg/packager/creator/skeleton.go
+++ b/src/pkg/packager/creator/skeleton.go
@@ -157,7 +157,7 @@ func (sc *SkeletonCreator) addComponent(component types.ZarfComponent, dst *layo
 
 	if component.DeprecatedCosignKeyPath != "" {
 		dst := filepath.Join(componentPaths.Base, "cosign.pub")
-		err := utils.CreatePathAndCopy(component.DeprecatedCosignKeyPath, dst)
+		err := helpers.CreatePathAndCopy(component.DeprecatedCosignKeyPath, dst)
 		if err != nil {
 			return nil, err
 		}
@@ -186,7 +186,7 @@ func (sc *SkeletonCreator) addComponent(component types.ZarfComponent, dst *layo
 			rel := filepath.Join(layout.ChartsDir, fmt.Sprintf("%s-%d", chart.Name, chartIdx))
 			dst := filepath.Join(componentPaths.Base, rel)
 
-			err := utils.CreatePathAndCopy(chart.LocalPath, dst)
+			err := helpers.CreatePathAndCopy(chart.LocalPath, dst)
 			if err != nil {
 				return nil, err
 			}
@@ -202,7 +202,7 @@ func (sc *SkeletonCreator) addComponent(component types.ZarfComponent, dst *layo
 			rel := fmt.Sprintf("%s-%d", helm.StandardName(layout.ValuesDir, chart), valuesIdx)
 			updatedComponent.Charts[chartIdx].ValuesFiles[valuesIdx] = rel
 
-			if err := utils.CreatePathAndCopy(path, filepath.Join(componentPaths.Base, rel)); err != nil {
+			if err := helpers.CreatePathAndCopy(path, filepath.Join(componentPaths.Base, rel)); err != nil {
 				return nil, fmt.Errorf("unable to copy chart values file %s: %w", path, err)
 			}
 		}
@@ -232,7 +232,7 @@ func (sc *SkeletonCreator) addComponent(component types.ZarfComponent, dst *layo
 				}
 			}
 		} else {
-			if err := utils.CreatePathAndCopy(file.Source, dst); err != nil {
+			if err := helpers.CreatePathAndCopy(file.Source, dst); err != nil {
 				return nil, fmt.Errorf("unable to copy file %s: %w", file.Source, err)
 			}
 		}
@@ -245,12 +245,12 @@ func (sc *SkeletonCreator) addComponent(component types.ZarfComponent, dst *layo
 
 		// Abort packaging on invalid shasum (if one is specified).
 		if file.Shasum != "" {
-			if err := utils.SHAsMatch(dst, file.Shasum); err != nil {
+			if err := helpers.SHAsMatch(dst, file.Shasum); err != nil {
 				return nil, err
 			}
 		}
 
-		if file.Executable || utils.IsDir(dst) {
+		if file.Executable || helpers.IsDir(dst) {
 			_ = os.Chmod(dst, helpers.ReadWriteExecuteUser)
 		} else {
 			_ = os.Chmod(dst, helpers.ReadWriteUser)
@@ -267,7 +267,7 @@ func (sc *SkeletonCreator) addComponent(component types.ZarfComponent, dst *layo
 			rel := filepath.Join(layout.DataInjectionsDir, strconv.Itoa(dataIdx), filepath.Base(data.Target.Path))
 			dst := filepath.Join(componentPaths.Base, rel)
 
-			if err := utils.CreatePathAndCopy(data.Source, dst); err != nil {
+			if err := helpers.CreatePathAndCopy(data.Source, dst); err != nil {
 				return nil, fmt.Errorf("unable to copy data injection %s: %s", data.Source, err.Error())
 			}
 
@@ -298,7 +298,7 @@ func (sc *SkeletonCreator) addComponent(component types.ZarfComponent, dst *layo
 				// Copy manifests without any processing.
 				spinner.Updatef("Copying manifest %s", path)
 
-				if err := utils.CreatePathAndCopy(path, dst); err != nil {
+				if err := helpers.CreatePathAndCopy(path, dst); err != nil {
 					return nil, fmt.Errorf("unable to copy manifest %s: %w", path, err)
 				}
 
diff --git a/src/pkg/packager/deploy.go b/src/pkg/packager/deploy.go
index 7a1cece304..0d0d92e2b6 100644
--- a/src/pkg/packager/deploy.go
+++ b/src/pkg/packager/deploy.go
@@ -26,7 +26,6 @@ import (
 	"github.com/defenseunicorns/zarf/src/pkg/packager/actions"
 	"github.com/defenseunicorns/zarf/src/pkg/packager/variables"
 	"github.com/defenseunicorns/zarf/src/pkg/transform"
-	"github.com/defenseunicorns/zarf/src/pkg/utils"
 	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 	"github.com/defenseunicorns/zarf/src/types"
 	corev1 "k8s.io/api/core/v1"
@@ -337,14 +336,14 @@ func (p *Packager) processComponentFiles(component types.ZarfComponent, pkgLocat
 		spinner.Updatef("Loading %s", file.Target)
 
 		fileLocation := filepath.Join(pkgLocation, strconv.Itoa(fileIdx), filepath.Base(file.Target))
-		if utils.InvalidPath(fileLocation) {
+		if helpers.InvalidPath(fileLocation) {
 			fileLocation = filepath.Join(pkgLocation, strconv.Itoa(fileIdx))
 		}
 
 		// If a shasum is specified check it again on deployment as well
 		if file.Shasum != "" {
 			spinner.Updatef("Validating SHASUM for %s", file.Target)
-			if err := utils.SHAsMatch(fileLocation, file.Shasum); err != nil {
+			if err := helpers.SHAsMatch(fileLocation, file.Shasum); err != nil {
 				return err
 			}
 		}
@@ -354,8 +353,8 @@ func (p *Packager) processComponentFiles(component types.ZarfComponent, pkgLocat
 		file.Target = config.GetAbsHomePath(file.Target)
 
 		fileList := []string{}
-		if utils.IsDir(fileLocation) {
-			files, _ := utils.RecursiveFileList(fileLocation, nil, false)
+		if helpers.IsDir(fileLocation) {
+			files, _ := helpers.RecursiveFileList(fileLocation, nil, false)
 			fileList = append(fileList, files...)
 		} else {
 			fileList = append(fileList, fileLocation)
@@ -363,7 +362,7 @@ func (p *Packager) processComponentFiles(component types.ZarfComponent, pkgLocat
 
 		for _, subFile := range fileList {
 			// Check if the file looks like a text file
-			isText, err := utils.IsTextFile(subFile)
+			isText, err := helpers.IsTextFile(subFile)
 			if err != nil {
 				message.Debugf("unable to determine if file %s is a text file: %s", subFile, err)
 			}
@@ -379,7 +378,7 @@ func (p *Packager) processComponentFiles(component types.ZarfComponent, pkgLocat
 
 		// Copy the file to the destination
 		spinner.Updatef("Saving %s", file.Target)
-		err := utils.CreatePathAndCopy(fileLocation, file.Target)
+		err := helpers.CreatePathAndCopy(fileLocation, file.Target)
 		if err != nil {
 			return fmt.Errorf("unable to copy file %s to %s: %w", fileLocation, file.Target, err)
 		}
@@ -390,7 +389,7 @@ func (p *Packager) processComponentFiles(component types.ZarfComponent, pkgLocat
 			// Try to remove the filepath if it exists
 			_ = os.RemoveAll(link)
 			// Make sure the parent directory exists
-			_ = utils.CreateParentDirectory(link)
+			_ = helpers.CreateParentDirectory(link)
 			// Create the symlink
 			err := os.Symlink(file.Target, link)
 			if err != nil {
@@ -573,10 +572,10 @@ func (p *Packager) installChartAndManifests(componentPaths *layout.ComponentPath
 
 	for _, manifest := range component.Manifests {
 		for idx := range manifest.Files {
-			if utils.InvalidPath(filepath.Join(componentPaths.Manifests, manifest.Files[idx])) {
+			if helpers.InvalidPath(filepath.Join(componentPaths.Manifests, manifest.Files[idx])) {
 				// The path is likely invalid because of how we compose OCI components, add an index suffix to the filename
 				manifest.Files[idx] = fmt.Sprintf("%s-%d.yaml", manifest.Name, idx)
-				if utils.InvalidPath(filepath.Join(componentPaths.Manifests, manifest.Files[idx])) {
+				if helpers.InvalidPath(filepath.Join(componentPaths.Manifests, manifest.Files[idx])) {
 					return installedCharts, fmt.Errorf("unable to find manifest file %s", manifest.Files[idx])
 				}
 			}
diff --git a/src/pkg/packager/generate.go b/src/pkg/packager/generate.go
index 286807d186..7b21e96f9e 100644
--- a/src/pkg/packager/generate.go
+++ b/src/pkg/packager/generate.go
@@ -14,7 +14,6 @@ import (
 	"github.com/defenseunicorns/zarf/src/internal/packager/validate"
 	"github.com/defenseunicorns/zarf/src/pkg/layout"
 	"github.com/defenseunicorns/zarf/src/pkg/message"
-	"github.com/defenseunicorns/zarf/src/pkg/utils"
 	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 	"github.com/defenseunicorns/zarf/src/types"
 	goyaml "github.com/goccy/go-yaml"
@@ -25,14 +24,14 @@ func (p *Packager) Generate() (err error) {
 	generatedZarfYAMLPath := filepath.Join(p.cfg.GenerateOpts.Output, layout.ZarfYAML)
 	spinner := message.NewProgressSpinner("Generating package for %q at %s", p.cfg.GenerateOpts.Name, generatedZarfYAMLPath)
 
-	if !utils.InvalidPath(generatedZarfYAMLPath) {
+	if !helpers.InvalidPath(generatedZarfYAMLPath) {
 		prefixed := filepath.Join(p.cfg.GenerateOpts.Output, fmt.Sprintf("%s-%s", p.cfg.GenerateOpts.Name, layout.ZarfYAML))
 
 		message.Warnf("%s already exists, writing to %s", generatedZarfYAMLPath, prefixed)
 
 		generatedZarfYAMLPath = prefixed
 
-		if !utils.InvalidPath(generatedZarfYAMLPath) {
+		if !helpers.InvalidPath(generatedZarfYAMLPath) {
 			return fmt.Errorf("unable to generate package, %s already exists", generatedZarfYAMLPath)
 		}
 	}
@@ -78,7 +77,7 @@ func (p *Packager) Generate() (err error) {
 		return err
 	}
 
-	if err := utils.CreateDirectory(p.cfg.GenerateOpts.Output, helpers.ReadExecuteAllWriteUser); err != nil {
+	if err := helpers.CreateDirectory(p.cfg.GenerateOpts.Output, helpers.ReadExecuteAllWriteUser); err != nil {
 		return err
 	}
 
diff --git a/src/pkg/packager/prepare.go b/src/pkg/packager/prepare.go
index c4cfc95d3c..877d882df0 100644
--- a/src/pkg/packager/prepare.go
+++ b/src/pkg/packager/prepare.go
@@ -168,7 +168,7 @@ func (p *Packager) findImages() (imgMap map[string][]string, err error) {
 				return nil, fmt.Errorf("unable to package the chart %s: %w", chart.Name, err)
 			}
 
-			valuesFilePaths, _ := utils.RecursiveFileList(componentPaths.Values, nil, false)
+			valuesFilePaths, _ := helpers.RecursiveFileList(componentPaths.Values, nil, false)
 			for _, path := range valuesFilePaths {
 				if err := values.Apply(component, path, false); err != nil {
 					return nil, err
@@ -231,7 +231,7 @@ func (p *Packager) findImages() (imgMap map[string][]string, err error) {
 				} else {
 					filename := filepath.Base(f)
 					newDestination := filepath.Join(componentPaths.Manifests, filename)
-					if err := utils.CreatePathAndCopy(f, newDestination); err != nil {
+					if err := helpers.CreatePathAndCopy(f, newDestination); err != nil {
 						return nil, fmt.Errorf("unable to copy manifest %s: %w", f, err)
 					}
 					f = newDestination
diff --git a/src/pkg/packager/sources/split.go b/src/pkg/packager/sources/split.go
index df5fbd4714..a5e09e7ec7 100644
--- a/src/pkg/packager/sources/split.go
+++ b/src/pkg/packager/sources/split.go
@@ -15,7 +15,7 @@ import (
 
 	"github.com/defenseunicorns/zarf/src/pkg/layout"
 	"github.com/defenseunicorns/zarf/src/pkg/message"
-	"github.com/defenseunicorns/zarf/src/pkg/utils"
+	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 	"github.com/defenseunicorns/zarf/src/types"
 )
 
@@ -92,7 +92,7 @@ func (s *SplitTarballSource) Collect(dir string) (string, error) {
 		}
 	}
 
-	if err := utils.SHAsMatch(reassembled, pkgData.Sha256Sum); err != nil {
+	if err := helpers.SHAsMatch(reassembled, pkgData.Sha256Sum); err != nil {
 		return "", fmt.Errorf("package integrity check failed: %w", err)
 	}
 
diff --git a/src/pkg/packager/sources/tarball.go b/src/pkg/packager/sources/tarball.go
index a28924f499..5926e513c2 100644
--- a/src/pkg/packager/sources/tarball.go
+++ b/src/pkg/packager/sources/tarball.go
@@ -39,7 +39,7 @@ func (s *TarballSource) LoadPackage(dst *layout.PackagePaths, unarchiveAll bool)
 	defer spinner.Stop()
 
 	if s.Shasum != "" {
-		if err := utils.SHAsMatch(s.PackageSource, s.Shasum); err != nil {
+		if err := helpers.SHAsMatch(s.PackageSource, s.Shasum); err != nil {
 			return err
 		}
 	}
@@ -138,7 +138,7 @@ func (s *TarballSource) LoadPackageMetadata(dst *layout.PackagePaths, wantSBOM b
 	var pkg types.ZarfPackage
 
 	if s.Shasum != "" {
-		if err := utils.SHAsMatch(s.PackageSource, s.Shasum); err != nil {
+		if err := helpers.SHAsMatch(s.PackageSource, s.Shasum); err != nil {
 			return err
 		}
 	}
@@ -154,7 +154,7 @@ func (s *TarballSource) LoadPackageMetadata(dst *layout.PackagePaths, wantSBOM b
 			return err
 		}
 		// archiver.Extract will not return an error if the file does not exist, so we must manually check
-		if !utils.InvalidPath(filepath.Join(dst.Base, rel)) {
+		if !helpers.InvalidPath(filepath.Join(dst.Base, rel)) {
 			pathsExtracted = append(pathsExtracted, rel)
 		}
 	}
diff --git a/src/pkg/packager/sources/utils.go b/src/pkg/packager/sources/utils.go
index 1347ee4127..e9adb824bd 100644
--- a/src/pkg/packager/sources/utils.go
+++ b/src/pkg/packager/sources/utils.go
@@ -13,7 +13,7 @@ import (
 
 	"github.com/defenseunicorns/zarf/src/config"
 	"github.com/defenseunicorns/zarf/src/pkg/layout"
-	"github.com/defenseunicorns/zarf/src/pkg/utils"
+	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 	"github.com/defenseunicorns/zarf/src/pkg/zoci"
 	"github.com/defenseunicorns/zarf/src/types"
 	goyaml "github.com/goccy/go-yaml"
@@ -21,7 +21,7 @@ import (
 )
 
 func identifyUnknownTarball(path string) (string, error) {
-	if utils.InvalidPath(path) {
+	if helpers.InvalidPath(path) {
 		return "", &os.PathError{Op: "open", Path: path, Err: os.ErrNotExist}
 	}
 	if filepath.Ext(path) != "" && config.IsValidFileExtension(path) {
diff --git a/src/pkg/packager/sources/validate.go b/src/pkg/packager/sources/validate.go
index 5168efc443..6768b22137 100644
--- a/src/pkg/packager/sources/validate.go
+++ b/src/pkg/packager/sources/validate.go
@@ -17,6 +17,7 @@ import (
 	"github.com/defenseunicorns/zarf/src/pkg/layout"
 	"github.com/defenseunicorns/zarf/src/pkg/message"
 	"github.com/defenseunicorns/zarf/src/pkg/utils"
+	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 )
 
 var (
@@ -61,15 +62,15 @@ func ValidatePackageSignature(paths *layout.PackagePaths, publicKeyPath string)
 // ValidatePackageIntegrity validates the integrity of a package by comparing checksums
 func ValidatePackageIntegrity(loaded *layout.PackagePaths, aggregateChecksum string, isPartial bool) error {
 	// ensure checksums.txt and zarf.yaml were loaded
-	if utils.InvalidPath(loaded.Checksums) {
+	if helpers.InvalidPath(loaded.Checksums) {
 		return fmt.Errorf("unable to validate checksums, %s was not loaded", layout.Checksums)
 	}
-	if utils.InvalidPath(loaded.ZarfYAML) {
+	if helpers.InvalidPath(loaded.ZarfYAML) {
 		return fmt.Errorf("unable to validate checksums, %s was not loaded", layout.ZarfYAML)
 	}
 
 	checksumPath := loaded.Checksums
-	if err := utils.SHAsMatch(checksumPath, aggregateChecksum); err != nil {
+	if err := helpers.SHAsMatch(checksumPath, aggregateChecksum); err != nil {
 		return err
 	}
 
@@ -102,7 +103,7 @@ func ValidatePackageIntegrity(loaded *layout.PackagePaths, aggregateChecksum str
 		}
 		path := filepath.Join(loaded.Base, rel)
 
-		if utils.InvalidPath(path) {
+		if helpers.InvalidPath(path) {
 			if !isPartial && !checkedMap[path] {
 				return fmt.Errorf("unable to validate checksums - missing file: %s", rel)
 			} else if isPartial {
@@ -120,7 +121,7 @@ func ValidatePackageIntegrity(loaded *layout.PackagePaths, aggregateChecksum str
 			return nil
 		}
 
-		if err := utils.SHAsMatch(path, sha); err != nil {
+		if err := helpers.SHAsMatch(path, sha); err != nil {
 			return err
 		}
 
diff --git a/src/pkg/utils/bytes.go b/src/pkg/utils/bytes.go
index 8d4d269fcd..8c7fdf2316 100644
--- a/src/pkg/utils/bytes.go
+++ b/src/pkg/utils/bytes.go
@@ -12,6 +12,7 @@ import (
 	"time"
 
 	"github.com/defenseunicorns/zarf/src/pkg/message"
+	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 )
 
 // RoundUp rounds a float64 to the given number of decimal places.
@@ -78,7 +79,7 @@ func RenderProgressBarForLocalDirWrite(filepath string, expectedTotal int64, com
 			}
 		default:
 			// Read the directory size
-			currentBytes, dirErr := GetDirSize(filepath)
+			currentBytes, dirErr := helpers.GetDirSize(filepath)
 			if dirErr != nil {
 				message.Debugf("unable to get updated progress: %s", dirErr.Error())
 				time.Sleep(200 * time.Millisecond)
diff --git a/src/pkg/utils/exec/exec.go b/src/pkg/utils/exec/exec.go
index 0bb6d1c171..40b4023d50 100644
--- a/src/pkg/utils/exec/exec.go
+++ b/src/pkg/utils/exec/exec.go
@@ -12,27 +12,26 @@ import (
 	"io"
 	"os"
 	"os/exec"
-	"os/signal"
 	"runtime"
 	"strings"
 	"sync"
-	"syscall"
-
-	"github.com/defenseunicorns/zarf/src/config/lang"
-	"github.com/defenseunicorns/zarf/src/pkg/message"
-	"github.com/defenseunicorns/zarf/src/types"
 )
 
-// SuppressGlobalInterrupt suppresses the global error on an interrupt
-var SuppressGlobalInterrupt = false
-
 // Config is a struct for configuring the Cmd function.
 type Config struct {
-	Print  bool
-	Dir    string
-	Env    []string
-	Stdout io.Writer
-	Stderr io.Writer
+	Print          bool
+	Dir            string
+	Env            []string
+	CommandPrinter func(format string, a ...any)
+	Stdout         io.Writer
+	Stderr         io.Writer
+}
+
+// Shell represents the desired shell to use for a given command
+type Shell struct {
+	Windows string `json:"windows,omitempty" jsonschema:"description=(default 'powershell') Indicates a preference for the shell to use on Windows systems (note that choosing 'cmd' will turn off migrations like touch -> New-Item),example=powershell,example=cmd,example=pwsh,example=sh,example=bash,example=gsh"`
+	Linux   string `json:"linux,omitempty" jsonschema:"description=(default 'sh') Indicates a preference for the shell to use on Linux systems,example=sh,example=bash,example=fish,example=zsh,example=pwsh"`
+	Darwin  string `json:"darwin,omitempty" jsonschema:"description=(default 'sh') Indicates a preference for the shell to use on macOS systems,example=sh,example=bash,example=fish,example=zsh,example=pwsh"`
 }
 
 // PrintCfg is a helper function for returning a Config struct with Print set to true.
@@ -100,8 +99,8 @@ func CmdWithContext(ctx context.Context, config Config, command string, args ...
 	stderr := io.MultiWriter(stdErrWriters...)
 
 	// If we're printing, print the command.
-	if config.Print {
-		message.Command("%s %s", command, strings.Join(args, " "))
+	if config.Print && config.CommandPrinter != nil {
+		config.CommandPrinter("%s %s", command, strings.Join(args, " "))
 	}
 
 	// Start the command.
@@ -154,7 +153,7 @@ func LaunchURL(url string) error {
 }
 
 // GetOSShell returns the shell and shellArgs based on the current OS
-func GetOSShell(shellPref types.ZarfComponentActionShell) (string, []string) {
+func GetOSShell(shellPref Shell) (string, []string) {
 	var shell string
 	var shellArgs []string
 	powershellShellArgs := []string{"-Command", "$ErrorActionPreference = 'Stop';"}
@@ -209,15 +208,3 @@ func GetOSShell(shellPref types.ZarfComponentActionShell) (string, []string) {
 func IsPowershell(shellName string) bool {
 	return shellName == "powershell" || shellName == "pwsh"
 }
-
-// ExitOnInterrupt catches an interrupt and exits with fatal error
-func ExitOnInterrupt() {
-	c := make(chan os.Signal, 1)
-	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
-	go func() {
-		<-c
-		if !SuppressGlobalInterrupt {
-			message.Fatal(lang.ErrInterrupt, lang.ErrInterrupt.Error())
-		}
-	}()
-}
diff --git a/src/pkg/utils/helpers/files.go b/src/pkg/utils/helpers/files.go
new file mode 100644
index 0000000000..673cb8472e
--- /dev/null
+++ b/src/pkg/utils/helpers/files.go
@@ -0,0 +1,298 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2021-Present The Zarf Authors
+
+// Package helpers provides generic helper functions with no external imports
+package helpers
+
+import (
+	"archive/tar"
+	"crypto/sha256"
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/otiai10/copy"
+)
+
+const dotCharacter = 46
+
+// CreateDirectory creates a directory for the given path and file mode.
+func CreateDirectory(path string, mode os.FileMode) error {
+	if InvalidPath(path) {
+		return os.MkdirAll(path, mode)
+	}
+	return nil
+}
+
+// CreateFile creates an empty file at the given path.
+func CreateFile(filepath string) error {
+	if InvalidPath(filepath) {
+		f, err := os.Create(filepath)
+		f.Close()
+		return err
+	}
+
+	return nil
+
+}
+
+// InvalidPath checks if the given path is valid (if it is a permissions error it is there we just don't have access)
+func InvalidPath(path string) bool {
+	_, err := os.Stat(path)
+	return !os.IsPermission(err) && err != nil
+}
+
+// ListDirectories returns a list of directories in the given directory.
+func ListDirectories(directory string) ([]string, error) {
+	var directories []string
+	paths, err := os.ReadDir(directory)
+	if err != nil {
+		return directories, fmt.Errorf("unable to load the directory %s: %w", directory, err)
+	}
+
+	for _, entry := range paths {
+		if entry.IsDir() {
+			directories = append(directories, filepath.Join(directory, entry.Name()))
+		}
+	}
+
+	return directories, nil
+}
+
+// RecursiveFileList walks a path with an optional regex pattern and returns a slice of file paths.
+// If skipHidden is true, hidden directories will be skipped.
+func RecursiveFileList(dir string, pattern *regexp.Regexp, skipHidden bool) (files []string, err error) {
+	err = filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
+
+		// Return errors
+		if err != nil {
+			return err
+		}
+
+		info, err := d.Info()
+
+		if err != nil {
+			return err
+		}
+
+		if info.Mode().IsRegular() {
+			if pattern != nil {
+				if len(pattern.FindStringIndex(path)) > 0 {
+					files = append(files, path)
+				}
+			} else {
+				files = append(files, path)
+			}
+			// Skip hidden directories
+		} else if skipHidden && IsHidden(d.Name()) {
+			return filepath.SkipDir
+		}
+
+		return nil
+	})
+	return files, err
+}
+
+// CreateParentDirectory creates the parent directory for the given file path.
+func CreateParentDirectory(destination string) error {
+	parentDest := filepath.Dir(destination)
+	return CreateDirectory(parentDest, ReadWriteExecuteUser)
+}
+
+// CreatePathAndCopy creates the parent directory for the given file path and copies the source file to the destination.
+func CreatePathAndCopy(source string, destination string) error {
+	if err := CreateParentDirectory(destination); err != nil {
+		return err
+	}
+
+	// Copy all the source data into the destination location
+	if err := copy.Copy(source, destination); err != nil {
+		return err
+	}
+
+	// If the path doesn't exist yet then this is an empty file and we should create it
+	return CreateFile(destination)
+}
+
+// ReadFileByChunks reads a file into multiple chunks by the given size.
+func ReadFileByChunks(path string, chunkSizeBytes int) (chunks [][]byte, sha256sum string, err error) {
+	var file []byte
+
+	// Open the created archive for io.Copy
+	if file, err = os.ReadFile(path); err != nil {
+		return chunks, sha256sum, err
+	}
+
+	//Calculate the sha256sum of the file before we split it up
+	sha256sum = fmt.Sprintf("%x", sha256.Sum256(file))
+
+	// Loop over the tarball breaking it into chunks based on the payloadChunkSize
+	for {
+		if len(file) == 0 {
+			break
+		}
+
+		// don't bust slice length
+		if len(file) < chunkSizeBytes {
+			chunkSizeBytes = len(file)
+		}
+
+		chunks = append(chunks, file[0:chunkSizeBytes])
+		file = file[chunkSizeBytes:]
+	}
+
+	return chunks, sha256sum, nil
+}
+
+// IsTrashBin checks if the given directory path corresponds to an operating system's trash bin.
+func IsTrashBin(dirPath string) bool {
+	dirPath = filepath.Clean(dirPath)
+
+	// Check if the directory path matches a Linux trash bin
+	if strings.HasSuffix(dirPath, "/Trash") || strings.HasSuffix(dirPath, "/.Trash-1000") {
+		return true
+	}
+
+	// Check if the directory path matches a macOS trash bin
+	if strings.HasSuffix(dirPath, "./Trash") || strings.HasSuffix(dirPath, "/.Trashes") {
+		return true
+	}
+
+	// Check if the directory path matches a Windows trash bin
+	if strings.HasSuffix(dirPath, "\\$RECYCLE.BIN") {
+		return true
+	}
+
+	return false
+}
+
+// IsHidden returns true if the given file name starts with a dot.
+func IsHidden(name string) bool {
+	return name[0] == dotCharacter
+}
+
+// GetDirSize walks through all files and directories in the provided path and returns the total size in bytes.
+func GetDirSize(path string) (int64, error) {
+	dirSize := int64(0)
+
+	// Walk all files in the path
+	err := filepath.Walk(path, func(_ string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if !info.IsDir() {
+			dirSize += info.Size()
+		}
+		return nil
+	})
+
+	return dirSize, err
+}
+
+// IsDir returns true if the given path is a directory.
+func IsDir(path string) bool {
+	info, err := os.Stat(filepath.Clean(path))
+	if os.IsNotExist(err) {
+		return false
+	}
+	return info.IsDir()
+}
+
+// GetSHA256OfFile returns the SHA256 hash of the provided file.
+func GetSHA256OfFile(filePath string) (string, error) {
+	f, err := os.Open(filePath)
+	if err != nil {
+		return "", err
+	}
+	defer f.Close()
+
+	return GetSHA256Hash(f)
+}
+
+// SHAsMatch returns an error if the SHA256 hash of the provided file does not match the expected hash.
+func SHAsMatch(path, expected string) error {
+	sha, err := GetSHA256OfFile(path)
+	if err != nil {
+		return err
+	}
+	if sha != expected {
+		return fmt.Errorf("expected sha256 of %s to be %s, found %s", path, expected, sha)
+	}
+	return nil
+}
+
+// CreateReproducibleTarballFromDir creates a tarball from a directory with stripped headers
+func CreateReproducibleTarballFromDir(dirPath, dirPrefix, tarballPath string) error {
+	tb, err := os.Create(tarballPath)
+	if err != nil {
+		return fmt.Errorf("error creating tarball: %w", err)
+	}
+	defer tb.Close()
+
+	tw := tar.NewWriter(tb)
+	defer tw.Close()
+
+	// Walk through the directory and process each file
+	return filepath.Walk(dirPath, func(filePath string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		link := ""
+		if info.Mode().Type() == os.ModeSymlink {
+			link, err = os.Readlink(filePath)
+			if err != nil {
+				return fmt.Errorf("error reading symlink: %w", err)
+			}
+		}
+
+		// Create a new header
+		header, err := tar.FileInfoHeader(info, link)
+		if err != nil {
+			return fmt.Errorf("error creating tar header: %w", err)
+		}
+
+		// Strip non-deterministic header data
+		header.ModTime = time.Time{}
+		header.AccessTime = time.Time{}
+		header.ChangeTime = time.Time{}
+		header.Uid = 0
+		header.Gid = 0
+		header.Uname = ""
+		header.Gname = ""
+
+		// Ensure the header's name is correctly set relative to the base directory
+		name, err := filepath.Rel(dirPath, filePath)
+		if err != nil {
+			return fmt.Errorf("error getting relative path: %w", err)
+		}
+		name = filepath.Join(dirPrefix, name)
+		name = filepath.ToSlash(name)
+		header.Name = name
+
+		// Write the header to the tarball
+		if err := tw.WriteHeader(header); err != nil {
+			return fmt.Errorf("error writing header: %w", err)
+		}
+
+		// If it's a file, write its content
+		if info.Mode().IsRegular() {
+			file, err := os.Open(filePath)
+			if err != nil {
+				return fmt.Errorf("error opening file: %w", err)
+			}
+			defer file.Close()
+
+			if _, err := io.Copy(tw, file); err != nil {
+				return fmt.Errorf("error writing file to tarball: %w", err)
+			}
+		}
+
+		return nil
+	})
+}
diff --git a/src/pkg/utils/helpers/text.go b/src/pkg/utils/helpers/text.go
new file mode 100644
index 0000000000..071faa099a
--- /dev/null
+++ b/src/pkg/utils/helpers/text.go
@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2021-Present The Zarf Authors
+
+// Package helpers provides generic helper functions with no external imports
+package helpers
+
+import (
+	"io"
+	"net/http"
+	"os"
+	"strings"
+)
+
+// Truncate truncates provided text to the requested length
+func Truncate(text string, length int, invert bool) string {
+	// Remove newlines and replace with semicolons
+	textEscaped := strings.ReplaceAll(text, "\n", "; ")
+	// Truncate the text if it is longer than length so it isn't too long.
+	if len(textEscaped) > length {
+		if invert {
+			start := len(textEscaped) - length + 3
+			textEscaped = "..." + textEscaped[start:]
+		} else {
+			end := length - 3
+			textEscaped = textEscaped[:end] + "..."
+		}
+	}
+	return textEscaped
+}
+
+// IsTextFile returns true if the given file is a text file.
+func IsTextFile(path string) (bool, error) {
+	// Open the file
+	f, err := os.Open(path)
+	if err != nil {
+		return false, err
+	}
+	defer f.Close() // Make sure to close the file when we're done
+
+	// Get file stat
+	stat, err := f.Stat()
+	if err != nil {
+		return false, err
+	}
+
+	// Clip offset to minimum of 0
+	lastOffset := max(0, stat.Size()-512)
+
+	// Take two passes checking front and back of the file
+	offsetPasses := []int64{0, lastOffset}
+	isTextCheck := []bool{false, false}
+	for idx, offset := range offsetPasses {
+		// Create 512 byte buffer
+		data := make([]byte, 512)
+
+		n, err := f.ReadAt(data, offset)
+		if err != nil && err != io.EOF {
+			return false, err
+		}
+
+		// Use http.DetectContentType to determine the MIME type of the file
+		mimeType := http.DetectContentType(data[:n])
+
+		// Check if the MIME type indicates that the file is text
+		hasText := strings.HasPrefix(mimeType, "text/")
+		hasJSON := strings.Contains(mimeType, "json")
+		hasXML := strings.Contains(mimeType, "xml")
+
+		// Save result
+		isTextCheck[idx] = hasText || hasJSON || hasXML
+	}
+
+	// Returns true if both front and back show they are text
+	return isTextCheck[0] && isTextCheck[1], nil
+}
diff --git a/src/pkg/utils/io.go b/src/pkg/utils/io.go
index 0e158cf1e0..9a711bfa5e 100755
--- a/src/pkg/utils/io.go
+++ b/src/pkg/utils/io.go
@@ -5,45 +5,27 @@
 package utils
 
 import (
-	"archive/tar"
-	"bufio"
 	"crypto/sha256"
 	"encoding/json"
 	"fmt"
 	"io"
-	"io/fs"
-	"net/http"
 	"os"
-	"os/exec"
 	"path/filepath"
-	"regexp"
-	"strings"
-	"time"
 
 	"github.com/defenseunicorns/zarf/src/config"
 	"github.com/defenseunicorns/zarf/src/pkg/message"
 	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 	"github.com/defenseunicorns/zarf/src/types"
-	"github.com/otiai10/copy"
 )
 
 const (
-	dotCharacter  = 46
 	tmpPathPrefix = "zarf-"
 )
 
-// TextTemplate represents a value to be templated into a text file.
-type TextTemplate struct {
-	Sensitive  bool
-	AutoIndent bool
-	Type       types.VariableType
-	Value      string
-}
-
 // MakeTempDir creates a temp directory with the zarf- prefix.
 func MakeTempDir(basePath string) (string, error) {
 	if basePath != "" {
-		if err := CreateDirectory(basePath, helpers.ReadWriteExecuteUser); err != nil {
+		if err := helpers.CreateDirectory(basePath, helpers.ReadWriteExecuteUser); err != nil {
 			return "", err
 		}
 	}
@@ -58,197 +40,6 @@ func MakeTempDir(basePath string) (string, error) {
 	return tmp, nil
 }
 
-// VerifyBinary returns true if binary is available.
-func VerifyBinary(binary string) bool {
-	_, err := exec.LookPath(binary)
-	return err == nil
-}
-
-// CreateDirectory creates a directory for the given path and file mode.
-func CreateDirectory(path string, mode os.FileMode) error {
-	if InvalidPath(path) {
-		return os.MkdirAll(path, mode)
-	}
-	return nil
-}
-
-// CreateFile creates an empty file at the given path.
-func CreateFile(filepath string) error {
-	if InvalidPath(filepath) {
-		f, err := os.Create(filepath)
-		f.Close()
-		return err
-	}
-
-	return nil
-
-}
-
-// InvalidPath checks if the given path is valid (if it is a permissions error it is there we just don't have access)
-func InvalidPath(path string) bool {
-	_, err := os.Stat(path)
-	return !os.IsPermission(err) && err != nil
-}
-
-// ListDirectories returns a list of directories in the given directory.
-func ListDirectories(directory string) ([]string, error) {
-	var directories []string
-	paths, err := os.ReadDir(directory)
-	if err != nil {
-		return directories, fmt.Errorf("unable to load the directory %s: %w", directory, err)
-	}
-
-	for _, entry := range paths {
-		if entry.IsDir() {
-			directories = append(directories, filepath.Join(directory, entry.Name()))
-		}
-	}
-
-	return directories, nil
-}
-
-// ReplaceTextTemplate loads a file from a given path, replaces text in it and writes it back in place.
-func ReplaceTextTemplate(path string, mappings map[string]*TextTemplate, deprecations map[string]string, templateRegex string) error {
-	textFile, err := os.Open(path)
-	if err != nil {
-		return err
-	}
-
-	// This regex takes a line and parses the text before and after a discovered template: https://regex101.com/r/ilUxAz/1
-	regexTemplateLine := regexp.MustCompile(fmt.Sprintf("(?P<preTemplate>.*?)(?P<template>%s)(?P<postTemplate>.*)", templateRegex))
-
-	fileScanner := bufio.NewScanner(textFile)
-
-	// Set the buffer to 1 MiB to handle long lines (i.e. base64 text in a secret)
-	// 1 MiB is around the documented maximum size for secrets and configmaps
-	const maxCapacity = 1024 * 1024
-	buf := make([]byte, maxCapacity)
-	fileScanner.Buffer(buf, maxCapacity)
-
-	// Set the scanner to split on new lines
-	fileScanner.Split(bufio.ScanLines)
-
-	text := ""
-
-	for fileScanner.Scan() {
-		line := fileScanner.Text()
-
-		for {
-			matches := regexTemplateLine.FindStringSubmatch(line)
-
-			// No template left on this line so move on
-			if len(matches) == 0 {
-				text += fmt.Sprintln(line)
-				break
-			}
-
-			preTemplate := matches[regexTemplateLine.SubexpIndex("preTemplate")]
-			templateKey := matches[regexTemplateLine.SubexpIndex("template")]
-
-			_, present := deprecations[templateKey]
-			if present {
-				message.Warnf("This Zarf Package uses a deprecated variable: '%s' changed to '%s'.  Please notify your package creator for an update.", templateKey, deprecations[templateKey])
-			}
-
-			template := mappings[templateKey]
-
-			// Check if the template is nil (present), use the original templateKey if not (so that it is not replaced).
-			value := templateKey
-			if template != nil {
-				value = template.Value
-
-				// Check if the value is a file type and load the value contents from the file
-				if template.Type == types.FileVariableType && value != "" {
-					if isText, err := IsTextFile(value); err != nil || !isText {
-						message.Warnf("Refusing to load a non-text file for templating %s", templateKey)
-						line = matches[regexTemplateLine.SubexpIndex("postTemplate")]
-						continue
-					}
-
-					contents, err := os.ReadFile(value)
-					if err != nil {
-						message.Warnf("Unable to read file for templating - skipping: %s", err.Error())
-						line = matches[regexTemplateLine.SubexpIndex("postTemplate")]
-						continue
-					}
-
-					value = string(contents)
-				}
-
-				// Check if the value is autoIndented and add the correct spacing
-				if template.AutoIndent {
-					indent := fmt.Sprintf("\n%s", strings.Repeat(" ", len(preTemplate)))
-					value = strings.ReplaceAll(value, "\n", indent)
-				}
-			}
-
-			// Add the processed text and continue processing the line
-			text += fmt.Sprintf("%s%s", preTemplate, value)
-			line = matches[regexTemplateLine.SubexpIndex("postTemplate")]
-		}
-	}
-
-	textFile.Close()
-
-	return os.WriteFile(path, []byte(text), helpers.ReadWriteUser)
-
-}
-
-// RecursiveFileList walks a path with an optional regex pattern and returns a slice of file paths.
-// If skipHidden is true, hidden directories will be skipped.
-func RecursiveFileList(dir string, pattern *regexp.Regexp, skipHidden bool) (files []string, err error) {
-	err = filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
-
-		// Return errors
-		if err != nil {
-			return err
-		}
-
-		info, err := d.Info()
-
-		if err != nil {
-			return err
-		}
-
-		if info.Mode().IsRegular() {
-			if pattern != nil {
-				if len(pattern.FindStringIndex(path)) > 0 {
-					files = append(files, path)
-				}
-			} else {
-				files = append(files, path)
-			}
-			// Skip hidden directories
-		} else if skipHidden && IsHidden(d.Name()) {
-			return filepath.SkipDir
-		}
-
-		return nil
-	})
-	return files, err
-}
-
-// CreateParentDirectory creates the parent directory for the given file path.
-func CreateParentDirectory(destination string) error {
-	parentDest := filepath.Dir(destination)
-	return CreateDirectory(parentDest, helpers.ReadWriteExecuteUser)
-}
-
-// CreatePathAndCopy creates the parent directory for the given file path and copies the source file to the destination.
-func CreatePathAndCopy(source string, destination string) error {
-	if err := CreateParentDirectory(destination); err != nil {
-		return err
-	}
-
-	// Copy all the source data into the destination location
-	if err := copy.Copy(source, destination); err != nil {
-		return err
-	}
-
-	// If the path doesn't exist yet then this is an empty file and we should create it
-	return CreateFile(destination)
-}
-
 // GetFinalExecutablePath returns the absolute path to the current executable, following any symlinks along the way.
 func GetFinalExecutablePath() (string, error) {
 	message.Debug("utils.GetExecutablePath()")
@@ -283,36 +74,6 @@ func GetFinalExecutableCommand() (string, error) {
 	return zarfCommand, err
 }
 
-// ReadFileByChunks reads a file into multiple chunks by the given size.
-func ReadFileByChunks(path string, chunkSizeBytes int) (chunks [][]byte, sha256sum string, err error) {
-	var file []byte
-
-	// Open the created archive for io.Copy
-	if file, err = os.ReadFile(path); err != nil {
-		return chunks, sha256sum, err
-	}
-
-	//Calculate the sha256sum of the file before we split it up
-	sha256sum = fmt.Sprintf("%x", sha256.Sum256(file))
-
-	// Loop over the tarball breaking it into chunks based on the payloadChunkSize
-	for {
-		if len(file) == 0 {
-			break
-		}
-
-		// don't bust slice length
-		if len(file) < chunkSizeBytes {
-			chunkSizeBytes = len(file)
-		}
-
-		chunks = append(chunks, file[0:chunkSizeBytes])
-		file = file[chunkSizeBytes:]
-	}
-
-	return chunks, sha256sum, nil
-}
-
 // SplitFile will take a srcFile path and split it into files based on chunkSizeBytes
 // the first file will be a metadata file containing:
 // - sha256sum of the original file
@@ -450,197 +211,3 @@ func SplitFile(srcPath string, chunkSizeBytes int) (err error) {
 
 	return nil
 }
-
-// IsTextFile returns true if the given file is a text file.
-func IsTextFile(path string) (bool, error) {
-	// Open the file
-	f, err := os.Open(path)
-	if err != nil {
-		return false, err
-	}
-	defer f.Close() // Make sure to close the file when we're done
-
-	// Get file stat
-	stat, err := f.Stat()
-	if err != nil {
-		return false, err
-	}
-
-	// Clip offset to minimum of 0
-	lastOffset := max(0, stat.Size()-512)
-
-	// Take two passes checking front and back of the file
-	offsetPasses := []int64{0, lastOffset}
-	isTextCheck := []bool{false, false}
-	for idx, offset := range offsetPasses {
-		// Create 512 byte buffer
-		data := make([]byte, 512)
-
-		n, err := f.ReadAt(data, offset)
-		if err != nil && err != io.EOF {
-			return false, err
-		}
-
-		// Use http.DetectContentType to determine the MIME type of the file
-		mimeType := http.DetectContentType(data[:n])
-
-		// Check if the MIME type indicates that the file is text
-		hasText := strings.HasPrefix(mimeType, "text/")
-		hasJSON := strings.Contains(mimeType, "json")
-		hasXML := strings.Contains(mimeType, "xml")
-
-		// Save result
-		isTextCheck[idx] = hasText || hasJSON || hasXML
-	}
-
-	// Returns true if both front and back show they are text
-	return isTextCheck[0] && isTextCheck[1], nil
-}
-
-// IsTrashBin checks if the given directory path corresponds to an operating system's trash bin.
-func IsTrashBin(dirPath string) bool {
-	dirPath = filepath.Clean(dirPath)
-
-	// Check if the directory path matches a Linux trash bin
-	if strings.HasSuffix(dirPath, "/Trash") || strings.HasSuffix(dirPath, "/.Trash-1000") {
-		return true
-	}
-
-	// Check if the directory path matches a macOS trash bin
-	if strings.HasSuffix(dirPath, "./Trash") || strings.HasSuffix(dirPath, "/.Trashes") {
-		return true
-	}
-
-	// Check if the directory path matches a Windows trash bin
-	if strings.HasSuffix(dirPath, "\\$RECYCLE.BIN") {
-		return true
-	}
-
-	return false
-}
-
-// IsHidden returns true if the given file name starts with a dot.
-func IsHidden(name string) bool {
-	return name[0] == dotCharacter
-}
-
-// GetDirSize walks through all files and directories in the provided path and returns the total size in bytes.
-func GetDirSize(path string) (int64, error) {
-	dirSize := int64(0)
-
-	// Walk all files in the path
-	err := filepath.Walk(path, func(_ string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-		if !info.IsDir() {
-			dirSize += info.Size()
-		}
-		return nil
-	})
-
-	return dirSize, err
-}
-
-// IsDir returns true if the given path is a directory.
-func IsDir(path string) bool {
-	info, err := os.Stat(filepath.Clean(path))
-	if os.IsNotExist(err) {
-		return false
-	}
-	return info.IsDir()
-}
-
-// GetSHA256OfFile returns the SHA256 hash of the provided file.
-func GetSHA256OfFile(filePath string) (string, error) {
-	f, err := os.Open(filePath)
-	if err != nil {
-		return "", err
-	}
-	defer f.Close()
-
-	return helpers.GetSHA256Hash(f)
-}
-
-// SHAsMatch returns an error if the SHA256 hash of the provided file does not match the expected hash.
-func SHAsMatch(path, expected string) error {
-	sha, err := GetSHA256OfFile(path)
-	if err != nil {
-		return err
-	}
-	if sha != expected {
-		return fmt.Errorf("expected sha256 of %s to be %s, found %s", path, expected, sha)
-	}
-	return nil
-}
-
-// CreateReproducibleTarballFromDir creates a tarball from a directory with stripped headers
-func CreateReproducibleTarballFromDir(dirPath, dirPrefix, tarballPath string) error {
-	tb, err := os.Create(tarballPath)
-	if err != nil {
-		return fmt.Errorf("error creating tarball: %w", err)
-	}
-	defer tb.Close()
-
-	tw := tar.NewWriter(tb)
-	defer tw.Close()
-
-	// Walk through the directory and process each file
-	return filepath.Walk(dirPath, func(filePath string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
-		}
-
-		link := ""
-		if info.Mode().Type() == os.ModeSymlink {
-			link, err = os.Readlink(filePath)
-			if err != nil {
-				return fmt.Errorf("error reading symlink: %w", err)
-			}
-		}
-
-		// Create a new header
-		header, err := tar.FileInfoHeader(info, link)
-		if err != nil {
-			return fmt.Errorf("error creating tar header: %w", err)
-		}
-
-		// Strip non-deterministic header data
-		header.ModTime = time.Time{}
-		header.AccessTime = time.Time{}
-		header.ChangeTime = time.Time{}
-		header.Uid = 0
-		header.Gid = 0
-		header.Uname = ""
-		header.Gname = ""
-
-		// Ensure the header's name is correctly set relative to the base directory
-		name, err := filepath.Rel(dirPath, filePath)
-		if err != nil {
-			return fmt.Errorf("error getting relative path: %w", err)
-		}
-		name = filepath.Join(dirPrefix, name)
-		name = filepath.ToSlash(name)
-		header.Name = name
-
-		// Write the header to the tarball
-		if err := tw.WriteHeader(header); err != nil {
-			return fmt.Errorf("error writing header: %w", err)
-		}
-
-		// If it's a file, write its content
-		if info.Mode().IsRegular() {
-			file, err := os.Open(filePath)
-			if err != nil {
-				return fmt.Errorf("error opening file: %w", err)
-			}
-			defer file.Close()
-
-			if _, err := io.Copy(tw, file); err != nil {
-				return fmt.Errorf("error writing file to tarball: %w", err)
-			}
-		}
-
-		return nil
-	})
-}
diff --git a/src/pkg/utils/network.go b/src/pkg/utils/network.go
index bf9c4c18a6..b21876224e 100644
--- a/src/pkg/utils/network.go
+++ b/src/pkg/utils/network.go
@@ -48,7 +48,7 @@ func DownloadToFile(src string, dst string, cosignKeyPath string) (err error) {
 		return err
 	}
 
-	err = CreateDirectory(filepath.Dir(dst), helpers.ReadWriteExecuteUser)
+	err = helpers.CreateDirectory(filepath.Dir(dst), helpers.ReadWriteExecuteUser)
 	if err != nil {
 		return fmt.Errorf(lang.ErrCreatingDir, filepath.Dir(dst), err.Error())
 	}
@@ -82,7 +82,7 @@ func DownloadToFile(src string, dst string, cosignKeyPath string) (err error) {
 
 	// If the file has a checksum, validate it
 	if len(checksum) > 0 {
-		received, err := GetSHA256OfFile(dst)
+		received, err := helpers.GetSHA256OfFile(dst)
 		if err != nil {
 			return err
 		}
diff --git a/src/pkg/utils/network_test.go b/src/pkg/utils/network_test.go
index 9aa2d4892d..31e4adc0e5 100644
--- a/src/pkg/utils/network_test.go
+++ b/src/pkg/utils/network_test.go
@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/defenseunicorns/zarf/src/pkg/message"
+	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 )
@@ -75,7 +76,7 @@ func (suite *TestNetworkSuite) Test_1_DownloadToFile() {
 	suite.NoError(err)
 	suite.Contains(string(content), "adr")
 
-	check, err := GetSHA256OfFile(path)
+	check, err := helpers.GetSHA256OfFile(path)
 	suite.NoError(err)
 	suite.Equal(sum, check)
 
diff --git a/src/pkg/utils/wait.go b/src/pkg/utils/wait.go
index ca5c8a1c2d..a4815e5ea5 100644
--- a/src/pkg/utils/wait.go
+++ b/src/pkg/utils/wait.go
@@ -14,7 +14,6 @@ import (
 	"time"
 
 	"github.com/defenseunicorns/zarf/src/pkg/utils/exec"
-	"github.com/defenseunicorns/zarf/src/types"
 
 	"github.com/defenseunicorns/zarf/src/config/lang"
 	"github.com/defenseunicorns/zarf/src/pkg/message"
@@ -79,7 +78,7 @@ func ExecuteWait(waitTimeout, waitNamespace, condition, kind, identifier string,
 	spinner := message.NewProgressSpinner(existMsg)
 
 	// Get the OS shell to execute commands in
-	shell, shellArgs := exec.GetOSShell(types.ZarfComponentActionShell{Windows: "cmd"})
+	shell, shellArgs := exec.GetOSShell(exec.Shell{Windows: "cmd"})
 
 	defer spinner.Stop()
 
diff --git a/src/test/e2e/05_tarball_test.go b/src/test/e2e/05_tarball_test.go
index f6df5f7e1b..4d29edae77 100644
--- a/src/test/e2e/05_tarball_test.go
+++ b/src/test/e2e/05_tarball_test.go
@@ -14,6 +14,7 @@ import (
 	"github.com/defenseunicorns/zarf/src/pkg/layout"
 	"github.com/defenseunicorns/zarf/src/pkg/message"
 	"github.com/defenseunicorns/zarf/src/pkg/utils"
+	"github.com/defenseunicorns/zarf/src/pkg/utils/helpers"
 	"github.com/defenseunicorns/zarf/src/types"
 	"github.com/stretchr/testify/require"
 )
@@ -69,7 +70,7 @@ func TestMultiPartPackage(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, pkgData.Bytes, fullFileInfo.Size())
 	// Ensure that the pkgData shasum was correct (should be checked during deploy as well, but this is to double check)
-	err = utils.SHAsMatch(parts[0], pkgData.Sha256Sum)
+	err = helpers.SHAsMatch(parts[0], pkgData.Sha256Sum)
 	require.NoError(t, err)
 
 	e2e.CleanFiles(parts...)
diff --git a/src/test/e2e/51_oci_compose_test.go b/src/test/e2e/51_oci_compose_test.go
index 4412e13226..be89bc8b97 100644
--- a/src/test/e2e/51_oci_compose_test.go
+++ b/src/test/e2e/51_oci_compose_test.go
@@ -178,7 +178,7 @@ func (suite *SkeletonSuite) Test_2_FilePaths() {
 }
 
 func (suite *SkeletonSuite) DirOrFileExists(path string) {
-	invalid := utils.InvalidPath(path)
+	invalid := helpers.InvalidPath(path)
 	suite.Falsef(invalid, "path specified does not exist: %s", path)
 }
 
diff --git a/src/types/component.go b/src/types/component.go
index f63e6ab2a7..82b931b868 100644
--- a/src/types/component.go
+++ b/src/types/component.go
@@ -7,6 +7,7 @@ package types
 import (
 	"reflect"
 
+	"github.com/defenseunicorns/zarf/src/pkg/utils/exec"
 	"github.com/defenseunicorns/zarf/src/types/extensions"
 )
 
@@ -140,19 +141,12 @@ type ZarfComponentActionSet struct {
 
 // ZarfComponentActionDefaults sets the default configs for child actions
 type ZarfComponentActionDefaults struct {
-	Mute            bool                     `json:"mute,omitempty" jsonschema:"description=Hide the output of commands during execution (default false)"`
-	MaxTotalSeconds int                      `json:"maxTotalSeconds,omitempty" jsonschema:"description=Default timeout in seconds for commands (default to 0, no timeout)"`
-	MaxRetries      int                      `json:"maxRetries,omitempty" jsonschema:"description=Retry commands given number of times if they fail (default 0)"`
-	Dir             string                   `json:"dir,omitempty" jsonschema:"description=Working directory for commands (default CWD)"`
-	Env             []string                 `json:"env,omitempty" jsonschema:"description=Additional environment variables for commands"`
-	Shell           ZarfComponentActionShell `json:"shell,omitempty" jsonschema:"description=(cmd only) Indicates a preference for a shell for the provided cmd to be executed in on supported operating systems"`
-}
-
-// ZarfComponentActionShell represents the desired shell to use for a given command
-type ZarfComponentActionShell struct {
-	Windows string `json:"windows,omitempty" jsonschema:"description=(default 'powershell') Indicates a preference for the shell to use on Windows systems (note that choosing 'cmd' will turn off migrations like touch -> New-Item),example=powershell,example=cmd,example=pwsh,example=sh,example=bash,example=gsh"`
-	Linux   string `json:"linux,omitempty" jsonschema:"description=(default 'sh') Indicates a preference for the shell to use on Linux systems,example=sh,example=bash,example=fish,example=zsh,example=pwsh"`
-	Darwin  string `json:"darwin,omitempty" jsonschema:"description=(default 'sh') Indicates a preference for the shell to use on macOS systems,example=sh,example=bash,example=fish,example=zsh,example=pwsh"`
+	Mute            bool       `json:"mute,omitempty" jsonschema:"description=Hide the output of commands during execution (default false)"`
+	MaxTotalSeconds int        `json:"maxTotalSeconds,omitempty" jsonschema:"description=Default timeout in seconds for commands (default to 0, no timeout)"`
+	MaxRetries      int        `json:"maxRetries,omitempty" jsonschema:"description=Retry commands given number of times if they fail (default 0)"`
+	Dir             string     `json:"dir,omitempty" jsonschema:"description=Working directory for commands (default CWD)"`
+	Env             []string   `json:"env,omitempty" jsonschema:"description=Additional environment variables for commands"`
+	Shell           exec.Shell `json:"shell,omitempty" jsonschema:"description=(cmd only) Indicates a preference for a shell for the provided cmd to be executed in on supported operating systems"`
 }
 
 // ZarfComponentAction represents a single action to run during a zarf package operation
@@ -163,7 +157,7 @@ type ZarfComponentAction struct {
 	Dir                   *string                          `json:"dir,omitempty" jsonschema:"description=The working directory to run the command in (default is CWD)"`
 	Env                   []string                         `json:"env,omitempty" jsonschema:"description=Additional environment variables to set for the command"`
 	Cmd                   string                           `json:"cmd,omitempty" jsonschema:"description=The command to run. Must specify either cmd or wait for the action to do anything."`
-	Shell                 *ZarfComponentActionShell        `json:"shell,omitempty" jsonschema:"description=(cmd only) Indicates a preference for a shell for the provided cmd to be executed in on supported operating systems"`
+	Shell                 *exec.Shell                      `json:"shell,omitempty" jsonschema:"description=(cmd only) Indicates a preference for a shell for the provided cmd to be executed in on supported operating systems"`
 	DeprecatedSetVariable string                           `json:"setVariable,omitempty" jsonschema:"description=[Deprecated] (replaced by setVariables) (onDeploy/cmd only) The name of a variable to update with the output of the command. This variable will be available to all remaining actions and components in the package. This will be removed in Zarf v1.0.0,pattern=^[A-Z0-9_]+$"`
 	SetVariables          []ZarfComponentActionSetVariable `json:"setVariables,omitempty" jsonschema:"description=(onDeploy/cmd only) An array of variables to update with the output of the command. These variables will be available to all remaining actions and components in the package."`
 	Description           string                           `json:"description,omitempty" jsonschema:"description=Description of the action to be displayed during package execution instead of the command"`
diff --git a/zarf.schema.json b/zarf.schema.json
index 539081048a..1a31e468f8 100644
--- a/zarf.schema.json
+++ b/zarf.schema.json
@@ -82,6 +82,49 @@
         "^x-": {}
       }
     },
+    "Shell": {
+      "properties": {
+        "windows": {
+          "type": "string",
+          "description": "(default 'powershell') Indicates a preference for the shell to use on Windows systems (note that choosing 'cmd' will turn off migrations like touch -> New-Item)",
+          "examples": [
+            "powershell",
+            "cmd",
+            "pwsh",
+            "sh",
+            "bash",
+            "gsh"
+          ]
+        },
+        "linux": {
+          "type": "string",
+          "description": "(default 'sh') Indicates a preference for the shell to use on Linux systems",
+          "examples": [
+            "sh",
+            "bash",
+            "fish",
+            "zsh",
+            "pwsh"
+          ]
+        },
+        "darwin": {
+          "type": "string",
+          "description": "(default 'sh') Indicates a preference for the shell to use on macOS systems",
+          "examples": [
+            "sh",
+            "bash",
+            "fish",
+            "zsh",
+            "pwsh"
+          ]
+        }
+      },
+      "additionalProperties": false,
+      "type": "object",
+      "patternProperties": {
+        "^x-": {}
+      }
+    },
     "ZarfBuildData": {
       "required": [
         "terminal",
@@ -359,7 +402,7 @@
           "description": "The command to run. Must specify either cmd or wait for the action to do anything."
         },
         "shell": {
-          "$ref": "#/definitions/ZarfComponentActionShell",
+          "$ref": "#/definitions/Shell",
           "description": "(cmd only) Indicates a preference for a shell for the provided cmd to be executed in on supported operating systems"
         },
         "setVariable": {
@@ -418,7 +461,7 @@
         },
         "shell": {
           "$schema": "http://json-schema.org/draft-04/schema#",
-          "$ref": "#/definitions/ZarfComponentActionShell",
+          "$ref": "#/definitions/Shell",
           "description": "(cmd only) Indicates a preference for a shell for the provided cmd to be executed in on supported operating systems"
         }
       },
@@ -508,49 +551,6 @@
         "^x-": {}
       }
     },
-    "ZarfComponentActionShell": {
-      "properties": {
-        "windows": {
-          "type": "string",
-          "description": "(default 'powershell') Indicates a preference for the shell to use on Windows systems (note that choosing 'cmd' will turn off migrations like touch -> New-Item)",
-          "examples": [
-            "powershell",
-            "cmd",
-            "pwsh",
-            "sh",
-            "bash",
-            "gsh"
-          ]
-        },
-        "linux": {
-          "type": "string",
-          "description": "(default 'sh') Indicates a preference for the shell to use on Linux systems",
-          "examples": [
-            "sh",
-            "bash",
-            "fish",
-            "zsh",
-            "pwsh"
-          ]
-        },
-        "darwin": {
-          "type": "string",
-          "description": "(default 'sh') Indicates a preference for the shell to use on macOS systems",
-          "examples": [
-            "sh",
-            "bash",
-            "fish",
-            "zsh",
-            "pwsh"
-          ]
-        }
-      },
-      "additionalProperties": false,
-      "type": "object",
-      "patternProperties": {
-        "^x-": {}
-      }
-    },
     "ZarfComponentActionWait": {
       "properties": {
         "cluster": {