@solaqua/gji 0.12.2 → 0.12.3

package/dist/dependency-bootstrap.js

@@ -1,20 +1,18 @@
-import { execFile } from "node:child_process";
-import { constants } from "node:fs";
-import { lstat, open, readdir, readFile, realpath, rm } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep, } from "node:path";
-import { promisify } from "node:util";
+import { readFile, realpath } from "node:fs/promises";
+import { join, relative, resolve, sep } from "node:path";
 import { runCommand } from "./command-runner.js";
-import { cloneDir, isCloneDestinationExistsError, isCloneInProgressError, } from "./dir-clone.js";
-import { isNotFoundError, pathExists } from "./fs-utils.js";
+import { pathExists } from "./fs-utils.js";
 import { inspectDestination } from "./safe-destination.js";
-const execFileAsync = promisify(execFile);
-const UV_VALIDATION_MAX_ENTRIES = 10_000;
-const UV_VALIDATION_MAX_FILE_BYTES = 1024 * 1024;
-const UV_VALIDATION_MAX_TOTAL_BYTES = 16 * 1024 * 1024;
+import { validateUvInstallation, validateUvStructure, } from "./uv-validation.js";
+export function resolveDependencyBootstrapMode(dependencyBootstrap, noInstall = false) {
+    if (noInstall || dependencyBootstrap === "off")
+        return "off";
+    return "install";
+}
 export async function prepareDependencyBootstrap(mode, context) {
     if (mode === "off")
         return { mode, targets: [] };
-    const adapters = createBootstrapAdapters(context.checkUvRuntime ?? defaultCheckUvRuntime, context.cargoBuildCommand);
+    const adapters = createBootstrapAdapters(context.cargoBuildCommand);
     const sourceRoots = [];
     for (const sourceRoot of uniquePaths([
         context.repoRoot,
@@ -29,8 +27,6 @@ export async function prepareDependencyBootstrap(mode, context) {
     for (const adapter of adapters) {
         if (plannedRelativePaths.has(adapter.relativePath))
             continue;
-        let firstDetected;
-        let selected;
         for (const sourceRoot of sourceRoots) {
             const target = await adapter.detect({
                 detectionRoot: context.detectionRoot,
@@ -39,46 +35,21 @@ export async function prepareDependencyBootstrap(mode, context) {
             });
             if (!target)
                 continue;
-            const seedable = mode !== "install-only" && (await adapter.canSeed(target));
-            const candidate = { target, seedable };
-            firstDetected ??= candidate;
-            if (mode === "install-only" || seedable) {
-                selected = candidate;
-                break;
-            }
-        }
-        const plannedTarget = selected ?? firstDetected;
-        if (plannedTarget) {
-            targets.push(plannedTarget);
+            targets.push({ adapter, target });
             plannedRelativePaths.add(adapter.relativePath);
+            break;
         }
     }
     return { mode, targets };
 }
-export async function detectDependencyBootstrapCandidate(context) {
-    const plan = await prepareDependencyBootstrap("cow-then-repair", context);
-    const planned = plan.targets[0];
-    if (!planned)
-        return null;
-    return {
-        adapter: planned.target.adapter,
-        kind: planned.target.kind,
-        lockfile: adapterForTarget(planned.target).lockfile,
-        target: planned.target.relativePath,
-        repairCommand: planned.target.repairCommand,
-        seedable: planned.seedable,
-    };
-}
 export function previewDependencyBootstrap(plan) {
     return {
         mode: plan.mode,
-        targets: plan.targets.map(({ target, seedable }) => ({
-            adapter: target.adapter,
-            kind: target.kind,
+        targets: plan.targets.map(({ adapter, target }) => ({
+            adapter: adapter.name,
+            kind: adapter.kind,
             target: target.relativePath,
-            repairCommand: target.repairCommand,
-            seedable,
-            strategy: bootstrapStrategy(plan.mode, target, seedable),
+            command: target.installCommand,
         })),
     };
 }
@@ -86,27 +57,16 @@ export async function executeDependencyBootstrap(plan, options) {
     if (plan.mode === "off")
         return { mode: plan.mode, ready: true, events: [] };
     const events = [];
-    const cloneDirectory = options.cloneDirectory ?? cloneDir;
     const execution = {
         runCommand: options.runCommand ?? runCommand,
         stderr: options.stderr ?? (() => undefined),
         stdout: options.stdout ?? ((chunk) => process.stdout.write(chunk)),
     };
-    const seededDirectories = new Set(options.seededDirectories ?? []);
     if (plan.targets.length === 0) {
-        recordBootstrapEvent(events, options.reporter, {
-            adapter: "none",
-            kind: "dependency",
-            reason: "no-lockfile",
-            state: "skipped",
-            target: "",
-            message: "no supported dependency or build-state lockfile was detected",
-        });
         return { mode: plan.mode, ready: true, events };
     }
-    for (const { target, seedable } of plan.targets) {
-        const adapter = adapterForTarget(target);
-        await executeBootstrapTarget(adapter, target, seedable, plan.mode, cloneDirectory, execution, seededDirectories.has(target.relativePath), events, options.reporter);
+    for (const { adapter, target } of plan.targets) {
+        await installTarget(adapter, target, execution, events, options.reporter);
     }
     return {
         mode: plan.mode,
@@ -114,207 +74,33 @@ export async function executeDependencyBootstrap(plan, options) {
         events,
     };
 }
-async function executeBootstrapTarget(adapter, target, seedable, mode, cloneDirectory, execution, seededBySyncDirs, events, reporter) {
-    const destinationInspection = await inspectDestination(target.worktreePath, target.targetPath);
-    if (destinationInspection.kind === "unsafe") {
-        recordBootstrapFailure(events, reporter, adapter, target, destinationInspection.reason, "destination-unsafe");
-        return;
-    }
-    if (mode === "install-only") {
-        await repairTarget(adapter, target, execution, destinationInspection.kind === "exists" ? "preserve" : "clean", events, reporter);
-        return;
-    }
-    let input = destinationInspection.kind === "exists" ? "preserve" : "clean";
-    const destinationExistsNow = destinationInspection.kind === "exists";
-    if (target.initialInput === "preserve" && destinationExistsNow) {
-        recordBootstrapEvent(events, reporter, {
-            adapter: adapter.name,
-            kind: adapter.kind,
-            reason: "target-exists",
-            state: "skipped",
-            target: target.relativePath,
-            message: "target already existed; using it as the repair input",
-        });
-    }
-    else if (seededBySyncDirs && destinationExistsNow) {
-        if (seedable) {
-            input = "seed";
-            recordBootstrapEvent(events, reporter, {
-                adapter: adapter.name,
-                kind: adapter.kind,
-                reason: "generic-seed",
-                state: "seeded",
-                target: target.relativePath,
-                message: "reusing a seed created by syncDirs",
-            });
-        }
-        else {
-            input = "preserve";
-            recordBootstrapEvent(events, reporter, {
-                adapter: adapter.name,
-                kind: adapter.kind,
-                reason: "generic-seed",
-                state: "repair-only",
-                target: target.relativePath,
-                message: "syncDirs created a generic target; this adapter uses repair without CoW",
-            });
-        }
-    }
-    else if (destinationExistsNow) {
-        input = "preserve";
-        recordBootstrapEvent(events, reporter, {
-            adapter: adapter.name,
-            kind: adapter.kind,
-            reason: "destination-race",
-            state: "skipped",
-            target: target.relativePath,
-            message: "target appeared during bootstrap; preserving it as the repair input",
-        });
-    }
-    else if (seedable) {
-        try {
-            await cloneDirectory(adapter.seedPath(target), target.targetPath, {
-                destinationRoot: target.worktreePath,
-                measureBytes: reporter.measureCloneSize,
-            });
-            input = "seed";
-            recordBootstrapEvent(events, reporter, {
-                adapter: adapter.name,
-                kind: adapter.kind,
-                state: "seeded",
-                target: target.relativePath,
-                message: "seeded with copy-on-write",
-            });
-        }
-        catch (error) {
-            if (isCloneDestinationExistsError(error)) {
-                input = "preserve";
-                recordBootstrapEvent(events, reporter, {
-                    adapter: adapter.name,
-                    kind: adapter.kind,
-                    state: "skipped",
-                    target: target.relativePath,
-                    message: "target appeared during CoW seeding; preserving it as the repair input",
-                });
-                await repairTarget(adapter, target, execution, input, events, reporter);
-                return;
-            }
-            if (isCloneInProgressError(error)) {
-                recordBootstrapFailure(events, reporter, adapter, target, `CoW seed is already in progress: ${toErrorMessage(error)}`, "clone-in-progress");
-                return;
-            }
-            const failedCloneInspection = await inspectDestination(target.worktreePath, target.targetPath);
-            if (failedCloneInspection.kind === "unsafe") {
-                recordBootstrapFailure(events, reporter, adapter, target, failedCloneInspection.reason, "destination-unsafe");
-                return;
-            }
-            input = failedCloneInspection.kind === "exists" ? "preserve" : "clean";
-            const repairInput = input === "preserve" ? "the preserved target" : "an empty target";
-            recordBootstrapEvent(events, reporter, {
-                adapter: adapter.name,
-                kind: adapter.kind,
-                reason: "cow-seed-failed",
-                state: "repair-only",
-                target: target.relativePath,
-                message: `CoW seed failed; repairing from ${repairInput} (${toErrorMessage(error)})`,
-            });
-        }
-    }
-    else {
-        recordBootstrapEvent(events, reporter, {
-            adapter: adapter.name,
-            kind: adapter.kind,
-            reason: "seed-unavailable",
-            state: "repair-only",
-            target: target.relativePath,
-            message: "CoW seed is unavailable; repairing from an empty target",
-        });
-    }
-    await repairTarget(adapter, target, execution, input, events, reporter);
-}
-async function repairTarget(adapter, target, execution, input, events, reporter) {
-    const beforeRepairInspection = await inspectDestination(target.worktreePath, target.targetPath);
-    if (beforeRepairInspection.kind === "unsafe") {
-        recordBootstrapFailure(events, reporter, adapter, target, beforeRepairInspection.reason, "destination-unsafe");
+async function installTarget(adapter, target, execution, events, reporter) {
+    const beforeInstallInspection = target.targetPath
+        ? await inspectDestination(target.worktreePath, target.targetPath)
+        : undefined;
+    if (beforeInstallInspection?.kind === "unsafe") {
+        recordBootstrapFailure(events, reporter, adapter, target, beforeInstallInspection.reason, "destination-unsafe");
         return;
     }
-    const effectiveInput = beforeRepairInspection.kind === "exists"
-        ? input === "seed"
-            ? "seed"
-            : "preserve"
-        : "clean";
+    const effectiveInput = beforeInstallInspection?.kind === "exists" ? "preserve" : "clean";
     try {
-        await adapter.repair(target, { ...execution, input: effectiveInput });
+        await adapter.install(target, { ...execution, input: effectiveInput });
         recordBootstrapEvent(events, reporter, {
             adapter: adapter.name,
             kind: adapter.kind,
-            state: target.repairState,
+            state: "installed",
             target: target.relativePath,
-            message: repairSuccessMessage(target, effectiveInput),
+            message: installSuccessMessage(target, effectiveInput),
         });
     }
-    catch (firstError) {
-        const firstFailureContext = {
-            input: effectiveInput,
-            target,
-        };
-        const cleanupError = await adapter
-            .cleanupAfterRepairFailure(firstFailureContext)
-            .then(() => undefined)
-            .catch((error) => toErrorMessage(error));
-        if (!adapter.shouldRetryAfterRepairFailure(firstFailureContext)) {
-            recordBootstrapFailure(events, reporter, adapter, target, formatRepairFailure(firstError, cleanupError === undefined ? undefined : cleanupError), "repair-failed");
-            return;
-        }
-        if (cleanupError) {
-            recordBootstrapFailure(events, reporter, adapter, target, formatRepairFailure(firstError, cleanupError), "repair-cleanup-failed");
-            return;
-        }
-        recordBootstrapEvent(events, reporter, {
-            adapter: adapter.name,
-            kind: adapter.kind,
-            reason: "seed-repair-failed",
-            state: "repair-only",
-            target: target.relativePath,
-            message: `seed repair failed; removed the seed and retrying clean (${toErrorMessage(firstError)})`,
-        });
-        const beforeRetryInspection = await inspectDestination(target.worktreePath, target.targetPath);
-        if (beforeRetryInspection.kind === "unsafe") {
-            recordBootstrapFailure(events, reporter, adapter, target, beforeRetryInspection.reason, "destination-unsafe");
-            return;
-        }
-        const retryInput = beforeRetryInspection.kind === "exists" ? "preserve" : "clean";
-        try {
-            await adapter.repair(target, { ...execution, input: retryInput });
-            recordBootstrapEvent(events, reporter, {
-                adapter: adapter.name,
-                kind: adapter.kind,
-                reason: "repair-retry",
-                state: target.repairState,
-                target: target.relativePath,
-                message: repairSuccessMessage(target, retryInput),
-            });
-        }
-        catch (secondError) {
-            const cleanupError = await adapter
-                .cleanupAfterRepairFailure({
-                input: retryInput,
-                target,
-            })
-                .then(() => undefined)
-                .catch((error) => toErrorMessage(error));
-            recordBootstrapFailure(events, reporter, adapter, target, formatRepairFailure(secondError, cleanupError), "repair-failed");
-        }
+    catch (error) {
+        recordBootstrapFailure(events, reporter, adapter, target, formatInstallFailure(error), "install-failed");
     }
 }
-function repairSuccessMessage(target, input) {
-    if (input === "seed")
-        return "reused and repaired";
+function installSuccessMessage(_target, input) {
     if (input === "preserve")
-        return "repaired the existing target";
-    return target.repairState === "installed"
-        ? "installed from a clean target"
-        : "repaired from a clean target";
+        return "installed into the existing target";
+    return "installed into a clean target";
 }
 function recordBootstrapFailure(events, reporter, adapter, target, message, reason) {
     recordBootstrapEvent(events, reporter, {
@@ -330,447 +116,195 @@ function recordBootstrapEvent(events, reporter, event) {
     events.push(event);
     reporter.dependency(event);
 }
-function formatRepairFailure(error, cleanupError) {
-    const message = `repair failed: ${toErrorMessage(error)}`;
-    return cleanupError ? `${message}; cleanup failed: ${cleanupError}` : message;
-}
-function bootstrapStrategy(mode, target, seedable) {
-    if (mode === "install-only" || target.repairState === "installed") {
-        return "install-only";
-    }
-    return seedable ? "cow-then-repair" : "repair-only";
+function formatInstallFailure(error) {
+    return `install failed: ${toErrorMessage(error)}`;
 }
-function adapterForTarget(target) {
-    const adapter = createBootstrapAdapters(defaultCheckUvRuntime).find((candidate) => candidate.name === target.adapter);
-    if (!adapter)
-        throw new Error(`unsupported bootstrap adapter: ${target.adapter}`);
-    return adapter;
-}
-function createBootstrapAdapters(checkUvRuntime, cargoBuildCommand) {
+function createBootstrapAdapters(cargoBuildCommand) {
     return [
         new LockfileBootstrapAdapter({
             name: "pnpm",
             kind: "dependency",
-            lockfile: "pnpm-lock.yaml",
+            lockfiles: ["pnpm-lock.yaml"],
             relativePath: "node_modules",
-            repairCommand: "pnpm install --frozen-lockfile",
-            shell: false,
-            beforeRepair: async (target, context) => {
-                if (context.input === "seed") {
-                    await rm(join(target.targetPath, ".modules.yaml"), {
-                        force: true,
-                    });
-                }
-            },
+            installCommand: "pnpm install --frozen-lockfile",
         }),
         new LockfileBootstrapAdapter({
             name: "yarn",
             kind: "dependency",
-            lockfile: "yarn.lock",
+            lockfiles: ["yarn.lock"],
             relativePath: "node_modules",
-            repairCommand: "yarn install --immutable",
-            shell: false,
-            beforeRepair: async (target, context) => {
-                if (context.input === "seed") {
-                    await rm(join(target.targetPath, ".yarn-state.yml"), {
-                        force: true,
-                    });
-                }
-            },
+            installCommand: "yarn install --frozen-lockfile",
+            selectInstallCommand: async (_target, _input) => (await isYarnBerry(_target.detectionRoot ?? _target.sourceRoot))
+                ? "yarn install --immutable"
+                : "yarn install --frozen-lockfile",
+        }),
+        new LockfileBootstrapAdapter({
+            name: "bun",
+            kind: "dependency",
+            lockfiles: ["bun.lock", "bun.lockb"],
+            relativePath: "node_modules",
+            installCommand: "bun install --frozen-lockfile",
         }),
         new LockfileBootstrapAdapter({
             name: "npm",
             kind: "dependency",
-            lockfile: "package-lock.json",
+            lockfiles: ["package-lock.json"],
             relativePath: "node_modules",
-            repairCommand: "npm ci",
-            shell: false,
-            seedPolicy: "never",
-            selectRepairCommand: (_target, input) => input === "preserve" ? "npm install" : "npm ci",
-            repairState: "installed",
+            installCommand: "npm ci",
+            selectInstallCommand: (_target, input) => input === "preserve" ? "npm install" : "npm ci",
         }),
         new LockfileBootstrapAdapter({
             name: "bundler",
             kind: "dependency",
-            lockfile: "Gemfile.lock",
+            lockfiles: ["Gemfile.lock"],
             relativePath: "vendor/bundle",
-            repairCommand: "bundle install",
-            shell: false,
+            installCommand: "bundle install",
             commandOptions: () => ({
                 env: { BUNDLE_PATH: "vendor/bundle" },
             }),
-            beforeRepair: async (target, context) => {
-                if (context.input === "seed") {
-                    await removeBundlerExtensionMarkers(target.targetPath);
-                }
-            },
+        }),
+        new LockfileBootstrapAdapter({
+            name: "poetry",
+            kind: "dependency",
+            lockfiles: ["poetry.lock"],
+            relativePath: ".venv",
+            installCommand: "poetry install --no-interaction",
+            commandOptions: () => ({
+                env: { POETRY_VIRTUALENVS_IN_PROJECT: "true" },
+            }),
         }),
         new LockfileBootstrapAdapter({
             name: "uv",
             kind: "dependency",
-            lockfile: "uv.lock",
+            lockfiles: ["uv.lock"],
+            relativePath: ".venv",
+            installCommand: "uv sync --locked",
+            beforeInstall: validateUvStructure,
+            afterInstall: validateUvInstallation,
+        }),
+        new LockfileBootstrapAdapter({
+            name: "pipenv",
+            kind: "dependency",
+            lockfiles: ["Pipfile.lock"],
             relativePath: ".venv",
-            repairCommand: "uv sync --locked",
-            shell: false,
-            canSeedOverride: checkUvRuntime,
-            beforeRepair: validateUvStructure,
-            afterRepair: validateUvRelocation,
+            installCommand: "pipenv sync",
+            commandOptions: () => ({
+                env: { PIPENV_VENV_IN_PROJECT: "1" },
+            }),
+        }),
+        new LockfileBootstrapAdapter({
+            name: "go",
+            kind: "dependency",
+            lockfiles: ["go.mod"],
+            relativePath: "",
+            installCommand: "go mod download",
+        }),
+        new LockfileBootstrapAdapter({
+            name: "composer",
+            kind: "dependency",
+            lockfiles: ["composer.lock"],
+            relativePath: "vendor",
+            installCommand: "composer install --no-interaction --prefer-dist",
         }),
         new LockfileBootstrapAdapter({
             name: "cargo",
             kind: "build-cache",
-            lockfile: "Cargo.lock",
+            lockfiles: ["Cargo.lock"],
             relativePath: "target",
-            repairCommand: cargoBuildCommand?.trim() || "cargo check",
+            installCommand: cargoBuildCommand?.trim() || "cargo check",
             shell: Boolean(cargoBuildCommand),
         }),
     ];
 }
 class LockfileBootstrapAdapter {
     kind;
-    lockfile;
     name;
     relativePath;
-    defaultRepairCommand;
+    defaultInstallCommand;
+    lockfiles;
     shell;
-    seedPolicy;
-    canSeedOverride;
-    beforeRepair;
-    afterRepair;
+    beforeInstall;
+    afterInstall;
     commandOptions;
-    selectRepairCommand;
-    repairState;
+    selectInstallCommand;
     constructor(spec) {
         this.name = spec.name;
         this.kind = spec.kind;
-        this.lockfile = spec.lockfile;
+        this.lockfiles = spec.lockfiles;
         this.relativePath = spec.relativePath;
-        this.defaultRepairCommand = spec.repairCommand;
-        this.shell = spec.shell;
-        this.seedPolicy = spec.seedPolicy ?? "always";
-        this.canSeedOverride = spec.canSeedOverride;
-        this.beforeRepair = spec.beforeRepair;
-        this.afterRepair = spec.afterRepair;
+        this.defaultInstallCommand = spec.installCommand;
+        this.shell = spec.shell ?? false;
+        this.beforeInstall = spec.beforeInstall;
+        this.afterInstall = spec.afterInstall;
         this.commandOptions = spec.commandOptions;
-        this.selectRepairCommand = spec.selectRepairCommand;
-        this.repairState = spec.repairState ?? "repaired";
+        this.selectInstallCommand = spec.selectInstallCommand;
     }
     async detect(context) {
         const detectionRoot = context.detectionRoot ?? context.sourceRoot;
-        if (!(await pathExists(join(detectionRoot, this.lockfile))))
+        const hasLockfile = await hasExistingPath(detectionRoot, this.lockfiles);
+        if (!hasLockfile)
             return null;
-        const sourcePath = join(context.sourceRoot, this.relativePath);
-        const targetPath = join(context.worktreePath, this.relativePath);
-        const destinationInspection = await inspectDestination(context.worktreePath, targetPath);
-        const initialInput = destinationInspection.kind === "exists" ? "preserve" : "clean";
+        const sourcePath = this.relativePath
+            ? join(context.sourceRoot, this.relativePath)
+            : undefined;
+        const targetPath = this.relativePath
+            ? join(context.worktreePath, this.relativePath)
+            : undefined;
+        const destinationInspection = targetPath
+            ? await inspectDestination(context.worktreePath, targetPath)
+            : undefined;
+        const initialInput = destinationInspection?.kind === "exists" ? "preserve" : "clean";
         const target = {
-            adapter: this.name,
             kind: this.kind,
             relativePath: this.relativePath,
             sourceRoot: context.sourceRoot,
+            detectionRoot,
             worktreePath: context.worktreePath,
             sourcePath,
             targetPath,
-            repairCommand: this.defaultRepairCommand,
-            repairState: this.repairState,
+            installCommand: this.defaultInstallCommand,
             shell: this.shell,
-            initialInput,
         };
         return {
             ...target,
-            repairCommand: this.selectRepairCommand?.(target, initialInput) ??
-                target.repairCommand,
+            installCommand: await this.selectCommand(target, initialInput),
         };
     }
-    seedPath(target) {
-        return target.sourcePath;
-    }
-    async repair(target, context) {
-        await this.beforeRepair?.(target, context);
-        const repairCommand = this.selectRepairCommand?.(target, context.input) ?? target.repairCommand;
-        await context.runCommand(repairCommand, target.worktreePath, context.stderr, context.stdout, {
+    async install(target, context) {
+        await this.beforeInstall?.(target, context);
+        const installCommand = await this.selectCommand(target, context.input);
+        await context.runCommand(installCommand, target.worktreePath, context.stderr, context.stdout, {
             ...this.commandOptions?.(target),
             shell: target.shell,
         });
-        await this.afterRepair?.(target, context);
+        await this.afterInstall?.(target, context);
     }
-    async canSeed(target) {
-        if (this.seedPolicy === "never")
-            return false;
-        if (!(await safeSourceDirectory(target)))
-            return false;
-        return (await this.canSeedOverride?.(target)) ?? true;
-    }
-    shouldRetryAfterRepairFailure(context) {
-        return context.input === "seed";
-    }
-    async cleanupAfterRepairFailure(context) {
-        if (context.input !== "seed")
-            return;
-        await rm(context.target.targetPath, { force: true, recursive: true });
+    async selectCommand(target, input) {
+        return ((await this.selectInstallCommand?.(target, input)) ??
+            target.installCommand);
     }
 }
-async function safeSourceDirectory(target) {
-    try {
-        const [root, source] = await Promise.all([
-            realpath(target.sourceRoot),
-            realpath(target.sourcePath),
-        ]);
-        const sourceStats = await lstat(source);
-        return sourceStats.isDirectory() && isWithin(root, source);
-    }
-    catch {
-        return false;
+async function hasExistingPath(root, paths) {
+    for (const path of paths) {
+        if (await pathExists(join(root, path)))
+            return true;
     }
+    return false;
 }
-async function defaultCheckUvRuntime(target) {
+async function isYarnBerry(root) {
+    if (await pathExists(join(root, ".yarnrc.yml")))
+        return true;
     try {
-        const config = await readFile(join(target.sourcePath, "pyvenv.cfg"), "utf8");
-        const expected = config.match(/^version(?:_info)?\s*=\s*(\d+\.\d+)/mu)?.[1];
-        if (!expected)
-            return false;
-        const expectedImplementation = config
-            .match(/^implementation\s*=\s*([^\s#]+)/imu)?.[1]
-            ?.toLowerCase();
-        const sourceInterpreter = join(target.sourcePath, process.platform === "win32" ? "Scripts/python.exe" : "bin/python");
-        const fingerprintScript = "import platform, sys; print(f'{sys.version_info.major}.{sys.version_info.minor}|{platform.machine()}|{sys.implementation.name}')";
-        const source = await execFileAsync(sourceInterpreter, [
-            "-c",
-            fingerprintScript,
-        ]);
-        const sourceFingerprint = source.stdout.trim();
-        const [sourceVersion, sourceMachine, sourceImplementation, extra] = sourceFingerprint.split("|");
-        return (extra === undefined &&
-            sourceVersion === expected &&
-            Boolean(sourceMachine) &&
-            Boolean(sourceImplementation) &&
-            (expectedImplementation === undefined ||
-                sourceImplementation.toLowerCase() === expectedImplementation));
+        const packageJson = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+        const packageManager = packageJson.packageManager;
+        const match = typeof packageManager === "string" &&
+            packageManager.match(/^yarn@(\d+)/u);
+        return match ? Number(match[1]) >= 2 : false;
     }
     catch {
         return false;
     }
 }
-function virtualEnvironmentPrefixes(text) {
-    const prefixes = [];
-    for (const line of text.split(/\r?\n/u)) {
-        if (!/\bVIRTUAL_ENV\b/u.test(line))
-            continue;
-        const quotedAssignment = line.match(/\bVIRTUAL_ENV(?:\s*=|\s+)\s*(?:"([^"]+)"|'([^']+)')/u);
-        const quotedPrefix = quotedAssignment?.[1] ?? quotedAssignment?.[2];
-        if (quotedPrefix && isAbsolute(quotedPrefix))
-            prefixes.push(quotedPrefix);
-        const unquoted = line.match(/\bVIRTUAL_ENV(?:\s*=|\s+)\s*([^\s"']+)/u)?.[1];
-        if (unquoted && isAbsolute(unquoted))
-            prefixes.push(unquoted);
-    }
-    return uniquePaths(prefixes);
-}
-function pythonPrefixFromShebang(text) {
-    const command = text
-        .match(/^#!\s*([^\r\n]+)/u)?.[1]
-        ?.trim()
-        .split(/\s+/u)[0];
-    if (!command || !isAbsolute(command))
-        return undefined;
-    if (!/^python(?:\d+(?:\.\d+)?)?(?:\.exe)?$/iu.test(command.split(sep).at(-1) ?? "")) {
-        return undefined;
-    }
-    return dirname(dirname(command));
-}
-function pythonPrefixesFromText(text) {
-    const interpreters = [];
-    for (const match of text.matchAll(/["'](\/[^"']+)["']/gu)) {
-        if (match[1])
-            interpreters.push(match[1]);
-    }
-    for (const match of text.matchAll(/(?:^|\s)(\/[^\s"']+)/gmu)) {
-        if (match[1])
-            interpreters.push(match[1]);
-    }
-    return uniquePaths(interpreters.flatMap((interpreter) => {
-        const name = interpreter.split(sep).at(-1) ?? "";
-        return /^python(?:\d+(?:\.\d+)?)?(?:\.exe)?$/iu.test(name)
-            ? [dirname(dirname(interpreter))]
-            : [];
-    }));
-}
-async function validateUvRelocation(target, context) {
-    if (context.input === "preserve")
-        return;
-    const scriptsDirectory = join(target.targetPath, process.platform === "win32" ? "Scripts" : "bin");
-    const interpreter = join(scriptsDirectory, process.platform === "win32" ? "python.exe" : "python");
-    const { stdout } = await execFileAsync(interpreter, [
-        "-c",
-        "import os, sys; print(os.path.realpath(sys.prefix))",
-    ]);
-    const [actualPrefix, expectedPrefix] = await Promise.all([
-        realpath(stdout.trim()),
-        realpath(target.targetPath),
-    ]);
-    if (actualPrefix !== expectedPrefix) {
-        throw new Error(`uv environment still points to its source prefix: ${actualPrefix}`);
-    }
-    const sourcePaths = uniquePaths([
-        target.sourcePath,
-        await realpath(target.sourcePath).catch(() => undefined),
-    ]);
-    const entries = await readdir(scriptsDirectory, { withFileTypes: true });
-    assertSafeUvScriptEntries(entries);
-    const environmentName = basename(target.targetPath);
-    const acceptedPrefixes = new Set([
-        resolve(target.targetPath),
-        await realpath(target.targetPath),
-    ]);
-    let validatedBytes = 0;
-    for (const path of [
-        join(target.targetPath, "pyvenv.cfg"),
-        ...entries
-            .filter((entry) => entry.isFile())
-            .map((entry) => join(scriptsDirectory, entry.name)),
-    ]) {
-        const validated = await readBoundedUvTextFile(path, UV_VALIDATION_MAX_TOTAL_BYTES - validatedBytes);
-        if (!validated)
-            continue;
-        validatedBytes += validated.bytes;
-        if (validated.text === undefined)
-            continue;
-        const { text } = validated;
-        if (sourcePaths.some((sourcePath) => text.includes(sourcePath))) {
-            throw new Error(`uv environment contains a stale source path: ${path}`);
-        }
-        const shebangPrefix = pythonPrefixFromShebang(text);
-        if (shebangPrefix &&
-            basename(shebangPrefix) === environmentName &&
-            !acceptedPrefixes.has(resolve(shebangPrefix))) {
-            throw new Error(`uv launcher points outside its environment: ${path}`);
-        }
-        if (pythonPrefixesFromText(text)
-            .filter((prefix) => basename(prefix) === environmentName)
-            .some((prefix) => !acceptedPrefixes.has(resolve(prefix)))) {
-            throw new Error(`uv launcher points outside its environment: ${path}`);
-        }
-        if (virtualEnvironmentPrefixes(text).some((prefix) => !acceptedPrefixes.has(resolve(prefix)))) {
-            throw new Error(`uv activation script points outside its environment: ${path}`);
-        }
-    }
-}
-async function validateUvStructure(target, context) {
-    if (context.input === "preserve")
-        return;
-    const targetStats = await lstat(target.targetPath).catch(() => undefined);
-    if (!targetStats)
-        return;
-    if (!targetStats.isDirectory() || targetStats.isSymbolicLink()) {
-        throw new Error("uv environment must be a real directory");
-    }
-    const configStats = await lstat(join(target.targetPath, "pyvenv.cfg")).catch(() => undefined);
-    if (configStats && (!configStats.isFile() || configStats.isSymbolicLink())) {
-        throw new Error("uv pyvenv.cfg must be a regular file");
-    }
-    const scriptsDirectory = join(target.targetPath, process.platform === "win32" ? "Scripts" : "bin");
-    const scriptsStats = await lstat(scriptsDirectory).catch(() => undefined);
-    if (!scriptsStats)
-        return;
-    if (!scriptsStats.isDirectory() || scriptsStats.isSymbolicLink()) {
-        throw new Error("uv scripts path must be a real directory");
-    }
-    assertSafeUvScriptEntries(await readdir(scriptsDirectory, { withFileTypes: true }));
-}
-function assertSafeUvScriptEntries(entries) {
-    if (entries.length > UV_VALIDATION_MAX_ENTRIES) {
-        throw new Error("uv scripts directory exceeds the validation entry limit");
-    }
-    for (const entry of entries) {
-        if (entry.isSymbolicLink() && !isUvInterpreterName(entry.name)) {
-            throw new Error(`uv script must not be a symbolic link: ${entry.name}`);
-        }
-    }
-}
-async function readBoundedUvTextFile(path, remainingBytes) {
-    let handle;
-    try {
-        handle = await open(path, constants.O_RDONLY |
-            (process.platform === "win32" ? 0 : constants.O_NOFOLLOW));
-    }
-    catch (error) {
-        if (isNotFoundError(error))
-            return undefined;
-        throw error;
-    }
-    try {
-        const stats = await handle.stat();
-        if (!stats.isFile())
-            return undefined;
-        if (stats.size > UV_VALIDATION_MAX_FILE_BYTES) {
-            throw new Error(`uv launcher exceeds the validation size limit: ${path}`);
-        }
-        if (stats.size > remainingBytes) {
-            throw new Error("uv launchers exceed the total validation size limit");
-        }
-        const readLimit = Math.min(UV_VALIDATION_MAX_FILE_BYTES, remainingBytes);
-        const contents = await readFilePrefix(handle, readLimit + 1);
-        if (contents.byteLength > UV_VALIDATION_MAX_FILE_BYTES) {
-            throw new Error(`uv launcher exceeds the validation size limit: ${path}`);
-        }
-        if (contents.byteLength > remainingBytes) {
-            throw new Error("uv launchers exceed the total validation size limit");
-        }
-        const text = contents.toString("utf8");
-        return Buffer.from(text, "utf8").equals(contents)
-            ? { bytes: contents.byteLength, text }
-            : { bytes: contents.byteLength };
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function readFilePrefix(handle, maxBytes) {
-    const contents = Buffer.allocUnsafe(maxBytes);
-    let offset = 0;
-    while (offset < contents.byteLength) {
-        const { bytesRead } = await handle.read(contents, offset, contents.byteLength - offset, offset);
-        if (bytesRead === 0)
-            break;
-        offset += bytesRead;
-    }
-    return contents.subarray(0, offset);
-}
-function isUvInterpreterName(name) {
-    return /^python(?:\d+(?:\.\d+)?)?(?:\.exe)?$/iu.test(name);
-}
-async function removeBundlerExtensionMarkers(root) {
-    const pending = [root];
-    while (pending.length > 0) {
-        const current = pending.pop();
-        if (!current)
-            continue;
-        let entries;
-        try {
-            entries = await readdir(current, { withFileTypes: true });
-        }
-        catch (error) {
-            if (isNotFoundError(error))
-                continue;
-            throw error;
-        }
-        for (const entry of entries) {
-            const path = join(current, entry.name);
-            if (entry.isDirectory())
-                pending.push(path);
-            else if (entry.isFile() && isBundlerExtensionMarker(root, path)) {
-                await rm(path, { force: true });
-            }
-        }
-    }
-}
-function isBundlerExtensionMarker(root, path) {
-    const segments = relative(root, path).split(sep);
-    return (segments.length >= 7 &&
-        segments[0] === "ruby" &&
-        segments[2] === "extensions" &&
-        segments.at(-1) === "gem.build_complete");
-}
 function uniquePaths(paths) {
     return [...new Set(paths.filter((path) => Boolean(path)))];
 }