diff --git a/api/internal/localizer/localizer.go b/api/internal/localizer/localizer.go
deleted file mode 100644
index 64d241d573d..00000000000
--- a/api/internal/localizer/localizer.go
+++ /dev/null
@@ -1,317 +0,0 @@
-// Copyright 2022 The Kubernetes Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package localizer
-
-import (
-	"log"
-	"path/filepath"
-	"strings"
-
-	"sigs.k8s.io/kustomize/api/ifc"
-	pluginsLoader "sigs.k8s.io/kustomize/api/internal/plugins/loader"
-	"sigs.k8s.io/kustomize/api/internal/target"
-	"sigs.k8s.io/kustomize/api/konfig"
-	"sigs.k8s.io/kustomize/api/krusty"
-	"sigs.k8s.io/kustomize/api/loader"
-	"sigs.k8s.io/kustomize/api/provider"
-	"sigs.k8s.io/kustomize/api/resmap"
-	"sigs.k8s.io/kustomize/api/types"
-	"sigs.k8s.io/kustomize/kyaml/errors"
-	"sigs.k8s.io/kustomize/kyaml/filesys"
-	"sigs.k8s.io/yaml"
-)
-
-// localizer localizes the kustomization root at ldr.
-type localizer struct {
-	fSys filesys.FileSystem
-
-	ldr ifc.Loader
-
-	// destination directory in newDir that mirrors ldr's current root.
-	dst filesys.ConfirmedDir
-
-	// all localize directories created
-	localizeDirs map[filesys.ConfirmedDir]struct{}
-
-	// kusttarget fields
-	rFactory  *resmap.Factory
-	pLdr      *pluginsLoader.Loader
-	validator ifc.Validator
-}
-
-// Run attempts to localize the kustomization root at targetArg with the given localize arguments
-func Run(fSys filesys.FileSystem, targetArg string, scopeArg string, newDirArg string) error {
-	ldr, args, err := NewLocLoader(targetArg, scopeArg, newDirArg, fSys)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = ldr.Cleanup() }()
-
-	toDst, err := filepath.Rel(args.Scope.String(), ldr.Root())
-	if err != nil {
-		//nolint:gocritic // should never happen, but if hit, something fundamentally wrong; should immediately exit
-		log.Fatalf("%s: %s", prefixRelErrWhenContains(args.Scope.String(), ldr.Root()), err.Error())
-	}
-	dst := args.NewDir.Join(toDst)
-	if err = fSys.MkdirAll(dst); err != nil {
-		return errors.WrapPrefixf(err, "unable to create directory in localize destination")
-	}
-
-	depProvider := provider.NewDepProvider()
-	rFactory := resmap.NewFactory(depProvider.GetResourceFactory())
-	err = (&localizer{
-		fSys:         fSys,
-		ldr:          ldr,
-		dst:          filesys.ConfirmedDir(dst),
-		localizeDirs: map[filesys.ConfirmedDir]struct{}{},
-		validator:    depProvider.GetFieldValidator(),
-		rFactory:     rFactory,
-		pLdr:         pluginsLoader.NewLoader(krusty.MakeDefaultOptions().PluginConfig, rFactory, filesys.MakeFsOnDisk()),
-	}).localize()
-	if err != nil {
-		if errCleanup := fSys.RemoveAll(args.NewDir.String()); errCleanup != nil {
-			log.Printf("unable to clean localize destination: %s", errCleanup.Error())
-		}
-		return errors.WrapPrefixf(err, "unable to localize target '%s'", targetArg)
-	}
-	return nil
-}
-
-// localize localizes the root that lclzr is at
-func (lclzr *localizer) localize() error {
-	kt := target.NewKustTarget(lclzr.ldr, lclzr.validator, lclzr.rFactory, lclzr.pLdr)
-	err := kt.Load()
-	if err != nil {
-		return errors.Wrap(err)
-	}
-
-	kust, err := lclzr.processKust(kt)
-	if err != nil {
-		return err
-	}
-
-	content, err := yaml.Marshal(kust)
-	if err != nil {
-		return errors.WrapPrefixf(err, "unable to serialize localized kustomization file")
-	}
-	if err = lclzr.fSys.WriteFile(lclzr.dst.Join(konfig.DefaultKustomizationFileName()), content); err != nil {
-		return errors.WrapPrefixf(err, "unable to write localized kustomization file")
-	}
-	return nil
-}
-
-// processKust returns a copy of the kustomization at kt with all paths localized.
-func (lclzr *localizer) processKust(kt *target.KustTarget) (*types.Kustomization, error) {
-	kust := kt.Kustomization()
-
-	if path, exists := kust.OpenAPI["path"]; exists {
-		var err error
-		kust.OpenAPI["path"], err = lclzr.localizeFile(path)
-		if err != nil {
-			return &kust, errors.WrapPrefixf(err, "unable to localize openapi path")
-		}
-	}
-
-	for i, p := range kust.PatchesStrategicMerge {
-		if _, err := lclzr.rFactory.RF().SliceFromBytes([]byte(p)); err == nil { // inline
-			continue
-		}
-		newPath, err := lclzr.localizeFile(string(p)) // file
-		if err != nil {
-			return &kust, errors.WrapPrefixf(err, "unable to localize patchesStrategicMerge path")
-		}
-		kust.PatchesStrategicMerge[i] = types.PatchStrategicMerge(newPath)
-	}
-	for name, patches := range map[string][]types.Patch{
-		"patchesJson6902": kust.PatchesJson6902,
-		"patches":         kust.Patches,
-	} {
-		for i, p := range patches {
-			if p.Path == "" {
-				continue
-			}
-			newPath, err := lclzr.localizeFile(p.Path)
-			if err != nil {
-				return &kust, errors.WrapPrefixf(err, "unable to localize %s path", name)
-			}
-			patches[i].Path = newPath
-		}
-	}
-
-	for i, r := range kust.Replacements {
-		if r.Path == "" {
-			continue
-		}
-		newPath, err := lclzr.localizeFile(r.Path)
-		if err != nil {
-			return &kust, errors.WrapPrefixf(err, "unable to localize replacements path")
-		}
-		kust.Replacements[i].Path = newPath
-	}
-
-	for name, field := range map[string]*struct {
-		Mapper func(string) (string, error)
-		Paths  []string
-	}{
-		"resources": {
-			lclzr.localizePath,
-			kust.Resources,
-		},
-		"components": {
-			lclzr.localizeDir,
-			kust.Components,
-		},
-		"crds": {
-			lclzr.localizeFile,
-			kust.Crds,
-		},
-	} {
-		for i, path := range field.Paths {
-			newPath, err := field.Mapper(path)
-			if err != nil {
-				return &kust, errors.WrapPrefixf(err, "unable to localize %s path", name)
-			}
-			field.Paths[i] = newPath
-		}
-	}
-
-	for i := 0; i < len(kust.ConfigMapGenerator); i++ {
-		if err := localizeGenerator(&kust.ConfigMapGenerator[i].GeneratorArgs, lclzr); err != nil {
-			return &kust, errors.WrapPrefixf(err, "unable to localize configMapGenerator path")
-		}
-	}
-	for i := 0; i < len(kust.SecretGenerator); i++ {
-		if err := localizeGenerator(&kust.SecretGenerator[i].GeneratorArgs, lclzr); err != nil {
-			return &kust, errors.WrapPrefixf(err, "unable to localize secretGenerator path")
-		}
-	}
-
-	if len(kust.Generators) > 0 {
-		log.Printf("'%v' %s", kust.Generators, GeneratorWarning)
-	}
-	if len(kust.Transformers) > 0 {
-		log.Printf("'%v' %s", kust.Transformers, TransformerWarning)
-	}
-
-	return &kust, nil
-}
-
-// localizePath localizes path, a root or file, and returns the localized path
-func (lclzr *localizer) localizePath(path string) (string, error) {
-	locPath, err := lclzr.localizeDir(path)
-	if errors.Is(err, ErrInvalidRoot) {
-		locPath, err = lclzr.localizeFile(path)
-	}
-	if err != nil {
-		return "", err
-	}
-	return locPath, nil
-}
-
-// localizeFile localizes file path and returns the localized path
-func (lclzr *localizer) localizeFile(path string) (string, error) {
-	content, err := lclzr.ldr.Load(path)
-	if err != nil {
-		return "", errors.Wrap(err)
-	}
-
-	var locPath string
-	if loader.HasRemoteFileScheme(path) {
-		if !lclzr.addLocalizeDir() {
-			return "", errors.Errorf("cannot localize remote '%s': %w at '%s'", path, ErrLocalizeDirExists, lclzr.ldr.Root())
-		}
-		lclzr.localizeDirs[lclzr.dst] = struct{}{}
-		locPath = locFilePath(path)
-	} else { // path must be relative; subject to change in beta
-		// avoid symlinks; only write file corresponding to actual location in root
-		// avoid path that Load() shows to be in root, but may traverse outside
-		// temporarily; for example, ../root/config; problematic for rename and
-		// relocation
-		locPath = cleanFilePath(lclzr.fSys, filesys.ConfirmedDir(lclzr.ldr.Root()), path)
-		if !lclzr.guardLocalizeDir(locPath) {
-			abs := filepath.Join(lclzr.ldr.Root(), locPath)
-			return "", errors.Errorf("invalid local file path '%s' at '%s': %w", path, abs, ErrLocalizeDirExists)
-		}
-	}
-	cleanPath := lclzr.dst.Join(locPath)
-	if err = lclzr.fSys.MkdirAll(filepath.Dir(cleanPath)); err != nil {
-		return "", errors.WrapPrefixf(err, "unable to create directories to localize file '%s'", path)
-	}
-	if err = lclzr.fSys.WriteFile(cleanPath, content); err != nil {
-		return "", errors.WrapPrefixf(err, "unable to localize file '%s'", path)
-	}
-	return locPath, nil
-}
-
-// localizeDir localizes root path and returns the localized path
-func (lclzr *localizer) localizeDir(path string) (string, error) {
-	ldr, err := lclzr.ldr.New(path)
-	if err != nil {
-		return "", errors.Wrap(err)
-	}
-	defer func() { _ = ldr.Cleanup() }()
-
-	var locPath string
-	if repo, isRemote := ldr.Repo(); isRemote {
-		if !lclzr.addLocalizeDir() {
-			return "", errors.Errorf("cannot localize remote '%s': %w at '%s'", path, ErrLocalizeDirExists, lclzr.ldr.Root())
-		}
-		locPath = locRootPath(path, filesys.ConfirmedDir(repo), filesys.ConfirmedDir(ldr.Root()))
-	} else {
-		locPath, err = filepath.Rel(lclzr.ldr.Root(), ldr.Root())
-		if err != nil {
-			//nolint:gocritic // should never occur, but if hit, something fundamentally wrong; should immediately exit
-			log.Fatalf("rel path error for 2 navigable roots '%s', '%s': %s", lclzr.ldr.Root(), ldr.Root(), err.Error())
-		}
-		if !lclzr.guardLocalizeDir(locPath) {
-			return "", errors.Errorf("invalid local root path '%s' at '%s': %w", path, ldr.Root(), ErrLocalizeDirExists)
-		}
-	}
-	newDst := lclzr.dst.Join(locPath)
-	if err = lclzr.fSys.MkdirAll(newDst); err != nil {
-		return "", errors.WrapPrefixf(err, "unable to create root '%s' in localize destination", path)
-	}
-	err = (&localizer{
-		fSys:         lclzr.fSys,
-		ldr:          ldr,
-		dst:          filesys.ConfirmedDir(newDst),
-		localizeDirs: lclzr.localizeDirs,
-		validator:    lclzr.validator,
-		rFactory:     lclzr.rFactory,
-		pLdr:         lclzr.pLdr,
-	}).localize()
-	if err != nil {
-		return "", errors.WrapPrefixf(err, "unable to localize root '%s'", path)
-	}
-	return locPath, nil
-}
-
-// addLocalizeDir returns whether it is able to add a localize directory at dst
-func (lclzr *localizer) addLocalizeDir() bool {
-	if _, exists := lclzr.localizeDirs[lclzr.dst]; !exists && lclzr.fSys.Exists(lclzr.dst.Join(LocalizeDir)) {
-		return false
-	}
-	lclzr.localizeDirs[lclzr.dst] = struct{}{}
-	return true
-}
-
-// guardLocalizeDir returns false if local path enters a localize directory, and true otherwise
-func (lclzr *localizer) guardLocalizeDir(path string) bool {
-	var prefix string
-	for _, dir := range strings.Split(path, string(filepath.Separator)) {
-		parent := lclzr.dst.Join(prefix)
-		// if never processed parent, inner directories cannot be localize directories
-		if !lclzr.fSys.Exists(parent) {
-			return true
-		}
-		prefix = filepath.Join(prefix, dir)
-		if dir != LocalizeDir {
-			continue
-		}
-		if _, exists := lclzr.localizeDirs[filesys.ConfirmedDir(parent)]; exists {
-			return false
-		}
-	}
-	return true
-}
diff --git a/api/internal/localizer/localizer_test.go b/api/internal/localizer/localizer_test.go
deleted file mode 100644
index 6769555e215..00000000000
--- a/api/internal/localizer/localizer_test.go
+++ /dev/null
@@ -1,330 +0,0 @@
-// Copyright 2022 The Kubernetes Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package localizer_test
-
-import (
-	"bytes"
-	"log"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-	"sigs.k8s.io/kustomize/api/internal/localizer"
-	"sigs.k8s.io/kustomize/kyaml/filesys"
-)
-
-func makeMemoryFs(t *testing.T) filesys.FileSystem {
-	t.Helper()
-	req := require.New(t)
-
-	fSys := filesys.MakeFsInMemory()
-	req.NoError(fSys.MkdirAll("/a/b"))
-	req.NoError(fSys.WriteFile("/a/pod.yaml", []byte("pod configuration")))
-
-	dirChain := "/alpha/beta/gamma/delta"
-	req.NoError(fSys.MkdirAll(dirChain))
-	req.NoError(fSys.WriteFile(filepath.Join(dirChain, "deployment.yaml"), []byte("deployment configuration")))
-	req.NoError(fSys.Mkdir("/alpha/beta/say"))
-	return fSys
-}
-
-func addFiles(t *testing.T, fSys filesys.FileSystem, parentDir string, files map[string]string) {
-	t.Helper()
-
-	// in-memory file system makes all necessary dirs when writing files
-	for file, content := range files {
-		require.NoError(t, fSys.WriteFile(filepath.Join(parentDir, file), []byte(content)))
-	}
-}
-
-func TestPatchStrategicMergeOnFile(t *testing.T) {
-	req := require.New(t)
-
-	var buf bytes.Buffer
-	log.SetOutput(&buf)
-	fSys := makeMemoryFs(t)
-
-	// tests both inline and file patches
-	// tests localize handles nested directory and winding path
-	files := map[string]string{
-		"kustomization.yaml": `
-patchesStrategicMerge:
-- ../beta/say/patch.yaml
-- |-
-  apiVersion: apps/v1
-  metadata:
-    name: myDeployment
-  kind: Deployment
-  spec:
-    replica: 2
-
-resources:
-- localized-files`,
-		// in the absence of remote references, localize directory name can be used by other files
-		"localized-files": "localized-files configuration",
-		"say/patch.yaml":  "patch configuration",
-	}
-	addFiles(t, fSys, "/alpha/beta", files)
-	err := localizer.Run(fSys, "/alpha/beta", "", "/alpha/newDir")
-	req.NoError(err)
-	req.Empty(buf.String())
-
-	fSysExpected := makeMemoryFs(t)
-	addFiles(t, fSysExpected, "/alpha/beta", files)
-	files["kustomization.yaml"] = `apiVersion: kustomize.config.k8s.io/v1beta1
-kind: Kustomization
-patchesStrategicMerge:
-- say/patch.yaml
-- |-
-  apiVersion: apps/v1
-  metadata:
-    name: myDeployment
-  kind: Deployment
-  spec:
-    replica: 2
-resources:
-- localized-files
-`
-	// directories in scope, but not referenced should not be copied to destination
-	addFiles(t, fSysExpected, "/alpha/newDir", files)
-	req.Equal(fSysExpected, fSys)
-}
-
-func TestComponents(t *testing.T) {
-	var buf bytes.Buffer
-	log.SetOutput(&buf)
-	fSys := makeMemoryFs(t)
-
-	// components test directory references
-	files := map[string]string{
-		// winding directory path
-		"a/kustomization.yaml": `
-components:
-- b/../../alpha/beta/..
-- localized-files
-resources:
-- pod.yaml
-- job.yaml
-`,
-
-		"a/job.yaml": "job configuration",
-
-		// should recognize different kustomization names
-		// inline and file replacements
-		"alpha/kustomization.yml": `apiVersion: kustomize.config.k8s.io/v1alpha1
-kind: Component
-replacements:
-- source:
-    fieldPath: metadata.name
-    kind: Job
-  targets:
-  - fieldPaths:
-    - metadata.name
-    select:
-      kind: Pod
-- path: my-replacement.yaml
-`,
-
-		"alpha/my-replacement.yaml": "replacement configuration",
-
-		// in the absence of remote references, directories can share localize directory name
-		"a/localized-files/Kustomization": `apiVersion: kustomize.config.k8s.io/v1alpha1
-kind: Component
-patches:
-- patch: |-
-    - op: replace
-      path: /spec/containers/0/name
-      value: my-nginx
-  target:
-    kind: Pod
-- path: patch.yaml
-  target:
-    kind: Pod
-`,
-
-		"a/localized-files/patch.yaml": "patch configuration",
-	}
-	addFiles(t, fSys, "/", files)
-
-	err := localizer.Run(fSys, "/a", "/", "")
-	require.NoError(t, err)
-	require.Empty(t, buf.String())
-
-	fSysExpected := makeMemoryFs(t)
-	addFiles(t, fSysExpected, "/", files)
-
-	filesExpected := map[string]string{
-		"a/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
-components:
-- ../alpha
-- localized-files
-kind: Kustomization
-resources:
-- pod.yaml
-- job.yaml
-`,
-		"a/pod.yaml":                           "pod configuration",
-		"a/job.yaml":                           files["a/job.yaml"],
-		"alpha/kustomization.yaml":             files["alpha/kustomization.yml"],
-		"alpha/my-replacement.yaml":            files["alpha/my-replacement.yaml"],
-		"a/localized-files/kustomization.yaml": files["a/localized-files/Kustomization"],
-		"a/localized-files/patch.yaml":         files["a/localized-files/patch.yaml"],
-	}
-	addFiles(t, fSysExpected, "/localized-a", filesExpected)
-	require.Equal(t, fSysExpected, fSys)
-}
-
-func TestNestedRoots(t *testing.T) {
-	var buf bytes.Buffer
-	log.SetOutput(&buf)
-
-	fSys := makeMemoryFs(t)
-	files := map[string]string{
-		// both file and directory resources
-		// kustomization fields without paths should also be copied
-		"beta/gamma/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
-kind: Kustomization
-namePrefix: nested-roots-
-resources:
-- delta/deployment.yaml
-- ../say
-`,
-
-		// configMapGenerator with envs and files, with both the default filename and keys
-		"beta/say/kustomization.yaml": `
-resources:
-- ../gamma/./delta/
-- ../../beta/gamma/delta/epsilon
-configMapGenerator:
-- name: my-config-map
-  behavior: create
-  files:
-  - application.properties
-  - environment.properties=../gamma/../say/weird-name
-  literals:
-  - THIS_KEY=/really/does/not/matter
-  envs:
-  - ./more.properties`,
-
-		"beta/say/application.properties": "application properties",
-
-		"beta/say/weird-name": "weird-name properties",
-
-		"beta/say/more.properties": "more properties",
-
-		"beta/gamma/delta/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
-commonLabels:
-  label: value
-crds:
-- epsilon/type-new-kind.yaml
-kind: Kustomization
-resources:
-- new-kind.yaml
-`,
-
-		"beta/gamma/delta/new-kind.yaml": "new-kind configuration",
-
-		"beta/gamma/delta/epsilon/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
-commonLabels:
-  label: anotherValue
-crds:
-- type-new-kind.yaml
-kind: Kustomization
-resources:
-- new-kind.yaml
-`,
-
-		"beta/gamma/delta/epsilon/new-kind.yaml": "another new-kind configuration",
-
-		// referenced more than once
-		"beta/gamma/delta/epsilon/type-new-kind.yaml": "new-kind definition",
-	}
-	addFiles(t, fSys, "/alpha", files)
-	err := localizer.Run(fSys, "/alpha/beta/gamma", "/alpha",
-		"/alpha/beta/gamma/delta/newDir")
-	require.NoError(t, err)
-	require.Empty(t, buf.String())
-
-	fSysExpected := makeMemoryFs(t)
-	addFiles(t, fSysExpected, "/alpha", files)
-	files["beta/say/kustomization.yaml"] = `apiVersion: kustomize.config.k8s.io/v1beta1
-configMapGenerator:
-- behavior: create
-  envs:
-  - more.properties
-  files:
-  - application.properties
-  - environment.properties=weird-name
-  literals:
-  - THIS_KEY=/really/does/not/matter
-  name: my-config-map
-kind: Kustomization
-resources:
-- ../gamma/delta
-- ../gamma/delta/epsilon
-`
-	files["beta/gamma/delta/deployment.yaml"] = "deployment configuration"
-	addFiles(t, fSysExpected, "/alpha/beta/gamma/delta/newDir", files)
-	require.Equal(t, fSysExpected, fSys)
-}
-
-func TestExtensions(t *testing.T) {
-	req := require.New(t)
-
-	var buf bytes.Buffer
-	log.SetOutput(&buf)
-
-	fSys := makeMemoryFs(t)
-	files := map[string]string{
-		"a/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
-generators:
-- generator.yaml
-kind: Kustomization
-resources:
-- pod.yaml
-transformers:
-- transformer.yaml
-`,
-
-		"a/generator.yaml": "generator configuration",
-
-		"a/transformer.yaml": "transformer configuration",
-	}
-	addFiles(t, fSys, "/", files)
-
-	err := localizer.Run(fSys, "a", ".", "newDir")
-	req.NoError(err)
-	req.Contains(buf.String(), localizer.GeneratorWarning)
-	req.Contains(buf.String(), localizer.TransformerWarning)
-
-	fSysExpected := makeMemoryFs(t)
-	addFiles(t, fSysExpected, "/", files)
-	filesExpected := map[string]string{
-		"a/kustomization.yaml": files["a/kustomization.yaml"],
-		"a/pod.yaml":           "pod configuration",
-	}
-	addFiles(t, fSysExpected, "/newDir", filesExpected)
-	req.Equal(fSysExpected, fSys)
-}
-
-func TestCleanDstOnErr(t *testing.T) {
-	fSys := makeMemoryFs(t)
-	files := map[string]string{
-		"a/kustomization.yaml": `
-resources:
-- pod.yaml
-- b
-namePrefix: my-`,
-		"b/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
-kind: Kustomization
-invalidField: invalidValue`,
-	}
-	addFiles(t, fSys, "/", files)
-	err := localizer.Run(fSys, "/a", "/", "/newDir")
-	require.Error(t, err)
-
-	fSysExpected := makeMemoryFs(t)
-	addFiles(t, fSysExpected, "/", files)
-	require.Equal(t, fSysExpected, fSys)
-}
diff --git a/api/internal/localizer/doc.go b/api/internal/loctarget/doc.go
similarity index 75%
rename from api/internal/localizer/doc.go
rename to api/internal/loctarget/doc.go
index b7995adfd53..65bc0d8a813 100644
--- a/api/internal/localizer/doc.go
+++ b/api/internal/loctarget/doc.go
@@ -1,7 +1,7 @@
 // Copyright 2022 The Kubernetes Authors.
 // SPDX-License-Identifier: Apache-2.0
 
