agl 1.0.17 → 21.0.2

package/dist_ts/classes.upgradetransaction.js

@@ -0,0 +1,2125 @@
+import * as plugins from './plugins.js';
+import { commitinfo } from './00_commitinfo_data.js';
+import { controllerPackageName, controllerProtocolVersion, controllerUpgradeManagementVersion, } from '../dist_ts_interfaces/index.js';
+import { controllerDataDirectory } from './classes.config.js';
+import { isLoopbackPortListening, queryControllerStatus, requestControllerUpgradeFinalize, requestControllerUpgradePrepareBegin, stopVerifiedController, } from './classes.controllermanagement.js';
+import { inspectControllerProcess, listControllerDataWriterProcessesForCli, listControllerProcessesForCli, processIdentityHasCliCommand, readControllerProcessIdentity, readProcessGroupMemberPids, } from './classes.processinspection.js';
+import { createUpgradeToken, UpgradeCoordinator, upgradeCoordinationVersion, upgradePackageTransitionTransactionVersion, upgradePackageTransitionSource, upgradePackageTransitionTarget, upgradeTokenEnvironmentVariable, serializeUpgradeWorkerPayload, } from './classes.upgradecoordinator.js';
+const npmRegistryUrl = 'https://registry.npmjs.org/';
+const commandOutputByteLimit = 1024 * 1024;
+const loggedCommandOutputByteLimit = 16 * 1024 * 1024;
+const packageManagerTimeoutMs = 10 * 60 * 1000;
+const controllerRestartTimeoutMs = 90_000;
+const commandGroupDrainTimeoutMs = 5_000;
+const candidateCleanupRetryIntervalMs = 250;
+const retainedUpgradeLogCount = 10;
+const minimumPrunableUpgradeLogAgeMs = 30 * 60 * 1000;
+const upgradePreparationPollMs = 250;
+const upgradePreparationSourceCheckMs = 500;
+const upgradePreparationAcceptanceReconciliationMs = 5_000;
+const upgradePreparationCleanupAllowanceMs = 60_000;
+const upgradeLogPattern = /^upgrade-[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{6}\.[0-9]{3}Z-[A-Za-z0-9_-]{10}\.log$/;
+const semverPattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+let upgradeWorkerCliPath;
+const currentPackageIdentity = String(controllerPackageName)
+    === upgradePackageTransitionSource.packageName
+    ? upgradePackageTransitionSource
+    : upgradePackageTransitionTarget;
+const currentCliName = currentPackageIdentity.cliName;
+const packageManagerEnvironmentAllowlist = new Set([
+    'CI',
+    'COREPACK_HOME',
+    'FORCE_COLOR',
+    'HOME',
+    'HTTP_PROXY',
+    'HTTPS_PROXY',
+    'LANG',
+    'LOGNAME',
+    'NODE_EXTRA_CA_CERTS',
+    'NO_PROXY',
+    'NPM_CONFIG_REGISTRY',
+    'NPM_CONFIG_USERCONFIG',
+    'PATH',
+    'PNPM_HOME',
+    'SHELL',
+    'SSL_CERT_DIR',
+    'SSL_CERT_FILE',
+    'TEMP',
+    'TERM',
+    'TMP',
+    'TMPDIR',
+    'TZ',
+    'USER',
+    'XDG_CACHE_HOME',
+    'XDG_CONFIG_HOME',
+    'XDG_DATA_HOME',
+    'XDG_RUNTIME_DIR',
+    'XDG_STATE_HOME',
+]);
+class UpgradeCommandCleanupError extends Error {
+}
+const proxyEnvironmentValueIsSafe = (valueArg) => {
+    try {
+        const parsed = new URL(valueArg);
+        return parsed.username.length === 0 && parsed.password.length === 0;
+    }
+    catch {
+        return false;
+    }
+};
+export const createPackageManagerEnvironment = (sourceArg = process.env) => {
+    const environment = {};
+    for (const [name, value] of Object.entries(sourceArg)) {
+        if (value === undefined)
+            continue;
+        const normalizedName = name.toUpperCase();
+        if (!packageManagerEnvironmentAllowlist.has(normalizedName)
+            && !normalizedName.startsWith('LC_'))
+            continue;
+        if ((normalizedName === 'HTTP_PROXY' || normalizedName === 'HTTPS_PROXY')
+            && !proxyEnvironmentValueIsSafe(value))
+            continue;
+        environment[name] = value;
+    }
+    return environment;
+};
+const findExecutable = async (nameArg, environmentArg) => {
+    const pathValue = environmentArg.PATH;
+    if (!pathValue)
+        throw new Error(`Unable to locate ${nameArg}: PATH is empty.`);
+    for (const directory of pathValue.split(plugins.path.delimiter)) {
+        if (!directory)
+            continue;
+        const candidate = plugins.path.join(directory, nameArg);
+        try {
+            await plugins.fs.promises.access(candidate, plugins.fs.constants.X_OK);
+            return await plugins.fs.promises.realpath(candidate);
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error(`Unable to locate ${nameArg} on PATH.`);
+};
+const prepareManagedCommand = async (optionsArg) => {
+    const workerIdentity = await readControllerProcessIdentity(process.pid);
+    if (!workerIdentity)
+        throw new Error('Unable to establish upgrade command ownership.');
+    const ownsWorkerProcessGroup = workerIdentity.processGroupLeader
+        && await processIdentityHasCliCommand(workerIdentity, upgradeWorkerCliPath ?? await resolveCurrentCliPath(), '__upgrade-worker', { allowMissingAbsolutePath: true });
+    return {
+        ...optionsArg,
+        cwd: plugins.os.homedir(),
+        workerIdentity,
+        ownsWorkerProcessGroup,
+    };
+};
+const runPreparedManagedCommand = async (optionsArg) => {
+    const child = plugins.childProcess.spawn(optionsArg.executable, optionsArg.arguments, {
+        cwd: optionsArg.cwd,
+        detached: !optionsArg.ownsWorkerProcessGroup,
+        env: optionsArg.environment,
+        shell: false,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const outcomePromise = new Promise((resolve) => {
+        child.once('error', (errorArg) => resolve({ code: null, signal: null, error: errorArg }));
+        child.once('close', (codeArg, signalArg) => resolve({ code: codeArg, signal: signalArg }));
+    });
+    const commandProcessGroupId = optionsArg.ownsWorkerProcessGroup
+        ? optionsArg.workerIdentity.processGroupId
+        : child.pid;
+    let stdout = '';
+    let stderr = '';
+    let outputBytes = 0;
+    let outputError;
+    const recordOutput = (streamArg, chunkArg, sourceArg) => {
+        outputBytes += chunkArg.byteLength;
+        if (outputBytes > (optionsArg.outputByteLimit ?? commandOutputByteLimit)) {
+            outputError ??= new Error('Upgrade command output exceeded its size limit.');
+            return;
+        }
+        if (optionsArg.captureOutput) {
+            if (streamArg === 'stdout')
+                stdout += chunkArg.toString('utf8');
+            else
+                stderr += chunkArg.toString('utf8');
+            return;
+        }
+        const destination = streamArg === 'stdout' ? process.stdout : process.stderr;
+        if (!destination.write(chunkArg) && sourceArg && 'pause' in sourceArg && 'resume' in sourceArg) {
+            sourceArg.pause();
+            destination.once('drain', () => sourceArg.resume());
+        }
+    };
+    child.stdout?.on('data', (chunkArg) => recordOutput('stdout', chunkArg, child.stdout));
+    child.stderr?.on('data', (chunkArg) => recordOutput('stderr', chunkArg, child.stderr));
+    const listCommandPids = async () => {
+        if (!commandProcessGroupId) {
+            return child.pid && child.exitCode === null && child.signalCode === null ? [child.pid] : [];
+        }
+        const members = await readProcessGroupMemberPids(commandProcessGroupId);
+        return optionsArg.ownsWorkerProcessGroup
+            ? members.filter((processIdArg) => processIdArg !== process.pid)
+            : members;
+    };
+    const signalDirectChild = (signalArg) => {
+        if (!child.pid || child.exitCode !== null || child.signalCode !== null)
+            return;
+        try {
+            process.kill(child.pid, signalArg);
+        }
+        catch (errorArg) {
+            if (errorArg.code !== 'ESRCH')
+                throw errorArg;
+        }
+    };
+    const signalCommand = async (signalArg) => {
+        let processIds;
+        try {
+            processIds = await listCommandPids();
+        }
+        catch (errorArg) {
+            signalDirectChild(signalArg);
+            throw errorArg;
+        }
+        for (const processId of processIds) {
+            try {
+                process.kill(processId, signalArg);
+            }
+            catch (errorArg) {
+                if (errorArg.code !== 'ESRCH')
+                    throw errorArg;
+            }
+        }
+    };
+    const waitForCommandDrain = async (timeoutMsArg) => {
+        const deadline = Date.now() + timeoutMsArg;
+        while (Date.now() < deadline) {
+            if ((await listCommandPids()).length === 0)
+                return true;
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        return (await listCommandPids()).length === 0;
+    };
+    let interruption;
+    let terminating;
+    let terminationError;
+    const terminate = () => {
+        if (terminating)
+            return terminating;
+        terminating = (async () => {
+            try {
+                await signalCommand('SIGTERM');
+                if (await waitForCommandDrain(commandGroupDrainTimeoutMs))
+                    return;
+                await signalCommand('SIGKILL');
+                if (!await waitForCommandDrain(commandGroupDrainTimeoutMs)) {
+                    throw new Error('The upgrade command process group did not terminate.');
+                }
+            }
+            catch (errorArg) {
+                terminationError = errorArg;
+                signalDirectChild('SIGKILL');
+                throw errorArg;
+            }
+        })();
+        return terminating;
+    };
+    const beginTermination = (reasonArg) => {
+        interruption ??= reasonArg;
+        void terminate().catch(() => undefined);
+    };
+    const onSigint = () => beginTermination('SIGINT');
+    const onSigterm = () => beginTermination('SIGTERM');
+    process.on('SIGINT', onSigint);
+    process.on('SIGTERM', onSigterm);
+    const timeout = setTimeout(() => beginTermination('timeout'), optionsArg.timeoutMs);
+    const outputLimitPoll = setInterval(() => {
+        if (outputError)
+            beginTermination('output limit');
+    }, 25);
+    try {
+        const outcome = await outcomePromise;
+        try {
+            if (!await waitForCommandDrain(2_000)) {
+                beginTermination('surviving child processes');
+            }
+        }
+        catch (errorArg) {
+            terminationError = errorArg;
+            signalDirectChild('SIGKILL');
+        }
+        if (terminating)
+            await terminating.catch(() => undefined);
+        if (terminationError) {
+            throw new UpgradeCommandCleanupError('Upgrade command cleanup failed.', {
+                cause: terminationError,
+            });
+        }
+        if (interruption) {
+            throw new Error(`${plugins.path.basename(optionsArg.executable)} was interrupted by ${interruption}.`);
+        }
+        if (outputError)
+            throw outputError;
+        if (outcome.error)
+            throw outcome.error;
+        if (outcome.code !== 0) {
+            throw new Error(`${plugins.path.basename(optionsArg.executable)} exited with ${outcome.signal ?? outcome.code ?? 'an unknown result'}${stderr.trim() ? `: ${stderr.trim()}` : '.'}`);
+        }
+        return { stdout, stderr };
+    }
+    finally {
+        clearTimeout(timeout);
+        clearInterval(outputLimitPoll);
+        process.removeListener('SIGINT', onSigint);
+        process.removeListener('SIGTERM', onSigterm);
+    }
+};
+const runManagedCommand = async (optionsArg) => await runPreparedManagedCommand(await prepareManagedCommand(optionsArg));
+const runCapturedCommand = async (executableArg, argumentsArg, environmentArg, timeoutMsArg = 30_000, outputByteLimitArg = commandOutputByteLimit) => {
+    const result = await runManagedCommand({
+        executable: executableArg,
+        arguments: argumentsArg,
+        environment: environmentArg,
+        timeoutMs: timeoutMsArg,
+        captureOutput: true,
+        outputByteLimit: outputByteLimitArg,
+    });
+    return result.stdout;
+};
+const assertSingleLineAbsolutePath = async (valueArg, nameArg) => {
+    const value = valueArg.trim();
+    if (!value || value.includes('\n') || !plugins.path.isAbsolute(value)) {
+        throw new Error(`${nameArg} did not return one absolute path.`);
+    }
+    return await plugins.fs.promises.realpath(value);
+};
+const readGlobalListDependency = (outputArg, packageNameArg) => {
+    let value;
+    try {
+        value = JSON.parse(outputArg);
+    }
+    catch {
+        throw new Error('pnpm list --global returned malformed JSON.');
+    }
+    if (!Array.isArray(value)) {
+        throw new Error('pnpm list --global returned an unexpected result.');
+    }
+    const dependencies = value.flatMap((entryArg) => {
+        if (!entryArg || typeof entryArg !== 'object' || Array.isArray(entryArg))
+            return [];
+        const entry = entryArg;
+        const dependency = entry.dependencies?.[packageNameArg];
+        return dependency ? [dependency] : [];
+    });
+    if (dependencies.length !== 1) {
+        throw new Error(`Expected exactly one pnpm-global installation of ${packageNameArg}.`);
+    }
+    const dependency = dependencies[0];
+    if (typeof dependency.version !== 'string'
+        || typeof dependency.path !== 'string'
+        || !plugins.path.isAbsolute(dependency.path)) {
+        throw new Error('pnpm reported invalid global package metadata.');
+    }
+    return { version: dependency.version, path: dependency.path };
+};
+export const resolvePnpmGlobalInstallation = async () => {
+    if (process.platform !== 'linux' && process.platform !== 'darwin') {
+        throw new Error(`${currentCliName} upgrade is currently supported on Linux and macOS only.`);
+    }
+    const environment = createPackageManagerEnvironment();
+    const packageManagerPath = await findExecutable('pnpm', environment);
+    const globalRootOutput = await runCapturedCommand(packageManagerPath, ['root', '--global'], environment);
+    const globalBinOutput = await runCapturedCommand(packageManagerPath, ['bin', '--global'], environment);
+    const listOutput = await runCapturedCommand(packageManagerPath, ['list', '--global', controllerPackageName, '--depth=0', '--json'], environment);
+    const globalRoot = await assertSingleLineAbsolutePath(globalRootOutput, 'pnpm root --global');
+    const globalBinDirectory = await assertSingleLineAbsolutePath(globalBinOutput, 'pnpm bin --global');
+    const dependency = readGlobalListDependency(listOutput, controllerPackageName);
+    const dependencyRelativePath = plugins.path.relative(globalRoot, dependency.path);
+    if (dependencyRelativePath.startsWith(`..${plugins.path.sep}`)
+        || dependencyRelativePath === '..'
+        || plugins.path.isAbsolute(dependencyRelativePath)) {
+        throw new Error('pnpm reported a global package path outside its global root.');
+    }
+    const packageDirectory = await plugins.fs.promises.realpath(dependency.path);
+    const packageJsonPath = plugins.path.join(packageDirectory, 'package.json');
+    const packageJsonStats = await plugins.fs.promises.stat(packageJsonPath);
+    if (!packageJsonStats.isFile() || packageJsonStats.size < 2 || packageJsonStats.size > 64 * 1024) {
+        throw new Error(`The pnpm-global ${controllerPackageName} package metadata is not a bounded file.`);
+    }
+    const packageJson = JSON.parse(await plugins.fs.promises.readFile(packageJsonPath, 'utf8'));
+    const currentIdentity = currentPackageIdentity;
+    if (packageJson.name !== controllerPackageName
+        || packageJson.version !== dependency.version
+        || packageJson.controllerUpgradeManagementVersion !== currentIdentity.managementVersion
+        || Number(controllerUpgradeManagementVersion) !== currentIdentity.managementVersion
+        || !packageJson.bin
+        || typeof packageJson.bin !== 'object'
+        || Array.isArray(packageJson.bin)
+        || !Object.keys(packageJson.bin).length
+        || Object.keys(packageJson.bin).length !== 1
+        || packageJson.bin[currentIdentity.cliName] !== './cli.js') {
+        throw new Error(`The pnpm-global ${controllerPackageName} package metadata is incompatible.`);
+    }
+    const cliPath = await plugins.fs.promises.realpath(plugins.path.join(packageDirectory, 'cli.js'));
+    if (!(await plugins.fs.promises.stat(cliPath)).isFile()) {
+        throw new Error('The pnpm-global controller direct CLI is not a file.');
+    }
+    return {
+        packageManagerPath,
+        globalRoot,
+        globalBinDirectory,
+        packageDirectory,
+        cliPath,
+        packageVersion: dependency.version,
+    };
+};
+const parseGlobalListDependencies = (outputArg) => {
+    let value;
+    try {
+        value = JSON.parse(outputArg);
+    }
+    catch {
+        throw new Error('pnpm list --global returned malformed JSON.');
+    }
+    if (!Array.isArray(value) || value.length !== 1) {
+        throw new Error('pnpm list --global returned an unexpected package-transition result.');
+    }
+    const entry = value[0];
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        throw new Error('pnpm list --global returned invalid package-transition metadata.');
+    }
+    const raw = entry;
+    if (typeof raw.path !== 'string' || !plugins.path.isAbsolute(raw.path)) {
+        throw new Error('pnpm list --global omitted its global package root.');
+    }
+    const dependencies = {};
+    for (const packageName of [
+        upgradePackageTransitionSource.packageName,
+        upgradePackageTransitionTarget.packageName,
+    ]) {
+        const dependency = raw.dependencies?.[packageName];
+        if (!dependency)
+            continue;
+        if (typeof dependency.version !== 'string'
+            || typeof dependency.path !== 'string'
+            || !plugins.path.isAbsolute(dependency.path))
+            throw new Error(`pnpm reported invalid global metadata for ${packageName}.`);
+        dependencies[packageName] = {
+            version: dependency.version,
+            path: dependency.path,
+        };
+    }
+    return { path: raw.path, dependencies };
+};
+const packageGroupDirectory = (globalRootArg, packagePathArg, packageNameArg) => {
+    const relative = plugins.path.relative(globalRootArg, packagePathArg);
+    if (!relative
+        || relative === '..'
+        || relative.startsWith(`..${plugins.path.sep}`)
+        || plugins.path.isAbsolute(relative))
+        throw new Error(`pnpm reported ${packageNameArg} outside its global root.`);
+    const expectedSuffix = plugins.path.join('node_modules', ...packageNameArg.split('/'));
+    const suffix = `${plugins.path.sep}${expectedSuffix}`;
+    if (!relative.endsWith(suffix)) {
+        throw new Error(`pnpm reported an unexpected global path for ${packageNameArg}.`);
+    }
+    const groupRelativePath = relative.slice(0, -suffix.length);
+    if (!groupRelativePath || groupRelativePath.includes(plugins.path.sep)) {
+        throw new Error(`pnpm reported an invalid isolated group for ${packageNameArg}.`);
+    }
+    return plugins.path.join(globalRootArg, groupRelativePath);
+};
+const readExactGlobalPackage = async (contextArg, dependencyArg, identityArg) => {
+    if (dependencyArg.version !== identityArg.version) {
+        throw new Error(`The pnpm-global ${identityArg.packageName} version is ${dependencyArg.version}, not ${identityArg.version}.`);
+    }
+    const groupDirectory = packageGroupDirectory(contextArg.globalRoot, dependencyArg.path, identityArg.packageName);
+    const packageDirectory = await plugins.fs.promises.realpath(dependencyArg.path);
+    const packageJsonPath = plugins.path.join(packageDirectory, 'package.json');
+    const packageJsonStats = await plugins.fs.promises.stat(packageJsonPath);
+    if (!packageJsonStats.isFile() || packageJsonStats.size < 2 || packageJsonStats.size > 64 * 1024) {
+        throw new Error(`The pnpm-global ${identityArg.packageName} metadata is not a bounded file.`);
+    }
+    let packageJson;
+    try {
+        packageJson = JSON.parse(await plugins.fs.promises.readFile(packageJsonPath, 'utf8'));
+    }
+    catch (errorArg) {
+        throw new Error(`The pnpm-global ${identityArg.packageName} metadata is malformed.`, {
+            cause: errorArg,
+        });
+    }
+    if (!packageJson || typeof packageJson !== 'object' || Array.isArray(packageJson)) {
+        throw new Error(`The pnpm-global ${identityArg.packageName} metadata is invalid.`);
+    }
+    const manifest = packageJson;
+    const bin = manifest.bin;
+    if (manifest.name !== identityArg.packageName
+        || manifest.version !== identityArg.version
+        || manifest.controllerUpgradeManagementVersion !== identityArg.managementVersion
+        || !bin
+        || typeof bin !== 'object'
+        || Array.isArray(bin)
+        || Object.keys(bin).length !== 1
+        || bin[identityArg.cliName] !== identityArg.cliRelativePath)
+        throw new Error(`The pnpm-global ${identityArg.packageName} identity is incompatible.`);
+    const cliPath = await plugins.fs.promises.realpath(plugins.path.join(packageDirectory, identityArg.cliRelativePath));
+    if (!(await plugins.fs.promises.stat(cliPath)).isFile()) {
+        throw new Error(`The pnpm-global ${identityArg.packageName} direct CLI is not a file.`);
+    }
+    return {
+        packageManagerPath: contextArg.packageManagerPath,
+        globalRoot: contextArg.globalRoot,
+        globalBinDirectory: contextArg.globalBinDirectory,
+        packageDirectory,
+        cliPath,
+        packageVersion: identityArg.version,
+        packageName: identityArg.packageName,
+        cliName: identityArg.cliName,
+        cliRelativePath: identityArg.cliRelativePath,
+        listedPackagePath: dependencyArg.path,
+        groupDirectory,
+    };
+};
+const readGlobalShimTarget = async (binDirectoryArg, cliNameArg) => {
+    const shimPath = plugins.path.join(binDirectoryArg, cliNameArg);
+    let stats;
+    try {
+        stats = await plugins.fs.promises.lstat(shimPath);
+    }
+    catch (errorArg) {
+        if (errorArg.code === 'ENOENT')
+            return undefined;
+        throw errorArg;
+    }
+    if (!stats.isFile()
+        || stats.isSymbolicLink()
+        || stats.size < 2
+        || stats.size > 1024 * 1024
+        || (stats.mode & 0o111) === 0)
+        throw new Error(`The pnpm-global ${cliNameArg} shim is not a bounded executable file.`);
+    const contents = await plugins.fs.promises.readFile(shimPath, 'utf8');
+    const markers = [...contents.matchAll(/^# cmd-shim-target=(.+)$/gm)];
+    if (markers.length !== 1 || !plugins.path.isAbsolute(markers[0][1])) {
+        throw new Error(`The pnpm-global ${cliNameArg} shim has no exact ownership marker.`);
+    }
+    try {
+        return await plugins.fs.promises.realpath(markers[0][1]);
+    }
+    catch (errorArg) {
+        throw new Error(`The pnpm-global ${cliNameArg} shim target is unavailable.`, {
+            cause: errorArg,
+        });
+    }
+};
+const assertGlobalShimOwnership = async (binDirectoryArg, cliNameArg, cliPathArg) => {
+    const markerTarget = await readGlobalShimTarget(binDirectoryArg, cliNameArg);
+    if (markerTarget === undefined) {
+        if (cliPathArg === undefined)
+            return;
+        throw new Error(`The pnpm-global ${cliNameArg} shim is missing.`);
+    }
+    if (cliPathArg === undefined) {
+        throw new Error(`The pnpm-global ${cliNameArg} shim survived without its owning package.`);
+    }
+    if (markerTarget !== cliPathArg) {
+        throw new Error(`The pnpm-global ${cliNameArg} shim is owned by a different package.`);
+    }
+};
+const maximumPnpmGlobalGroups = 1_024;
+const findExactGlobalPackageLink = async (globalRootArg, packageNameArg, packageDirectoryArg) => {
+    const entries = await plugins.fs.promises.readdir(globalRootArg, { withFileTypes: true });
+    if (entries.length > maximumPnpmGlobalGroups) {
+        throw new Error('The pnpm global root exceeds the recovery scan bound.');
+    }
+    const matches = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const candidate = plugins.path.join(globalRootArg, entry.name, 'node_modules', ...packageNameArg.split('/'));
+        try {
+            if (await plugins.fs.promises.realpath(candidate) === packageDirectoryArg) {
+                matches.push(candidate);
+            }
+        }
+        catch (errorArg) {
+            const code = errorArg.code;
+            if (code !== 'ENOENT' && code !== 'ENOTDIR')
+                throw errorArg;
+        }
+    }
+    if (matches.length !== 1) {
+        throw new Error(`Expected exactly one filesystem-owned installation of ${packageNameArg}.`);
+    }
+    return {
+        listedPackagePath: matches[0],
+        groupDirectory: packageGroupDirectory(globalRootArg, matches[0], packageNameArg),
+    };
+};
+const resolveAuthoritativeRecoveryInstallation = async (transactionArg, capturedInstallationArg) => {
+    const [globalRoot, globalBinDirectory, packageManagerPath] = await Promise.all([
+        plugins.fs.promises.realpath(capturedInstallationArg.globalRoot),
+        plugins.fs.promises.realpath(capturedInstallationArg.globalBinDirectory),
+        plugins.fs.promises.realpath(capturedInstallationArg.packageManagerPath),
+    ]);
+    if (globalRoot !== capturedInstallationArg.globalRoot
+        || globalBinDirectory !== capturedInstallationArg.globalBinDirectory
+        || packageManagerPath !== capturedInstallationArg.packageManagerPath)
+        throw new Error('The captured pnpm recovery paths changed unexpectedly.');
+    await plugins.fs.promises.access(packageManagerPath, plugins.fs.constants.X_OK);
+    const currentIdentity = transactionArg.version === upgradePackageTransitionTransactionVersion
+        ? (() => {
+            const identity = transactionArg.targetPackageCommitStarted === true
+                ? upgradePackageTransitionTarget
+                : upgradePackageTransitionSource;
+            return {
+                packageName: identity.packageName,
+                versions: [identity.version],
+                managementVersion: identity.managementVersion,
+                cliName: identity.cliName,
+                cliRelativePath: identity.cliRelativePath,
+            };
+        })()
+        : (() => {
+            const identity = String(controllerPackageName) === upgradePackageTransitionTarget.packageName
+                ? upgradePackageTransitionTarget
+                : upgradePackageTransitionSource;
+            return {
+                packageName: String(controllerPackageName),
+                versions: [
+                    transactionArg.sourceVersion,
+                    ...(transactionArg.targetVersion ? [transactionArg.targetVersion] : []),
+                ],
+                managementVersion: Number(controllerUpgradeManagementVersion),
+                cliName: identity.cliName,
+                cliRelativePath: identity.cliRelativePath,
+            };
+        })();
+    const cliPath = await readGlobalShimTarget(globalBinDirectory, currentIdentity.cliName);
+    if (!cliPath) {
+        throw new Error(`The authoritative pnpm-global ${currentIdentity.cliName} shim is missing.`);
+    }
+    const packageDirectory = plugins.path.dirname(cliPath);
+    if (await plugins.fs.promises.realpath(plugins.path.join(packageDirectory, currentIdentity.cliRelativePath)) !== cliPath)
+        throw new Error('The authoritative recovery CLI path is incompatible.');
+    const packageJsonPath = plugins.path.join(packageDirectory, 'package.json');
+    const packageJsonStats = await plugins.fs.promises.stat(packageJsonPath);
+    if (!packageJsonStats.isFile() || packageJsonStats.size < 2 || packageJsonStats.size > 64 * 1024) {
+        throw new Error('The authoritative recovery package metadata is not a bounded file.');
+    }
+    let packageJson;
+    try {
+        packageJson = JSON.parse(await plugins.fs.promises.readFile(packageJsonPath, 'utf8'));
+    }
+    catch (errorArg) {
+        throw new Error('The authoritative recovery package metadata is malformed.', {
+            cause: errorArg,
+        });
+    }
+    if (!packageJson || typeof packageJson !== 'object' || Array.isArray(packageJson)) {
+        throw new Error('The authoritative recovery package metadata is invalid.');
+    }
+    const manifest = packageJson;
+    const bin = manifest.bin;
+    if (manifest.name !== currentIdentity.packageName
+        || typeof manifest.version !== 'string'
+        || !currentIdentity.versions.includes(manifest.version)
+        || manifest.controllerUpgradeManagementVersion !== currentIdentity.managementVersion
+        || !bin
+        || typeof bin !== 'object'
+        || Array.isArray(bin)
+        || Object.keys(bin).length !== 1
+        || bin[currentIdentity.cliName]
+            !== currentIdentity.cliRelativePath)
+        throw new Error('The authoritative recovery package identity is incompatible.');
+    if (!(await plugins.fs.promises.stat(cliPath)).isFile()) {
+        throw new Error('The authoritative recovery CLI is not a file.');
+    }
+    await findExactGlobalPackageLink(globalRoot, currentIdentity.packageName, packageDirectory);
+    return {
+        packageManagerPath,
+        globalRoot,
+        globalBinDirectory,
+        packageDirectory,
+        cliPath,
+        packageVersion: manifest.version,
+    };
+};
+const verifyPackageTransitionTopology = async (contextArg, expectedArg) => {
+    const output = await runCapturedCommand(contextArg.packageManagerPath, [
+        'list',
+        '--global',
+        upgradePackageTransitionSource.packageName,
+        upgradePackageTransitionTarget.packageName,
+        '--depth=0',
+        '--json',
+    ], createPackageManagerEnvironment());
+    const listed = parseGlobalListDependencies(output);
+    if (await plugins.fs.promises.realpath(listed.path) !== contextArg.globalRoot) {
+        throw new Error('The pnpm global root changed during the package transition.');
+    }
+    const sourceDependency = listed.dependencies[upgradePackageTransitionSource.packageName];
+    const targetDependency = listed.dependencies[upgradePackageTransitionTarget.packageName];
+    const sourceExpected = expectedArg !== 'target-only';
+    const targetExpected = expectedArg !== 'source-only';
+    if (Boolean(sourceDependency) !== sourceExpected || Boolean(targetDependency) !== targetExpected) {
+        throw new Error(`The pnpm-global package topology is not ${expectedArg}.`);
+    }
+    const [source, target] = await Promise.all([
+        sourceDependency
+            ? readExactGlobalPackage(contextArg, sourceDependency, upgradePackageTransitionSource)
+            : undefined,
+        targetDependency
+            ? readExactGlobalPackage(contextArg, targetDependency, upgradePackageTransitionTarget)
+            : undefined,
+    ]);
+    if (expectedArg === 'grouped' && source?.groupDirectory !== target?.groupDirectory) {
+        throw new Error('The source and target packages are not installed in one pnpm group.');
+    }
+    await Promise.all([
+        assertGlobalShimOwnership(contextArg.globalBinDirectory, upgradePackageTransitionSource.cliName, source?.cliPath),
+        assertGlobalShimOwnership(contextArg.globalBinDirectory, upgradePackageTransitionTarget.cliName, target?.cliPath),
+    ]);
+    return {
+        ...(source ? { source } : {}),
+        ...(target ? { target } : {}),
+    };
+};
+const resolvePackageManagerContext = async () => {
+    if (process.platform !== 'linux' && process.platform !== 'darwin') {
+        throw new Error(`${currentCliName} upgrade is currently supported on Linux and macOS only.`);
+    }
+    const environment = createPackageManagerEnvironment();
+    const packageManagerPath = await findExecutable('pnpm', environment);
+    const globalRoot = await assertSingleLineAbsolutePath(await runCapturedCommand(packageManagerPath, ['root', '--global'], environment), 'pnpm root --global');
+    const globalBinDirectory = await assertSingleLineAbsolutePath(await runCapturedCommand(packageManagerPath, ['bin', '--global'], environment), 'pnpm bin --global');
+    return { packageManagerPath, globalRoot, globalBinDirectory };
+};
+export const resolveInheritedUpgradeTargetInstallation = async (transactionArg) => {
+    if (transactionArg.version === upgradeCoordinationVersion) {
+        return await resolvePnpmGlobalInstallation();
+    }
+    const topology = await verifyPackageTransitionTopology(await resolvePackageManagerContext(), 'target-only');
+    if (!topology.target)
+        throw new Error('The committed target package is unavailable.');
+    return topology.target;
+};
+export const resolveCurrentCliPath = async () => {
+    return await plugins.fs.promises.realpath(plugins.url.fileURLToPath(new URL('../cli.js', import.meta.url)));
+};
+const currentPackageIsDevelopmentCheckout = async () => {
+    const packageRoot = plugins.path.dirname(await resolveCurrentCliPath());
+    try {
+        const stats = await plugins.fs.promises.lstat(plugins.path.join(packageRoot, '.git'));
+        return stats.isDirectory() || stats.isFile();
+    }
+    catch (errorArg) {
+        if (errorArg.code === 'ENOENT')
+            return false;
+        throw errorArg;
+    }
+};
+export const resolveCurrentPnpmGlobalInstallation = async () => {
+    const [installation, cliPath] = await Promise.all([
+        resolvePnpmGlobalInstallation(),
+        resolveCurrentCliPath(),
+    ]);
+    if (installation.cliPath !== cliPath || installation.packageVersion !== commitinfo.version) {
+        throw new Error(`${currentCliName} upgrade must be run from the active pnpm-global installation.`);
+    }
+    return installation;
+};
+export const tryResolveCurrentPnpmGlobalInstallation = async () => {
+    if (await currentPackageIsDevelopmentCheckout())
+        return undefined;
+    return await resolveCurrentPnpmGlobalInstallation();
+};
+const parseSemver = (valueArg) => {
+    const match = semverPattern.exec(valueArg);
+    if (!match)
+        throw new Error(`Invalid semantic version: ${valueArg}`);
+    const prerelease = match[4]?.split('.') ?? [];
+    if (prerelease.some((identifierArg) => /^\d+$/.test(identifierArg)
+        && identifierArg.length > 1
+        && identifierArg.startsWith('0'))) {
+        throw new Error(`Invalid semantic version: ${valueArg}`);
+    }
+    return {
+        major: match[1],
+        minor: match[2],
+        patch: match[3],
+        prerelease,
+    };
+};
+const compareNumericStrings = (leftArg, rightArg) => {
+    if (leftArg.length !== rightArg.length)
+        return leftArg.length < rightArg.length ? -1 : 1;
+    return leftArg === rightArg ? 0 : leftArg < rightArg ? -1 : 1;
+};
+export const compareSemver = (leftArg, rightArg) => {
+    const left = parseSemver(leftArg);
+    const right = parseSemver(rightArg);
+    for (const key of ['major', 'minor', 'patch']) {
+        const comparison = compareNumericStrings(left[key], right[key]);
+        if (comparison !== 0)
+            return comparison;
+    }
+    if (left.prerelease.length === 0 || right.prerelease.length === 0) {
+        if (left.prerelease.length === right.prerelease.length)
+            return 0;
+        return left.prerelease.length === 0 ? 1 : -1;
+    }
+    const identifierCount = Math.max(left.prerelease.length, right.prerelease.length);
+    for (let index = 0; index < identifierCount; index++) {
+        const leftIdentifier = left.prerelease[index];
+        const rightIdentifier = right.prerelease[index];
+        if (leftIdentifier === undefined || rightIdentifier === undefined) {
+            return leftIdentifier === rightIdentifier ? 0 : leftIdentifier === undefined ? -1 : 1;
+        }
+        if (leftIdentifier === rightIdentifier)
+            continue;
+        const leftNumeric = /^\d+$/.test(leftIdentifier);
+        const rightNumeric = /^\d+$/.test(rightIdentifier);
+        if (leftNumeric && rightNumeric) {
+            return compareNumericStrings(leftIdentifier, rightIdentifier);
+        }
+        if (leftNumeric !== rightNumeric)
+            return leftNumeric ? -1 : 1;
+        return leftIdentifier < rightIdentifier ? -1 : 1;
+    }
+    return 0;
+};
+const readLatestVersion = async (installationArg) => {
+    const output = await runCapturedCommand(installationArg.packageManagerPath, [
+        'view',
+        controllerPackageName,
+        'dist-tags.latest',
+        `--registry=${npmRegistryUrl}`,
+        '--json',
+    ], createPackageManagerEnvironment());
+    let version;
+    try {
+        version = JSON.parse(output);
+    }
+    catch {
+        throw new Error('pnpm view returned malformed JSON for the npm latest tag.');
+    }
+    if (typeof version !== 'string') {
+        throw new Error('The npm latest tag did not resolve to one package version.');
+    }
+    parseSemver(version);
+    return version;
+};
+const assertInternalRegistryUrl = (valueArg) => {
+    let parsed;
+    try {
+        parsed = new URL(valueArg);
+    }
+    catch (errorArg) {
+        throw new Error('The internal upgrade registry URL is invalid.', { cause: errorArg });
+    }
+    if ((parsed.protocol !== 'https:' && parsed.protocol !== 'http:')
+        || parsed.username.length > 0
+        || parsed.password.length > 0)
+        throw new Error('The internal upgrade registry URL is unsafe.');
+    return parsed.toString();
+};
+const resolveExactPackageTransitionTarget = async (contextArg, registryUrlArg) => {
+    const output = await runCapturedCommand(contextArg.packageManagerPath, [
+        'view',
+        `${upgradePackageTransitionTarget.packageName}@${upgradePackageTransitionTarget.version}`,
+        `--registry=${registryUrlArg}`,
+        '--json',
+    ], createPackageManagerEnvironment());
+    let metadata;
+    try {
+        metadata = JSON.parse(output);
+    }
+    catch (errorArg) {
+        throw new Error('pnpm view returned malformed target package metadata.', { cause: errorArg });
+    }
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
+        throw new Error('pnpm view returned invalid target package metadata.');
+    }
+    const manifest = metadata;
+    const bin = manifest.bin;
+    if (manifest.name !== upgradePackageTransitionTarget.packageName
+        || manifest.version !== upgradePackageTransitionTarget.version
+        || manifest.controllerUpgradeManagementVersion
+            !== upgradePackageTransitionTarget.managementVersion
+        || !bin
+        || typeof bin !== 'object'
+        || Array.isArray(bin)
+        || Object.keys(bin).length !== 1
+        || bin[upgradePackageTransitionTarget.cliName]
+            !== upgradePackageTransitionTarget.cliRelativePath)
+        throw new Error('The exact target package metadata is incompatible.');
+};
+const openUpgradeLog = async (tokenArg) => {
+    const directory = controllerDataDirectory();
+    await plugins.fs.promises.mkdir(directory, { recursive: true, mode: 0o700 });
+    const directoryStats = await plugins.fs.promises.lstat(directory);
+    if (!directoryStats.isDirectory()
+        || directoryStats.isSymbolicLink()
+        || (typeof process.getuid === 'function' && directoryStats.uid !== process.getuid())
+        || (directoryStats.mode & 0o077) !== 0) {
+        throw new Error(`The ${currentCliName} upgrade log directory is unsafe: ${directory}`);
+    }
+    const existingLogs = [];
+    for (const entry of await plugins.fs.promises.readdir(directory, { withFileTypes: true })) {
+        if (!entry.isFile() || !upgradeLogPattern.test(entry.name))
+            continue;
+        const existingPath = plugins.path.join(directory, entry.name);
+        const stats = await plugins.fs.promises.lstat(existingPath);
+        if (!stats.isFile()
+            || stats.isSymbolicLink()
+            || (typeof process.getuid === 'function' && stats.uid !== process.getuid())
+            || (stats.mode & 0o077) !== 0) {
+            throw new Error(`An existing ${currentCliName} upgrade log is unsafe: ${existingPath}`);
+        }
+        existingLogs.push({ path: existingPath, mtimeMs: stats.mtimeMs });
+    }
+    existingLogs.sort((leftArg, rightArg) => rightArg.mtimeMs - leftArg.mtimeMs);
+    for (const staleLog of existingLogs.slice(retainedUpgradeLogCount - 1)) {
+        if (Date.now() - staleLog.mtimeMs < minimumPrunableUpgradeLogAgeMs)
+            continue;
+        await plugins.fs.promises.unlink(staleLog.path).catch((errorArg) => {
+            if (errorArg.code !== 'ENOENT')
+                throw errorArg;
+        });
+    }
+    const filePath = plugins.path.join(directory, `upgrade-${new Date().toISOString().replaceAll(':', '')}-${plugins.crypto
+        .createHash('sha256')
+        .update(tokenArg, 'utf8')
+        .digest('hex')
+        .slice(0, 10)}.log`);
+    const handle = await plugins.fs.promises.open(filePath, plugins.fs.constants.O_WRONLY
+        | plugins.fs.constants.O_APPEND
+        | plugins.fs.constants.O_CREAT
+        | plugins.fs.constants.O_EXCL
+        | plugins.fs.constants.O_NOFOLLOW, 0o600);
+    return { handle, path: filePath };
+};
+const serializeUpgradeRecoveryWorkerContext = (contextArg) => Buffer.from(JSON.stringify(contextArg), 'utf8').toString('base64url');
+const parseUpgradeRecoveryWorkerContext = (valueArg) => {
+    if (typeof valueArg !== 'string' || valueArg.length < 16 || valueArg.length > 16 * 1024) {
+        throw new Error('The internal upgrade recovery worker context is invalid.');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(valueArg, 'base64url').toString('utf8'));
+    }
+    catch (errorArg) {
+        throw new Error('The internal upgrade recovery worker context is malformed.', {
+            cause: errorArg,
+        });
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('The internal upgrade recovery worker context is malformed.');
+    }
+    const context = parsed;
+    if (Object.keys(context).length !== 6
+        || ![
+            'version',
+            'mode',
+            'canonicalGlobalRoot',
+            'packageManagerPath',
+            'globalBinDirectory',
+            'cliPath',
+        ].every((keyArg) => Object.hasOwn(context, keyArg))
+        || context.version !== 1
+        || context.mode !== 'recovery'
+        || typeof context.canonicalGlobalRoot !== 'string'
+        || typeof context.packageManagerPath !== 'string'
+        || typeof context.globalBinDirectory !== 'string'
+        || typeof context.cliPath !== 'string'
+        || !plugins.path.isAbsolute(context.canonicalGlobalRoot)
+        || !plugins.path.isAbsolute(context.packageManagerPath)
+        || !plugins.path.isAbsolute(context.globalBinDirectory)
+        || !plugins.path.isAbsolute(context.cliPath))
+        throw new Error('The internal upgrade recovery worker context is incompatible.');
+    return context;
+};
+const waitForProcessGroupDrain = async (processGroupIdArg, timeoutMsArg) => {
+    const deadline = Date.now() + timeoutMsArg;
+    while (Date.now() < deadline) {
+        if ((await readProcessGroupMemberPids(processGroupIdArg)).length === 0)
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    return (await readProcessGroupMemberPids(processGroupIdArg)).length === 0;
+};
+const terminateSpawnedDetachedWorker = async (processIdArg) => {
+    const signal = (signalArg) => {
+        try {
+            process.kill(-processIdArg, signalArg);
+        }
+        catch (errorArg) {
+            if (errorArg.code !== 'ESRCH')
+                throw errorArg;
+        }
+    };
+    signal('SIGTERM');
+    if (await waitForProcessGroupDrain(processIdArg, commandGroupDrainTimeoutMs))
+        return;
+    signal('SIGKILL');
+    if (!await waitForProcessGroupDrain(processIdArg, commandGroupDrainTimeoutMs)) {
+        throw new Error('The detached upgrade worker candidate group did not terminate.');
+    }
+};
+const retryCandidateCleanupUntilDrained = async (cleanupArg, dependenciesArg = {}, processIdArg) => {
+    const delay = dependenciesArg.delay
+        ?? (async (millisecondsArg) => new Promise((resolve) => (setTimeout(resolve, millisecondsArg))));
+    while (true) {
+        try {
+            await dependenciesArg.beforeAttempt?.(processIdArg);
+            await cleanupArg();
+            return;
+        }
+        catch {
+            await delay(candidateCleanupRetryIntervalMs);
+        }
+    }
+};
+const launchDetachedUpgradeWorkerProcess = async (optionsArg, dependenciesArg = {}) => {
+    if (process.platform !== 'linux' && process.platform !== 'darwin') {
+        throw new Error(`${currentCliName} upgrade is currently supported on Linux and macOS only.`);
+    }
+    const log = await openUpgradeLog(optionsArg.payload.token);
+    let child;
+    let logClosed = false;
+    try {
+        const launchedChild = plugins.childProcess.spawn(process.execPath, [
+            optionsArg.installation.cliPath,
+            '__upgrade-worker',
+            serializeUpgradeWorkerPayload(optionsArg.payload),
+            ...(optionsArg.internalArguments ?? []),
+        ], {
+            cwd: plugins.os.homedir(),
+            detached: true,
+            env: {
+                ...(optionsArg.environment ?? process.env),
+                [upgradeTokenEnvironmentVariable]: optionsArg.payload.token,
+            },
+            shell: false,
+            stdio: ['ignore', log.handle.fd, log.handle.fd],
+        });
+        child = launchedChild;
+        await new Promise((resolve, reject) => {
+            launchedChild.once('spawn', resolve);
+            launchedChild.once('error', reject);
+        });
+        await log.handle.close();
+        logClosed = true;
+        if (!launchedChild.pid) {
+            throw new Error(`The detached ${currentCliName} upgrade worker has no process ID.`);
+        }
+        const identity = await (dependenciesArg.readProcessIdentity
+            ?? readControllerProcessIdentity)(launchedChild.pid);
+        if (!identity
+            || !identity.processGroupLeader
+            || identity.processGroupId !== launchedChild.pid
+            || !await (dependenciesArg.processHasCliCommand ?? processIdentityHasCliCommand)(identity, optionsArg.installation.cliPath, '__upgrade-worker'))
+            throw new Error('The detached upgrade worker candidate identity is invalid.');
+        launchedChild.unref();
+        return {
+            pid: identity.pid,
+            processGroupId: identity.processGroupId,
+            fingerprint: identity.fingerprint,
+            cliPath: optionsArg.installation.cliPath,
+            logFilePath: log.path,
+        };
+    }
+    catch (errorArg) {
+        const errors = [errorArg];
+        if (!logClosed) {
+            try {
+                await log.handle.close();
+                logClosed = true;
+            }
+            catch (logCleanupErrorArg) {
+                errors.push(logCleanupErrorArg);
+            }
+        }
+        if (child?.pid) {
+            await retryCandidateCleanupUntilDrained(async () => terminateSpawnedDetachedWorker(child.pid), dependenciesArg.candidateCleanup, child.pid);
+        }
+        if (errors.length > 1) {
+            throw new AggregateError(errors, 'The detached upgrade worker launch and log cleanup both failed.');
+        }
+        throw errorArg;
+    }
+};
+export async function launchDetachedUpgradeWorker(optionsArg, dependenciesArg = {}) {
+    return await launchDetachedUpgradeWorkerProcess(optionsArg, dependenciesArg);
+}
+const launchDetachedRecoveryWorker = async (optionsArg) => await launchDetachedUpgradeWorkerProcess({
+    ...optionsArg,
+    internalArguments: [serializeUpgradeRecoveryWorkerContext({
+            version: 1,
+            mode: 'recovery',
+            canonicalGlobalRoot: optionsArg.installation.globalRoot,
+            packageManagerPath: optionsArg.installation.packageManagerPath,
+            globalBinDirectory: optionsArg.installation.globalBinDirectory,
+            cliPath: optionsArg.installation.cliPath,
+        })],
+});
+const runLoggedCommand = async (optionsArg) => {
+    await runManagedCommand({
+        ...optionsArg,
+        captureOutput: false,
+        outputByteLimit: loggedCommandOutputByteLimit,
+    });
+};
+const installVersion = async (installationArg, versionArg) => {
+    await runLoggedCommand({
+        executable: installationArg.packageManagerPath,
+        arguments: [
+            'add',
+            '--global',
+            '--save-exact',
+            '--yes',
+            '--reporter=append-only',
+            '--allow-build=node-pty',
+            '--allow-build=fs-ext-extra-prebuilt',
+            `--registry=${npmRegistryUrl}`,
+            `${controllerPackageName}@${versionArg}`,
+        ],
+        environment: createPackageManagerEnvironment(),
+        timeoutMs: packageManagerTimeoutMs,
+    });
+};
+const packageAddArguments = (packageSpecArg, registryUrlArg) => [
+    'add',
+    '--global',
+    '--save-exact',
+    '--yes',
+    '--reporter=append-only',
+    '--allow-build=node-pty',
+    '--allow-build=fs-ext-extra-prebuilt',
+    `--registry=${registryUrlArg}`,
+    packageSpecArg,
+];
+const preparePackageAdd = async (contextArg, packageSpecArg, registryUrlArg) => await prepareManagedCommand({
+    executable: contextArg.packageManagerPath,
+    arguments: packageAddArguments(packageSpecArg, registryUrlArg),
+    environment: createPackageManagerEnvironment(),
+    timeoutMs: packageManagerTimeoutMs,
+    captureOutput: false,
+    outputByteLimit: loggedCommandOutputByteLimit,
+});
+const addExactPackage = async (contextArg, packageSpecArg, registryUrlArg) => {
+    await runPreparedManagedCommand(await preparePackageAdd(contextArg, packageSpecArg, registryUrlArg));
+};
+const assertExpectedController = (statusArg, expectedArg) => {
+    if (statusArg.controllerPid !== expectedArg.pid
+        || statusArg.processGroupId !== expectedArg.processGroupId
+        || statusArg.processFingerprint !== expectedArg.processFingerprint
+        || statusArg.lifecycleState !== 'ready') {
+        throw new Error('The running controller changed after the upgrade request was authorized.');
+    }
+};
+const prepareControllerStart = async (installationArg, portArg, tokenArg) => await prepareManagedCommand({
+    executable: process.execPath,
+    arguments: [installationArg.cliPath, 'start', '--port', String(portArg)],
+    environment: {
+        ...process.env,
+        [upgradeTokenEnvironmentVariable]: tokenArg,
+    },
+    timeoutMs: controllerRestartTimeoutMs,
+    captureOutput: false,
+    outputByteLimit: loggedCommandOutputByteLimit,
+});
+const startController = async (installationArg, portArg, tokenArg) => await runPreparedManagedCommand(await prepareControllerStart(installationArg, portArg, tokenArg)).then(() => undefined);
+const retainedTargetTransactionMatches = (transactionArg, installationArg) => Boolean(!transactionArg.terminal
+    && transactionArg.controllerWasRunning
+    && transactionArg.targetStartupInvoked === true
+    && (transactionArg.version === upgradeCoordinationVersion
+        || transactionArg.targetPackageCommitted === true)
+    && (transactionArg.phase === 'restarting' || transactionArg.phase === 'continuing')
+    && transactionArg.targetVersion === installationArg.packageVersion
+    && transactionArg.controller?.command === '__serve'
+    && transactionArg.controller.cliPath === installationArg.cliPath
+    && transactionArg.controller.pid === transactionArg.controller.processGroupId
+    && /^linux:[1-9][0-9]*:[1-9][0-9]*$/.test(transactionArg.controller.fingerprint));
+export const retainedUpgradeTargetIsAuthoritative = async (optionsArg, dependenciesArg = {}) => {
+    if ((dependenciesArg.platform ?? process.platform) !== 'linux')
+        return false;
+    const resolveInstallation = dependenciesArg.resolveInstallation
+        ?? resolveInheritedUpgradeTargetInstallation;
+    const inspectProcess = dependenciesArg.inspectProcess ?? inspectControllerProcess;
+    const transaction = await optionsArg.coordinator.readTransaction(optionsArg.token);
+    const installation = await resolveInstallation(transaction);
+    if (!retainedTargetTransactionMatches(transaction, installation))
+        return false;
+    const controller = transaction.controller;
+    const identity = await inspectProcess({
+        pid: controller.pid,
+        cliPath: controller.cliPath,
+        port: transaction.port,
+        expectedProcessGroupId: controller.processGroupId,
+        expectedFingerprint: controller.fingerprint,
+        command: controller.command,
+    });
+    if (!identity?.processGroupLeader || identity.fingerprint !== controller.fingerprint)
+        return false;
+    const currentTransaction = await optionsArg.coordinator.readTransaction(optionsArg.token);
+    const currentInstallation = await resolveInstallation(currentTransaction);
+    if (!retainedTargetTransactionMatches(currentTransaction, currentInstallation)
+        || currentTransaction.controller.pid !== controller.pid
+        || currentTransaction.controller.processGroupId !== controller.processGroupId
+        || currentTransaction.controller.fingerprint !== controller.fingerprint
+        || currentTransaction.controller.cliPath !== controller.cliPath)
+        return false;
+    const currentIdentity = await inspectProcess({
+        pid: currentTransaction.controller.pid,
+        cliPath: currentTransaction.controller.cliPath,
+        port: currentTransaction.port,
+        expectedProcessGroupId: currentTransaction.controller.processGroupId,
+        expectedFingerprint: currentTransaction.controller.fingerprint,
+        command: currentTransaction.controller.command,
+    });
+    return Boolean(currentIdentity?.processGroupLeader
+        && currentIdentity.fingerprint === currentTransaction.controller.fingerprint);
+};
+const updateWorkerProgress = async (coordinatorArg, tokenArg, phaseArg, messageArg) => coordinatorArg.mutateTransaction(tokenArg, (current) => ({
+    ...current,
+    phase: phaseArg,
+    message: messageArg,
+}));
+const grantControllerAction = async (coordinatorArg, tokenArg, statusArg, actionArg, modeArg) => coordinatorArg.createControllerActionGrant({
+    token: tokenArg,
+    action: actionArg,
+    ...(modeArg === undefined ? {} : { mode: modeArg }),
+    packageVersion: statusArg.packageVersion,
+    controller: {
+        pid: statusArg.controllerPid,
+        processGroupId: statusArg.processGroupId,
+        processFingerprint: statusArg.processFingerprint,
+    },
+});
+const queryUpgradeManagedController = async (portArg, identityArg) => queryControllerStatus(portArg, {
+    packageName: identityArg.packageName,
+    packageVersion: identityArg.packageVersion,
+    upgradeManagementVersion: identityArg.managementVersion,
+});
+const finalizeControllerUpgrade = async (coordinatorArg, tokenArg, statusArg, modeArg) => {
+    await grantControllerAction(coordinatorArg, tokenArg, statusArg, 'finalize', modeArg);
+    let response;
+    try {
+        response = await requestControllerUpgradeFinalize(statusArg.controllerPid > 0
+            ? (await coordinatorArg.readTransaction(tokenArg)).port
+            : 0, tokenArg, modeArg);
+    }
+    finally {
+        await coordinatorArg.removeControllerActionGrant('finalize', tokenArg);
+    }
+    if (response.failed > 0) {
+        throw new Error(`${response.failed} paused session${response.failed === 1 ? '' : 's'} could not be continued.`);
+    }
+};
+export const waitForControllerUpgradePreparation = async (optionsArg) => {
+    const now = optionsArg.now ?? Date.now;
+    const delay = optionsArg.delay
+        ?? (async (millisecondsArg) => new Promise((resolve) => (setTimeout(resolve, millisecondsArg))));
+    const acceptanceReconciliationDeadline = now()
+        + upgradePreparationAcceptanceReconciliationMs;
+    let nextSourceCheckAt = 0;
+    while (true) {
+        const currentTime = now();
+        if (currentTime >= nextSourceCheckAt) {
+            if (!await optionsArg.controllerIsLive()) {
+                throw new Error('The source controller exited before upgrade preparation completed.');
+            }
+            nextSourceCheckAt = currentTime + upgradePreparationSourceCheckMs;
+        }
+        const transaction = await optionsArg.coordinator.readTransaction(optionsArg.token);
+        if (transaction.terminal) {
+            throw new Error(transaction.terminal.error
+                ?? transaction.message
+                ?? 'The source controller rejected upgrade preparation.');
+        }
+        if (transaction.preparationAcceptedAt === undefined
+            || transaction.preparationDeadlineAt === undefined) {
+            if (currentTime >= acceptanceReconciliationDeadline) {
+                throw new Error('The source controller did not durably accept upgrade preparation.');
+            }
+            await delay(upgradePreparationPollMs);
+            continue;
+        }
+        if (transaction.targetVersion !== optionsArg.targetVersion
+            || transaction.gracePeriodMs !== optionsArg.gracePeriodMs
+            || transaction.preparationDeadlineAt
+                !== transaction.preparationAcceptedAt + optionsArg.gracePeriodMs)
+            throw new Error('The durable upgrade preparation does not match the worker request.');
+        if (transaction.phase === 'stopping') {
+            if (transaction.preparationCompletedAt === undefined
+                || transaction.preparationCompletedAt < transaction.preparationAcceptedAt
+                || transaction.preparationCompletedAt > transaction.preparationDeadlineAt)
+                throw new Error('The durable upgrade preparation completion is invalid.');
+            return transaction;
+        }
+        if (currentTime > transaction.preparationDeadlineAt + upgradePreparationCleanupAllowanceMs) {
+            throw new Error('Timed out waiting for upgrade preparation cleanup to settle.');
+        }
+        await delay(upgradePreparationPollMs);
+    }
+};
+export const prepareAndStopRunningController = async (optionsArg, dependenciesArg = {}) => {
+    await updateWorkerProgress(optionsArg.coordinator, optionsArg.token, 'preparing', `Preparing sessions for ${optionsArg.currentInstallation.packageVersion} to ${optionsArg.targetVersion}.`);
+    await grantControllerAction(optionsArg.coordinator, optionsArg.token, optionsArg.runningStatus, 'prepare');
+    let beginError;
+    try {
+        await (dependenciesArg.requestPrepareBegin ?? requestControllerUpgradePrepareBegin)(optionsArg.port, optionsArg.token, optionsArg.targetVersion, optionsArg.gracePeriodMs);
+    }
+    catch (errorArg) {
+        beginError = errorArg;
+    }
+    finally {
+        await optionsArg.coordinator.removeControllerActionGrant('prepare', optionsArg.token);
+    }
+    try {
+        await waitForControllerUpgradePreparation({
+            coordinator: optionsArg.coordinator,
+            token: optionsArg.token,
+            targetVersion: optionsArg.targetVersion,
+            gracePeriodMs: optionsArg.gracePeriodMs,
+            controllerIsLive: dependenciesArg.controllerIsLive ?? (async () => Boolean(await inspectControllerProcess({
+                pid: optionsArg.runningStatus.controllerPid,
+                cliPath: optionsArg.currentInstallation.cliPath,
+                port: optionsArg.port,
+                expectedProcessGroupId: optionsArg.runningStatus.processGroupId,
+                expectedFingerprint: optionsArg.runningStatus.processFingerprint,
+                command: optionsArg.runningStatus.processMode === 'detached' ? '__serve' : 'foreground',
+            }))),
+            ...(dependenciesArg.now ? { now: dependenciesArg.now } : {}),
+            ...(dependenciesArg.delay ? { delay: dependenciesArg.delay } : {}),
+        });
+    }
+    catch (errorArg) {
+        if (beginError === undefined)
+            throw errorArg;
+        throw new AggregateError([beginError, errorArg], 'The source controller did not complete asynchronous upgrade preparation.');
+    }
+    await (dependenciesArg.stopController ?? stopVerifiedController)({
+        status: optionsArg.runningStatus,
+        cliPath: optionsArg.currentInstallation.cliPath,
+        port: optionsArg.port,
+    });
+};
+const restorePreviousInstallation = async (installationArg) => {
+    try {
+        const current = await resolvePnpmGlobalInstallation();
+        if (current.packageVersion === installationArg.packageVersion)
+            return current;
+    }
+    catch (errorArg) {
+        if (errorContainsCommandCleanupFailure(errorArg))
+            throw errorArg;
+        // Reinstalling the exact prior version is the authoritative rollback.
+    }
+    await installVersion(installationArg, installationArg.packageVersion);
+    const restored = await resolvePnpmGlobalInstallation();
+    if (restored.packageVersion !== installationArg.packageVersion) {
+        throw new Error('The previous pnpm-global package version was not restored.');
+    }
+    return restored;
+};
+const errorContainsCommandCleanupFailure = (errorArg) => {
+    if (errorArg instanceof UpgradeCommandCleanupError)
+        return true;
+    if (errorArg instanceof AggregateError) {
+        return errorArg.errors.some((nestedErrorArg) => (errorContainsCommandCleanupFailure(nestedErrorArg)));
+    }
+    return errorArg instanceof Error
+        && errorArg.cause !== undefined
+        && errorContainsCommandCleanupFailure(errorArg.cause);
+};
+const sourceControllerIdentity = (transactionArg) => transactionArg.version === upgradeCoordinationVersion
+    ? {
+        packageName: controllerPackageName,
+        packageVersion: transactionArg.sourceVersion,
+        managementVersion: controllerUpgradeManagementVersion,
+    }
+    : {
+        packageName: transactionArg.sourcePackageName,
+        packageVersion: transactionArg.sourceVersion,
+        managementVersion: transactionArg.sourceManagementVersion,
+    };
+const requirePackageTransitionTransaction = (transactionArg) => {
+    if (transactionArg.version !== upgradePackageTransitionTransactionVersion) {
+        throw new Error('The package-transition transaction changed format.');
+    }
+    return transactionArg;
+};
+const targetControllerIdentity = (transactionArg) => transactionArg.version === upgradeCoordinationVersion
+    ? {
+        packageName: controllerPackageName,
+        packageVersion: transactionArg.targetVersion
+            ?? (() => { throw new Error('The upgrade target version is unavailable.'); })(),
+        managementVersion: controllerUpgradeManagementVersion,
+    }
+    : {
+        packageName: transactionArg.targetPackageName,
+        packageVersion: transactionArg.targetVersion,
+        managementVersion: transactionArg.targetManagementVersion,
+    };
+export const assertInheritedUpgradeTransaction = (transactionArg, currentIdentityArg) => {
+    if (!transactionArg.controllerWasRunning
+        || transactionArg.targetStartupInvoked !== true
+        || transactionArg.targetVersion !== currentIdentityArg.packageVersion)
+        throw new Error('The inherited upgrade transaction did not authorize target startup.');
+    if (transactionArg.version === upgradeCoordinationVersion) {
+        if (currentIdentityArg.packageName !== String(controllerPackageName)
+            || currentIdentityArg.managementVersion !== controllerUpgradeManagementVersion)
+            throw new Error('The inherited v2 upgrade target identity is incompatible.');
+        return;
+    }
+    if (transactionArg.targetPackageCommitted !== true
+        || transactionArg.targetPackageName !== currentIdentityArg.packageName
+        || transactionArg.targetManagementVersion !== currentIdentityArg.managementVersion
+        || transactionArg.targetCliName !== currentIdentityArg.cliName
+        || transactionArg.targetCliRelativePath !== currentIdentityArg.cliRelativePath)
+        throw new Error('The inherited v3 upgrade target identity is incompatible.');
+};
+const runPackageTransitionUpgradeWorker = async (optionsArg) => {
+    const { coordinator, payload, transaction: initialTransaction, currentInstallation, registryUrl, } = optionsArg;
+    if (commitinfo.name !== initialTransaction.sourcePackageName
+        || commitinfo.version !== initialTransaction.sourceVersion
+        || currentInstallation.packageVersion !== initialTransaction.sourceVersion)
+        throw new Error('The package-transition worker is not running from the exact bridge package.');
+    const context = {
+        packageManagerPath: currentInstallation.packageManagerPath,
+        globalRoot: currentInstallation.globalRoot,
+        globalBinDirectory: currentInstallation.globalBinDirectory,
+    };
+    // Registry validation is deliberately complete before controller preparation or package mutation.
+    await resolveExactPackageTransitionTarget(context, registryUrl);
+    await coordinator.mutateTransaction(payload.token, (current) => {
+        if (current.version !== upgradePackageTransitionTransactionVersion) {
+            throw new Error('The package-transition transaction changed format.');
+        }
+        return {
+            ...current,
+            phase: 'checking',
+            message: `Resolved exact target ${current.targetPackageName}@${current.targetVersion}.`,
+        };
+    });
+    process.stdout.write(`${initialTransaction.sourceCliName} upgrade: resolved ${initialTransaction.targetPackageName}@${initialTransaction.targetVersion}.\n`);
+    const controllerProcesses = await listControllerProcessesForCli(currentInstallation.cliPath);
+    let runningStatus;
+    if (payload.expectedController) {
+        runningStatus = await queryControllerStatus(payload.port, {
+            packageName: initialTransaction.sourcePackageName,
+            packageVersion: initialTransaction.sourceVersion,
+            protocolVersion: controllerProtocolVersion,
+            upgradeManagementVersion: initialTransaction.sourceManagementVersion,
+        });
+        assertExpectedController(runningStatus, payload.expectedController);
+        if (controllerProcesses.length !== 1
+            || controllerProcesses[0].identity.pid !== runningStatus.controllerPid
+            || controllerProcesses[0].port !== payload.port)
+            throw new Error('Additional or mismatched pnpm-global controller instances prevent upgrade.');
+    }
+    else if (controllerProcesses.length > 0) {
+        throw new Error('A pnpm-global controller started after the upgrade request; upgrade aborted.');
+    }
+    else if (await isLoopbackPortListening(payload.port)) {
+        throw new Error(`The requested controller port became occupied while ${initialTransaction.sourceCliName} upgrade was starting.`);
+    }
+    if (runningStatus) {
+        await prepareAndStopRunningController({
+            coordinator,
+            token: payload.token,
+            port: payload.port,
+            targetVersion: initialTransaction.targetVersion,
+            gracePeriodMs: payload.gracePeriodMs,
+            currentInstallation,
+            runningStatus,
+        });
+        process.stdout.write(`${initialTransaction.sourceCliName} upgrade: bridge controller stopped cleanly.\n`);
+    }
+    let targetInstallation;
+    try {
+        await updateWorkerProgress(coordinator, payload.token, 'installing', `Transitioning ${initialTransaction.sourcePackageName} to ${initialTransaction.targetPackageName}.`);
+        if (await isLoopbackPortListening(payload.port)) {
+            throw new Error('The controller port became occupied before package replacement.');
+        }
+        const sourceDataWriters = await listControllerDataWriterProcessesForCli(currentInstallation.cliPath);
+        if (sourceDataWriters.length > 0) {
+            const writer = sourceDataWriters[0];
+            throw new Error(`Package replacement is blocked by ${writer.kind} source writer PID ${writer.identity.pid}.`);
+        }
+        const sourceSpec = `${initialTransaction.sourcePackageName}@${initialTransaction.sourceVersion}`;
+        const targetSpec = `${initialTransaction.targetPackageName}@${initialTransaction.targetVersion}`;
+        const groupedSpec = `${sourceSpec},${targetSpec}`;
+        let current = requirePackageTransitionTransaction(await coordinator.readTransaction(payload.token));
+        if (current.targetPackageCommitStarted !== true) {
+            if (current.groupedTargetVerified !== true) {
+                if (current.packageTransitionStarted === true) {
+                    await addExactPackage(context, sourceSpec, registryUrl);
+                    await verifyPackageTransitionTopology(context, 'source-only');
+                }
+                const groupedAdd = await preparePackageAdd(context, groupedSpec, registryUrl);
+                if (current.packageTransitionStarted !== true) {
+                    current = requirePackageTransitionTransaction(await coordinator.mutateTransaction(payload.token, (transaction) => {
+                        if (transaction.version !== upgradePackageTransitionTransactionVersion) {
+                            throw new Error('The package-transition transaction changed format.');
+                        }
+                        return {
+                            ...transaction,
+                            packageTransitionStarted: true,
+                            message: `Installing grouped ${sourceSpec},${targetSpec}.`,
+                        };
+                    }));
+                }
+                await runPreparedManagedCommand(groupedAdd);
+                await verifyPackageTransitionTopology(context, 'grouped');
+                current = requirePackageTransitionTransaction(await coordinator.mutateTransaction(payload.token, (transaction) => {
+                    if (transaction.version !== upgradePackageTransitionTransactionVersion) {
+                        throw new Error('The package-transition transaction changed format.');
+                    }
+                    return {
+                        ...transaction,
+                        groupedTargetVerified: true,
+                        message: 'Verified the grouped bridge and target package topology.',
+                    };
+                }));
+            }
+            else {
+                await verifyPackageTransitionTopology(context, 'grouped');
+            }
+            const targetAdd = await preparePackageAdd(context, targetSpec, registryUrl);
+            current = requirePackageTransitionTransaction(await coordinator.mutateTransaction(payload.token, (transaction) => {
+                if (transaction.version !== upgradePackageTransitionTransactionVersion) {
+                    throw new Error('The package-transition transaction changed format.');
+                }
+                return {
+                    ...transaction,
+                    targetPackageCommitStarted: true,
+                    message: `Committing exact target ${targetSpec}.`,
+                };
+            }));
+            await runPreparedManagedCommand(targetAdd);
+        }
+        else if (current.targetPackageCommitted !== true) {
+            await addExactPackage(context, targetSpec, registryUrl);
+        }
+        if (current.targetPackageCommitted !== true) {
+            const topology = await verifyPackageTransitionTopology(context, 'target-only');
+            if (!topology.target)
+                throw new Error('The exact target package installation is unavailable.');
+            targetInstallation = topology.target;
+            await coordinator.mutateTransaction(payload.token, (transaction) => {
+                if (transaction.version !== upgradePackageTransitionTransactionVersion) {
+                    throw new Error('The package-transition transaction changed format.');
+                }
+                return {
+                    ...transaction,
+                    targetPackageCommitted: true,
+                    message: `Committed exact target ${targetSpec}.`,
+                };
+            });
+        }
+        else {
+            const topology = await verifyPackageTransitionTopology(context, 'target-only');
+            if (!topology.target)
+                throw new Error('The exact target package installation is unavailable.');
+            targetInstallation = topology.target;
+        }
+    }
+    catch (upgradeErrorArg) {
+        if (errorContainsCommandCleanupFailure(upgradeErrorArg))
+            throw upgradeErrorArg;
+        const current = await coordinator.readTransaction(payload.token);
+        if (current.version === upgradePackageTransitionTransactionVersion
+            && current.targetPackageCommitStarted === true)
+            throw upgradeErrorArg;
+        const recoveryErrors = [upgradeErrorArg];
+        try {
+            const sourceSpec = `${initialTransaction.sourcePackageName}@${initialTransaction.sourceVersion}`;
+            if (current.version === upgradePackageTransitionTransactionVersion
+                && current.packageTransitionStarted === true)
+                await addExactPackage(context, sourceSpec, registryUrl);
+            const sourceTopology = await verifyPackageTransitionTopology(context, 'source-only');
+            if (!sourceTopology.source)
+                throw new Error('The exact bridge package was not restored.');
+            if (runningStatus) {
+                await startController(sourceTopology.source, payload.port, payload.token);
+                const restoredStatus = await queryUpgradeManagedController(payload.port, sourceControllerIdentity(initialTransaction));
+                await finalizeControllerUpgrade(coordinator, payload.token, restoredStatus, 'compensate');
+                process.stdout.write(`${initialTransaction.sourceCliName} upgrade: bridge package restored and restarted.\n`);
+            }
+        }
+        catch (recoveryErrorArg) {
+            recoveryErrors.push(recoveryErrorArg);
+        }
+        throw new AggregateError(recoveryErrors, `${initialTransaction.sourceCliName} upgrade failed before target package commit began.`);
+    }
+    process.stdout.write(`${initialTransaction.sourceCliName} upgrade: committed ${initialTransaction.targetPackageName}@${initialTransaction.targetVersion}.\n`);
+    if (runningStatus) {
+        await updateWorkerProgress(coordinator, payload.token, 'restarting', `Restarting ${initialTransaction.targetPackageName} ${initialTransaction.targetVersion}.`);
+        const preparedTargetStart = await prepareControllerStart(targetInstallation, payload.port, payload.token);
+        await coordinator.mutateTransaction(payload.token, (current) => {
+            if (current.version !== upgradePackageTransitionTransactionVersion) {
+                throw new Error('The package-transition transaction changed format.');
+            }
+            return {
+                ...current,
+                targetStartupInvoked: true,
+                message: `Invoking ${current.targetPackageName} ${current.targetVersion}.`,
+            };
+        });
+        await runPreparedManagedCommand(preparedTargetStart);
+        const targetStatus = await queryUpgradeManagedController(payload.port, targetControllerIdentity(initialTransaction));
+        await updateWorkerProgress(coordinator, payload.token, payload.continueSessions ? 'continuing' : 'restarting', payload.continueSessions
+            ? 'Continuing sessions paused for the upgrade.'
+            : 'Reopening harness prompt admission.');
+        await finalizeControllerUpgrade(coordinator, payload.token, targetStatus, payload.continueSessions ? 'continue' : 'reopen');
+        process.stdout.write(`${initialTransaction.sourceCliName} upgrade: target controller restarted on port ${payload.port}.\n`);
+    }
+    await coordinator.finishTransaction(payload.token, true, `Upgrade to ${initialTransaction.targetPackageName}@${initialTransaction.targetVersion} completed.`);
+};
+const runRecoveryUpgradeWorker = async (payloadArg, internalOptionsArg) => {
+    const context = parseUpgradeRecoveryWorkerContext(internalOptionsArg.recoveryContext);
+    const coordinator = new UpgradeCoordinator(context.canonicalGlobalRoot);
+    let lock;
+    let releaseLock = true;
+    try {
+        await coordinator.waitForWorkerAcknowledgement(payloadArg.token, 10_000);
+        lock = await coordinator.acquireUpgradeLock({
+            token: payloadArg.token,
+            cliPath: context.cliPath,
+        });
+        await coordinator.waitForStartLeasesToDrain(lock);
+        const transaction = await coordinator.readTransaction(payloadArg.token);
+        if (transaction.terminal)
+            return;
+        if (transaction.port !== payloadArg.port
+            || transaction.gracePeriodMs !== payloadArg.gracePeriodMs
+            || transaction.continueSessions !== payloadArg.continueSessions)
+            throw new Error('The recovery worker payload does not match its upgrade transaction.');
+        const identity = await readControllerProcessIdentity(process.pid);
+        if (!identity
+            || !identity.processGroupLeader
+            || identity.processGroupId !== process.pid
+            || transaction.worker?.pid !== identity.pid
+            || transaction.worker.processGroupId !== identity.processGroupId
+            || transaction.worker.fingerprint !== identity.fingerprint
+            || transaction.worker.cliPath !== context.cliPath)
+            throw new Error('The recovery worker transaction identity is incompatible.');
+        const installation = await resolveAuthoritativeRecoveryInstallation(transaction, {
+            packageManagerPath: context.packageManagerPath,
+            globalRoot: context.canonicalGlobalRoot,
+            globalBinDirectory: context.globalBinDirectory,
+            packageDirectory: plugins.path.dirname(context.cliPath),
+            cliPath: context.cliPath,
+            packageVersion: '',
+        });
+        if (installation.cliPath !== context.cliPath) {
+            throw new Error('The authoritative recovery CLI changed during handoff.');
+        }
+        upgradeWorkerCliPath = installation.cliPath;
+        await (internalOptionsArg.recoveryBody ?? recoverStalledUpgradeUnderLock)({
+            coordinator,
+            token: payloadArg.token,
+            transaction,
+            installation,
+        });
+    }
+    catch (errorArg) {
+        const cleanupFailed = (internalOptionsArg.isCommandCleanupFailure
+            ?? errorContainsCommandCleanupFailure)(errorArg);
+        if (cleanupFailed)
+            releaseLock = false;
+        await coordinator.mutateTransaction(payloadArg.token, (current) => ({
+            ...current,
+            message: errorArg instanceof Error ? errorArg.message : String(errorArg),
+        })).catch(() => undefined);
+        throw errorArg;
+    }
+    finally {
+        if (releaseLock)
+            await lock?.release();
+    }
+};
+export async function runUpgradeWorker(payloadArg, internalOptionsArg = {}) {
+    const environmentToken = process.env[upgradeTokenEnvironmentVariable];
+    if (environmentToken !== payloadArg.token) {
+        throw new Error(`The detached ${currentCliName} upgrade worker token binding is invalid.`);
+    }
+    delete process.env[upgradeTokenEnvironmentVariable];
+    if (internalOptionsArg.recoveryContext !== undefined) {
+        await runRecoveryUpgradeWorker(payloadArg, internalOptionsArg);
+        return;
+    }
+    const installation = await resolveCurrentPnpmGlobalInstallation();
+    upgradeWorkerCliPath = installation.cliPath;
+    const coordinator = new UpgradeCoordinator(installation.globalRoot);
+    let lock;
+    let releaseLock = true;
+    try {
+        await coordinator.registerWorker(payloadArg.token, installation.cliPath);
+        await coordinator.waitForWorkerAcknowledgement(payloadArg.token, 10_000);
+        lock = await coordinator.acquireUpgradeLock({
+            token: payloadArg.token,
+            cliPath: installation.cliPath,
+        });
+        await coordinator.waitForStartLeasesToDrain(lock);
+        const currentInstallation = await resolveCurrentPnpmGlobalInstallation();
+        if (currentInstallation.globalRoot !== installation.globalRoot) {
+            throw new Error(`The pnpm global root changed while ${currentCliName} upgrade was starting.`);
+        }
+        const transaction = await coordinator.readTransaction(payloadArg.token);
+        if (transaction.version === upgradePackageTransitionTransactionVersion) {
+            await runPackageTransitionUpgradeWorker({
+                coordinator,
+                payload: payloadArg,
+                transaction,
+                currentInstallation,
+                registryUrl: assertInternalRegistryUrl(internalOptionsArg.registryUrl ?? npmRegistryUrl),
+            });
+            return;
+        }
+        const latestVersion = await readLatestVersion(currentInstallation);
+        await coordinator.mutateTransaction(payloadArg.token, (current) => {
+            if (current.version !== upgradeCoordinationVersion) {
+                throw new Error('The same-package upgrade transaction changed format.');
+            }
+            return {
+                ...current,
+                targetVersion: latestVersion,
+                phase: 'checking',
+                message: `Installed ${currentInstallation.packageVersion}; npm latest is ${latestVersion}.`,
+            };
+        });
+        const versionComparison = compareSemver(latestVersion, currentInstallation.packageVersion);
+        process.stdout.write(`${currentCliName} upgrade: installed ${currentInstallation.packageVersion}, npm latest ${latestVersion}.\n`);
+        if (versionComparison <= 0) {
+            process.stdout.write(versionComparison === 0
+                ? `${currentCliName} upgrade: already up to date.\n`
+                : `${currentCliName} upgrade: installed version is newer than npm latest; refusing to downgrade.\n`);
+            await coordinator.finishTransaction(payloadArg.token, true, versionComparison === 0
+                ? 'Already up to date.'
+                : 'Installed version is newer than npm latest; no downgrade was performed.');
+            return;
+        }
+        const controllerProcesses = await listControllerProcessesForCli(currentInstallation.cliPath);
+        let runningStatus;
+        if (payloadArg.expectedController) {
+            runningStatus = await queryControllerStatus(payloadArg.port, {
+                packageName: controllerPackageName,
+                packageVersion: currentInstallation.packageVersion,
+                protocolVersion: controllerProtocolVersion,
+                upgradeManagementVersion: controllerUpgradeManagementVersion,
+            });
+            assertExpectedController(runningStatus, payloadArg.expectedController);
+            if (controllerProcesses.length !== 1
+                || controllerProcesses[0].identity.pid !== runningStatus.controllerPid
+                || controllerProcesses[0].port !== payloadArg.port) {
+                throw new Error('Additional or mismatched pnpm-global controller instances prevent upgrade.');
+            }
+        }
+        else if (controllerProcesses.length > 0) {
+            throw new Error('A pnpm-global controller started after the upgrade request; upgrade aborted.');
+        }
+        else if (await isLoopbackPortListening(payloadArg.port)) {
+            throw new Error(`The requested controller port became occupied while ${currentCliName} upgrade was starting.`);
+        }
+        if (runningStatus) {
+            await prepareAndStopRunningController({
+                coordinator,
+                token: payloadArg.token,
+                port: payloadArg.port,
+                targetVersion: latestVersion,
+                gracePeriodMs: payloadArg.gracePeriodMs,
+                currentInstallation,
+                runningStatus,
+            });
+            process.stdout.write(`${currentCliName} upgrade: previous controller stopped cleanly.\n`);
+        }
+        let upgradedInstallation;
+        try {
+            await updateWorkerProgress(coordinator, payloadArg.token, 'installing', `Installing ${controllerPackageName} ${latestVersion}.`);
+            if (await isLoopbackPortListening(payloadArg.port)) {
+                throw new Error('The controller port became occupied before package replacement.');
+            }
+            const sourceDataWriters = await listControllerDataWriterProcessesForCli(currentInstallation.cliPath);
+            if (sourceDataWriters.length > 0) {
+                const writer = sourceDataWriters[0];
+                throw new Error(`Package replacement is blocked by ${writer.kind} source writer PID ${writer.identity.pid}.`);
+            }
+            await installVersion(currentInstallation, latestVersion);
+            upgradedInstallation = await resolvePnpmGlobalInstallation();
+            if (upgradedInstallation.packageVersion !== latestVersion) {
+                throw new Error('pnpm completed without installing the requested npm latest version.');
+            }
+        }
+        catch (upgradeErrorArg) {
+            if (errorContainsCommandCleanupFailure(upgradeErrorArg))
+                throw upgradeErrorArg;
+            const recoveryErrors = [upgradeErrorArg];
+            try {
+                const restored = await restorePreviousInstallation(currentInstallation);
+                if (runningStatus) {
+                    await startController(restored, payloadArg.port, payloadArg.token);
+                    const restoredStatus = await queryUpgradeManagedController(payloadArg.port, {
+                        packageName: controllerPackageName,
+                        packageVersion: restored.packageVersion,
+                        managementVersion: controllerUpgradeManagementVersion,
+                    });
+                    await finalizeControllerUpgrade(coordinator, payloadArg.token, restoredStatus, 'compensate');
+                    process.stdout.write(`${currentCliName} upgrade: previous controller version restored and restarted.\n`);
+                }
+            }
+            catch (recoveryErrorArg) {
+                recoveryErrors.push(recoveryErrorArg);
+            }
+            throw new AggregateError(recoveryErrors, `${currentCliName} upgrade failed before the new controller started.`);
+        }
+        process.stdout.write(`${currentCliName} upgrade: installed ${latestVersion}.\n`);
+        if (runningStatus) {
+            // From this point onward rollback is unsafe: startup may run data migrations.
+            await updateWorkerProgress(coordinator, payloadArg.token, 'restarting', `Restarting ${controllerPackageName} ${latestVersion}.`);
+            await coordinator.mutateTransaction(payloadArg.token, (current) => ({
+                ...current,
+                targetStartupInvoked: true,
+                message: `Invoking ${controllerPackageName} ${latestVersion}.`,
+            }));
+            await startController(upgradedInstallation, payloadArg.port, payloadArg.token);
+            const upgradedStatus = await queryUpgradeManagedController(payloadArg.port, {
+                packageName: controllerPackageName,
+                packageVersion: latestVersion,
+                managementVersion: controllerUpgradeManagementVersion,
+            });
+            await updateWorkerProgress(coordinator, payloadArg.token, payloadArg.continueSessions ? 'continuing' : 'restarting', payloadArg.continueSessions
+                ? 'Continuing sessions paused for the upgrade.'
+                : 'Reopening harness prompt admission.');
+            await finalizeControllerUpgrade(coordinator, payloadArg.token, upgradedStatus, payloadArg.continueSessions ? 'continue' : 'reopen');
+            process.stdout.write(`${currentCliName} upgrade: controller restarted on port ${payloadArg.port}.\n`);
+        }
+        await coordinator.finishTransaction(payloadArg.token, true, `Upgrade to ${latestVersion} completed.`);
+    }
+    catch (errorArg) {
+        if (errorContainsCommandCleanupFailure(errorArg))
+            releaseLock = false;
+        const failedTransaction = await coordinator.readTransaction(payloadArg.token).catch(() => undefined);
+        if ((failedTransaction?.version === upgradePackageTransitionTransactionVersion
+            ? failedTransaction.targetPackageCommitStarted === true
+            : failedTransaction?.targetStartupInvoked === true)
+            || errorContainsCommandCleanupFailure(errorArg)) {
+            await coordinator.mutateTransaction(payloadArg.token, (current) => ({
+                ...current,
+                message: errorArg instanceof Error ? errorArg.message : String(errorArg),
+            })).catch(() => undefined);
+            throw errorArg;
+        }
+        await coordinator.finishTransaction(payloadArg.token, false, 'Upgrade failed.', errorArg instanceof Error ? errorArg.message : String(errorArg)).catch(() => undefined);
+        throw errorArg;
+    }
+    finally {
+        if (releaseLock)
+            await lock?.release();
+    }
+}
+const recoverPackageTransition = async (optionsArg) => {
+    const context = {
+        packageManagerPath: optionsArg.installation.packageManagerPath,
+        globalRoot: optionsArg.installation.globalRoot,
+        globalBinDirectory: optionsArg.installation.globalBinDirectory,
+    };
+    const registryUrl = assertInternalRegistryUrl(npmRegistryUrl);
+    const transaction = optionsArg.transaction;
+    if (transaction.targetPackageCommitStarted === true) {
+        const targetSpec = `${transaction.targetPackageName}@${transaction.targetVersion}`;
+        let targetTopology;
+        if (transaction.targetPackageCommitted === true) {
+            try {
+                targetTopology = await verifyPackageTransitionTopology(context, 'target-only');
+            }
+            catch (verificationErrorArg) {
+                try {
+                    await addExactPackage(context, targetSpec, registryUrl);
+                    targetTopology = await verifyPackageTransitionTopology(context, 'target-only');
+                }
+                catch (normalizationErrorArg) {
+                    throw new AggregateError([verificationErrorArg, normalizationErrorArg], 'The committed target package could not be normalized without restoring the bridge.');
+                }
+            }
+        }
+        else {
+            await addExactPackage(context, targetSpec, registryUrl);
+            targetTopology = await verifyPackageTransitionTopology(context, 'target-only');
+            await optionsArg.coordinator.mutateTransaction(optionsArg.token, (current) => {
+                if (current.version !== upgradePackageTransitionTransactionVersion) {
+                    throw new Error('The package-transition transaction changed format.');
+                }
+                return {
+                    ...current,
+                    targetPackageCommitted: true,
+                    message: `Committed exact target ${targetSpec} during bounded recovery.`,
+                };
+            });
+        }
+        const targetInstallation = targetTopology.target;
+        if (!targetInstallation)
+            throw new Error('The exact target package is unavailable.');
+        let current = requirePackageTransitionTransaction(await optionsArg.coordinator.readTransaction(optionsArg.token));
+        if (current.controllerWasRunning) {
+            if (current.targetStartupInvoked !== true) {
+                const candidates = (await listControllerProcessesForCli(targetInstallation.cliPath))
+                    .filter((candidateArg) => candidateArg.port === current.port);
+                if (candidates.length > 0 || await isLoopbackPortListening(current.port)) {
+                    throw new Error('A target controller exists before its durable startup marker; refusing to adopt it.');
+                }
+                const preparedTargetStart = await prepareControllerStart(targetInstallation, current.port, optionsArg.token);
+                current = requirePackageTransitionTransaction(await optionsArg.coordinator.mutateTransaction(optionsArg.token, (candidate) => {
+                    if (candidate.version !== upgradePackageTransitionTransactionVersion) {
+                        throw new Error('The package-transition transaction changed format.');
+                    }
+                    return {
+                        ...candidate,
+                        phase: 'restarting',
+                        targetStartupInvoked: true,
+                        message: `Invoking ${candidate.targetPackageName} during bounded recovery.`,
+                    };
+                }));
+                await runPreparedManagedCommand(preparedTargetStart);
+            }
+            let status = await queryControllerStatus(current.port, {
+                packageName: current.targetPackageName,
+                packageVersion: current.targetVersion,
+                upgradeManagementVersion: current.targetManagementVersion,
+            }).catch(() => undefined);
+            if (!status) {
+                if (await retainedUpgradeTargetIsAuthoritative({
+                    coordinator: optionsArg.coordinator,
+                    token: optionsArg.token,
+                }))
+                    return false;
+                const targetCandidates = (await listControllerProcessesForCli(targetInstallation.cliPath))
+                    .filter((candidateArg) => candidateArg.port === current.port);
+                if (targetCandidates.length > 0 || await isLoopbackPortListening(current.port)) {
+                    throw new Error('A target controller is already starting or listening but cannot be adopted safely; refusing to launch a replacement.');
+                }
+                await startController(targetInstallation, current.port, optionsArg.token);
+                status = await queryUpgradeManagedController(current.port, targetControllerIdentity(current));
+            }
+            await finalizeControllerUpgrade(optionsArg.coordinator, optionsArg.token, status, current.continueSessions ? 'continue' : 'reopen');
+        }
+        await optionsArg.coordinator.finishTransaction(optionsArg.token, true, `Upgrade to ${current.targetPackageName}@${current.targetVersion} completed during bounded recovery.`);
+        return true;
+    }
+    const sourceSpec = `${transaction.sourcePackageName}@${transaction.sourceVersion}`;
+    let sourceTopology;
+    if (transaction.packageTransitionStarted === true) {
+        await addExactPackage(context, sourceSpec, registryUrl);
+        sourceTopology = await verifyPackageTransitionTopology(context, 'source-only');
+    }
+    else {
+        sourceTopology = await verifyPackageTransitionTopology(context, 'source-only');
+    }
+    const sourceInstallation = sourceTopology.source;
+    if (!sourceInstallation)
+        throw new Error('The exact bridge package is unavailable.');
+    if (transaction.controllerWasRunning) {
+        let status = await queryControllerStatus(transaction.port, {
+            packageName: transaction.sourcePackageName,
+            packageVersion: transaction.sourceVersion,
+            upgradeManagementVersion: transaction.sourceManagementVersion,
+        }).catch(() => undefined);
+        if (!status) {
+            await startController(sourceInstallation, transaction.port, optionsArg.token);
+            status = await queryUpgradeManagedController(transaction.port, sourceControllerIdentity(transaction));
+        }
+        await finalizeControllerUpgrade(optionsArg.coordinator, optionsArg.token, status, 'compensate');
+    }
+    await optionsArg.coordinator.finishTransaction(optionsArg.token, false, 'The stalled package transition restored the exact bridge package.', `The upgrade stopped making progress during phase ${transaction.phase}.`);
+    return true;
+};
+const recoverStalledUpgradeUnderLock = async (optionsArg) => {
+    const transaction = optionsArg.transaction;
+    if (transaction.terminal)
+        return true;
+    if (transaction.targetStartupInvoked === true && await retainedUpgradeTargetIsAuthoritative({
+        coordinator: optionsArg.coordinator,
+        token: optionsArg.token,
+    }, {
+        resolveInstallation: async () => optionsArg.installation,
+    }))
+        return false;
+    if (transaction.version === upgradePackageTransitionTransactionVersion) {
+        return await recoverPackageTransition({
+            coordinator: optionsArg.coordinator,
+            token: optionsArg.token,
+            transaction,
+            installation: optionsArg.installation,
+        });
+    }
+    const afterTargetStartupBoundary = transaction.targetStartupInvoked === true;
+    if (afterTargetStartupBoundary) {
+        if (!transaction.targetVersion) {
+            throw new Error('The stalled upgrade has no retained target version.');
+        }
+        const targetInstallation = await resolvePnpmGlobalInstallation();
+        if (targetInstallation.packageVersion !== transaction.targetVersion) {
+            throw new Error('The package installation does not match the retained post-startup upgrade target.');
+        }
+        if (transaction.controllerWasRunning) {
+            let status = await queryControllerStatus(transaction.port, {
+                packageName: controllerPackageName,
+                packageVersion: targetInstallation.packageVersion,
+                upgradeManagementVersion: controllerUpgradeManagementVersion,
+            }).catch(() => undefined);
+            if (!status) {
+                if (await retainedUpgradeTargetIsAuthoritative({
+                    coordinator: optionsArg.coordinator,
+                    token: optionsArg.token,
+                }))
+                    return false;
+                const targetCandidates = (await listControllerProcessesForCli(targetInstallation.cliPath))
+                    .filter((candidateArg) => candidateArg.port === transaction.port);
+                if (targetCandidates.length > 0 || await isLoopbackPortListening(transaction.port)) {
+                    throw new Error('A target controller is already starting or listening but cannot be adopted safely; refusing to launch a replacement.');
+                }
+                await startController(targetInstallation, transaction.port, optionsArg.token);
+                status = await queryUpgradeManagedController(transaction.port, {
+                    packageName: controllerPackageName,
+                    packageVersion: targetInstallation.packageVersion,
+                    managementVersion: controllerUpgradeManagementVersion,
+                });
+            }
+            await finalizeControllerUpgrade(optionsArg.coordinator, optionsArg.token, status, transaction.continueSessions ? 'continue' : 'reopen');
+        }
+        await optionsArg.coordinator.finishTransaction(optionsArg.token, true, `Upgrade to ${transaction.targetVersion} completed during bounded recovery.`);
+        return true;
+    }
+    const sourceInstallation = await restorePreviousInstallation({
+        ...optionsArg.installation,
+        packageVersion: transaction.sourceVersion,
+    });
+    if (transaction.controllerWasRunning) {
+        let status = await queryControllerStatus(transaction.port, {
+            packageName: controllerPackageName,
+            packageVersion: sourceInstallation.packageVersion,
+            upgradeManagementVersion: controllerUpgradeManagementVersion,
+        }).catch(() => undefined);
+        if (!status) {
+            await startController(sourceInstallation, transaction.port, optionsArg.token);
+            status = await queryUpgradeManagedController(transaction.port, {
+                packageName: controllerPackageName,
+                packageVersion: sourceInstallation.packageVersion,
+                managementVersion: controllerUpgradeManagementVersion,
+            });
+        }
+        await finalizeControllerUpgrade(optionsArg.coordinator, optionsArg.token, status, 'compensate');
+    }
+    await optionsArg.coordinator.finishTransaction(optionsArg.token, false, 'The stalled upgrade restored the source package.', `The upgrade stopped making progress during phase ${transaction.phase}.`);
+    return true;
+};
+export async function recoverStalledUpgrade(optionsArg, dependenciesArg = {}) {
+    await optionsArg.coordinator.terminateTransactionWorker(optionsArg.transaction);
+    let lock;
+    try {
+        lock = await optionsArg.coordinator.acquireUpgradeLock({
+            token: optionsArg.token,
+            cliPath: optionsArg.installation.cliPath,
+            command: optionsArg.command,
+        });
+    }
+    catch (errorArg) {
+        if (errorArg instanceof Error
+            && (errorArg.message.includes('already running')
+                || errorArg.message.includes('initializing')))
+            return false;
+        throw errorArg;
+    }
+    let candidate;
+    let lockTransferred = false;
+    try {
+        const transaction = await optionsArg.coordinator.readTransaction(optionsArg.token);
+        if (transaction.terminal) {
+            await lock.release();
+            return true;
+        }
+        const recoveryInstallation = await resolveAuthoritativeRecoveryInstallation(transaction, optionsArg.installation);
+        const payload = {
+            version: upgradeCoordinationVersion,
+            token: optionsArg.token,
+            port: transaction.port,
+            gracePeriodMs: transaction.gracePeriodMs,
+            continueSessions: transaction.continueSessions,
+        };
+        candidate = await (dependenciesArg.launchRecoveryWorker ?? launchDetachedRecoveryWorker)({
+            installation: recoveryInstallation,
+            payload,
+        });
+        const launchedTransaction = await optionsArg.coordinator.recordWorkerLaunch(optionsArg.token, candidate.pid, candidate.cliPath, candidate.logFilePath);
+        const worker = launchedTransaction.worker;
+        if (!worker
+            || worker.pid !== candidate.pid
+            || worker.processGroupId !== candidate.processGroupId
+            || worker.fingerprint !== candidate.fingerprint
+            || worker.cliPath !== candidate.cliPath
+            || worker.logFilePath !== candidate.logFilePath)
+            throw new Error('The recovery worker launch identity was not retained exactly.');
+        await optionsArg.coordinator.transferUpgradeLockToWorker({
+            lock,
+            token: optionsArg.token,
+            worker,
+        });
+        lockTransferred = true;
+        await optionsArg.coordinator.acknowledgeWorker(optionsArg.token);
+        return true;
+    }
+    catch (errorArg) {
+        const errors = [errorArg];
+        if (candidate) {
+            await retryCandidateCleanupUntilDrained(async () => await (dependenciesArg.terminateWorkerCandidate
+                ?? ((candidateArg) => optionsArg.coordinator.terminateUpgradeWorkerCandidate(candidateArg)))(candidate), dependenciesArg.candidateCleanup, candidate.pid);
+        }
+        try {
+            if (!lockTransferred) {
+                try {
+                    await lock.release();
+                }
+                catch {
+                    const replacementLock = await optionsArg.coordinator.acquireUpgradeLock({
+                        token: optionsArg.token,
+                        cliPath: optionsArg.installation.cliPath,
+                        command: optionsArg.command,
+                    });
+                    await replacementLock.release();
+                }
+            }
+            else {
+                const replacementLock = await optionsArg.coordinator.acquireUpgradeLock({
+                    token: optionsArg.token,
+                    cliPath: optionsArg.installation.cliPath,
+                    command: optionsArg.command,
+                });
+                await replacementLock.release();
+            }
+        }
+        catch (lockCleanupErrorArg) {
+            errors.push(lockCleanupErrorArg);
+        }
+        if (errors.length > 1) {
+            throw new AggregateError(errors, 'Stalled upgrade recovery handoff failed and cleanup was incomplete.');
+        }
+        throw errorArg;
+    }
+}
+export const createUpgradeWorkerPayload = (optionsArg) => ({
+    version: upgradeCoordinationVersion,
+    token: createUpgradeToken(),
+    port: optionsArg.port,
+    gracePeriodMs: optionsArg.gracePeriodMs,
+    continueSessions: optionsArg.continueSessions,
+    ...(optionsArg.expectedController
+        ? { expectedController: optionsArg.expectedController }
+        : {}),
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.upgradetransaction.js","sourceRoot":"","sources":["../../ts/classes.upgradetransaction.ts"],"names":[],"mappings":"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"}