diff --git a/src/cmd/dev.go b/src/cmd/dev.go
index 1266232cde..adc5420a15 100644
--- a/src/cmd/dev.go
+++ b/src/cmd/dev.go
@@ -204,7 +204,7 @@ var devFindImagesCmd = &cobra.Command{
 	Args:    cobra.MaximumNArgs(1),
 	Short:   lang.CmdDevFindImagesShort,
 	Long:    lang.CmdDevFindImagesLong,
-	Run: func(_ *cobra.Command, args []string) {
+	Run: func(cmd *cobra.Command, args []string) {
 		pkgConfig.CreateOpts.BaseDir = common.SetBaseDirectory(args)
 
 		v := common.GetViper()
@@ -216,7 +216,7 @@ var devFindImagesCmd = &cobra.Command{
 		pkgClient := packager.NewOrDie(&pkgConfig)
 		defer pkgClient.ClearTempPaths()
 
-		if _, err := pkgClient.FindImages(); err != nil {
+		if _, err := pkgClient.FindImages(cmd.Context()); err != nil {
 			message.Fatalf(err, lang.CmdDevFindImagesErr, err.Error())
 		}
 	},
@@ -249,12 +249,12 @@ var devLintCmd = &cobra.Command{
 	Aliases: []string{"l"},
 	Short:   lang.CmdDevLintShort,
 	Long:    lang.CmdDevLintLong,
-	Run: func(_ *cobra.Command, args []string) {
+	Run: func(cmd *cobra.Command, args []string) {
 		pkgConfig.CreateOpts.BaseDir = common.SetBaseDirectory(args)
 		v := common.GetViper()
 		pkgConfig.CreateOpts.SetVariables = helpers.TransformAndMergeMap(
 			v.GetStringMapString(common.VPkgCreateSet), pkgConfig.CreateOpts.SetVariables, strings.ToUpper)
-		validator, err := lint.Validate(pkgConfig.CreateOpts)
+		validator, err := lint.Validate(cmd.Context(), pkgConfig.CreateOpts)
 		if err != nil {
 			message.Fatal(err, err.Error())
 		}
diff --git a/src/cmd/initialize.go b/src/cmd/initialize.go
index 7673be27c4..75a8a049e0 100644
--- a/src/cmd/initialize.go
+++ b/src/cmd/initialize.go
@@ -5,6 +5,7 @@
 package cmd
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"os"
@@ -49,7 +50,7 @@ var initCmd = &cobra.Command{
 
 		// Try to use an init-package in the executable directory if none exist in current working directory
 		var err error
-		if pkgConfig.PkgOpts.PackageSource, err = findInitPackage(initPackageName); err != nil {
+		if pkgConfig.PkgOpts.PackageSource, err = findInitPackage(cmd.Context(), initPackageName); err != nil {
 			message.Fatal(err, err.Error())
 		}
 
@@ -74,7 +75,7 @@ var initCmd = &cobra.Command{
 	},
 }
 
-func findInitPackage(initPackageName string) (string, error) {
+func findInitPackage(ctx context.Context, initPackageName string) (string, error) {
 	// First, look for the init package in the current working directory
 	if !helpers.InvalidPath(initPackageName) {
 		return initPackageName, nil
@@ -103,7 +104,7 @@ func findInitPackage(initPackageName string) (string, error) {
 	}
 
 	// Finally, if the init-package doesn't exist in the cache directory, suggest downloading it
-	downloadCacheTarget, err := downloadInitPackage(config.GetAbsCachePath())
+	downloadCacheTarget, err := downloadInitPackage(ctx, config.GetAbsCachePath())
 	if err != nil {
 		if errors.Is(err, lang.ErrInitNotFound) {
 			message.Fatal(err, err.Error())
@@ -114,7 +115,7 @@ func findInitPackage(initPackageName string) (string, error) {
 	return downloadCacheTarget, nil
 }
 
-func downloadInitPackage(cacheDirectory string) (string, error) {
+func downloadInitPackage(ctx context.Context, cacheDirectory string) (string, error) {
 	if config.CommonOptions.Confirm {
 		return "", lang.ErrInitNotFound
 	}
@@ -144,7 +145,7 @@ func downloadInitPackage(cacheDirectory string) (string, error) {
 			return "", err
 		}
 		source := &sources.OCISource{Remote: remote}
-		return source.Collect(cacheDirectory)
+		return source.Collect(ctx, cacheDirectory)
 	}
 	// Otherwise, exit and tell the user to manually download the init-package
 	return "", errors.New(lang.CmdInitPullErrManual)
diff --git a/src/cmd/package.go b/src/cmd/package.go
index c6ac07e698..b94fccee23 100644
--- a/src/cmd/package.go
+++ b/src/cmd/package.go
@@ -39,7 +39,7 @@ var packageCreateCmd = &cobra.Command{
 	Args:    cobra.MaximumNArgs(1),
 	Short:   lang.CmdPackageCreateShort,
 	Long:    lang.CmdPackageCreateLong,
-	Run: func(_ *cobra.Command, args []string) {
+	Run: func(cmd *cobra.Command, args []string) {
 		pkgConfig.CreateOpts.BaseDir = common.SetBaseDirectory(args)
 
 		var isCleanPathRegex = regexp.MustCompile(`^[a-zA-Z0-9\_\-\/\.\~\\:]+$`)
@@ -55,7 +55,7 @@ var packageCreateCmd = &cobra.Command{
 		pkgClient := packager.NewOrDie(&pkgConfig)
 		defer pkgClient.ClearTempPaths()
 
-		if err := pkgClient.Create(); err != nil {
+		if err := pkgClient.Create(cmd.Context()); err != nil {
 			message.Fatalf(err, lang.CmdPackageCreateErr, err.Error())
 		}
 	},
@@ -112,7 +112,7 @@ var packageInspectCmd = &cobra.Command{
 	Short:   lang.CmdPackageInspectShort,
 	Long:    lang.CmdPackageInspectLong,
 	Args:    cobra.MaximumNArgs(1),
-	Run: func(_ *cobra.Command, args []string) {
+	Run: func(cmd *cobra.Command, args []string) {
 		pkgConfig.PkgOpts.PackageSource = choosePackage(args)
 
 		src := identifyAndFallbackToClusterSource()
@@ -120,7 +120,7 @@ var packageInspectCmd = &cobra.Command{
 		pkgClient := packager.NewOrDie(&pkgConfig, packager.WithSource(src))
 		defer pkgClient.ClearTempPaths()
 
-		if err := pkgClient.Inspect(); err != nil {
+		if err := pkgClient.Inspect(cmd.Context()); err != nil {
 			message.Fatalf(err, lang.CmdPackageInspectErr, err.Error())
 		}
 	},
@@ -190,7 +190,7 @@ var packagePublishCmd = &cobra.Command{
 	Short:   lang.CmdPackagePublishShort,
 	Example: lang.CmdPackagePublishExample,
 	Args:    cobra.ExactArgs(2),
-	Run: func(_ *cobra.Command, args []string) {
+	Run: func(cmd *cobra.Command, args []string) {
 		pkgConfig.PkgOpts.PackageSource = args[0]
 
 		if !helpers.IsOCIURL(args[1]) {
@@ -216,7 +216,7 @@ var packagePublishCmd = &cobra.Command{
 		pkgClient := packager.NewOrDie(&pkgConfig)
 		defer pkgClient.ClearTempPaths()
 
-		if err := pkgClient.Publish(); err != nil {
+		if err := pkgClient.Publish(cmd.Context()); err != nil {
 			message.Fatalf(err, lang.CmdPackagePublishErr, err.Error())
 		}
 	},
@@ -227,13 +227,13 @@ var packagePullCmd = &cobra.Command{
 	Short:   lang.CmdPackagePullShort,
 	Example: lang.CmdPackagePullExample,
 	Args:    cobra.ExactArgs(1),
-	Run: func(_ *cobra.Command, args []string) {
+	Run: func(cmd *cobra.Command, args []string) {
 		pkgConfig.PkgOpts.PackageSource = args[0]
 
 		pkgClient := packager.NewOrDie(&pkgConfig)
 		defer pkgClient.ClearTempPaths()
 
-		if err := pkgClient.Pull(); err != nil {
+		if err := pkgClient.Pull(cmd.Context()); err != nil {
 			message.Fatalf(err, lang.CmdPackagePullErr, err.Error())
 		}
 	},
diff --git a/src/cmd/tools/zarf.go b/src/cmd/tools/zarf.go
index 243bc74027..843fcb9ae3 100644
--- a/src/cmd/tools/zarf.go
+++ b/src/cmd/tools/zarf.go
@@ -186,7 +186,7 @@ var clearCacheCmd = &cobra.Command{
 var downloadInitCmd = &cobra.Command{
 	Use:   "download-init",
 	Short: lang.CmdToolsDownloadInitShort,
-	Run: func(_ *cobra.Command, _ []string) {
+	Run: func(cmd *cobra.Command, _ []string) {
 		url := zoci.GetInitPackageURL(config.CLIVersion)
 
 		remote, err := zoci.NewRemote(url, oci.PlatformForArch(config.GetArch()))
@@ -196,7 +196,7 @@ var downloadInitCmd = &cobra.Command{
 
 		source := &sources.OCISource{Remote: remote}
 
-		_, err = source.Collect(outputDirectory)
+		_, err = source.Collect(cmd.Context(), outputDirectory)
 		if err != nil {
 			message.Fatalf(err, lang.CmdToolsDownloadInitErr, err.Error())
 		}
diff --git a/src/pkg/packager/composer/list.go b/src/pkg/packager/composer/list.go
index 5c2d378d14..69aa5fdb8e 100644
--- a/src/pkg/packager/composer/list.go
+++ b/src/pkg/packager/composer/list.go
@@ -120,7 +120,7 @@ func (ic *ImportChain) append(c types.ZarfComponent, index int, originalPackageN
 
 // NewImportChain creates a new import chain from a component
 // Returning the chain on error so we can have additional information to use during lint
-func NewImportChain(head types.ZarfComponent, index int, originalPackageName, arch, flavor string) (*ImportChain, error) {
+func NewImportChain(ctx context.Context, head types.ZarfComponent, index int, originalPackageName, arch, flavor string) (*ImportChain, error) {
 	ic := &ImportChain{}
 	if arch == "" {
 		return ic, fmt.Errorf("cannot build import chain: architecture must be provided")
@@ -179,11 +179,11 @@ func NewImportChain(head types.ZarfComponent, index int, originalPackageName, ar
 			}
 		} else if isRemote {
 			importURL = node.Import.URL
-			remote, err := ic.getRemote(node.Import.URL)
+			remote, err := ic.getRemote(ctx, node.Import.URL)
 			if err != nil {
 				return ic, err
 			}
-			pkg, err = remote.FetchZarfYAML(context.TODO())
+			pkg, err = remote.FetchZarfYAML(ctx)
 			if err != nil {
 				return ic, err
 			}
@@ -274,7 +274,7 @@ func (ic *ImportChain) Migrate(build types.ZarfBuildData) (warnings []string) {
 
 // Compose merges the import chain into a single component
 // fixing paths, overriding metadata, etc
-func (ic *ImportChain) Compose() (composed *types.ZarfComponent, err error) {
+func (ic *ImportChain) Compose(ctx context.Context) (composed *types.ZarfComponent, err error) {
 	composed = &ic.tail.ZarfComponent
 
 	if ic.tail.prev == nil {
@@ -282,7 +282,7 @@ func (ic *ImportChain) Compose() (composed *types.ZarfComponent, err error) {
 		return composed, nil
 	}
 
-	if err := ic.fetchOCISkeleton(); err != nil {
+	if err := ic.fetchOCISkeleton(ctx); err != nil {
 		return nil, err
 	}
 
diff --git a/src/pkg/packager/composer/list_test.go b/src/pkg/packager/composer/list_test.go
index 622647357c..0f96e0beb0 100644
--- a/src/pkg/packager/composer/list_test.go
+++ b/src/pkg/packager/composer/list_test.go
@@ -5,6 +5,7 @@
 package composer
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -48,7 +49,7 @@ func TestNewImportChain(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			_, err := NewImportChain(tt.head, 0, testPackageName, tt.arch, tt.flavor)
+			_, err := NewImportChain(context.Background(), tt.head, 0, testPackageName, tt.arch, tt.flavor)
 			require.ErrorContains(t, err, tt.expectedErr)
 		})
 	}
@@ -239,7 +240,7 @@ func TestCompose(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			composed, err := tt.ic.Compose()
+			composed, err := tt.ic.Compose(context.Background())
 			require.NoError(t, err)
 			require.EqualValues(t, &tt.expectedComposed, composed)
 		})
diff --git a/src/pkg/packager/composer/oci.go b/src/pkg/packager/composer/oci.go
index baa4d0fc81..f4f02fbaf3 100644
--- a/src/pkg/packager/composer/oci.go
+++ b/src/pkg/packager/composer/oci.go
@@ -23,7 +23,7 @@ import (
 	ocistore "oras.land/oras-go/v2/content/oci"
 )
 
-func (ic *ImportChain) getRemote(url string) (*zoci.Remote, error) {
+func (ic *ImportChain) getRemote(ctx context.Context, url string) (*zoci.Remote, error) {
 	if ic.remote != nil {
 		return ic.remote, nil
 	}
@@ -32,7 +32,7 @@ func (ic *ImportChain) getRemote(url string) (*zoci.Remote, error) {
 	if err != nil {
 		return nil, err
 	}
-	_, err = ic.remote.ResolveRoot(context.TODO())
+	_, err = ic.remote.ResolveRoot(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("published skeleton package for %q does not exist: %w", url, err)
 	}
@@ -45,17 +45,16 @@ func (ic *ImportChain) ContainsOCIImport() bool {
 	return ic.tail.prev != nil && ic.tail.prev.Import.URL != ""
 }
 
-func (ic *ImportChain) fetchOCISkeleton() error {
+func (ic *ImportChain) fetchOCISkeleton(ctx context.Context) error {
 	if !ic.ContainsOCIImport() {
 		return nil
 	}
 	node := ic.tail.prev
-	remote, err := ic.getRemote(node.Import.URL)
+	remote, err := ic.getRemote(ctx, node.Import.URL)
 	if err != nil {
 		return err
 	}
 
-	ctx := context.TODO()
 	manifest, err := remote.FetchRoot(ctx)
 	if err != nil {
 		return err
@@ -91,7 +90,6 @@ func (ic *ImportChain) fetchOCISkeleton() error {
 			return err
 		}
 
-		ctx := context.TODO()
 		// ensure the tarball is in the cache
 		exists, err := store.Exists(ctx, componentDesc)
 		if err != nil {
diff --git a/src/pkg/packager/create.go b/src/pkg/packager/create.go
index 7613c2f6f4..ab46bdaa30 100755
--- a/src/pkg/packager/create.go
+++ b/src/pkg/packager/create.go
@@ -5,6 +5,7 @@
 package packager
 
 import (
+	"context"
 	"fmt"
 	"os"
 
@@ -16,7 +17,7 @@ import (
 )
 
 // Create generates a Zarf package tarball for a given PackageConfig and optional base directory.
-func (p *Packager) Create() (err error) {
+func (p *Packager) Create(ctx context.Context) (err error) {
 	cwd, err := os.Getwd()
 	if err != nil {
 		return err
@@ -34,7 +35,7 @@ func (p *Packager) Create() (err error) {
 		return err
 	}
 
-	p.cfg.Pkg, p.warnings, err = pc.LoadPackageDefinition(p.layout)
+	p.cfg.Pkg, p.warnings, err = pc.LoadPackageDefinition(ctx, p.layout)
 	if err != nil {
 		return err
 	}
@@ -43,7 +44,7 @@ func (p *Packager) Create() (err error) {
 		return fmt.Errorf("package creation canceled")
 	}
 
-	if err := pc.Assemble(p.layout, p.cfg.Pkg.Components, p.cfg.Pkg.Metadata.Architecture); err != nil {
+	if err := pc.Assemble(ctx, p.layout, p.cfg.Pkg.Components, p.cfg.Pkg.Metadata.Architecture); err != nil {
 		return err
 	}
 
@@ -52,5 +53,5 @@ func (p *Packager) Create() (err error) {
 		return err
 	}
 
-	return pc.Output(p.layout, &p.cfg.Pkg)
+	return pc.Output(ctx, p.layout, &p.cfg.Pkg)
 }
diff --git a/src/pkg/packager/creator/compose.go b/src/pkg/packager/creator/compose.go
index dd2e429731..6cd5277388 100644
--- a/src/pkg/packager/creator/compose.go
+++ b/src/pkg/packager/creator/compose.go
@@ -5,13 +5,15 @@
 package creator
 
 import (
+	"context"
+
 	"github.com/defenseunicorns/zarf/src/pkg/message"
 	"github.com/defenseunicorns/zarf/src/pkg/packager/composer"
 	"github.com/defenseunicorns/zarf/src/types"
 )
 
 // ComposeComponents composes components and their dependencies into a single Zarf package using an import chain.
-func ComposeComponents(pkg types.ZarfPackage, flavor string) (types.ZarfPackage, []string, error) {
+func ComposeComponents(ctx context.Context, pkg types.ZarfPackage, flavor string) (types.ZarfPackage, []string, error) {
 	components := []types.ZarfComponent{}
 	warnings := []string{}
 
@@ -31,7 +33,7 @@ func ComposeComponents(pkg types.ZarfPackage, flavor string) (types.ZarfPackage,
 		component.Only.Flavor = ""
 
 		// build the import chain
-		chain, err := composer.NewImportChain(component, i, pkg.Metadata.Name, arch, flavor)
+		chain, err := composer.NewImportChain(ctx, component, i, pkg.Metadata.Name, arch, flavor)
 		if err != nil {
 			return types.ZarfPackage{}, nil, err
 		}
@@ -42,7 +44,7 @@ func ComposeComponents(pkg types.ZarfPackage, flavor string) (types.ZarfPackage,
 		warnings = append(warnings, warning...)
 
 		// get the composed component
-		composed, err := chain.Compose()
+		composed, err := chain.Compose(ctx)
 		if err != nil {
 			return types.ZarfPackage{}, nil, err
 		}
diff --git a/src/pkg/packager/creator/compose_test.go b/src/pkg/packager/creator/compose_test.go
index 7d1310bf3e..35e298f553 100644
--- a/src/pkg/packager/creator/compose_test.go
+++ b/src/pkg/packager/creator/compose_test.go
@@ -5,6 +5,7 @@
 package creator
 
 import (
+	"context"
 	"testing"
 
 	"github.com/defenseunicorns/zarf/src/types"
@@ -160,7 +161,7 @@ func TestComposeComponents(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			pkg, _, err := ComposeComponents(tt.pkg, tt.flavor)
+			pkg, _, err := ComposeComponents(context.Background(), tt.pkg, tt.flavor)
 
 			if tt.expectedErr == "" {
 				require.NoError(t, err)
diff --git a/src/pkg/packager/creator/creator.go b/src/pkg/packager/creator/creator.go
index 5e34fd46c1..aae86172c6 100644
--- a/src/pkg/packager/creator/creator.go
+++ b/src/pkg/packager/creator/creator.go
@@ -5,13 +5,15 @@
 package creator
 
 import (
+	"context"
+
 	"github.com/defenseunicorns/zarf/src/pkg/layout"
 	"github.com/defenseunicorns/zarf/src/types"
 )
 
 // Creator is an interface for creating Zarf packages.
 type Creator interface {
-	LoadPackageDefinition(src *layout.PackagePaths) (pkg types.ZarfPackage, warnings []string, err error)
-	Assemble(dst *layout.PackagePaths, components []types.ZarfComponent, arch string) error
-	Output(dst *layout.PackagePaths, pkg *types.ZarfPackage) error
+	LoadPackageDefinition(ctx context.Context, src *layout.PackagePaths) (pkg types.ZarfPackage, warnings []string, err error)
+	Assemble(ctx context.Context, dst *layout.PackagePaths, components []types.ZarfComponent, arch string) error
+	Output(ctx context.Context, dst *layout.PackagePaths, pkg *types.ZarfPackage) error
 }
diff --git a/src/pkg/packager/creator/differential.go b/src/pkg/packager/creator/differential.go
index ee373836d0..d2c3c80480 100644
--- a/src/pkg/packager/creator/differential.go
+++ b/src/pkg/packager/creator/differential.go
@@ -5,6 +5,7 @@
 package creator
 
 import (
+	"context"
 	"os"
 
 	"github.com/defenseunicorns/zarf/src/config"
@@ -15,7 +16,7 @@ import (
 )
 
 // loadDifferentialData sets any images and repos from the existing reference package in the DifferentialData and returns it.
-func loadDifferentialData(diffPkgPath string) (diffData *types.DifferentialData, err error) {
+func loadDifferentialData(ctx context.Context, diffPkgPath string) (diffData *types.DifferentialData, err error) {
 	tmpdir, err := utils.MakeTempDir(config.CommonOptions.TempDirectory)
 	if err != nil {
 		return nil, err
@@ -31,7 +32,7 @@ func loadDifferentialData(diffPkgPath string) (diffData *types.DifferentialData,
 		return nil, err
 	}
 
-	diffPkg, _, err := src.LoadPackageMetadata(diffLayout, false, false)
+	diffPkg, _, err := src.LoadPackageMetadata(ctx, diffLayout, false, false)
 	if err != nil {
 		return nil, err
 	}
diff --git a/src/pkg/packager/creator/normal.go b/src/pkg/packager/creator/normal.go
index 96f219e584..8af841f060 100644
--- a/src/pkg/packager/creator/normal.go
+++ b/src/pkg/packager/creator/normal.go
@@ -61,7 +61,7 @@ func NewPackageCreator(createOpts types.ZarfCreateOptions, cwd string) *PackageC
 }
 
 // LoadPackageDefinition loads and configures a zarf.yaml file during package create.
-func (pc *PackageCreator) LoadPackageDefinition(src *layout.PackagePaths) (pkg types.ZarfPackage, warnings []string, err error) {
+func (pc *PackageCreator) LoadPackageDefinition(ctx context.Context, src *layout.PackagePaths) (pkg types.ZarfPackage, warnings []string, err error) {
 	pkg, warnings, err = src.ReadZarfYAML()
 	if err != nil {
 		return types.ZarfPackage{}, nil, err
@@ -70,7 +70,7 @@ func (pc *PackageCreator) LoadPackageDefinition(src *layout.PackagePaths) (pkg t
 	pkg.Metadata.Architecture = config.GetArch(pkg.Metadata.Architecture)
 
 	// Compose components into a single zarf.yaml file
-	pkg, composeWarnings, err := ComposeComponents(pkg, pc.createOpts.Flavor)
+	pkg, composeWarnings, err := ComposeComponents(ctx, pkg, pc.createOpts.Flavor)
 	if err != nil {
 		return types.ZarfPackage{}, nil, err
 	}
@@ -95,7 +95,7 @@ func (pc *PackageCreator) LoadPackageDefinition(src *layout.PackagePaths) (pkg t
 	if pc.createOpts.DifferentialPackagePath != "" {
 		pkg.Build.Differential = true
 
-		diffData, err := loadDifferentialData(pc.createOpts.DifferentialPackagePath)
+		diffData, err := loadDifferentialData(ctx, pc.createOpts.DifferentialPackagePath)
 		if err != nil {
 			return types.ZarfPackage{}, nil, err
 		}
@@ -127,7 +127,7 @@ func (pc *PackageCreator) LoadPackageDefinition(src *layout.PackagePaths) (pkg t
 }
 
 // Assemble assembles all of the package assets into Zarf's tmp directory layout.
-func (pc *PackageCreator) Assemble(dst *layout.PackagePaths, components []types.ZarfComponent, arch string) error {
+func (pc *PackageCreator) Assemble(ctx context.Context, dst *layout.PackagePaths, components []types.ZarfComponent, arch string) error {
 	var imageList []transform.Image
 
 	skipSBOMFlagUsed := pc.createOpts.SkipSBOM
@@ -184,8 +184,6 @@ func (pc *PackageCreator) Assemble(dst *layout.PackagePaths, components []types.
 
 		dst.AddImages()
 
-		ctx := context.TODO()
-
 		pullCfg := images.PullConfig{
 			DestinationDirectory: dst.Images.Base,
 			ImageList:            imageList,
@@ -238,7 +236,7 @@ func (pc *PackageCreator) Assemble(dst *layout.PackagePaths, components []types.
 //
 // - writes the Zarf package as a tarball to a local directory,
 // or an OCI registry based on the --output flag
-func (pc *PackageCreator) Output(dst *layout.PackagePaths, pkg *types.ZarfPackage) (err error) {
+func (pc *PackageCreator) Output(ctx context.Context, dst *layout.PackagePaths, pkg *types.ZarfPackage) (err error) {
 	// Process the component directories into compressed tarballs
 	// NOTE: This is purposefully being done after the SBOM cataloging
 	for _, component := range pkg.Components {
@@ -278,8 +276,6 @@ func (pc *PackageCreator) Output(dst *layout.PackagePaths, pkg *types.ZarfPackag
 		if err != nil {
 			return err
 		}
-
-		ctx := context.TODO()
 		err = remote.PublishPackage(ctx, pkg, dst, config.CommonOptions.OCIConcurrency)
 		if err != nil {
 			return fmt.Errorf("unable to publish package: %w", err)
diff --git a/src/pkg/packager/creator/normal_test.go b/src/pkg/packager/creator/normal_test.go
index 95998ba1ca..32b1a2ce4b 100644
--- a/src/pkg/packager/creator/normal_test.go
+++ b/src/pkg/packager/creator/normal_test.go
@@ -5,6 +5,7 @@
 package creator
 
 import (
+	"context"
 	"path/filepath"
 	"testing"
 
@@ -86,7 +87,7 @@ func TestLoadPackageDefinition(t *testing.T) {
 
 			src := layout.New(filepath.Join("testdata", tt.testDir))
 			pc := NewPackageCreator(types.ZarfCreateOptions{}, "")
-			pkg, _, err := pc.LoadPackageDefinition(src)
+			pkg, _, err := pc.LoadPackageDefinition(context.Background(), src)
 
 			if tt.expectedErr == "" {
 				require.NoError(t, err)
diff --git a/src/pkg/packager/creator/skeleton.go b/src/pkg/packager/creator/skeleton.go
index 43866f8484..e0e86126b4 100644
--- a/src/pkg/packager/creator/skeleton.go
+++ b/src/pkg/packager/creator/skeleton.go
@@ -5,6 +5,7 @@
 package creator
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -42,7 +43,7 @@ func NewSkeletonCreator(createOpts types.ZarfCreateOptions, publishOpts types.Za
 }
 
 // LoadPackageDefinition loads and configure a zarf.yaml file when creating and publishing a skeleton package.
-func (sc *SkeletonCreator) LoadPackageDefinition(src *layout.PackagePaths) (pkg types.ZarfPackage, warnings []string, err error) {
+func (sc *SkeletonCreator) LoadPackageDefinition(ctx context.Context, src *layout.PackagePaths) (pkg types.ZarfPackage, warnings []string, err error) {
 	pkg, warnings, err = src.ReadZarfYAML()
 	if err != nil {
 		return types.ZarfPackage{}, nil, err
@@ -51,7 +52,7 @@ func (sc *SkeletonCreator) LoadPackageDefinition(src *layout.PackagePaths) (pkg
 	pkg.Metadata.Architecture = config.GetArch()
 
 	// Compose components into a single zarf.yaml file
-	pkg, composeWarnings, err := ComposeComponents(pkg, sc.createOpts.Flavor)
+	pkg, composeWarnings, err := ComposeComponents(ctx, pkg, sc.createOpts.Flavor)
 	if err != nil {
 		return types.ZarfPackage{}, nil, err
 	}
@@ -79,7 +80,7 @@ func (sc *SkeletonCreator) LoadPackageDefinition(src *layout.PackagePaths) (pkg
 // Assemble updates all components of the loaded Zarf package with necessary modifications for package assembly.
 //
 // It processes each component to ensure correct structure and resource locations.
-func (sc *SkeletonCreator) Assemble(dst *layout.PackagePaths, components []types.ZarfComponent, _ string) error {
+func (sc *SkeletonCreator) Assemble(_ context.Context, dst *layout.PackagePaths, components []types.ZarfComponent, _ string) error {
 	for _, component := range components {
 		c, err := sc.addComponent(component, dst)
 		if err != nil {
@@ -100,7 +101,7 @@ func (sc *SkeletonCreator) Assemble(dst *layout.PackagePaths, components []types
 // - writes the loaded zarf.yaml to disk
 //
 // - signs the package
-func (sc *SkeletonCreator) Output(dst *layout.PackagePaths, pkg *types.ZarfPackage) (err error) {
+func (sc *SkeletonCreator) Output(_ context.Context, dst *layout.PackagePaths, pkg *types.ZarfPackage) (err error) {
 	for _, component := range pkg.Components {
 		if err := dst.Components.Archive(component, false); err != nil {
 			return err
diff --git a/src/pkg/packager/creator/skeleton_test.go b/src/pkg/packager/creator/skeleton_test.go
index 1fed6f985d..ca2e9cd352 100644
--- a/src/pkg/packager/creator/skeleton_test.go
+++ b/src/pkg/packager/creator/skeleton_test.go
@@ -5,6 +5,7 @@
 package creator
 
 import (
+	"context"
 	"path/filepath"
 	"testing"
 
@@ -40,7 +41,7 @@ func TestSkeletonLoadPackageDefinition(t *testing.T) {
 
 			src := layout.New(filepath.Join("testdata", tt.testDir))
 			sc := NewSkeletonCreator(types.ZarfCreateOptions{}, types.ZarfPublishOptions{})
-			pkg, _, err := sc.LoadPackageDefinition(src)
+			pkg, _, err := sc.LoadPackageDefinition(context.Background(), src)
 
 			if tt.expectedErr == "" {
 				require.NoError(t, err)
diff --git a/src/pkg/packager/deploy.go b/src/pkg/packager/deploy.go
index b6e26e7693..39fb2eaa88 100644
--- a/src/pkg/packager/deploy.go
+++ b/src/pkg/packager/deploy.go
@@ -60,12 +60,12 @@ func (p *Packager) Deploy(ctx context.Context) (err error) {
 	if isInteractive {
 		filter := filters.Empty()
 
-		p.cfg.Pkg, p.warnings, err = p.source.LoadPackage(p.layout, filter, true)
+		p.cfg.Pkg, p.warnings, err = p.source.LoadPackage(ctx, p.layout, filter, true)
 		if err != nil {
 			return fmt.Errorf("unable to load the package: %w", err)
 		}
 	} else {
-		p.cfg.Pkg, p.warnings, err = p.source.LoadPackage(p.layout, deployFilter, true)
+		p.cfg.Pkg, p.warnings, err = p.source.LoadPackage(ctx, p.layout, deployFilter, true)
 		if err != nil {
 			return fmt.Errorf("unable to load the package: %w", err)
 		}
diff --git a/src/pkg/packager/dev.go b/src/pkg/packager/dev.go
index a18d1dec0f..4bb07fcb0c 100644
--- a/src/pkg/packager/dev.go
+++ b/src/pkg/packager/dev.go
@@ -39,7 +39,7 @@ func (p *Packager) DevDeploy(ctx context.Context) error {
 		return err
 	}
 
-	p.cfg.Pkg, p.warnings, err = pc.LoadPackageDefinition(p.layout)
+	p.cfg.Pkg, p.warnings, err = pc.LoadPackageDefinition(ctx, p.layout)
 	if err != nil {
 		return err
 	}
@@ -69,7 +69,7 @@ func (p *Packager) DevDeploy(ctx context.Context) error {
 		}
 	}
 
-	if err := pc.Assemble(p.layout, p.cfg.Pkg.Components, p.cfg.Pkg.Metadata.Architecture); err != nil {
+	if err := pc.Assemble(ctx, p.layout, p.cfg.Pkg.Components, p.cfg.Pkg.Metadata.Architecture); err != nil {
 		return err
 	}
 
diff --git a/src/pkg/packager/inspect.go b/src/pkg/packager/inspect.go
index 5500be26da..d7e4be3e18 100644
--- a/src/pkg/packager/inspect.go
+++ b/src/pkg/packager/inspect.go
@@ -5,6 +5,7 @@
 package packager
 
 import (
+	"context"
 	"fmt"
 	"os"
 
@@ -14,10 +15,10 @@ import (
 )
 
 // Inspect list the contents of a package.
-func (p *Packager) Inspect() (err error) {
+func (p *Packager) Inspect(ctx context.Context) (err error) {
 	wantSBOM := p.cfg.InspectOpts.ViewSBOM || p.cfg.InspectOpts.SBOMOutputDir != ""
 
-	p.cfg.Pkg, p.warnings, err = p.source.LoadPackageMetadata(p.layout, wantSBOM, true)
+	p.cfg.Pkg, p.warnings, err = p.source.LoadPackageMetadata(ctx, p.layout, wantSBOM, true)
 	if err != nil {
 		return err
 	}
diff --git a/src/pkg/packager/lint/lint.go b/src/pkg/packager/lint/lint.go
index 1a58ef857f..b835e0ad58 100644
--- a/src/pkg/packager/lint/lint.go
+++ b/src/pkg/packager/lint/lint.go
@@ -5,6 +5,7 @@
 package lint
 
 import (
+	"context"
 	"embed"
 	"fmt"
 	"os"
@@ -33,7 +34,7 @@ func getSchemaFile() ([]byte, error) {
 
 // Validate validates a zarf file against the zarf schema, returns *validator with warnings or errors if they exist
 // along with an error if the validation itself failed
-func Validate(createOpts types.ZarfCreateOptions) (*Validator, error) {
+func Validate(ctx context.Context, createOpts types.ZarfCreateOptions) (*Validator, error) {
 	validator := Validator{}
 	var err error
 
@@ -51,7 +52,7 @@ func Validate(createOpts types.ZarfCreateOptions) (*Validator, error) {
 
 	validator.baseDir = createOpts.BaseDir
 
-	lintComponents(&validator, &createOpts)
+	lintComponents(ctx, &validator, &createOpts)
 
 	if validator.jsonSchema, err = getSchemaFile(); err != nil {
 		return nil, err
@@ -64,7 +65,7 @@ func Validate(createOpts types.ZarfCreateOptions) (*Validator, error) {
 	return &validator, nil
 }
 
-func lintComponents(validator *Validator, createOpts *types.ZarfCreateOptions) {
+func lintComponents(ctx context.Context, validator *Validator, createOpts *types.ZarfCreateOptions) {
 	for i, component := range validator.typedZarfPackage.Components {
 		arch := config.GetArch(validator.typedZarfPackage.Metadata.Architecture)
 
@@ -72,7 +73,7 @@ func lintComponents(validator *Validator, createOpts *types.ZarfCreateOptions) {
 			continue
 		}
 
-		chain, err := composer.NewImportChain(component, i, validator.typedZarfPackage.Metadata.Name, arch, createOpts.Flavor)
+		chain, err := composer.NewImportChain(ctx, component, i, validator.typedZarfPackage.Metadata.Name, arch, createOpts.Flavor)
 		baseComponent := chain.Head()
 
 		var badImportYqPath string
diff --git a/src/pkg/packager/lint/lint_test.go b/src/pkg/packager/lint/lint_test.go
index eba52b7743..b259fd89ed 100644
--- a/src/pkg/packager/lint/lint_test.go
+++ b/src/pkg/packager/lint/lint_test.go
@@ -5,6 +5,7 @@
 package lint
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"os"
@@ -182,7 +183,7 @@ func TestValidateSchema(t *testing.T) {
 				Metadata: types.ZarfMetadata{Name: "test-zarf-package"}}}
 
 		createOpts := types.ZarfCreateOptions{Flavor: "", BaseDir: "."}
-		lintComponents(&validator, &createOpts)
+		lintComponents(context.Background(), &validator, &createOpts)
 		// Require.contains rather than equals since the error message changes from linux to windows
 		require.Contains(t, validator.findings[0].description, fmt.Sprintf("open %s", filepath.Join("fake-path", "zarf.yaml")))
 		require.Equal(t, ".components.[0].import.path", validator.findings[0].yqPath)
diff --git a/src/pkg/packager/mirror.go b/src/pkg/packager/mirror.go
index 658967560d..f19536443c 100644
--- a/src/pkg/packager/mirror.go
+++ b/src/pkg/packager/mirror.go
@@ -23,7 +23,7 @@ func (p *Packager) Mirror(ctx context.Context) (err error) {
 		filters.BySelectState(p.cfg.PkgOpts.OptionalComponents),
 	)
 
-	p.cfg.Pkg, p.warnings, err = p.source.LoadPackage(p.layout, filter, true)
+	p.cfg.Pkg, p.warnings, err = p.source.LoadPackage(ctx, p.layout, filter, true)
 	if err != nil {
 		return fmt.Errorf("unable to load the package: %w", err)
 	}
diff --git a/src/pkg/packager/prepare.go b/src/pkg/packager/prepare.go
index 276cdcc4db..4bd9c88e54 100644
--- a/src/pkg/packager/prepare.go
+++ b/src/pkg/packager/prepare.go
@@ -5,6 +5,7 @@
 package packager
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -37,7 +38,7 @@ import (
 type imageMap map[string]bool
 
 // FindImages iterates over a Zarf.yaml and attempts to parse any images.
-func (p *Packager) FindImages() (imgMap map[string][]string, err error) {
+func (p *Packager) FindImages(ctx context.Context) (imgMap map[string][]string, err error) {
 	cwd, err := os.Getwd()
 	if err != nil {
 		return nil, err
@@ -59,7 +60,7 @@ func (p *Packager) FindImages() (imgMap map[string][]string, err error) {
 		return nil, err
 	}
 
-	p.cfg.Pkg, p.warnings, err = c.LoadPackageDefinition(p.layout)
+	p.cfg.Pkg, p.warnings, err = c.LoadPackageDefinition(ctx, p.layout)
 	if err != nil {
 		return nil, err
 	}
diff --git a/src/pkg/packager/publish.go b/src/pkg/packager/publish.go
index c06ecafb34..e889ea89b6 100644
--- a/src/pkg/packager/publish.go
+++ b/src/pkg/packager/publish.go
@@ -25,10 +25,9 @@ import (
 )
 
 // Publish publishes the package to a registry
-func (p *Packager) Publish() (err error) {
+func (p *Packager) Publish(ctx context.Context) (err error) {
 	_, isOCISource := p.source.(*sources.OCISource)
 	if isOCISource && p.cfg.PublishOpts.SigningKeyPath == "" {
-		ctx := context.TODO()
 		// oci --> oci is a special case, where we will use oci.CopyPackage so that we can transfer the package
 		// w/o layers touching the filesystem
 		srcRemote := p.source.(*sources.OCISource).Remote
@@ -59,21 +58,21 @@ func (p *Packager) Publish() (err error) {
 			return err
 		}
 
-		p.cfg.Pkg, p.warnings, err = sc.LoadPackageDefinition(p.layout)
+		p.cfg.Pkg, p.warnings, err = sc.LoadPackageDefinition(ctx, p.layout)
 		if err != nil {
 			return err
 		}
 
-		if err := sc.Assemble(p.layout, p.cfg.Pkg.Components, ""); err != nil {
+		if err := sc.Assemble(ctx, p.layout, p.cfg.Pkg.Components, ""); err != nil {
 			return err
 		}
 
-		if err := sc.Output(p.layout, &p.cfg.Pkg); err != nil {
+		if err := sc.Output(ctx, p.layout, &p.cfg.Pkg); err != nil {
 			return err
 		}
 	} else {
 		filter := filters.Empty()
-		p.cfg.Pkg, p.warnings, err = p.source.LoadPackage(p.layout, filter, false)
+		p.cfg.Pkg, p.warnings, err = p.source.LoadPackage(ctx, p.layout, filter, false)
 		if err != nil {
 			return fmt.Errorf("unable to load the package: %w", err)
 		}
@@ -103,7 +102,6 @@ func (p *Packager) Publish() (err error) {
 	message.HeaderInfof("📦 PACKAGE PUBLISH %s:%s", p.cfg.Pkg.Metadata.Name, ref)
 
 	// Publish the package/skeleton to the registry
-	ctx := context.TODO()
 	if err := remote.PublishPackage(ctx, &p.cfg.Pkg, p.layout, config.CommonOptions.OCIConcurrency); err != nil {
 		return err
 	}
diff --git a/src/pkg/packager/pull.go b/src/pkg/packager/pull.go
index 5d915dabb1..7c00d36c9c 100644
--- a/src/pkg/packager/pull.go
+++ b/src/pkg/packager/pull.go
@@ -5,16 +5,17 @@
 package packager
 
 import (
+	"context"
 	"fmt"
 )
 
 // Pull pulls a Zarf package and saves it as a compressed tarball.
-func (p *Packager) Pull() (err error) {
+func (p *Packager) Pull(ctx context.Context) (err error) {
 	if p.cfg.PkgOpts.OptionalComponents != "" {
 		return fmt.Errorf("pull does not support optional components")
 	}
 
-	_, err = p.source.Collect(p.cfg.PullOpts.OutputDirectory)
+	_, err = p.source.Collect(ctx, p.cfg.PullOpts.OutputDirectory)
 	if err != nil {
 		return err
 	}
diff --git a/src/pkg/packager/remove.go b/src/pkg/packager/remove.go
index 535e7dedc4..5169e53cbf 100644
--- a/src/pkg/packager/remove.go
+++ b/src/pkg/packager/remove.go
@@ -39,7 +39,7 @@ func (p *Packager) Remove(ctx context.Context) (err error) {
 
 	// we do not want to allow removal of signed packages without a signature if there are remove actions
 	// as this is arbitrary code execution from an untrusted source
-	p.cfg.Pkg, p.warnings, err = p.source.LoadPackageMetadata(p.layout, false, false)
+	p.cfg.Pkg, p.warnings, err = p.source.LoadPackageMetadata(ctx, p.layout, false, false)
 	if err != nil {
 		return err
 	}
diff --git a/src/pkg/packager/sources/cluster.go b/src/pkg/packager/sources/cluster.go
index ad14136afd..5936c5d6f0 100644
--- a/src/pkg/packager/sources/cluster.go
+++ b/src/pkg/packager/sources/cluster.go
@@ -46,21 +46,19 @@ type ClusterSource struct {
 // LoadPackage loads a package from a cluster.
 //
 // This is not implemented.
-func (s *ClusterSource) LoadPackage(_ *layout.PackagePaths, _ filters.ComponentFilterStrategy, _ bool) (types.ZarfPackage, []string, error) {
+func (s *ClusterSource) LoadPackage(_ context.Context, _ *layout.PackagePaths, _ filters.ComponentFilterStrategy, _ bool) (types.ZarfPackage, []string, error) {
 	return types.ZarfPackage{}, nil, fmt.Errorf("not implemented")
 }
 
 // Collect collects a package from a cluster.
 //
 // This is not implemented.
-func (s *ClusterSource) Collect(_ string) (string, error) {
+func (s *ClusterSource) Collect(_ context.Context, _ string) (string, error) {
 	return "", fmt.Errorf("not implemented")
 }
 
 // LoadPackageMetadata loads package metadata from a cluster.
-func (s *ClusterSource) LoadPackageMetadata(dst *layout.PackagePaths, _ bool, _ bool) (types.ZarfPackage, []string, error) {
-	ctx := context.Background()
-
+func (s *ClusterSource) LoadPackageMetadata(ctx context.Context, dst *layout.PackagePaths, _ bool, _ bool) (types.ZarfPackage, []string, error) {
 	dpkg, err := s.GetDeployedPackage(ctx, s.PackageSource)
 	if err != nil {
 		return types.ZarfPackage{}, nil, err
diff --git a/src/pkg/packager/sources/new.go b/src/pkg/packager/sources/new.go
index 192bd39f88..c9f1f46a14 100644
--- a/src/pkg/packager/sources/new.go
+++ b/src/pkg/packager/sources/new.go
@@ -5,6 +5,7 @@
 package sources
 
 import (
+	"context"
 	"fmt"
 	"net/url"
 	"strings"
@@ -30,13 +31,13 @@ import (
 //	`sources.ValidatePackageSignature` and `sources.ValidatePackageIntegrity` can be leveraged for this purpose.
 type PackageSource interface {
 	// LoadPackage loads a package from a source.
-	LoadPackage(dst *layout.PackagePaths, filter filters.ComponentFilterStrategy, unarchiveAll bool) (pkg types.ZarfPackage, warnings []string, err error)
+	LoadPackage(ctx context.Context, dst *layout.PackagePaths, filter filters.ComponentFilterStrategy, unarchiveAll bool) (pkg types.ZarfPackage, warnings []string, err error)
 
 	// LoadPackageMetadata loads a package's metadata from a source.
-	LoadPackageMetadata(dst *layout.PackagePaths, wantSBOM bool, skipValidation bool) (pkg types.ZarfPackage, warnings []string, err error)
+	LoadPackageMetadata(ctx context.Context, dst *layout.PackagePaths, wantSBOM bool, skipValidation bool) (pkg types.ZarfPackage, warnings []string, err error)
 
 	// Collect relocates a package from its source to a tarball in a given destination directory.
-	Collect(destinationDirectory string) (tarball string, err error)
+	Collect(ctx context.Context, destinationDirectory string) (tarball string, err error)
 }
 
 // Identify returns the type of package source based on the provided package source string.
diff --git a/src/pkg/packager/sources/new_test.go b/src/pkg/packager/sources/new_test.go
index ee770f51aa..bad95a9051 100644
--- a/src/pkg/packager/sources/new_test.go
+++ b/src/pkg/packager/sources/new_test.go
@@ -5,6 +5,7 @@
 package sources
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -160,7 +161,7 @@ func TestPackageSource(t *testing.T) {
 			require.NoError(t, err)
 			packageDir := t.TempDir()
 			pkgLayout := layout.New(packageDir)
-			pkg, warnings, err := ps.LoadPackage(pkgLayout, filters.Empty(), false)
+			pkg, warnings, err := ps.LoadPackage(context.Background(), pkgLayout, filters.Empty(), false)
 			require.NoError(t, err)
 			require.Empty(t, warnings)
 			require.Equal(t, expectedPkg, pkg)
@@ -169,7 +170,7 @@ func TestPackageSource(t *testing.T) {
 			require.NoError(t, err)
 			metadataDir := t.TempDir()
 			metadataLayout := layout.New(metadataDir)
-			metadata, warnings, err := ps.LoadPackageMetadata(metadataLayout, true, false)
+			metadata, warnings, err := ps.LoadPackageMetadata(context.Background(), metadataLayout, true, false)
 			require.NoError(t, err)
 			require.Empty(t, warnings)
 			require.Equal(t, expectedPkg, metadata)
@@ -177,7 +178,7 @@ func TestPackageSource(t *testing.T) {
 			ps, err = New(opts)
 			require.NoError(t, err)
 			collectDir := t.TempDir()
-			fp, err := ps.Collect(collectDir)
+			fp, err := ps.Collect(context.Background(), collectDir)
 			require.NoError(t, err)
 			require.Equal(t, filepath.Join(collectDir, filepath.Base(tt.src)), fp)
 		})
diff --git a/src/pkg/packager/sources/oci.go b/src/pkg/packager/sources/oci.go
index 83735a9503..84ba85ebaf 100644
--- a/src/pkg/packager/sources/oci.go
+++ b/src/pkg/packager/sources/oci.go
@@ -34,9 +34,7 @@ type OCISource struct {
 }
 
 // LoadPackage loads a package from an OCI registry.
-func (s *OCISource) LoadPackage(dst *layout.PackagePaths, filter filters.ComponentFilterStrategy, unarchiveAll bool) (pkg types.ZarfPackage, warnings []string, err error) {
-	ctx := context.TODO()
-
+func (s *OCISource) LoadPackage(ctx context.Context, dst *layout.PackagePaths, filter filters.ComponentFilterStrategy, unarchiveAll bool) (pkg types.ZarfPackage, warnings []string, err error) {
 	message.Debugf("Loading package from %q", s.PackageSource)
 
 	pkg, err = s.FetchZarfYAML(ctx)
@@ -112,12 +110,11 @@ func (s *OCISource) LoadPackage(dst *layout.PackagePaths, filter filters.Compone
 }
 
 // LoadPackageMetadata loads a package's metadata from an OCI registry.
-func (s *OCISource) LoadPackageMetadata(dst *layout.PackagePaths, wantSBOM bool, skipValidation bool) (pkg types.ZarfPackage, warnings []string, err error) {
+func (s *OCISource) LoadPackageMetadata(ctx context.Context, dst *layout.PackagePaths, wantSBOM bool, skipValidation bool) (pkg types.ZarfPackage, warnings []string, err error) {
 	toPull := zoci.PackageAlwaysPull
 	if wantSBOM {
 		toPull = append(toPull, layout.SBOMTar)
 	}
-	ctx := context.TODO()
 	layersFetched, err := s.PullPaths(ctx, dst.Base, toPull)
 	if err != nil {
 		return pkg, nil, err
@@ -165,13 +162,12 @@ func (s *OCISource) LoadPackageMetadata(dst *layout.PackagePaths, wantSBOM bool,
 }
 
 // Collect pulls a package from an OCI registry and writes it to a tarball.
-func (s *OCISource) Collect(dir string) (string, error) {
+func (s *OCISource) Collect(ctx context.Context, dir string) (string, error) {
 	tmp, err := utils.MakeTempDir(config.CommonOptions.TempDirectory)
 	if err != nil {
 		return "", err
 	}
 	defer os.RemoveAll(tmp)
-	ctx := context.TODO()
 	fetched, err := s.PullPackage(ctx, tmp, config.CommonOptions.OCIConcurrency)
 	if err != nil {
 		return "", err
diff --git a/src/pkg/packager/sources/split.go b/src/pkg/packager/sources/split.go
index d635159002..1594a51c20 100644
--- a/src/pkg/packager/sources/split.go
+++ b/src/pkg/packager/sources/split.go
@@ -5,6 +5,7 @@
 package sources
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -31,7 +32,7 @@ type SplitTarballSource struct {
 }
 
 // Collect turns a split tarball into a full tarball.
-func (s *SplitTarballSource) Collect(dir string) (string, error) {
+func (s *SplitTarballSource) Collect(_ context.Context, dir string) (string, error) {
 	pattern := strings.Replace(s.PackageSource, ".part000", ".part*", 1)
 	fileList, err := filepath.Glob(pattern)
 	if err != nil {
@@ -109,8 +110,8 @@ func (s *SplitTarballSource) Collect(dir string) (string, error) {
 }
 
 // LoadPackage loads a package from a split tarball.
-func (s *SplitTarballSource) LoadPackage(dst *layout.PackagePaths, filter filters.ComponentFilterStrategy, unarchiveAll bool) (pkg types.ZarfPackage, warnings []string, err error) {
-	tb, err := s.Collect(filepath.Dir(s.PackageSource))
+func (s *SplitTarballSource) LoadPackage(ctx context.Context, dst *layout.PackagePaths, filter filters.ComponentFilterStrategy, unarchiveAll bool) (pkg types.ZarfPackage, warnings []string, err error) {
+	tb, err := s.Collect(ctx, filepath.Dir(s.PackageSource))
 	if err != nil {
 		return pkg, nil, err
 	}
@@ -123,12 +124,12 @@ func (s *SplitTarballSource) LoadPackage(dst *layout.PackagePaths, filter filter
 	ts := &TarballSource{
 		s.ZarfPackageOptions,
 	}
-	return ts.LoadPackage(dst, filter, unarchiveAll)
+	return ts.LoadPackage(ctx, dst, filter, unarchiveAll)
 }
 
 // LoadPackageMetadata loads a package's metadata from a split tarball.
-func (s *SplitTarballSource) LoadPackageMetadata(dst *layout.PackagePaths, wantSBOM bool, skipValidation bool) (pkg types.ZarfPackage, warnings []string, err error) {
-	tb, err := s.Collect(filepath.Dir(s.PackageSource))
+func (s *SplitTarballSource) LoadPackageMetadata(ctx context.Context, dst *layout.PackagePaths, wantSBOM bool, skipValidation bool) (pkg types.ZarfPackage, warnings []string, err error) {
+	tb, err := s.Collect(ctx, filepath.Dir(s.PackageSource))
 	if err != nil {
 		return pkg, nil, err
 	}
@@ -139,5 +140,5 @@ func (s *SplitTarballSource) LoadPackageMetadata(dst *layout.PackagePaths, wantS
 	ts := &TarballSource{
 		s.ZarfPackageOptions,
 	}
-	return ts.LoadPackageMetadata(dst, wantSBOM, skipValidation)
+	return ts.LoadPackageMetadata(ctx, dst, wantSBOM, skipValidation)
 }
diff --git a/src/pkg/packager/sources/tarball.go b/src/pkg/packager/sources/tarball.go
index b6a70d4355..663a4bd31c 100644
--- a/src/pkg/packager/sources/tarball.go
+++ b/src/pkg/packager/sources/tarball.go
@@ -6,6 +6,7 @@ package sources
 
 import (
 	"archive/tar"
+	"context"
 	"errors"
 	"fmt"
 	"io"
@@ -32,7 +33,7 @@ type TarballSource struct {
 }
 
 // LoadPackage loads a package from a tarball.
-func (s *TarballSource) LoadPackage(dst *layout.PackagePaths, filter filters.ComponentFilterStrategy, unarchiveAll bool) (pkg types.ZarfPackage, warnings []string, err error) {
+func (s *TarballSource) LoadPackage(_ context.Context, dst *layout.PackagePaths, filter filters.ComponentFilterStrategy, unarchiveAll bool) (pkg types.ZarfPackage, warnings []string, err error) {
 	spinner := message.NewProgressSpinner("Loading package from %q", s.PackageSource)
 	defer spinner.Stop()
 
@@ -137,7 +138,7 @@ func (s *TarballSource) LoadPackage(dst *layout.PackagePaths, filter filters.Com
 }
 
 // LoadPackageMetadata loads a package's metadata from a tarball.
-func (s *TarballSource) LoadPackageMetadata(dst *layout.PackagePaths, wantSBOM bool, skipValidation bool) (pkg types.ZarfPackage, warnings []string, err error) {
+func (s *TarballSource) LoadPackageMetadata(_ context.Context, dst *layout.PackagePaths, wantSBOM bool, skipValidation bool) (pkg types.ZarfPackage, warnings []string, err error) {
 	if s.Shasum != "" {
 		if err := helpers.SHAsMatch(s.PackageSource, s.Shasum); err != nil {
 			return pkg, nil, err
@@ -202,7 +203,7 @@ func (s *TarballSource) LoadPackageMetadata(dst *layout.PackagePaths, wantSBOM b
 }
 
 // Collect for the TarballSource is essentially an `mv`
-func (s *TarballSource) Collect(dir string) (string, error) {
+func (s *TarballSource) Collect(_ context.Context, dir string) (string, error) {
 	dst := filepath.Join(dir, filepath.Base(s.PackageSource))
 	err := os.Rename(s.PackageSource, dst)
 	linkErr := &os.LinkError{}
diff --git a/src/pkg/packager/sources/url.go b/src/pkg/packager/sources/url.go
index 67b6ccd1d9..9fa3cfb8e0 100644
--- a/src/pkg/packager/sources/url.go
+++ b/src/pkg/packager/sources/url.go
@@ -5,6 +5,7 @@
 package sources
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -29,7 +30,7 @@ type URLSource struct {
 }
 
 // Collect downloads a package from the source URL.
-func (s *URLSource) Collect(dir string) (string, error) {
+func (s *URLSource) Collect(_ context.Context, dir string) (string, error) {
 	if !config.CommonOptions.Insecure && s.Shasum == "" && !strings.HasPrefix(s.PackageSource, helpers.SGETURLPrefix) {
 		return "", fmt.Errorf("remote package provided without a shasum, use --insecure to ignore, or provide one w/ --shasum")
 	}
@@ -50,14 +51,14 @@ func (s *URLSource) Collect(dir string) (string, error) {
 }
 
 // LoadPackage loads a package from an http, https or sget URL.
-func (s *URLSource) LoadPackage(dst *layout.PackagePaths, filter filters.ComponentFilterStrategy, unarchiveAll bool) (pkg types.ZarfPackage, warnings []string, err error) {
+func (s *URLSource) LoadPackage(ctx context.Context, dst *layout.PackagePaths, filter filters.ComponentFilterStrategy, unarchiveAll bool) (pkg types.ZarfPackage, warnings []string, err error) {
 	tmp, err := utils.MakeTempDir(config.CommonOptions.TempDirectory)
 	if err != nil {
 		return pkg, nil, err
 	}
 	defer os.Remove(tmp)
 
-	dstTarball, err := s.Collect(tmp)
+	dstTarball, err := s.Collect(ctx, tmp)
 	if err != nil {
 		return pkg, nil, err
 	}
@@ -70,18 +71,18 @@ func (s *URLSource) LoadPackage(dst *layout.PackagePaths, filter filters.Compone
 		s.ZarfPackageOptions,
 	}
 
-	return ts.LoadPackage(dst, filter, unarchiveAll)
+	return ts.LoadPackage(ctx, dst, filter, unarchiveAll)
 }
 
 // LoadPackageMetadata loads a package's metadata from an http, https or sget URL.
-func (s *URLSource) LoadPackageMetadata(dst *layout.PackagePaths, wantSBOM bool, skipValidation bool) (pkg types.ZarfPackage, warnings []string, err error) {
+func (s *URLSource) LoadPackageMetadata(ctx context.Context, dst *layout.PackagePaths, wantSBOM bool, skipValidation bool) (pkg types.ZarfPackage, warnings []string, err error) {
 	tmp, err := utils.MakeTempDir(config.CommonOptions.TempDirectory)
 	if err != nil {
 		return pkg, nil, err
 	}
 	defer os.Remove(tmp)
 
-	dstTarball, err := s.Collect(tmp)
+	dstTarball, err := s.Collect(ctx, tmp)
 	if err != nil {
 		return pkg, nil, err
 	}
@@ -92,5 +93,5 @@ func (s *URLSource) LoadPackageMetadata(dst *layout.PackagePaths, wantSBOM bool,
 		s.ZarfPackageOptions,
 	}
 
-	return ts.LoadPackageMetadata(dst, wantSBOM, skipValidation)
+	return ts.LoadPackageMetadata(ctx, dst, wantSBOM, skipValidation)
 }