-// Package localizer contains utilities for the command kustomize localize, which is
+// Package loctarget contains utilities for the command kustomize localize, which is
 // documented under proposals/localize-command or at
 // https://github.com/kubernetes-sigs/kustomize/blob/master/proposals/22-04-localize-command.md
-package localizer
+package loctarget
diff --git a/api/internal/localizer/errors.go b/api/internal/loctarget/errors.go
similarity index 98%
rename from api/internal/localizer/errors.go
rename to api/internal/loctarget/errors.go
index c1598271cdb..9f4bc97d64e 100644
--- a/api/internal/localizer/errors.go
+++ b/api/internal/loctarget/errors.go
@@ -1,7 +1,7 @@
 // Copyright 2022 The Kubernetes Authors.
 // SPDX-License-Identifier: Apache-2.0
 
-package localizer
+package loctarget
 
 import (
 	"fmt"
diff --git a/api/internal/localizer/locloader.go b/api/internal/loctarget/locloader.go
similarity index 92%
rename from api/internal/localizer/locloader.go
rename to api/internal/loctarget/locloader.go
index 8a4901f581f..9946f6ed85f 100644
--- a/api/internal/localizer/locloader.go
+++ b/api/internal/loctarget/locloader.go
@@ -1,7 +1,7 @@
 // Copyright 2022 The Kubernetes Authors.
 // SPDX-License-Identifier: Apache-2.0
 
-package localizer
+package loctarget
 
 import (
 	"path/filepath"
@@ -29,8 +29,8 @@ type LocArgs struct {
 	NewDir filesys.ConfirmedDir
 }
 
-// locLoader is the Loader for kustomize localize. It is an ifc.Loader that enforces localize constraints.
-type locLoader struct {
+// LocLoader is the Loader for kustomize localize. It is an ifc.Loader that enforces localize constraints.
+type LocLoader struct {
 	fSys filesys.FileSystem
 
 	args *LocArgs
@@ -42,11 +42,11 @@ type locLoader struct {
 	local bool
 }
 
-var _ ifc.Loader = &locLoader{}
+var _ ifc.Loader = &LocLoader{}
 
 // NewLocLoader is the factory method for Loader, under localize constraints, at targetArg. For invalid localize arguments,
 // NewLocLoader returns an error.
-func NewLocLoader(targetArg string, scopeArg string, newDirArg string, fSys filesys.FileSystem) (ifc.Loader, LocArgs, error) {
+func NewLocLoader(targetArg string, scopeArg string, newDirArg string, fSys filesys.FileSystem) (*LocLoader, LocArgs, error) {
 	// check earlier to avoid cleanup
 	repoSpec, err := git.NewRepoSpecFromURL(targetArg)
 	if err == nil && repoSpec.Ref == "" {
@@ -77,7 +77,7 @@ func NewLocLoader(targetArg string, scopeArg string, newDirArg string, fSys file
 		NewDir: newDir,
 	}
 	_, isRemote := ldr.Repo()
-	return &locLoader{
+	return &LocLoader{
 		fSys:   fSys,
 		args:   &args,
 		Loader: ldr,
@@ -87,7 +87,7 @@ func NewLocLoader(targetArg string, scopeArg string, newDirArg string, fSys file
 
 // Load returns the contents of path if path is a valid localize file.
 // Otherwise, Load returns an error.
-func (ll *locLoader) Load(path string) ([]byte, error) {
+func (ll *LocLoader) Load(path string) ([]byte, error) {
 	// checks in root, and thus in scope
 	content, err := ll.Loader.Load(path)
 	if err != nil {
@@ -112,7 +112,7 @@ func (ll *locLoader) Load(path string) ([]byte, error) {
 
 // New returns a Loader at path if path is a valid localize root.
 // Otherwise, New returns an error.
-func (ll *locLoader) New(path string) (ifc.Loader, error) {
+func (ll *LocLoader) New(path string) (ifc.Loader, error) {
 	ldr, err := ll.Loader.New(path)
 	// timeout indicates path is a root, not a file
 	if utils.IsErrTimeout(err) {
@@ -140,7 +140,7 @@ func (ll *locLoader) New(path string) (ifc.Loader, error) {
 		}
 	}
 
-	return &locLoader{
+	return &LocLoader{
 		fSys:   ll.fSys,
 		args:   ll.args,
 		Loader: ldr,
diff --git a/api/internal/localizer/locloader_test.go b/api/internal/loctarget/locloader_test.go
similarity index 84%
rename from api/internal/localizer/locloader_test.go
rename to api/internal/loctarget/locloader_test.go
index 61e760c5d5c..90b84aa3a04 100644
--- a/api/internal/localizer/locloader_test.go
+++ b/api/internal/loctarget/locloader_test.go
@@ -1,7 +1,7 @@
 // Copyright 2022 The Kubernetes Authors.
 // SPDX-License-Identifier: Apache-2.0
 
-package localizer_test
+package loctarget_test
 
 import (
 	"bytes"
@@ -10,13 +10,13 @@ import (
 
 	"github.com/stretchr/testify/require"
 	"sigs.k8s.io/kustomize/api/ifc"
-	lclzr "sigs.k8s.io/kustomize/api/internal/localizer"
+	lt "sigs.k8s.io/kustomize/api/internal/loctarget"
 	"sigs.k8s.io/kustomize/kyaml/filesys"
 )
 
 const dstPrefix = "localized"
 
-func checkNewLocLoader(req *require.Assertions, ldr ifc.Loader, args *lclzr.LocArgs, target string, scope string, newDir string, fSys filesys.FileSystem) {
+func checkNewLocLoader(req *require.Assertions, ldr *lt.LocLoader, args *lt.LocArgs, target string, scope string, newDir string, fSys filesys.FileSystem) {
 	checkLoader(req, ldr, target)
 	checkLocArgs(req, args, target, scope, newDir, fSys)
 }
@@ -28,7 +28,7 @@ func checkLoader(req *require.Assertions, ldr ifc.Loader, root string) {
 	req.Equal("", repo)
 }
 
-func checkLocArgs(req *require.Assertions, args *lclzr.LocArgs, target string, scope string, newDir string, fSys filesys.FileSystem) {
+func checkLocArgs(req *require.Assertions, args *lt.LocArgs, target string, scope string, newDir string, fSys filesys.FileSystem) {
 	req.Equal(target, args.Target.String())
 	req.Equal(scope, args.Scope.String())
 	req.Equal(newDir, args.NewDir.String())
@@ -42,7 +42,7 @@ func TestLocalLoadNewAndCleanup(t *testing.T) {
 	var buf bytes.Buffer
 	log.SetOutput(&buf)
 	// typical setup
-	ldr, args, err := lclzr.NewLocLoader("a", "/", "/newDir", fSys)
+	ldr, args, err := lt.NewLocLoader("a", "/", "/newDir", fSys)
 	req.NoError(err)
 	checkNewLocLoader(req, ldr, &args, "/a", "/", "/newDir", fSys)
 
@@ -89,7 +89,7 @@ func TestNewLocLoaderDefaultForRootTarget(t *testing.T) {
 			req := require.New(t)
 			fSys := makeMemoryFs(t)
 
-			ldr, args, err := lclzr.NewLocLoader(params.target, params.scope, "", fSys)
+			ldr, args, err := lt.NewLocLoader(params.target, params.scope, "", fSys)
 			req.NoError(err)
 			checkNewLocLoader(req, ldr, &args, "/", "/", "/"+dstPrefix, fSys)
 
@@ -116,7 +116,7 @@ func TestNewMultiple(t *testing.T) {
 
 	// default destination for non-file system root target
 	// destination outside of scope
-	ldr, args, err := lclzr.NewLocLoader("/alpha/beta", "/alpha", "", fSys)
+	ldr, args, err := lt.NewLocLoader("/alpha/beta", "/alpha", "", fSys)
 	req.NoError(err)
 	checkNewLocLoader(req, ldr, &args, "/alpha/beta", "/alpha", "/"+dstPrefix+"-beta", fSys)
 
@@ -177,7 +177,7 @@ func TestNewLocLoaderCwdNotRoot(t *testing.T) {
 			req := require.New(t)
 			fSys := makeWdFs(t)[test.wd]
 
-			ldr, args, err := lclzr.NewLocLoader(test.target, test.scope, test.newDir, fSys)
+			ldr, args, err := lt.NewLocLoader(test.target, test.scope, test.newDir, fSys)
 			req.NoError(err)
 			checkLoader(req, ldr, "a/b/c/d/e")
 
@@ -227,7 +227,7 @@ func TestNewLocLoaderFails(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			var buf bytes.Buffer
 			log.SetOutput(&buf)
-			_, _, err := lclzr.NewLocLoader(params.target, params.scope, params.dest, makeMemoryFs(t))
+			_, _, err := lt.NewLocLoader(params.target, params.scope, params.dest, makeMemoryFs(t))
 			require.Error(t, err)
 			require.Empty(t, buf.String())
 		})
@@ -238,7 +238,7 @@ func TestNewFails(t *testing.T) {
 	req := require.New(t)
 	fSys := makeMemoryFs(t)
 
-	ldr, args, err := lclzr.NewLocLoader("/alpha/beta/gamma", "alpha", "alpha/beta/gamma/newDir", fSys)
+	ldr, args, err := lt.NewLocLoader("/alpha/beta/gamma", "alpha", "alpha/beta/gamma/newDir", fSys)
 	req.NoError(err)
 	checkNewLocLoader(req, ldr, &args, "/alpha/beta/gamma", "/alpha", "/alpha/beta/gamma/newDir", fSys)
 
@@ -270,13 +270,13 @@ func TestNewFails(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			fSys := makeMemoryFs(t)
 
-			ldr, _, err := lclzr.NewLocLoader("/alpha/beta/gamma", "alpha", "alpha/beta/gamma/newDir", fSys)
+			ldr, _, err := lt.NewLocLoader("/alpha/beta/gamma", "alpha", "alpha/beta/gamma/newDir", fSys)
 			require.NoError(t, err)
 
 			_, err = ldr.New(root.arg)
 			require.Error(t, err)
 			if !root.localizeError {
-				require.ErrorIs(t, err, lclzr.ErrInvalidRoot)
+				require.ErrorIs(t, err, lt.ErrInvalidRoot)
 			}
 		})
 	}
@@ -286,7 +286,7 @@ func TestLoadFails(t *testing.T) {
 	req := require.New(t)
 	fSys := makeMemoryFs(t)
 
-	ldr, args, err := lclzr.NewLocLoader("./a/../a", "/a/../a", "/a/newDir", fSys)
+	ldr, args, err := lt.NewLocLoader("./a/../a", "/a/../a", "/a/newDir", fSys)
 	req.NoError(err)
 	checkNewLocLoader(req, ldr, &args, "/a", "/a", "/a/newDir", fSys)
 
@@ -303,7 +303,7 @@ func TestLoadFails(t *testing.T) {
 			req := require.New(t)
 			fSys := makeMemoryFs(t)
 
-			ldr, _, err := lclzr.NewLocLoader("./a/../a", "/a/../a", "/a/newDir", fSys)
+			ldr, _, err := lt.NewLocLoader("./a/../a", "/a/../a", "/a/newDir", fSys)
 			req.NoError(err)
 
 			req.NoError(fSys.WriteFile("/a/newDir/pod.yaml", []byte("pod configuration")))
diff --git a/api/internal/loctarget/loctarget.go b/api/internal/loctarget/loctarget.go
new file mode 100644
index 00000000000..5b5fc21d724
--- /dev/null
+++ b/api/internal/loctarget/loctarget.go
@@ -0,0 +1,310 @@
+// Copyright 2022 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package loctarget
+
+import (
+	"log"
+	"path/filepath"
+	"sigs.k8s.io/kustomize/api/internal/plugins/builtinconfig"
+	"sigs.k8s.io/kustomize/api/internal/plugins/builtinhelpers"
+	"strings"
+
+	"sigs.k8s.io/kustomize/api/ifc"
+	plgnsLdr "sigs.k8s.io/kustomize/api/internal/plugins/loader"
+	"sigs.k8s.io/kustomize/api/internal/target"
+	"sigs.k8s.io/kustomize/api/konfig"
+	"sigs.k8s.io/kustomize/api/loader"
+	"sigs.k8s.io/kustomize/api/resmap"
+	"sigs.k8s.io/kustomize/api/types"
+	"sigs.k8s.io/kustomize/kyaml/errors"
+	"sigs.k8s.io/kustomize/kyaml/filesys"
+	"sigs.k8s.io/yaml"
+)
+
+// LocTarget encapsulates all state needed to localize the root at ldr.
+type LocTarget struct {
+	fSys filesys.FileSystem
+
+	// should be LocLoader
+	ldr ifc.Loader
+
+	// destination directory in newDir that mirrors ldr's current root.
+	dst filesys.ConfirmedDir
+
+	// all localize directories created
+	localizeDirs map[filesys.ConfirmedDir]struct{}
+
+	// kusttarget fields
+	validator ifc.Validator
+	rFactory  *resmap.Factory
+	pLdr      *plgnsLdr.Loader
+}
+
+// NewLocTarget is the factory method for LocTarget
+func NewLocTarget(ldr *LocLoader, validator ifc.Validator, rFactory *resmap.Factory, pLdr *plgnsLdr.Loader) (*LocTarget, error) {
+	// log.Println("Localize adjusts for use of legacy kustomization fields")
+	toDst, err := filepath.Rel(ldr.args.Scope.String(), ldr.Root())
+	if err != nil {
+		log.Fatalf("%s: %s", prefixRelErrWhenContains(ldr.args.Scope.String(), ldr.Root()), err.Error())
+	}
+	dst := ldr.args.NewDir.Join(toDst)
+	if err = ldr.fSys.MkdirAll(dst); err != nil {
+		return nil, errors.WrapPrefixf(err, "unable to create directory in localize destination")
+	}
+	return &LocTarget{
+		fSys:         ldr.fSys,
+		ldr:          ldr,
+		dst:          filesys.ConfirmedDir(dst),
+		localizeDirs: make(map[filesys.ConfirmedDir]struct{}),
+		validator:    validator,
+		rFactory:     rFactory,
+		// TODO: do I need to copy? And set working directory?
+		pLdr: pLdr,
+	}, nil
+}
+
+// Localize localizes the root that lt is at
+func (lt *LocTarget) Localize() error {
+	kt := target.NewKustTarget(lt.ldr, lt.validator, lt.rFactory, lt.pLdr)
+	err := kt.Load()
+	if err != nil {
+		return errors.Wrap(err)
+	}
+
+	kust, err := lt.processKust(kt)
+	if err != nil {
+		return err
+	}
+
+	content, err := yaml.Marshal(kust)
+	if err != nil {
+		return errors.WrapPrefixf(err, "unable to serialize localized kustomization file")
+	}
+	if err = lt.fSys.WriteFile(lt.dst.Join(konfig.DefaultKustomizationFileName()), content); err != nil {
+		return errors.WrapPrefixf(err, "unable to write localized kustomization file")
+	}
+	return nil
+}
+
+// processKust returns a copy of the kustomization at kt with all paths localized.
+func (lt *LocTarget) processKust(kt *target.KustTarget) (*types.Kustomization, error) {
+	kust := kt.Kustomization()
+
+	for name, field := range map[string]*struct {
+		Mapper func(string) (string, error)
+		Paths  []string
+	}{
+		"resources": {
+			lt.localizePath,
+			kust.Resources,
+		},
+		"components": {
+			lt.localizeDir,
+			kust.Components,
+		},
+		"crds": {
+			lt.localizeFile,
+			kust.Crds,
+		},
+		"configurations": {
+			lt.localizeFile,
+			kust.Configurations,
+		},
+	} {
+		for i, path := range field.Paths {
+			newPath, err := field.Mapper(path)
+			if err != nil {
+				return &kust, errors.WrapPrefixf(err, "unable to localize %s path", name)
+			}
+			field.Paths[i] = newPath
+		}
+	}
+
+	if path, exists := kust.OpenAPI["path"]; exists {
+		var err error
+		kust.OpenAPI["path"], err = lt.localizeFile(path)
+		if err != nil {
+			return &kust, errors.WrapPrefixf(err, "unable to localize openapi path")
+		}
+	}
+
+	generatorOptions := kust.GeneratorOptions
+	kust.GeneratorOptions = nil
+
+	generatorConfigurator := target.GetGeneratorConfigurators()
+	writers := target.GetPluginWriters()
+	helper := resmap.NewPluginHelpers(lt.ldr, lt.validator, lt.rFactory, lt.pLdr.Config())
+	for _, gbpt := range []builtinhelpers.BuiltinPluginType{
+		builtinhelpers.SecretGenerator,
+		builtinhelpers.ConfigMapGenerator,
+	} {
+		generators, err := generatorConfigurator[gbpt](&kust, helper)
+		if err != nil {
+			return nil, err
+		}
+		writables := make([]resmap.APIObject, 0)
+		for _, g := range generators {
+			m, ok := g.(resmap.Localizable)
+			if !ok {
+				log.Fatalf("localize code not implemented for generator %s", gbpt)
+			}
+			if err = m.MapFiles(lt.localizeFile); err != nil {
+				return nil, err
+			}
+			writables = append(writables, m)
+		}
+		if err = writers[gbpt](&kust, writables); err != nil {
+			return nil, err
+		}
+	}
+	kust.GeneratorOptions = generatorOptions
+
+	transformerConfigurators := target.GetTransformerConfigurators()
+	for _, tbpt := range []builtinhelpers.BuiltinPluginType{
+		builtinhelpers.PatchTransformer,
+		builtinhelpers.PatchStrategicMergeTransformer,
+		builtinhelpers.PatchJson6902Transformer,
+		builtinhelpers.ReplacementTransformer,
+	} {
+		transformers, err := transformerConfigurators[tbpt](&kust, &builtinconfig.TransformerConfig{}, helper)
+		if err != nil {
+			return nil, err
+		}
+		writables := make([]resmap.APIObject, 0)
+		for _, transformer := range transformers {
+			m, ok := transformer.(resmap.Localizable)
+			if !ok {
+				log.Fatalf("localize code not implemented for generator %s", tbpt)
+			}
+			if err = m.MapFiles(lt.localizeFile); err != nil {
+				return nil, err
+			}
+			writables = append(writables, m)
+		}
+		if err = writers[tbpt](&kust, writables); err != nil {
+			return nil, err
+		}
+	}
+
+	return &kust, nil
+}
+
+// localizePath localizes path, a root or file, and returns the localized path
+func (lt *LocTarget) localizePath(path string) (string, error) {
+	locPath, err := lt.localizeDir(path)
+	if errors.Is(err, ErrInvalidRoot) {
+		locPath, err = lt.localizeFile(path)
+	}
+	if err != nil {
+		return "", err
+	}
+	return locPath, nil
+}
+
+// localizeFile localizes file path and returns the localized path
+func (lt *LocTarget) localizeFile(path string) (string, error) {
+	content, err := lt.ldr.Load(path)
+	if err != nil {
+		return "", errors.Wrap(err)
+	}
+
+	var locPath string
+	if loader.HasRemoteFileScheme(path) {
+		if !lt.addLocalizeDir() {
+			return "", errors.Errorf("cannot localize remote '%s': %w at '%s'", path, ErrLocalizeDirExists, lt.ldr.Root())
+		}
+		lt.localizeDirs[lt.dst] = struct{}{}
+		locPath = locFilePath(path)
+	} else { // path must be relative; subject to change in beta
+		// avoid symlinks; only write file corresponding to actual location in root
+		// avoid path that Load() shows to be in root, but may traverse outside
+		// temporarily; for example, ../root/config; problematic for rename and
+		// relocation
+		locPath = cleanFilePath(lt.fSys, filesys.ConfirmedDir(lt.ldr.Root()), path)
+		if !lt.guardLocalizeDir(locPath) {
+			abs := filepath.Join(lt.ldr.Root(), locPath)
+			return "", errors.Errorf("invalid local file path '%s' at '%s': %w", path, abs, ErrLocalizeDirExists)
+		}
+	}
+	cleanPath := lt.dst.Join(locPath)
+	if err = lt.fSys.MkdirAll(filepath.Dir(cleanPath)); err != nil {
+		return "", errors.WrapPrefixf(err, "unable to create directories to localize file '%s'", path)
+	}
+	if err = lt.fSys.WriteFile(cleanPath, content); err != nil {
+		return "", errors.WrapPrefixf(err, "unable to localize file '%s'", path)
+	}
+	return locPath, nil
+}
+
+// localizeDir localizes root path and returns the localized path
+func (lt *LocTarget) localizeDir(path string) (string, error) {
+	ldr, err := lt.ldr.New(path)
+	if err != nil {
+		return "", errors.Wrap(err)
+	}
+	defer func() { _ = ldr.Cleanup() }()
+
+	var locPath string
+	if repo, isRemote := ldr.Repo(); isRemote {
+		if !lt.addLocalizeDir() {
+			return "", errors.Errorf("cannot localize remote '%s': %w at '%s'", path, ErrLocalizeDirExists, lt.ldr.Root())
+		}
+		locPath = locRootPath(path, filesys.ConfirmedDir(repo), filesys.ConfirmedDir(ldr.Root()))
+	} else {
+		locPath, err = filepath.Rel(lt.ldr.Root(), ldr.Root())
+		if err != nil {
+			//nolint:gocritic // should never occur, but if hit, something fundamentally wrong; should immediately exit
+			log.Fatalf("rel path error for 2 navigable roots '%s', '%s': %s", lt.ldr.Root(), ldr.Root(), err.Error())
+		}
+		if !lt.guardLocalizeDir(locPath) {
+			return "", errors.Errorf("invalid local root path '%s' at '%s': %w", path, ldr.Root(), ErrLocalizeDirExists)
+		}
+	}
+	newDst := lt.dst.Join(locPath)
+	if err = lt.fSys.MkdirAll(newDst); err != nil {
+		return "", errors.WrapPrefixf(err, "unable to create root '%s' in localize destination", path)
+	}
+	err = (&LocTarget{
+		fSys:         lt.fSys,
+		ldr:          ldr,
+		dst:          filesys.ConfirmedDir(newDst),
+		localizeDirs: lt.localizeDirs,
+		validator:    lt.validator,
+		rFactory:     lt.rFactory,
+		pLdr:         lt.pLdr,
+	}).Localize()
+	if err != nil {
+		return "", errors.WrapPrefixf(err, "unable to localize root '%s'", path)
+	}
+	return locPath, nil
+}
+
+// addLocalizeDir returns whether it is able to add a localize directory at dst
+func (lt *LocTarget) addLocalizeDir() bool {
+	if _, exists := lt.localizeDirs[lt.dst]; !exists && lt.fSys.Exists(lt.dst.Join(LocalizeDir)) {
+		return false
+	}
+	lt.localizeDirs[lt.dst] = struct{}{}
+	return true
+}
+
+// guardLocalizeDir returns false if local path enters a localize directory, and true otherwise
+func (lt *LocTarget) guardLocalizeDir(path string) bool {
+	var prefix string
+	for _, dir := range strings.Split(path, string(filepath.Separator)) {
+		parent := lt.dst.Join(prefix)
+		// if never processed parent, inner directories cannot be localize directories
+		if !lt.fSys.Exists(parent) {
+			return true
+		}
+		prefix = filepath.Join(prefix, dir)
+		if dir != LocalizeDir {
+			continue
+		}
+		if _, exists := lt.localizeDirs[filesys.ConfirmedDir(parent)]; exists {
+			return false
+		}
+	}
+	return true
+}
diff --git a/api/internal/loctarget/loctarget_test.go b/api/internal/loctarget/loctarget_test.go
new file mode 100644
index 00000000000..7e7fa4fe814
--- /dev/null
+++ b/api/internal/loctarget/loctarget_test.go
@@ -0,0 +1,341 @@
+// Copyright 2022 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package loctarget_test
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"sigs.k8s.io/kustomize/kyaml/filesys"
+)
+
+func makeMemoryFs(t *testing.T) filesys.FileSystem {
+	t.Helper()
+	req := require.New(t)
+
+	fSys := filesys.MakeFsInMemory()
+	req.NoError(fSys.MkdirAll("/a/b"))
+	req.NoError(fSys.WriteFile("/a/pod.yaml", []byte("pod configuration")))
+
+	dirChain := "/alpha/beta/gamma/delta"
+	req.NoError(fSys.MkdirAll(dirChain))
+	req.NoError(fSys.WriteFile(filepath.Join(dirChain, "deployment.yaml"), []byte("deployment configuration")))
+	req.NoError(fSys.Mkdir("/alpha/beta/say"))
+	return fSys
+}
+
+func addFiles(t *testing.T, fSys filesys.FileSystem, parentDir string, files map[string]string) {
+	t.Helper()
+
+	// in-memory file system makes all necessary dirs when writing files
+	for file, content := range files {
+		require.NoError(t, fSys.WriteFile(filepath.Join(parentDir, file), []byte(content))) /**/
+	}
+}
+
+//func TestPatchStrategicMergeOnFile(t *testing.T) {
+//	req := require.New(t)
+//
+//	var buf bytes.Buffer
+//	log.SetOutput(&buf)
+//	fSys := makeMemoryFs(t)
+//
+//	// tests both inline and file patches
+//	// tests localize handles nested directory and winding path
+//	files := map[string]string{
+//		"kustomization.yaml": `
+//patchesStrategicMerge:
+//- ../beta/say/patch.yaml
+//- |-
+// apiVersion: v1
+// metadata:
+//   name: myPod
+// kind: Pod
+// spec:
+//   containers:
+//   - name: nginx
+//     image: nginx:1.14.2
+//     ports:
+//     - containerPort: 80
+//resources:
+//- localized-files`,
+//		// in the absence of remote references, localize directory name can be used by other files
+//		"localized-files": "deployment configuration",
+//		"say/patch.yaml": `apiVersion: v1
+//metadata:
+//  name: myPod
+//kind: Pod
+//spec:
+//  containers:
+//  - name: app
+//    image: images.my-company.example/app:v4`,
+//	}
+//	addFiles(t, fSys, "/alpha/beta", files)
+//	err := loctarget.Run(fSys, "/alpha/beta", "", "/alpha/newDir")
+//	req.NoError(err)
+//	req.Empty(buf.String())
+//
+//	fSysExpected := makeMemoryFs(t)
+//	addFiles(t, fSysExpected, "/alpha/beta", files)
+//	files["kustomization.yaml"] = `apiVersion: kustomize.config.k8s.io/v1beta1
+//kind: Kustomization
+//patchesStrategicMerge:
+//- say/patch.yaml
+//- |-
+//  apiVersion: v1
+//  metadata:
+//    name: myPod
+//  kind: Pod
+//  spec:
+//    containers:
+//    - name: nginx
+//      image: nginx:1.14.2
+//      ports:
+//      - containerPort: 80
+//resources:
+//- localized-files
+//`
+//	// directories in scope, but not referenced should not be copied to destination
+//	addFiles(t, fSysExpected, "/alpha/newDir", files)
+//	req.Equal(fSysExpected, fSys)
+//}
+
+//func TestComponents(t *testing.T) {
+//	var buf bytes.Buffer
+//	log.SetOutput(&buf)
+//	fSys := makeMemoryFs(t)
+//
+//	// components test directory references
+//	files := map[string]string{
+//		// winding directory path
+//		"a/kustomization.yaml": `
+//components:
+//- b/../../alpha/beta/..
+//- localized-files
+//resources:
+//- pod.yaml
+//- job.yaml
+//`,
+//
+//		"a/job.yaml": "job configuration",
+//
+//		// should recognize different kustomization names
+//		// inline and file replacements
+//		"alpha/kustomization.yml": `apiVersion: kustomize.config.k8s.io/v1alpha1
+//kind: Component
+//replacements:
+//- source:
+//   fieldPath: metadata.name
+//   kind: Job
+// targets:
+// - fieldPaths:
+//   - metadata.name
+//   select:
+//     kind: Pod
+//- path: my-replacement.yaml
+//`,
+//
+//		"alpha/my-replacement.yaml": "replacement configuration",
+//
+//		// in the absence of remote references, directories can share localize directory name
+//		"a/localized-files/Kustomization": `apiVersion: kustomize.config.k8s.io/v1alpha1
+//kind: Component
+//patches:
+//- patch: |-
+//   - op: replace
+//     path: /spec/containers/0/name
+//     value: my-nginx
+// target:
+//   kind: Pod
+//- path: patch.yaml
+// target:
+//   kind: Pod
+//`,
+//
+//		"a/localized-files/patch.yaml": "patch configuration",
+//	}
+//	addFiles(t, fSys, "/", files)
+//
+//	err := loctarget.Run(fSys, "/a", "/", "")
+//	require.NoError(t, err)
+//	require.Empty(t, buf.String())
+//
+//	fSysExpected := makeMemoryFs(t)
+//	addFiles(t, fSysExpected, "/", files)
+//
+//	filesExpected := map[string]string{
+//		"a/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
+//components:
+//- ../alpha
+//- localized-files
+//kind: Kustomization
+//resources:
+//- pod.yaml
+//- job.yaml
+//`,
+//		"a/pod.yaml":                           "pod configuration",
+//		"a/job.yaml":                           files["a/job.yaml"],
+//		"alpha/kustomization.yaml":             files["alpha/kustomization.yml"],
+//		"alpha/my-replacement.yaml":            files["alpha/my-replacement.yaml"],
+//		"a/localized-files/kustomization.yaml": files["a/localized-files/Kustomization"],
+//		"a/localized-files/patch.yaml":         files["a/localized-files/patch.yaml"],
+//	}
+//	addFiles(t, fSysExpected, "/localized-a", filesExpected)
+//	require.Equal(t, fSysExpected, fSys)
+//}
+
+//func TestNestedRoots(t *testing.T) {
+//	var buf bytes.Buffer
+//	log.SetOutput(&buf)
+//
+//	fSys := makeMemoryFs(t)
+//	files := map[string]string{
+//		// both file and directory resources
+//		// kustomization fields without paths should also be copied
+//		"beta/gamma/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
+//kind: Kustomization
+//namePrefix: nested-roots-
+//resources:
+//- delta/deployment.yaml
+//- ../say
+//`,
+//
+//		// configMapGenerator with envs and files, with both the default filename and keys
+//		"beta/say/kustomization.yaml": `
+//resources:
+//- ../gamma/./delta/
+//- ../../beta/gamma/delta/epsilon
+//configMapGenerator:
+//- name: my-config-map
+//  behavior: create
+//  files:
+//  - application.properties
+//  - environment.properties=../gamma/../say/weird-name
+//  literals:
+//  - THIS_KEY=/really/does/not/matter
+//  envs:
+//  - ./more.properties`,
+//
+//		"beta/say/application.properties": "application properties",
+//
+//		"beta/say/weird-name": "weird-name properties",
+//
+//		"beta/say/more.properties": "more properties",
+//
+//		"beta/gamma/delta/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
+//commonLabels:
+//  label: value
+//crds:
+//- epsilon/type-new-kind.yaml
+//kind: Kustomization
+//resources:
+//- new-kind.yaml
+//`,
+//
+//		"beta/gamma/delta/new-kind.yaml": "new-kind configuration",
+//
+//		"beta/gamma/delta/epsilon/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
+//commonLabels:
+//  label: anotherValue
+//crds:
+//- type-new-kind.yaml
+//kind: Kustomization
+//resources:
+//- new-kind.yaml
+//`,
+//
+//		"beta/gamma/delta/epsilon/new-kind.yaml": "another new-kind configuration",
+//
+//		// referenced more than once
+//		"beta/gamma/delta/epsilon/type-new-kind.yaml": "new-kind definition",
+//	}
+//	addFiles(t, fSys, "/alpha", files)
+//	err := loctarget.Run(fSys, "/alpha/beta/gamma", "/alpha",
+//		"/alpha/beta/gamma/delta/newDir")
+//	require.NoError(t, err)
+//	require.Empty(t, buf.String())
+//
+//	fSysExpected := makeMemoryFs(t)
+//	addFiles(t, fSysExpected, "/alpha", files)
+//	files["beta/say/kustomization.yaml"] = `apiVersion: kustomize.config.k8s.io/v1beta1
+//configMapGenerator:
+//- behavior: create
+//  envs:
+//  - more.properties
+//  files:
+//  - application.properties
+//  - environment.properties=weird-name
+//  literals:
+//  - THIS_KEY=/really/does/not/matter
+//  name: my-config-map
+//kind: Kustomization
+//resources:
+//- ../gamma/delta
+//- ../gamma/delta/epsilon
+//`
+//	files["beta/gamma/delta/deployment.yaml"] = "deployment configuration"
+//	addFiles(t, fSysExpected, "/alpha/beta/gamma/delta/newDir", files)
+//	require.Equal(t, fSysExpected, fSys)
+//}
+//
+//func TestExtensions(t *testing.T) {
+//	req := require.New(t)
+//
+//	var buf bytes.Buffer
+//	log.SetOutput(&buf)
+//
+//	fSys := makeMemoryFs(t)
+//	files := map[string]string{
+//		"a/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
+//generators:
+//- generator.yaml
+//kind: Kustomization
+//resources:
+//- pod.yaml
+//transformers:
+//- transformer.yaml
+//`,
+//
+//		"a/generator.yaml": "generator configuration",
+//
+//		"a/transformer.yaml": "transformer configuration",
+//	}
+//	addFiles(t, fSys, "/", files)
+//
+//	err := loctarget.Run(fSys, "a", ".", "newDir")
+//	req.NoError(err)
+//	req.Contains(buf.String(), loctarget.GeneratorWarning)
+//	req.Contains(buf.String(), loctarget.TransformerWarning)
+//
+//	fSysExpected := makeMemoryFs(t)
+//	addFiles(t, fSysExpected, "/", files)
+//	filesExpected := map[string]string{
+//		"a/kustomization.yaml": files["a/kustomization.yaml"],
+//		"a/pod.yaml":           "pod configuration",
+//	}
+//	addFiles(t, fSysExpected, "/newDir", filesExpected)
+//	req.Equal(fSysExpected, fSys)
+//}
+//
+//func TestCleanDstOnErr(t *testing.T) {
+//	fSys := makeMemoryFs(t)
+//	files := map[string]string{
+//		"a/kustomization.yaml": `
+//resources:
+//- pod.yaml
+//- b
+//namePrefix: my-`,
+//		"b/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
+//kind: Kustomization
+//invalidField: invalidValue`,
+//	}
+//	addFiles(t, fSys, "/", files)
+//	err := loctarget.Run(fSys, "/a", "/", "/newDir")
+//	require.Error(t, err)
+//
+//	fSysExpected := makeMemoryFs(t)
+//	addFiles(t, fSysExpected, "/", files)
+//	require.Equal(t, fSysExpected, fSys)
+//}
diff --git a/api/internal/localizer/util.go b/api/internal/loctarget/util.go
similarity index 89%
rename from api/internal/localizer/util.go
rename to api/internal/loctarget/util.go
index d7213e91955..1875f416984 100644
--- a/api/internal/localizer/util.go
+++ b/api/internal/loctarget/util.go
@@ -1,7 +1,7 @@
 // Copyright 2022 The Kubernetes Authors.
 // SPDX-License-Identifier: Apache-2.0
 
-package localizer
+package loctarget
 
 import (
 	"log"
@@ -11,8 +11,6 @@ import (
 
 	"sigs.k8s.io/kustomize/api/ifc"
 	"sigs.k8s.io/kustomize/api/internal/git"
-	"sigs.k8s.io/kustomize/api/kv"
-	"sigs.k8s.io/kustomize/api/types"
 	"sigs.k8s.io/kustomize/kyaml/errors"
 	"sigs.k8s.io/kustomize/kyaml/filesys"
 )
@@ -123,7 +121,7 @@ func cleanFilePath(fSys filesys.FileSystem, root filesys.ConfirmedDir, file stri
 	return locPath
 }
 
-// locFilePath returns the relative localized path of validated file url u
+// locFilePath returns the relative localized path of validated file url fileURL
 func locFilePath(fileURL string) string {
 	// file urls must have http or https scheme
 	u, err := url.Parse(fileURL)
@@ -174,29 +172,3 @@ func parseDomain(host string) string {
 	// remove http path delimiter
 	return strings.TrimSuffix(target, "/")
 }
-
-// localizeGenerator localizes the paths in gen using lclzr
-func localizeGenerator(gen *types.GeneratorArgs, lclzr *localizer) error {
-	for i, env := range gen.EnvSources {
-		newPath, err := lclzr.localizeFile(env)
-		if err != nil {
-			return err
-		}
-		gen.EnvSources[i] = newPath
-	}
-	for i, file := range gen.FileSources {
-		k, f, err := kv.ParseFileSource(file)
-		if err != nil {
-			return errors.Wrap(err)
-		}
-		newFile, err := lclzr.localizeFile(f)
-		if err != nil {
-			return err
-		}
-		if file != f {
-			newFile = k + "=" + newFile
-		}
-		gen.FileSources[i] = newFile
-	}
-	return nil
-}
diff --git a/api/internal/localizer/util_test.go b/api/internal/loctarget/util_test.go
similarity index 90%
rename from api/internal/localizer/util_test.go
rename to api/internal/loctarget/util_test.go
index ca8096e739f..d3117e49137 100644
--- a/api/internal/localizer/util_test.go
+++ b/api/internal/loctarget/util_test.go
@@ -1,7 +1,7 @@
 // Copyright 2022 The Kubernetes Authors.
 // SPDX-License-Identifier: Apache-2.0
 
-package localizer //nolint:testpackage
+package loctarget //nolint:testpackage
 
 import (
 	"testing"
diff --git a/api/krusty/localizer.go b/api/krusty/localizer.go
new file mode 100644
index 00000000000..0360d62769b
--- /dev/null
+++ b/api/krusty/localizer.go
@@ -0,0 +1,45 @@
+// Copyright 2022 The Kubernetes Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package krusty
+
+import (
+	"log"
+
+	"sigs.k8s.io/kustomize/api/internal/loctarget"
+	pluginsLoader "sigs.k8s.io/kustomize/api/internal/plugins/loader"
+	"sigs.k8s.io/kustomize/api/provider"
+	"sigs.k8s.io/kustomize/api/resmap"
+	"sigs.k8s.io/kustomize/kyaml/errors"
+	"sigs.k8s.io/kustomize/kyaml/filesys"
+)
+
+// Localizer runs `kustomize localize`: it simulates execution of the kustomize CLI sub-process.
+type Localizer struct {
+	Scope string
+}
+
+// Run attempts to localize the kustomization root at targetArg with the given localize arguments
+func (lclzr *Localizer) Run(fSys filesys.FileSystem, targetArg string, newDirArg string) error {
+	ldr, args, err := loctarget.NewLocLoader(targetArg, lclzr.Scope, newDirArg, fSys)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = ldr.Cleanup() }()
+
+	depProvider := provider.NewDepProvider()
+	rFactory := resmap.NewFactory(depProvider.GetResourceFactory())
+	pLdr := pluginsLoader.NewLoader(MakeDefaultOptions().PluginConfig, rFactory, filesys.MakeFsOnDisk())
+	lt, err := loctarget.NewLocTarget(ldr, depProvider.GetFieldValidator(), rFactory, pLdr)
+	if err != nil {
+		return err
+	}
+	err = lt.Localize()
+	if err != nil {
+		if errCleanup := fSys.RemoveAll(args.NewDir.String()); errCleanup != nil {
+			log.Printf("unable to clean localize destination: %s", errCleanup.Error())
+		}
+		return errors.WrapPrefixf(err, "unable to localize target '%s'", targetArg)
+	}
+	return nil
+}
diff --git a/api/krusty/remotelocalizer_test.go b/api/krusty/remotelocalizer_test.go
index f0b69854d2b..dd8b098855f 100644
--- a/api/krusty/remotelocalizer_test.go
+++ b/api/krusty/remotelocalizer_test.go
@@ -10,10 +10,11 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	lt "sigs.k8s.io/kustomize/api/internal/loctarget"
+	"sigs.k8s.io/kustomize/api/krusty"
 	"testing"
 
 	"github.com/stretchr/testify/require"
-	loc "sigs.k8s.io/kustomize/api/internal/localizer"
 	"sigs.k8s.io/kustomize/kyaml/filesys"
 )
 
@@ -100,7 +101,7 @@ kind: Kustomization
 resources:
 - %s/github.com/kubernetes-sigs/kustomize/kustomize/v4.5.7/api/krusty/testdata/localize/simple
 - hpa.yaml
-`, loc.LocalizeDir),
+`, lt.LocalizeDir),
 
 		"hpa.yaml": `apiVersion: autoscaling/v2
 kind: HorizontalPodAutoscaler
@@ -259,7 +260,9 @@ openapi:
 	// unable to reference parent directories in in-memory file system
 	changeWd(t, filepath.Join(scope, "root2", "nested-root"))
 	// target, destination arguments contain symlinks
-	err := loc.Run(fSys, "../../../fake-target", "../..", "../../../root2-link/newDir")
+	err := (&krusty.Localizer{
+		Scope: "../..",
+	}).Run(fSys, "../../../fake-target", "../../../root2-link/newDir")
 	req.NoError(err)
 
 	dst := filepath.Join(scope, "root2", "newDir")
@@ -292,7 +295,9 @@ func TestRemoteTarget(t *testing.T) {
 	// slash in ref
 	target := simpleHTTPS + query
 	// folder in repo with default localize destination
-	err := loc.Run(fSys, target, "", "")
+	err := (&krusty.Localizer{
+		Scope: "",
+	}).Run(fSys, target, "")
 	require.NoError(t, err)
 
 	dst := filepath.Join(dir, "localized-simple-kustomize-v4.5.7")
@@ -304,239 +309,240 @@ func TestRemoteTarget(t *testing.T) {
 	checkFileSystem(t, fSys, dir, dirs, files)
 }
 
-func TestRemoteFile(t *testing.T) {
-	fSys := filesys.MakeFsOnDisk()
-	checkLogs(t)
-	dir := t.TempDir()
-
-	// unreferenced localize directory should not cause error
-	extraDirs := map[string]struct{}{filepath.Join(dir, loc.LocalizeDir): {}}
-	files := map[string]string{
-		filepath.Join(dir, "kustomization.yaml"): fmt.Sprintf(`
-resources:
-- %s
-namePrefix: my-`, fileURL),
-	}
-	mkDirsAndFiles(t, fSys, extraDirs, files)
-
-	dst := filepath.Join(dir, "newDir")
-	err := loc.Run(fSys, dir, "", dst)
-	require.NoError(t, err)
-
-	hostPrefix := filepath.Join(dst, loc.LocalizeDir, "raw.githubusercontent.com")
-	simplePrefix := filepath.Join(hostPrefix, orgToRefPrefix, pathPrefix, "simple")
-	checkFileSystem(t, fSys, dir,
-		combine(t,
-			extraDirs,
-			addPrefixToPaths(t, hostPrefix, combine(t, orgrepoDirs(), refDirs(),
-				addPrefixToPaths(t, orgToRefPrefix, testDirs()))),
-			map[string]struct{}{
-				dir:                                 {},
-				dst:                                 {},
-				filepath.Join(dst, loc.LocalizeDir): {},
-				hostPrefix:                          {},
-				simplePrefix:                        {},
-			}),
-
-		combine(t, files, map[string]string{
-			filepath.Join(dst, "kustomization.yaml"): fmt.Sprintf(`apiVersion: kustomize.config.k8s.io/v1beta1
-kind: Kustomization
-namePrefix: my-
-resources:
-- %s/raw.githubusercontent.com/kubernetes-sigs/kustomize/kustomize/v4.5.7/api/krusty/testdata/localize/simple/deployment.yaml
-`, loc.LocalizeDir),
-
-			filepath.Join(simplePrefix, "deployment.yaml"): simpleFiles()["deployment.yaml"],
-		}))
-}
-
-func TestNestedRemoteRoots(t *testing.T) {
-	fSys := filesys.MakeFsOnDisk()
-	checkLogs(t)
-	dir := t.TempDir()
-
-	// should not conflict with localize directory name
-	falseLocalizeDir := loc.LocalizeDir + loc.LocalizeDir
-	roots := map[string]struct{}{
-		falseLocalizeDir: {},
-	}
-	absoluteRoots := addPrefixToPaths(t, dir, roots)
-
-	files := map[string]string{
-		// ref without slash
-		// ssh url
-		"kustomization.yaml": fmt.Sprintf(`
-resources:
-- git@github.com:kubernetes-sigs/kustomize.git//api/krusty/testdata/localize/remote?submodules=0&ref=master&timeout=300
-- %s%s
-- ./%s
-namePrefix: my-`, simpleHTTPS, query, falseLocalizeDir),
-
-		filepath.Join(falseLocalizeDir, "kustomization.yaml"): `apiVersion: kustomize.config.k8s.io/v1beta1
-kind: Kustomization
-namePrefix: very-own-
-resources:
-- configmap.yaml
-`,
-
-		filepath.Join(falseLocalizeDir, "configmap.yaml"): "configmap configuration",
-	}
-	absoluteFiles := addPrefixToPaths(t, dir, files)
-	mkDirsAndFiles(t, fSys, absoluteRoots, absoluteFiles)
-
-	configureGitSSHCommand(t) // must be called before changing working directory
-	changeWd(t, dir)
-
-	err := loc.Run(fSys, ".", ".", "")
-	require.NoError(t, err)
-
-	dst := filepath.Join(dir, "localized-"+filepath.Base(dir))
-
-	masterDirs := addPrefixToPaths(t, filepath.Join(loc.LocalizeDir, "github.com"), combine(t,
-		orgrepoDirs(),
-		map[string]struct{}{"kubernetes-sigs/kustomize/master": {}},
-		addPrefixToPaths(t, "kubernetes-sigs/kustomize/master", testDirs())))
-	versionDirs := addPrefixToPaths(t, filepath.Join(loc.LocalizeDir, "github.com"), combine(t,
-		orgrepoDirs(), refDirs(), addPrefixToPaths(t, orgToRefPrefix, testDirs())))
-
-	remoteDir := filepath.Join(dst, loc.LocalizeDir, "github.com", "kubernetes-sigs", "kustomize", "master", pathPrefix,
-		"remote")
-	simpleRelDir := filepath.Join(loc.LocalizeDir, "github.com", orgToRefPrefix, pathPrefix, "simple")
-
-	checkFileSystem(t, fSys, dir,
-		combine(t, absoluteRoots, addPrefixToPaths(t, dst, combine(t, roots, masterDirs, versionDirs)),
-			addPrefixToPaths(t, remoteDir, versionDirs), map[string]struct{}{
-				dir:                                 {},
-				dst:                                 {},
-				filepath.Join(dst, loc.LocalizeDir): {},
-				filepath.Join(dst, loc.LocalizeDir, "github.com"):       {},
-				filepath.Join(dst, simpleRelDir):                        {},
-				remoteDir:                                               {},
-				filepath.Join(remoteDir, loc.LocalizeDir):               {},
-				filepath.Join(remoteDir, loc.LocalizeDir, "github.com"): {},
-				filepath.Join(remoteDir, simpleRelDir):                  {},
-			}),
-		combine(t, absoluteFiles, addPrefixToPaths(t, remoteDir, remoteFiles()),
-			addPrefixToPaths(t, filepath.Join(dst, simpleRelDir), simpleFiles()),
-			addPrefixToPaths(t, filepath.Join(remoteDir, simpleRelDir), simpleFiles()),
-			addPrefixToPaths(t, dst, map[string]string{
-				"kustomization.yaml": fmt.Sprintf(`apiVersion: kustomize.config.k8s.io/v1beta1
-kind: Kustomization
-namePrefix: my-
-resources:
-- %s/github.com/kubernetes-sigs/kustomize/master/api/krusty/testdata/localize/remote
-- %s/github.com/kubernetes-sigs/kustomize/kustomize/v4.5.7/api/krusty/testdata/localize/simple
-- %s
-`, loc.LocalizeDir, loc.LocalizeDir, falseLocalizeDir),
-				filepath.Join(falseLocalizeDir, "kustomization.yaml"): files[filepath.Join(falseLocalizeDir, "kustomization.yaml")],
-				filepath.Join(falseLocalizeDir, "configmap.yaml"):     files[filepath.Join(falseLocalizeDir, "configmap.yaml")],
-			})))
-}
-
-func TestExistingLocalizeDir(t *testing.T) {
-	fSys := filesys.MakeFsOnDisk()
-	checkLogs(t)
-	dir := t.TempDir()
-	locDir := filepath.Join(loc.LocalizeDir, loc.LocalizeDir)
-
-	folders := addPrefixToPaths(t, dir, map[string]struct{}{
-		loc.LocalizeDir: {},
-		locDir:          {},
-		"root2":         {},
-	})
-	files := addPrefixToPaths(t, dir, map[string]string{
-		filepath.Join(loc.LocalizeDir, "kustomization.yaml"): fmt.Sprintf(`
-resources:
-- %s
-- ../root2
-namePrefix: my-`, fileURL),
-		"root2/kustomization.yaml": fmt.Sprintf(`
-resources:
-- ../%s
-nameSuffix: config`, filepath.Join(loc.LocalizeDir, loc.LocalizeDir)),
-		filepath.Join(locDir, "kustomization.yaml"): `
-resources: 
-- pod.yaml
-namePrefix: prod-`,
-		filepath.Join(locDir, "pod.yaml"): "pod configuration",
-	})
-	mkDirsAndFiles(t, fSys, folders, files)
-
-	err := loc.Run(fSys, filepath.Join(dir, loc.LocalizeDir), dir, filepath.Join(dir, "newDir"))
-	require.ErrorIs(t, err, loc.ErrLocalizeDirExists)
-	checkFileSystem(t, fSys, dir, combine(t, map[string]struct{}{dir: {}}, folders), files)
-}
-
-func TestRemoteResourceNoRef(t *testing.T) {
-	req := require.New(t)
-	fSys := filesys.MakeFsOnDisk()
-	checkLogs(t)
-
-	dir := t.TempDir()
-	kustPath := filepath.Join(dir, "kustomization.yaml")
-	files := map[string]string{
-		kustPath: fmt.Sprintf(`apiVersion: kustomize.config.k8s.io/v1beta1
-kind: Kustomization
-resources:
-- %s
-`, simpleHTTPS),
-	}
-	err := fSys.WriteFile(kustPath, []byte(files[kustPath]))
-	req.NoError(err)
-
-	err = loc.Run(fSys, dir, "", filepath.Join(dir, "newDir"))
-	req.ErrorIs(err, loc.ErrNoRef)
-	checkFileSystem(t, fSys, dir, map[string]struct{}{
-		dir: {},
-	}, files)
-}
-
-func TestBadArgs(t *testing.T) {
-	tests := map[string]*struct {
-		target string
-		scope  string
-		newDir string
-	}{
-		"target missing ref": {
-			simpleHTTPS,
-			"",
-			"",
-		},
-		"non-empty scope for remote target": {
-			simpleHTTPS + query,
-			"api",
-			"",
-		},
-		// unable to test on in-memory file system, which treats mkdir and mkdirall the same
-		"dst in non-existing dir": {
-			".",
-			"",
-			"does-not-exist/does-not-exist",
-		},
-	}
-	for name, args := range tests {
-		t.Run(name, func(t *testing.T) {
-			fSys := filesys.MakeFsOnDisk()
-			checkLogs(t)
-
-			dir := t.TempDir()
-			kustPath := filepath.Join(dir, "kustomization.yaml")
-			files := map[string]string{
-				kustPath: `apiVersion: kustomize.config.k8s.io/v1beta1
-kind: Kustomization
-`,
-			}
-			err := fSys.WriteFile(filepath.Join(dir, "kustomization.yaml"), []byte(files[kustPath]))
-			require.NoError(t, err)
-
-			changeWd(t, dir)
-
-			err = loc.Run(fSys, args.target, args.scope, args.newDir)
-			require.Error(t, err)
-			// cleaned dst
-			checkFileSystem(t, fSys, dir, map[string]struct{}{
-				dir: {},
-			}, files)
-		})
-	}
-}
+//
+//func TestRemoteFile(t *testing.T) {
+//	fSys := filesys.MakeFsOnDisk()
+//	checkLogs(t)
+//	dir := t.TempDir()
+//
+//	// unreferenced localize directory should not cause error
+//	extraDirs := map[string]struct{}{filepath.Join(dir, loc.LocalizeDir): {}}
+//	files := map[string]string{
+//		filepath.Join(dir, "kustomization.yaml"): fmt.Sprintf(`
+//resources:
+//- %s
+//namePrefix: my-`, fileURL),
+//	}
+//	mkDirsAndFiles(t, fSys, extraDirs, files)
+//
+//	dst := filepath.Join(dir, "newDir")
+//	err := loc.Run(fSys, dir, "", dst)
+//	require.NoError(t, err)
+//
+//	hostPrefix := filepath.Join(dst, loc.LocalizeDir, "raw.githubusercontent.com")
+//	simplePrefix := filepath.Join(hostPrefix, orgToRefPrefix, pathPrefix, "simple")
+//	checkFileSystem(t, fSys, dir,
+//		combine(t,
+//			extraDirs,
+//			addPrefixToPaths(t, hostPrefix, combine(t, orgrepoDirs(), refDirs(),
+//				addPrefixToPaths(t, orgToRefPrefix, testDirs()))),
+//			map[string]struct{}{
+//				dir:                                 {},
+//				dst:                                 {},
+//				filepath.Join(dst, loc.LocalizeDir): {},
+//				hostPrefix:                          {},
+//				simplePrefix:                        {},
+//			}),
+//
+//		combine(t, files, map[string]string{
+//			filepath.Join(dst, "kustomization.yaml"): fmt.Sprintf(`apiVersion: kustomize.config.k8s.io/v1beta1
+//kind: Kustomization
+//namePrefix: my-
+//resources:
+//- %s/raw.githubusercontent.com/kubernetes-sigs/kustomize/kustomize/v4.5.7/api/krusty/testdata/localize/simple/deployment.yaml
+//`, loc.LocalizeDir),
+//
+//			filepath.Join(simplePrefix, "deployment.yaml"): simpleFiles()["deployment.yaml"],
+//		}))
+//}
+//
+//func TestNestedRemoteRoots(t *testing.T) {
+//	fSys := filesys.MakeFsOnDisk()
+//	checkLogs(t)
+//	dir := t.TempDir()
+//
+//	// should not conflict with localize directory name
+//	falseLocalizeDir := loc.LocalizeDir + loc.LocalizeDir
+//	roots := map[string]struct{}{
+//		falseLocalizeDir: {},
+//	}
+//	absoluteRoots := addPrefixToPaths(t, dir, roots)
+//
+//	files := map[string]string{
+//		// ref without slash
+//		// ssh url
+//		"kustomization.yaml": fmt.Sprintf(`
+//resources:
+//- git@github.com:kubernetes-sigs/kustomize.git//api/krusty/testdata/localize/remote?submodules=0&ref=master&timeout=300
+//- %s%s
+//- ./%s
+//namePrefix: my-`, simpleHTTPS, query, falseLocalizeDir),
+//
+//		filepath.Join(falseLocalizeDir, "kustomization.yaml"): `apiVersion: kustomize.config.k8s.io/v1beta1
+//kind: Kustomization
+//namePrefix: very-own-
+//resources:
+//- configmap.yaml
+//`,
+//
+//		filepath.Join(falseLocalizeDir, "configmap.yaml"): "configmap configuration",
+//	}
+//	absoluteFiles := addPrefixToPaths(t, dir, files)
+//	mkDirsAndFiles(t, fSys, absoluteRoots, absoluteFiles)
+//
+//	configureGitSSHCommand(t) // must be called before changing working directory
+//	changeWd(t, dir)
+//
+//	err := loc.Run(fSys, ".", ".", "")
+//	require.NoError(t, err)
+//
+//	dst := filepath.Join(dir, "localized-"+filepath.Base(dir))
+//
+//	masterDirs := addPrefixToPaths(t, filepath.Join(loc.LocalizeDir, "github.com"), combine(t,
+//		orgrepoDirs(),
+//		map[string]struct{}{"kubernetes-sigs/kustomize/master": {}},
+//		addPrefixToPaths(t, "kubernetes-sigs/kustomize/master", testDirs())))
+//	versionDirs := addPrefixToPaths(t, filepath.Join(loc.LocalizeDir, "github.com"), combine(t,
+//		orgrepoDirs(), refDirs(), addPrefixToPaths(t, orgToRefPrefix, testDirs())))
+//
+//	remoteDir := filepath.Join(dst, loc.LocalizeDir, "github.com", "kubernetes-sigs", "kustomize", "master", pathPrefix,
+//		"remote")
+//	simpleRelDir := filepath.Join(loc.LocalizeDir, "github.com", orgToRefPrefix, pathPrefix, "simple")
+//
+//	checkFileSystem(t, fSys, dir,
+//		combine(t, absoluteRoots, addPrefixToPaths(t, dst, combine(t, roots, masterDirs, versionDirs)),
+//			addPrefixToPaths(t, remoteDir, versionDirs), map[string]struct{}{
+//				dir:                                 {},
+//				dst:                                 {},
+//				filepath.Join(dst, loc.LocalizeDir): {},
+//				filepath.Join(dst, loc.LocalizeDir, "github.com"):       {},
+//				filepath.Join(dst, simpleRelDir):                        {},
+//				remoteDir:                                               {},
+//				filepath.Join(remoteDir, loc.LocalizeDir):               {},
+//				filepath.Join(remoteDir, loc.LocalizeDir, "github.com"): {},
+//				filepath.Join(remoteDir, simpleRelDir):                  {},
+//			}),
+//		combine(t, absoluteFiles, addPrefixToPaths(t, remoteDir, remoteFiles()),
+//			addPrefixToPaths(t, filepath.Join(dst, simpleRelDir), simpleFiles()),
+//			addPrefixToPaths(t, filepath.Join(remoteDir, simpleRelDir), simpleFiles()),
+//			addPrefixToPaths(t, dst, map[string]string{
+//				"kustomization.yaml": fmt.Sprintf(`apiVersion: kustomize.config.k8s.io/v1beta1
+//kind: Kustomization
+//namePrefix: my-
+//resources:
+//- %s/github.com/kubernetes-sigs/kustomize/master/api/krusty/testdata/localize/remote
+//- %s/github.com/kubernetes-sigs/kustomize/kustomize/v4.5.7/api/krusty/testdata/localize/simple
+//- %s
+//`, loc.LocalizeDir, loc.LocalizeDir, falseLocalizeDir),
+//				filepath.Join(falseLocalizeDir, "kustomization.yaml"): files[filepath.Join(falseLocalizeDir, "kustomization.yaml")],
+//				filepath.Join(falseLocalizeDir, "configmap.yaml"):     files[filepath.Join(falseLocalizeDir, "configmap.yaml")],
+//			})))
+//}
+//
+//func TestExistingLocalizeDir(t *testing.T) {
+//	fSys := filesys.MakeFsOnDisk()
+//	checkLogs(t)
+//	dir := t.TempDir()
+//	locDir := filepath.Join(loc.LocalizeDir, loc.LocalizeDir)
+//
+//	folders := addPrefixToPaths(t, dir, map[string]struct{}{
+//		loc.LocalizeDir: {},
+//		locDir:          {},
+//		"root2":         {},
+//	})
+//	files := addPrefixToPaths(t, dir, map[string]string{
+//		filepath.Join(loc.LocalizeDir, "kustomization.yaml"): fmt.Sprintf(`
+//resources:
+//- %s
+//- ../root2
+//namePrefix: my-`, fileURL),
+//		"root2/kustomization.yaml": fmt.Sprintf(`
+//resources:
+//- ../%s
+//nameSuffix: config`, filepath.Join(loc.LocalizeDir, loc.LocalizeDir)),
+//		filepath.Join(locDir, "kustomization.yaml"): `
+//resources:
+//- pod.yaml
+//namePrefix: prod-`,
+//		filepath.Join(locDir, "pod.yaml"): "pod configuration",
+//	})
+//	mkDirsAndFiles(t, fSys, folders, files)
+//
+//	err := loc.Run(fSys, filepath.Join(dir, loc.LocalizeDir), dir, filepath.Join(dir, "newDir"))
+//	require.ErrorIs(t, err, loc.ErrLocalizeDirExists)
+//	checkFileSystem(t, fSys, dir, combine(t, map[string]struct{}{dir: {}}, folders), files)
+//}
+//
+//func TestRemoteResourceNoRef(t *testing.T) {
+//	req := require.New(t)
+//	fSys := filesys.MakeFsOnDisk()
+//	checkLogs(t)
+//
+//	dir := t.TempDir()
+//	kustPath := filepath.Join(dir, "kustomization.yaml")
+//	files := map[string]string{
+//		kustPath: fmt.Sprintf(`apiVersion: kustomize.config.k8s.io/v1beta1
+//kind: Kustomization
+//resources:
+//- %s
+//`, simpleHTTPS),
+//	}
+//	err := fSys.WriteFile(kustPath, []byte(files[kustPath]))
+//	req.NoError(err)
+//
+//	err = loc.Run(fSys, dir, "", filepath.Join(dir, "newDir"))
+//	req.ErrorIs(err, loc.ErrNoRef)
+//	checkFileSystem(t, fSys, dir, map[string]struct{}{
+//		dir: {},
+//	}, files)
+//}
+//
+//func TestBadArgs(t *testing.T) {
+//	tests := map[string]*struct {
+//		target string
+//		scope  string
+//		newDir string
+//	}{
+//		"target missing ref": {
+//			simpleHTTPS,
+//			"",
+//			"",
+//		},
+//		"non-empty scope for remote target": {
+//			simpleHTTPS + query,
+//			"api",
+//			"",
+//		},
+//		// unable to test on in-memory file system, which treats mkdir and mkdirall the same
+//		"dst in non-existing dir": {
+//			".",
+//			"",
+//			"does-not-exist/does-not-exist",
+//		},
+//	}
+//	for name, args := range tests {
+//		t.Run(name, func(t *testing.T) {
+//			fSys := filesys.MakeFsOnDisk()
+//			checkLogs(t)
+//
+//			dir := t.TempDir()
+//			kustPath := filepath.Join(dir, "kustomization.yaml")
+//			files := map[string]string{
+//				kustPath: `apiVersion: kustomize.config.k8s.io/v1beta1
+//kind: Kustomization
+//`,
+//			}
+//			err := fSys.WriteFile(filepath.Join(dir, "kustomization.yaml"), []byte(files[kustPath]))
+//			require.NoError(t, err)
+//
+//			changeWd(t, dir)
+//
+//			err = loc.Run(fSys, args.target, args.scope, args.newDir)
+//			require.Error(t, err)
+//			// cleaned dst
+//			checkFileSystem(t, fSys, dir, map[string]struct{}{
+//				dir: {},
+//			}, files)
+//		})
+//	}
+//}