unpruned                    // no transitive dependencies are pruned out
	workspace                   // pruned to the union of modules in the workspace
)

func (p modPruning) String() string {
	switch p {
	case pruned:
		return "pruned"
	case unpruned:
		return "unpruned"
	case workspace:
		return "workspace"
	default:
		return fmt.Sprintf("%T(%d)", p, p)
	}
}

7. NOTE: Do not edit go.mod or go.sum in the new repo (staging/src/k8s.io/<newrepo>/) manually. Run the following instead:

```
  ./hack/update-vendor.sh
```

8. Run [`./hack/update-go-workspace.sh`](/hack/update-go-workspace.sh) to add
   the module to the workspace.

### Creating the published repository

1. Create an [issue](https://github.com/kubernetes/org/issues/new?template=repo-create.md)

import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.internal.execution.InputFingerprinter;
import org.gradle.internal.execution.MutableUnitOfWork;
import org.gradle.internal.execution.workspace.MutableWorkspaceProvider;
import org.gradle.internal.fingerprint.CurrentFileCollectionFingerprint;
import org.gradle.internal.operations.BuildOperationProgressEventEmitter;
import org.gradle.internal.operations.BuildOperationRunner;

licenses(["notice"])  # Apache 2.0

filegroup(
    name = "model_files",
    srcs = glob(
        [
            "**/*",
        ],
        exclude = [
            "**/BUILD",
            "**/WORKSPACE",
            "**/LICENSE",
            "**/*.zip",
        ],
    ),

    def setup() {
        concurrent.shortTimeout = 180000
    }

    def cleanup() {
        new DaemonLogsAnalyzer(workspace.file("daemon")).daemons.each { it.kill() }
    }

    def "handles concurrent access to changing artifacts"() {
        expect:
        4.times { count ->
            def buildDir = workspace.file(count)
            concurrent.start {
                buildDir.file('build.gradle') << """
import java.util.zip.*

        WorkspaceReader workspace = session.getWorkspaceReader();
        if (workspace != null) {
            List<String> versions = workspace.findVersions(request.getArtifact());
            for (String version : versions) {
                versionIndex.put(version, workspace.getRepository());
            }
        }

 *
 * It is effectively the root dir of a build.
 * That is, two builds with the same root dir share the same workspace.
 *
 * In practice, this generally maps to what users would think of as “checkout” of a project.
 * Builds of the same checkout over time will share the same workspace ID.
 *
 * This ID is persisted in the root build's project cache dir.
 * If this cache directory is destroyed, a new ID will be issued.

            """
        def inc1 = multiProjectBuildInSubFolder("includedBuild1", ["a", "b", "c"])
        def inc2 = multiProjectBuildInSubFolder("includedBuild2", ["a", "b", "c"])
        def workspace = eclipseWorkspace([
            project("root", projectDir), gradleProject("a"), project("explicitName", file("b")),
            externalProject("root-a"),

        //      engines instead.
        ExecutionEngine effectiveEngine;
        if (producerProject == null) {
            // Non-project-bound transforms run in a global immutable workspace,
            // and are identified by a non-normalized identity
            // See comments on NonNormalizedIdentityImmutableTransformExecution
            identityCache = immutableWorkspaceServices.getIdentityCache();

     */
    default void visitRegularInputs(InputVisitor visitor) {}

    /**
     * Visit outputs of the work in the given workspace.
     * <p>
     * Note: For tasks {@code workspace} is {@code null} for now.
     */
    void visitOutputs(File workspace, OutputVisitor visitor);

    interface InputVisitor {
        default void visitInputProperty(
            String propertyName,