trm-core 9.10.5 → 10.0.0

package/dist/actions/commons/utils/packageCleanup.js

@@ -0,0 +1,1017 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackagesInstalledIn = getPackagesInstalledIn;
+exports.getInstalledObjectsLocks = getInstalledObjectsLocks;
+exports.deleteTemporaryCleanupPackages = deleteTemporaryCleanupPackages;
+exports.deleteCleanupStagingPackages = deleteCleanupStagingPackages;
+exports.restoreTadirAssignments = restoreTadirAssignments;
+exports.createStagingPackage = createStagingPackage;
+exports.cleanupInstalledPackage = cleanupInstalledPackage;
+exports.isDeletionForwardable = isDeletionForwardable;
+exports.forwardDeletionTransport = forwardDeletionTransport;
+exports.removeFromImportQueue = removeFromImportQueue;
+exports.revertForwardedDeletionTransport = revertForwardedDeletionTransport;
+exports.revertInstalledPackageCleanup = revertInstalledPackageCleanup;
+const trm_commons_1 = require("trm-commons");
+const systemConnector_1 = require("../../../systemConnector");
+const transport_1 = require("../../../transport");
+const registry_1 = require("../../../registry");
+const commons_1 = require("../../../commons");
+const crypto_1 = require("crypto");
+const releaseDeletionTransport_1 = require("./releaseDeletionTransport");
+const restoreTransport_1 = require("./restoreTransport");
+const withScopedPrefix_1 = require("./withScopedPrefix");
+const actionLocks_1 = require("./actionLocks");
+const owningInstallation_1 = require("./owningInstallation");
+function normalize(value) {
+    return value.trim().toUpperCase();
+}
+function objectKey(object) {
+    return `${normalize(object.pgmid)}\u0000${normalize(object.object)}\u0000${normalize(object.objName)}`;
+}
+function isDevclass(object) {
+    return normalize(object.pgmid) === 'R3TR' && normalize(object.object) === 'DEVC';
+}
+function isNamespace(object) {
+    return normalize(object.pgmid) === 'R3TR' && normalize(object.object) === 'NSPC';
+}
+/** Custom (`/XXX/`) namespace of a SAP package, if any. */
+function getCustomNamespace(devclass) {
+    try {
+        const namespace = (0, commons_1.getPackageNamespace)(devclass);
+        return namespace.startsWith('/') ? namespace : undefined;
+    }
+    catch (e) {
+        // devclass doesn't use a custom namespace
+        return undefined;
+    }
+}
+/**
+ * TRM packages, other than `installed`, installed in one of `devclasses` (normalized SAP package
+ * names, usually the live subtree of the installed release).
+ */
+function getPackagesInstalledIn(systemPackages, installed, devclasses) {
+    const installedDevclass = normalize(installed.getDevclass() || '');
+    return systemPackages.filter(pkg => {
+        const devclass = normalize(pkg.getDevclass() || '');
+        return devclass && devclass !== installedDevclass && devclasses.has(devclass);
+    });
+}
+/**
+ * Objects of the installed transport the cleanup deletes, and the namespaces it carries.
+ */
+function readInstalledTransportObjects(installed) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const installedTransportObjects = installed.getTransport()
+            ? yield installed.getTransport().getE071()
+            : [];
+        // Table content (entries with E071K keys, e.g. a landscape transport carrying the CUST
+        // transports) is deleted by key through the customizing transports. Added without
+        // its keys, it would request the deletion of the whole table object.
+        const keyedObjects = new Set(installed.getTransport() && installedTransportObjects.length > 0
+            ? (yield installed.getTransport().getE071K()).map(key => objectKey((0, transport_1.getE071KOwner)(key)))
+            : []);
+        return {
+            // A namespace may be used by packages outside this installation: it's only deleted
+            // through the usage check, never because the installed transport carries it.
+            previousNamespaces: installedTransportObjects.filter(object => !keyedObjects.has(objectKey(object)) && isNamespace(object)),
+            // Translations (LANG rows, e.g. a landscape transport carrying the LANG transport) are deleted
+            // with their objects: SAP rejects them as deletion entries.
+            previousTransportObjects: installedTransportObjects.filter(object => !keyedObjects.has(objectKey(object))
+                && !isNamespace(object) && normalize(object.pgmid) !== 'LANG')
+        };
+    });
+}
+/** SAP packages of an installed release, as they are on the system now. */
+function readInstallationTree(installed, previousInstallPackages, previousTransportObjects, deletedObjects, systemPackages) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const previousDevclasses = new Map();
+        previousInstallPackages.forEach(replacement => {
+            previousDevclasses.set(normalize(replacement.installDevclass), replacement.installDevclass);
+        });
+        // Older installations that kept the publisher package names have no replacement rows.
+        if (previousDevclasses.size === 0 && installed.getDevclass()) {
+            const previousRoot = installed.getDevclass();
+            previousDevclasses.set(normalize(previousRoot), previousRoot);
+        }
+        previousTransportObjects.forEach(object => {
+            if (isDevclass(object)) {
+                previousDevclasses.set(normalize(object.objName), object.objName);
+            }
+        });
+        const installedDevclasses = new Set(previousDevclasses.keys());
+        // Installation mappings do not include subpackages created locally afterwards.
+        // Inspect the live hierarchy even when the installation keeps its root package.
+        const deletedKeys = new Set(deletedObjects.map(objectKey));
+        const packageParents = new Map();
+        for (const devclass of Array.from(previousDevclasses.values())) {
+            for (const subpackage of yield systemConnector_1.SystemConnector.getSubpackages(devclass)) {
+                if (deletedKeys.has(objectKey({ pgmid: 'R3TR', object: 'DEVC', objName: subpackage.devclass }))) {
+                    continue;
+                }
+                const key = normalize(subpackage.devclass);
+                previousDevclasses.set(key, subpackage.devclass);
+                if (subpackage.parentcl) {
+                    packageParents.set(key, normalize(subpackage.parentcl));
+                }
+                // Without mapping rows (a published development copy, or an older installation that kept the
+                // publisher names) the installed transport doesn't list the SAP packages: the live ones are the installation's.
+                if (previousInstallPackages.length === 0) {
+                    installedDevclasses.add(key);
+                }
+            }
+        }
+        // Other TRM packages installed underneath have their own lifecycle and are ignored: the uninstall
+        // action deletes them first, an upgrade removes everything else. Their ancestors stay as packages.
+        const otherInstallations = new Map(getPackagesInstalledIn(systemPackages, installed, new Set(previousDevclasses.keys())).map(pkg => [normalize(pkg.getDevclass()), pkg]));
+        const isOtherInstallation = (devclass) => {
+            const visited = new Set();
+            let current = normalize(devclass);
+            while (current && !visited.has(current)) {
+                if (otherInstallations.has(current)) {
+                    return true;
+                }
+                visited.add(current);
+                current = packageParents.get(current);
+            }
+            return false;
+        };
+        return { previousDevclasses, installedDevclasses, packageParents, otherInstallations, isOtherInstallation };
+    });
+}
+/**
+ * Installed objects now in a SAP package outside the installation, or in the SAP package of
+ * another TRM package installed underneath.
+ */
+function readRelocatedObjects(objects, tree) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield systemConnector_1.SystemConnector.getExistingObjects(objects
+            .filter(object => normalize(object.pgmid) === 'R3TR' && !isDevclass(object))
+            .map(object => ({ pgmid: object.pgmid, object: object.object, objName: object.objName, devclass: '' }))))
+            .filter(object => object.devclass && (!tree.previousDevclasses.has(normalize(object.devclass)) || tree.isOtherInstallation(object.devclass)));
+    });
+}
+/**
+ * Locks on those of `objects` that removing `installed` certainly deletes: the objects of its
+ * installed transport still in its SAP packages. These would abort the cleanup at its objects
+ * lock check, so they can be checked before asking anything. Objects added locally or moved
+ * outside the installation are left out, as the cleanup may keep them.
+ */
+function getInstalledObjectsLocks(installed, previousInstallPackages, systemPackages, objects) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (objects.length === 0) {
+            return [];
+        }
+        const { previousTransportObjects } = yield readInstalledTransportObjects(installed);
+        const installedKeys = new Set(previousTransportObjects.map(objectKey));
+        const candidates = new Map(objects
+            .filter(object => installedKeys.has(objectKey(object)))
+            .map(object => [objectKey(object), object]));
+        if (candidates.size === 0) {
+            return [];
+        }
+        const tree = yield readInstallationTree(installed, previousInstallPackages, previousTransportObjects, [], systemPackages);
+        (yield readRelocatedObjects(Array.from(candidates.values()), tree)).forEach(object => candidates.delete(objectKey(object)));
+        if (candidates.size === 0) {
+            return [];
+        }
+        return systemConnector_1.SystemConnector.getObjectsLocks(Array.from(candidates.values(), object => ({
+            PGMID: object.pgmid,
+            OBJECT: object.object,
+            OBJ_NAME: object.objName
+        })));
+    });
+}
+/** Deletes every temporary package, reporting the first failure after the cleanup pass. */
+function deleteTemporaryCleanupPackages(temporaryPackages) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let firstError;
+        for (const devclass of temporaryPackages) {
+            try {
+                yield systemConnector_1.SystemConnector.deleteTemporaryPackage(devclass.objName);
+            }
+            catch (error) {
+                firstError || (firstError = error);
+            }
+        }
+        if (firstError) {
+            throw firstError;
+        }
+    });
+}
+/**
+ * Deletes the staging packages created by the cleanup, once their objects were assigned back.
+ * Every package is attempted; the first failure is thrown afterwards.
+ */
+function deleteCleanupStagingPackages(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let firstError;
+        for (const devclass of context.revert.stagingPackages || []) {
+            try {
+                if (!(yield systemConnector_1.SystemConnector.getDevclass(devclass))) {
+                    continue;
+                }
+                const objects = (yield systemConnector_1.SystemConnector.getDevclassObjects(devclass, false)).filter(object => !isDevclass(object));
+                if (objects.length > 0) {
+                    throw new Error(`SAP package ${devclass} still contains ${objects.length} objects: manual cleanup is necessary.`);
+                }
+                trm_commons_1.Logger.loading(`Deleting package ${devclass}...`, true);
+                const transport = yield transport_1.Transport.createToc({
+                    text: `@X1@TRM (DELE) ${context.rawInput.packageData.name} ${context.runtime.update.manifest.get().version}`,
+                    target: systemConnector_1.SystemConnector.getDest()
+                });
+                try {
+                    yield transport.addObjects([{ pgmid: 'R3TR', object: 'DEVC', objName: devclass }], false);
+                    yield (0, releaseDeletionTransport_1.releaseDeletionTransport)(transport, context.rawInput.packageData.registry, context, false);
+                }
+                catch (error) {
+                    try {
+                        if (yield transport.canBeDeleted()) {
+                            yield transport.delete();
+                        }
+                    }
+                    catch (deleteError) {
+                        trm_commons_1.Logger.warning(`Could not delete transport ${transport.trkorr}: ${String(deleteError)}`, { important: true });
+                    }
+                    throw error;
+                }
+            }
+            catch (error) {
+                trm_commons_1.Logger.warning(`Could not delete SAP package ${devclass}, manual cleanup might be necessary.`, { important: true });
+                firstError || (firstError = error);
+            }
+        }
+        // Namespaces imported for the staging go once no package uses them.
+        for (const namespace of context.revert.temporaryNamespaces || []) {
+            try {
+                if (!(yield systemConnector_1.SystemConnector.getNamespace(namespace))) {
+                    continue;
+                }
+                const packages = yield systemConnector_1.SystemConnector.getNamespacePackages(namespace);
+                if (packages.length > 0) {
+                    throw new Error(`Namespace ${namespace} is still used by SAP packages ${packages.map(o => o.devclass).join(', ')}.`);
+                }
+                trm_commons_1.Logger.loading(`Deleting namespace ${namespace}...`, true);
+                const transport = yield transport_1.Transport.createToc({
+                    text: `@X1@TRM (DELE) ${context.rawInput.packageData.name} ${context.runtime.update.manifest.get().version}`,
+                    target: systemConnector_1.SystemConnector.getDest()
+                });
+                try {
+                    yield transport.addObjects([{ pgmid: 'R3TR', object: 'NSPC', objName: namespace }], false);
+                    yield (0, releaseDeletionTransport_1.releaseDeletionTransport)(transport, context.rawInput.packageData.registry, context, false);
+                }
+                catch (error) {
+                    try {
+                        if (yield transport.canBeDeleted()) {
+                            yield transport.delete();
+                        }
+                    }
+                    catch (deleteError) {
+                        trm_commons_1.Logger.warning(`Could not delete transport ${transport.trkorr}: ${String(deleteError)}`, { important: true });
+                    }
+                    throw error;
+                }
+            }
+            catch (error) {
+                trm_commons_1.Logger.warning(`Could not delete namespace ${namespace}, imported for the cleanup: manual cleanup might be necessary.`, { important: true });
+                firstError || (firstError = error);
+            }
+        }
+        if (firstError) {
+            throw firstError;
+        }
+    });
+}
+function restoreCleanupPackages(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Snapshots are stored in deletion order: reverse it to recreate parents first.
+        let firstError;
+        for (const pkg of [...(context.revert.cleanupTemporaryPackages || [])].reverse()) {
+            try {
+                if (yield systemConnector_1.SystemConnector.getDevclass(pkg.devclass)) {
+                    continue;
+                }
+                yield systemConnector_1.SystemConnector.createPackage(Object.assign(Object.assign({}, (0, commons_1.packageDataFromTdevc)(pkg, {
+                    devclass: pkg.devclass,
+                    ctext: pkg.ctext || '',
+                    as4user: pkg.as4user || systemConnector_1.SystemConnector.getLogonUser(),
+                    dlvunit: pkg.dlvunit,
+                    pdevclass: pkg.pdevclass || ''
+                })), { parentcl: pkg.parentcl, tpclass: pkg.tpclass }));
+            }
+            catch (error) {
+                firstError || (firstError = error);
+            }
+        }
+        if (firstError) {
+            throw firstError;
+        }
+    });
+}
+function restoreCleanupAssignments(context, restorePackages) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (restorePackages) {
+            yield restoreCleanupPackages(context);
+        }
+        yield restoreTadirAssignments(context.revert.cleanupOriginalTadir || []);
+    });
+}
+/**
+ * Assigns the objects that still exist back to their previous TADIR rows. Every object is
+ * attempted; the first failure is thrown afterwards.
+ */
+function restoreTadirAssignments(originals) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (originals.length === 0) {
+            return;
+        }
+        const existing = new Set((yield systemConnector_1.SystemConnector.getExistingObjects(originals)).map(objectKey));
+        let firstError;
+        for (const object of originals) {
+            if (existing.has(objectKey(object))) {
+                try {
+                    yield systemConnector_1.SystemConnector.tadirInterface(object);
+                }
+                catch (error) {
+                    firstError || (firstError = error);
+                }
+            }
+        }
+        if (firstError) {
+            throw firstError;
+        }
+    });
+}
+/**
+ * Releases a transport of copies with the previous definition of the retained tables,
+ * so a rollback can restore them without dropping their data.
+ */
+function backupRetainedTables(context, retainedTables) {
+    return __awaiter(this, void 0, void 0, function* () {
+        trm_commons_1.Logger.loading(`Backing up ${retainedTables.length} retained tables...`, true);
+        const backup = yield transport_1.Transport.createToc({
+            text: `@X1@TRM (BKP) ${context.rawInput.packageData.name} ${context.runtime.update.manifest.get().version}`,
+            target: systemConnector_1.SystemConnector.getDest()
+        });
+        context.revert.updateTablesBackupTransport = backup;
+        yield backup.addObjects(retainedTables.map(object => ({
+            pgmid: object.pgmid,
+            object: object.object,
+            objName: object.objName
+        })), false);
+        yield backup.release(false, true);
+        context.revert.retainedTables = {
+            trkorr: backup.trkorr,
+            entries: undefined,
+            binaries: (yield backup.download()).binaries
+        };
+        context.revert.retainedTableObjects = retainedTables.map(object => ({
+            pgmid: object.pgmid,
+            object: object.object,
+            objName: object.objName
+        }));
+    });
+}
+/**
+ * Customizing transports of the installed release whose rows must be deleted. Only transports
+ * recorded at install time and still on the system count.
+ */
+function getCustomizingSources(context, target) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sources = [];
+        for (const transport of context.runtime.previousInstallTransports || []) {
+            if (normalize(transport.trmType || '') !== transport_1.TrmTransportIdentifier.CUST) {
+                continue;
+            }
+            if (yield new transport_1.Transport(transport.trkorr).getE070()) {
+                sources.push(transport.trkorr);
+            }
+            else {
+                trm_commons_1.Logger.warning(`Customizing transport ${transport.trkorr} is no longer on ${systemConnector_1.SystemConnector.getDest()}: its rows can't be deleted.`, { important: true });
+            }
+        }
+        if (sources.length === 0) {
+            return [];
+        }
+        if (target.keepCustomizing) {
+            trm_commons_1.Logger.warning(`Keeping customizing of ${sources.length} transports (${sources.join(', ')}).`, { important: true });
+            return [];
+        }
+        return sources;
+    });
+}
+/**
+ * Lists the customizing rows the cleanup deletes and asks to continue: always for a generic key or a
+ * whole table, which also delete rows not shipped by the package (default no); otherwise only when
+ * the incoming release doesn't ship customizing that rewrites them (default yes).
+ * Without prompts, it only warns.
+ */
+function confirmCustomizingDeletion(context, target, sources) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const rows = [];
+        for (const trkorr of sources) {
+            rows.push(...yield new transport_1.Transport(trkorr).getCustomizingKeys());
+        }
+        const generic = rows.filter(row => row.tabkey === undefined || row.tabkey.includes('*'));
+        // Rows the incoming release ships again are rewritten by its import: only the others are lost.
+        const incoming = target.incomingCustomizing || [];
+        const wholeTables = new Set(incoming.filter(row => row.tabkey === undefined).map(row => normalize(row.table)));
+        const incomingKeys = new Set(incoming.filter(row => row.tabkey !== undefined).map(row => `${normalize(row.table)}\u0000${row.tabkey}`));
+        const lost = rows.filter(row => !generic.includes(row)
+            && !wholeTables.has(normalize(row.table)) && !incomingKeys.has(`${normalize(row.table)}\u0000${row.tabkey}`));
+        const listed = [...generic, ...lost];
+        if (listed.length === 0) {
+            trm_commons_1.Logger.log(`Deleting ${rows.length} customizing rows rewritten by the incoming release`, true);
+            return;
+        }
+        const label = (row) => row.tabkey === undefined ? `${row.table} (all rows)` : `${row.table} ${row.tabkey}`;
+        const shown = listed.slice(0, 20).map(label);
+        if (listed.length > shown.length) {
+            shown.push(`...and ${listed.length - shown.length} more`);
+        }
+        const name = context.rawInput.packageData.name;
+        const version = context.runtime.update.manifest.get().version;
+        const message = generic.length > 0
+            ? `${generic.length} customizing ${generic.length === 1 ? 'entry' : 'entries'} of ${name} v${version} ${generic.length === 1 ? 'uses' : 'use'} a generic key or a whole table: every matching row will be deleted, including rows not shipped by ${name}`
+            : `${listed.length} customizing ${listed.length === 1 ? 'row' : 'rows'} shipped by ${name} v${version} will be deleted${incoming.length > 0 ? ' (not shipped by the new release)' : ''}`;
+        trm_commons_1.Logger.warning(`${message}:\n${shown.join('\n')}`, { important: true });
+        if ((_a = context.rawInput.contextData) === null || _a === void 0 ? void 0 : _a.noInquirer) {
+            return;
+        }
+        const { deleteCustomizing } = yield trm_commons_1.Inquirer.prompt({
+            name: 'deleteCustomizing',
+            type: 'confirm',
+            message: `${message}. Continue?`,
+            default: generic.length === 0
+        });
+        if (!deleteCustomizing) {
+            throw new Error(`${target.actionName} aborted.`);
+        }
+    });
+}
+/** Whether `namespace` has the producer role (P) on the system: its objects are developed here. */
+function isProducerNamespace(namespace) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rows = yield systemConnector_1.SystemConnector.readTable('TRNSPACE', [{ fieldName: 'ROLE' }], `NAMESPACE EQ '${namespace.replace(/'/g, "''")}'`);
+        return rows.some(row => normalize(row.role || '') === 'P');
+    });
+}
+/**
+ * Imports a custom namespace missing on the system, with the repair license of the installed
+ * release, so its objects can be staged in a package of the namespace.
+ */
+function importStagingNamespace(context, namespace) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (yield systemConnector_1.SystemConnector.getNamespace(namespace)) {
+            return;
+        }
+        const manifestNamespace = context.runtime.update.manifest.get().namespace;
+        if (!(manifestNamespace === null || manifestNamespace === void 0 ? void 0 : manifestNamespace.replicense) || normalize(manifestNamespace.ns || '') !== normalize(namespace)) {
+            throw new Error(`Namespace ${namespace} doesn't exist in ${systemConnector_1.SystemConnector.getDest()} and its repair license is unknown: add it in SE03 to delete the objects of the local installation.`);
+        }
+        trm_commons_1.Logger.loading(`Importing namespace ${namespace}...`, true);
+        // Track before the mutating await: SAP may commit the namespace and still fail the response.
+        (_a = context.revert).temporaryNamespaces || (_a.temporaryNamespaces = []);
+        context.revert.temporaryNamespaces.push(namespace);
+        yield systemConnector_1.SystemConnector.addNamespace(namespace, manifestNamespace.replicense, manifestNamespace.texts.map(o => ({
+            namespace,
+            spras: o.language,
+            descriptn: o.description,
+            owner: o.owner
+        })));
+    });
+}
+/** Creates a short-lived transportable package, in `namespace` when set, so CTS can export local objects. */
+function createStagingPackage(context, namespace) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const prefix = namespace ? `${namespace}TRMD_` : 'ZTRM_DELE_';
+        // DEVCLASS allows 30 characters.
+        const hexLength = Math.min(16, 30 - prefix.length);
+        let stagingDevclass;
+        do {
+            stagingDevclass = `${prefix}${(0, crypto_1.randomBytes)(8).toString('hex').toUpperCase().substring(0, hexLength)}`;
+        } while (yield systemConnector_1.SystemConnector.getDevclass(stagingDevclass));
+        trm_commons_1.Logger.loading(`Creating package ${stagingDevclass}...`, true);
+        // Track before the mutating await because SAP may commit the package
+        // even when the connector response fails.
+        (_a = context.revert).stagingPackages || (_a.stagingPackages = []);
+        context.revert.stagingPackages.push(stagingDevclass);
+        yield systemConnector_1.SystemConnector.createPackage({
+            devclass: stagingDevclass,
+            ctext: 'TRM upgrade cleanup',
+            as4user: systemConnector_1.SystemConnector.getLogonUser(),
+            dlvunit: 'HOME',
+            pdevclass: yield systemConnector_1.SystemConnector.getDefaultTransportLayer()
+        });
+        yield systemConnector_1.SystemConnector.tadirInterface({
+            pgmid: 'R3TR', object: 'DEVC', objName: stagingDevclass,
+            devclass: stagingDevclass, srcsystem: 'TRM'
+        });
+        return stagingDevclass;
+    });
+}
+/**
+ * Removes the objects of the installed release (`context.runtime.update`) that are not part
+ * of `target`, through a deletion transport generated by the registry.
+ *
+ * Shared by upgrades, where the target is the incoming release, and by uninstalls, where the
+ * target is empty. It also removes SAP packages left empty, locally added objects (after
+ * confirmation), the package namespace when no other package uses it, and the customizing rows
+ * of the installed release. Tables shipped again by the target are kept and
+ * backed up so a rollback preserves their data.
+ */
+function cleanupInstalledPackage(context, target) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield (0, withScopedPrefix_1.withScopedPrefix)(target.prefix, () => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const installed = context.runtime.update;
+            //1- generate dummy transport
+            trm_commons_1.Logger.loading(`Generating transport...`);
+            const dummy = yield transport_1.Transport.createToc({
+                text: `@X1@TRM (DELE) ${context.rawInput.packageData.name} ${installed.manifest.get().version}`,
+                target: systemConnector_1.SystemConnector.getDest()
+            });
+            context.revert.updateCleanupTransport = dummy;
+            const { previousNamespaces, previousTransportObjects } = yield readInstalledTransportObjects(installed);
+            const incomingObjects = target.incomingObjects;
+            // Tables shipped again by the new release are adjusted by its import instead of
+            // being dropped and re-created, which would lose their data.
+            const incomingKeys = new Set(incomingObjects.map(objectKey));
+            const retainedTables = previousTransportObjects.filter(object => normalize(object.pgmid) === 'R3TR' && normalize(object.object) === 'TABL'
+                && incomingKeys.has(objectKey(object)));
+            const retainedKeys = new Set(retainedTables.map(objectKey));
+            retainedTables.forEach(object => trm_commons_1.Logger.log(`Keeping table ${object.objName} (present in new release)`, true));
+            const currentDevclasses = new Set(target.keptDevclasses.map(normalize));
+            const deletedKeys = new Set((context.runtime.deletedObjects || []).map(objectKey));
+            const { previousDevclasses, installedDevclasses, packageParents, otherInstallations, isOtherInstallation } = yield readInstallationTree(installed, context.runtime.previousInstallPackages, previousTransportObjects, context.runtime.deletedObjects || [], ((_a = context.rawInput.contextData) === null || _a === void 0 ? void 0 : _a.systemPackages) || []);
+            const generatedDevclasses = new Set(context.revert.sapPackages.map(normalize));
+            otherInstallations.forEach(pkg => trm_commons_1.Logger.log(`Ignoring SAP package ${pkg.getDevclass()}: TRM package ${pkg.packageName} is installed there`, true));
+            // Local additions remain cleanup candidates even when reused as incoming targets.
+            // The first local package owns the decision for its locally added descendants.
+            const cleanupGroups = new Map();
+            for (const normalizedDevclass of previousDevclasses.keys()) {
+                const locallyAdded = !installedDevclasses.has(normalizedDevclass);
+                if (generatedDevclasses.has(normalizedDevclass) || (!locallyAdded && currentDevclasses.has(normalizedDevclass))
+                    || isOtherInstallation(normalizedDevclass)) {
+                    continue;
+                }
+                let root = normalizedDevclass;
+                const visited = new Set([root]);
+                let parent = packageParents.get(root);
+                while (parent && previousDevclasses.has(parent) && !generatedDevclasses.has(parent)
+                    && (!installedDevclasses.has(parent) === locallyAdded)
+                    && (locallyAdded || !currentDevclasses.has(parent)) && !visited.has(parent)) {
+                    root = parent;
+                    visited.add(root);
+                    parent = packageParents.get(root);
+                }
+                if (!cleanupGroups.has(root)) {
+                    cleanupGroups.set(root, new Set());
+                }
+                cleanupGroups.get(root).add(normalizedDevclass);
+            }
+            const changedDevclassesToDelete = [];
+            const extraObjectsToDelete = new Map();
+            for (const [root, group] of cleanupGroups) {
+                const devclass = previousDevclasses.get(root);
+                // Only objects outside both releases need an extra cleanup decision.
+                const objectsAfterImport = new Map();
+                for (const member of group) {
+                    for (const object of yield systemConnector_1.SystemConnector.getDevclassObjects(previousDevclasses.get(member), false)) {
+                        // Package definitions follow the decision for the whole subtree; namespaces the usage check.
+                        if (!isDevclass(object) && !isNamespace(object) && !deletedKeys.has(objectKey(object))) {
+                            objectsAfterImport.set(objectKey(object), object);
+                        }
+                    }
+                }
+                previousTransportObjects.forEach(object => objectsAfterImport.delete(objectKey(object)));
+                incomingObjects.forEach(object => {
+                    objectsAfterImport.delete(objectKey(object));
+                });
+                // Every locally added package definition is an extra object, including
+                // the root of this cleanup group, regardless of whether it has contents.
+                const packagesToRemove = Array.from(group).filter(member => !currentDevclasses.has(member));
+                const extraObjectCount = objectsAfterImport.size + packagesToRemove.filter(member => !installedDevclasses.has(member)).length;
+                if (extraObjectCount > 0) {
+                    const extraObjectsMessage = `Cleanup of SAP package ${devclass}${group.size > 1 ? ' and its subpackages' : ''} will delete ${extraObjectCount} extra objects outside this installation`;
+                    // Name the objects, so the user can tell local developments worth keeping.
+                    const extraObjects = [
+                        ...Array.from(objectsAfterImport.values()).map(object => `${object.pgmid} ${object.object} ${object.objName}`),
+                        ...packagesToRemove.filter(member => !installedDevclasses.has(member)).map(member => `R3TR DEVC ${previousDevclasses.get(member)}`)
+                    ];
+                    trm_commons_1.Logger.warning(`${extraObjectsMessage}:\n${extraObjects.join('\n')}`, { important: true });
+                    const { deleteExtraObjects } = context.rawInput.contextData.noInquirer
+                        ? { deleteExtraObjects: true }
+                        : yield trm_commons_1.Inquirer.prompt({
+                            name: 'deleteExtraObjects',
+                            type: 'confirm',
+                            message: `${extraObjectsMessage}. Continue?`,
+                            default: true
+                        });
+                    if (!deleteExtraObjects) {
+                        continue;
+                    }
+                    objectsAfterImport.forEach((object, key) => extraObjectsToDelete.set(key, {
+                        pgmid: object.pgmid,
+                        object: object.object,
+                        objName: object.objName
+                    }));
+                }
+                changedDevclassesToDelete.push(...packagesToRemove.map(member => previousDevclasses.get(member)));
+            }
+            // A retained child still needs its ancestors, including when cleanup was declined.
+            const deletableDevclasses = new Set(changedDevclassesToDelete.map(normalize));
+            for (const devclass of previousDevclasses.keys()) {
+                if (deletableDevclasses.has(devclass)) {
+                    continue;
+                }
+                const visited = new Set();
+                let parent = packageParents.get(devclass);
+                while (parent && !visited.has(parent)) {
+                    visited.add(parent);
+                    deletableDevclasses.delete(parent);
+                    parent = packageParents.get(parent);
+                }
+            }
+            const packagesToDelete = changedDevclassesToDelete.filter(devclass => deletableDevclasses.has(normalize(devclass)));
+            // A namespace can only be cleaned up alongside its last remaining package: any other SAP
+            // package in it (TDEVC NAMESPACE), installed by TRM or not, keeps it. Namespaces of the
+            // incoming release are kept, as its packages may not have been imported yet.
+            const incomingNamespaces = new Set(target.keptDevclasses.map(getCustomNamespace).filter(Boolean).map(normalize));
+            const namespaceCandidates = new Map();
+            previousNamespaces.forEach(object => namespaceCandidates.set(normalize(object.objName), object.objName));
+            const rootNamespace = installed.getDevclass() ? getCustomNamespace(installed.getDevclass()) : undefined;
+            if (rootNamespace) {
+                namespaceCandidates.set(normalize(rootNamespace), rootNamespace);
+            }
+            const deletingDevclasses = new Set(packagesToDelete.map(normalize));
+            const namespacesToDelete = [];
+            for (const [key, namespace] of namespaceCandidates) {
+                if (incomingNamespaces.has(key)) {
+                    trm_commons_1.Logger.log(`Keeping namespace ${namespace}: used by the incoming release`, true);
+                    continue;
+                }
+                try {
+                    if (!(yield systemConnector_1.SystemConnector.getNamespace(namespace))) {
+                        continue;
+                    }
+                    // A producer namespace is developed on this system (TRM imports namespaces as recipient, role C): never delete it.
+                    if (yield isProducerNamespace(namespace)) {
+                        trm_commons_1.Logger.log(`Keeping namespace ${namespace}: it's a producer namespace of ${systemConnector_1.SystemConnector.getDest()}`, true);
+                        continue;
+                    }
+                    const remainingPackages = (yield systemConnector_1.SystemConnector.getNamespacePackages(namespace))
+                        .filter(pkg => !deletingDevclasses.has(normalize(pkg.devclass)));
+                    if (remainingPackages.length === 0) {
+                        namespacesToDelete.push(namespace);
+                    }
+                    else {
+                        trm_commons_1.Logger.log(`Keeping namespace ${namespace}: still used by SAP packages ${remainingPackages.map(pkg => pkg.devclass).join(', ')}`, true);
+                    }
+                }
+                catch (e) {
+                    trm_commons_1.Logger.warning(`Keeping namespace ${namespace}: its usage could not be checked (${String(e)})`, { important: true });
+                }
+            }
+            // Installed objects moved to a package outside this installation (customer development)
+            // are kept unless confirmed; those now in another TRM package belong to it and are kept.
+            const relocatedObjects = yield readRelocatedObjects(previousTransportObjects.filter(object => !retainedKeys.has(objectKey(object))), { previousDevclasses, isOtherInstallation });
+            const movedKeys = new Set();
+            const movedObjects = [];
+            for (const object of relocatedObjects) {
+                // Shipped again by the incoming release: its import overwrites them and moves them back (confirmed at check-transports).
+                if (incomingKeys.has(objectKey(object))) {
+                    trm_commons_1.Logger.log(`Keeping ${object.pgmid} ${object.object} ${object.objName}: the incoming release overwrites it`, true);
+                    movedKeys.add(objectKey(object));
+                    continue;
+                }
+                if (isOtherInstallation(object.devclass)) {
+                    trm_commons_1.Logger.log(`Keeping ${object.pgmid} ${object.object} ${object.objName}: it's in SAP package ${object.devclass} of another TRM package`, true);
+                    movedKeys.add(objectKey(object));
+                    continue;
+                }
+                // An object now shipped by another installed TRM package belongs to it: never offer to delete it.
+                const owner = yield (0, owningInstallation_1.getOwningInstallation)(object.devclass, ((_b = context.rawInput.contextData) === null || _b === void 0 ? void 0 : _b.systemPackages) || [], installed);
+                if (owner) {
+                    trm_commons_1.Logger.info(`Keeping ${object.pgmid} ${object.object} ${object.objName}: it belongs to TRM package ${owner.packageName} (SAP package ${object.devclass}).`);
+                    movedKeys.add(objectKey(object));
+                    continue;
+                }
+                movedObjects.push(object);
+            }
+            if (movedObjects.length > 0) {
+                movedObjects.forEach(object => trm_commons_1.Logger.warning(`${object.pgmid} ${object.object} ${object.objName} was moved to SAP package ${object.devclass}, outside this installation`));
+                const { deleteMovedObjects } = context.rawInput.contextData.noInquirer
+                    ? { deleteMovedObjects: false }
+                    : yield trm_commons_1.Inquirer.prompt({
+                        name: 'deleteMovedObjects',
+                        type: 'confirm',
+                        message: `Delete ${movedObjects.length} installed objects moved outside this installation too?`,
+                        default: false
+                    });
+                if (!deleteMovedObjects) {
+                    movedObjects.forEach(object => movedKeys.add(objectKey(object)));
+                    trm_commons_1.Logger.warning(`Keeping ${movedObjects.length} objects moved outside this installation.`, { important: true });
+                }
+            }
+            const customizingSources = yield getCustomizingSources(context, target);
+            if (customizingSources.length > 0) {
+                yield confirmCustomizingDeletion(context, target, customizingSources);
+            }
+            const additionalObjects = [...extraObjectsToDelete.values(), ...packagesToDelete.map(devclass => ({
+                    pgmid: 'R3TR',
+                    object: 'DEVC',
+                    objName: devclass
+                })), ...namespacesToDelete.map(namespace => ({
+                    pgmid: 'R3TR',
+                    object: 'NSPC',
+                    objName: namespace
+                }))];
+            // Validate the complete deletion selection before adding anything to the transport.
+            // SAP packages the incoming release keeps are never deleted: a renamed installation has already
+            // generated them (generate-devclass), and the import of the others updates them in place.
+            const deletionObjects = new Map([...previousTransportObjects, ...additionalObjects]
+                .filter(object => !retainedKeys.has(objectKey(object)) && !movedKeys.has(objectKey(object)))
+                .filter(object => !(isDevclass(object) && currentDevclasses.has(normalize(object.objName))))
+                .map(object => [objectKey(object), object]));
+            // TRM comment rows of the installed transport are not objects to delete.
+            const hasObjectsToDelete = Array.from(deletionObjects.values()).some(object => normalize(object.pgmid) !== '*');
+            if (!hasObjectsToDelete && retainedTables.length === 0 && customizingSources.length === 0) {
+                trm_commons_1.Logger.warning(`Nothing to delete for package ${context.rawInput.packageData.name}: deletion transport was not generated. Manual cleanup of previous release install might be necessary.`, { important: true });
+                try {
+                    if (yield dummy.canBeDeleted()) {
+                        yield dummy.delete();
+                        context.revert.updateCleanupTransport = undefined;
+                    }
+                }
+                catch (e) {
+                    trm_commons_1.Logger.warning(`Could not delete transport ${dummy.trkorr}: ${String(e)}`, { important: true });
+                }
+                return;
+            }
+            yield context.lockScope.acquire([
+                // TRM comment rows are not objects and are shared by every package.
+                ...Array.from(deletionObjects.values()).filter(object => normalize(object.pgmid) !== '*').map(actionLocks_1.objectLockResource),
+                ...Array.from(deletionObjects.values())
+                    .filter(isDevclass)
+                    .map(object => ({ type: "DEVCLASS", name: object.objName }))
+            ]);
+            if (deletionObjects.size > 0) {
+                trm_commons_1.Logger.loading(`Checking cleanup objects locks...`, true);
+                const locks = yield systemConnector_1.SystemConnector.getObjectsLocks(Array.from(deletionObjects.values(), object => ({
+                    PGMID: object.pgmid,
+                    OBJECT: object.object,
+                    OBJ_NAME: object.objName
+                })));
+                if (locks.length > 0) {
+                    locks.forEach(lock => trm_commons_1.Logger.error(`${lock.pgmid} ${lock.object} ${lock.objName} is currently locked in transport ${lock.trkorr}`, { important: true }));
+                    throw new Error(`${target.actionName} aborted. To continue, all cleanup objects and SAP packages must be released`);
+                }
+            }
+            const temporaryPackages = Array.from(deletionObjects.values()).filter(object => isDevclass(object) && normalize(object.objName).startsWith('$'));
+            const objectsToTransport = Array.from(deletionObjects.values()).filter(object => !temporaryPackages.includes(object));
+            // Cleanup exports the previous installation's objects, regardless of the new namespace.
+            const needsStaging = normalize(installed.getDevclass() || '').startsWith('$');
+            const stagingDevclasses = [];
+            let retainedOriginalTadir = [];
+            if (needsStaging && (objectsToTransport.length > 0 || retainedTables.length > 0)) {
+                const existingObjects = yield systemConnector_1.SystemConnector.getExistingObjects([...objectsToTransport, ...retainedTables].map(object => ({
+                    pgmid: object.pgmid, object: object.object, objName: object.objName, devclass: ''
+                })));
+                // SAP only accepts objects of a custom namespace in packages of that namespace:
+                // stage them by namespace.
+                const stagingGroups = new Map();
+                for (const object of existingObjects) {
+                    const namespace = getCustomNamespace(object.objName) || '';
+                    stagingGroups.set(namespace, [...(stagingGroups.get(namespace) || []), object]);
+                }
+                context.revert.cleanupOriginalTadir = [];
+                for (const [namespace, objects] of stagingGroups) {
+                    if (namespace) {
+                        yield importStagingNamespace(context, namespace);
+                    }
+                    const stagingDevclass = yield createStagingPackage(context, namespace);
+                    stagingDevclasses.push(stagingDevclass);
+                    for (const object of objects) {
+                        context.revert.cleanupOriginalTadir.push(Object.assign({}, object));
+                        if (retainedKeys.has(objectKey(object))) {
+                            retainedOriginalTadir.push(Object.assign({}, object));
+                        }
+                        yield systemConnector_1.SystemConnector.tadirInterface(Object.assign(Object.assign({}, object), { devclass: stagingDevclass, srcsystem: 'TRM' }));
+                    }
+                }
+            }
+            if (retainedTables.length > 0) {
+                yield backupRetainedTables(context, retainedTables);
+                // Retained tables stay installed: move them out of the staging package before it is deleted.
+                yield restoreTadirAssignments(retainedOriginalTadir);
+            }
+            if (objectsToTransport.length > 0) {
+                yield dummy.addObjects(objectsToTransport, false);
+            }
+            if (stagingDevclasses.length > 0) {
+                yield dummy.addObjects(stagingDevclasses.map(devclass => ({ pgmid: 'R3TR', object: 'DEVC', objName: devclass })), false);
+            }
+            // Namespaces imported for the staging go with their staging packages.
+            const temporaryNamespaces = (context.revert.temporaryNamespaces || [])
+                .filter(namespace => !namespacesToDelete.some(o => normalize(o) === normalize(namespace)));
+            if (temporaryNamespaces.length > 0) {
+                yield dummy.addObjects(temporaryNamespaces.map(namespace => ({ pgmid: 'R3TR', object: 'NSPC', objName: namespace })), false);
+            }
+            // The copy keeps the E071K keys and OBJFUNC K: the release exports the current rows
+            // (restored by a rollback) and the registry turns them into deletions by key.
+            context.revert.cleanupCustomizingSources = [];
+            for (const trkorr of customizingSources) {
+                trm_commons_1.Logger.loading(`Including customizing from transport ${trkorr}...`, true);
+                yield dummy.addObjectsFromTransport(trkorr);
+                context.revert.cleanupCustomizingSources.push(trkorr);
+            }
+            const packageDepth = (devclass) => {
+                const visited = new Set();
+                let parent = packageParents.get(normalize(devclass));
+                while (parent && !visited.has(parent)) {
+                    visited.add(parent);
+                    parent = packageParents.get(parent);
+                }
+                return visited.size;
+            };
+            // Delete descendants before their parents, regardless of transport entry order.
+            temporaryPackages.sort((a, b) => packageDepth(b.objName) - packageDepth(a.objName));
+            context.revert.cleanupTemporaryPackages = [];
+            // Snapshot every definition before deleting any package, including for partial failures.
+            for (const devclass of temporaryPackages) {
+                const pkg = yield systemConnector_1.SystemConnector.getDevclass(devclass.objName);
+                if (!pkg) {
+                    throw new Error(`Cannot back up temporary SAP package ${devclass.objName}`);
+                }
+                context.revert.cleanupTemporaryPackages.push(Object.assign({}, pkg));
+            }
+            try {
+                yield deleteTemporaryCleanupPackages(temporaryPackages);
+            }
+            catch (e) {
+                // Their objects are already in the deletion transport: an empty local package is a harmless leftover.
+                trm_commons_1.Logger.warning(`Could not delete local SAP package(s) ${temporaryPackages.map(o => o.objName).join(', ')} (${e instanceof Error ? e.message : String(e)}): delete them manually.`, { important: true });
+            }
+            //guard: clean and rebuild comments
+            yield dummy.removeComments();
+            yield dummy.addComment(`name=${installed.manifest.get().name}`);
+            yield dummy.addComment(`version=${installed.manifest.get().version}`);
+            try {
+                yield (0, releaseDeletionTransport_1.releaseDeletionTransport)(dummy, context.rawInput.packageData.registry, context);
+            }
+            catch (e) {
+                if (!(e instanceof registry_1.RegistryDeletionTransportUnavailableError)) {
+                    throw e;
+                }
+                //at this point the dummy is already released, transport cannot be deleted but it's a harmless release of a transport of copies.
+                yield restoreCleanupAssignments(context, true);
+                if (target.requireDeletion) {
+                    trm_commons_1.Logger.error(e.message, { important: true });
+                    throw e;
+                }
+                trm_commons_1.Logger.warning(`${e.message} Manual cleanup of previous release install might be necessary.`, { important: true });
+                // Deleting the staging packages needs a deletion transport too.
+                if (stagingDevclasses.length > 0) {
+                    trm_commons_1.Logger.warning(`SAP package(s) ${stagingDevclasses.join(', ')}, created for the cleanup, were left on ${systemConnector_1.SystemConnector.getDest()}: delete them manually.`, { important: true });
+                }
+                if (((_c = context.revert.temporaryNamespaces) === null || _c === void 0 ? void 0 : _c.length) > 0) {
+                    trm_commons_1.Logger.warning(`Namespace(s) ${context.revert.temporaryNamespaces.join(', ')}, imported for the cleanup, were left on ${systemConnector_1.SystemConnector.getDest()}: delete them manually.`, { important: true });
+                }
+            }
+        }));
+    });
+}
+/**
+ * Whether the deletion transport generated by {@link cleanupInstalledPackage} must be carried
+ * through the landscape. Objects of a temporary (`$`) installation only exist on this system.
+ */
+function isDeletionForwardable(context) {
+    var _a;
+    return !!context.revert.dele && !normalize(((_a = context.runtime.update) === null || _a === void 0 ? void 0 : _a.getDevclass()) || '').startsWith('$');
+}
+/**
+ * Adds the deletion transport to the import queue of the landscape target system, so the
+ * removed objects are also deleted there.
+ * For a clean landscape, it has to be imported before any transport of a later release.
+ */
+function forwardDeletionTransport(context, targetSystem) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // The queue may be changed even when the connector response fails.
+        context.revert.deleInTargetTms = true;
+        yield systemConnector_1.SystemConnector.forwardTransport(context.revert.dele.trkorr, targetSystem, systemConnector_1.SystemConnector.getDest(), true);
+    });
+}
+/**
+ * Removes a transport from the import queue of `targetSystem`. Only the queue of the connected
+ * system can be changed: another system's queue would need its credentials, so the operator is
+ * warned to remove it manually. Returns whether the transport was removed.
+ */
+function removeFromImportQueue(trkorr, targetSystem, description) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (normalize(targetSystem) === normalize(systemConnector_1.SystemConnector.getDest())) {
+            yield systemConnector_1.SystemConnector.deleteTmsTransport(trkorr, targetSystem);
+            return true;
+        }
+        trm_commons_1.Logger.warning(`${description} ${trkorr} may be in the ${targetSystem} import queue: remove it manually in STMS (it can't be removed from ${systemConnector_1.SystemConnector.getDest()}).`, { important: true });
+        return false;
+    });
+}
+/** Removes the deletion transport from the target system import queue, when it was forwarded. */
+function revertForwardedDeletionTransport(context, targetSystem) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (context.revert.deleInTargetTms) {
+            yield removeFromImportQueue(context.revert.dele.trkorr, targetSystem, `Deletion transport`);
+        }
+    });
+}
+/**
+ * Rolls back {@link cleanupInstalledPackage}: recreates deleted temporary packages, deletes the
+ * deletion transport or, once its import started, re-imports the copy of the deleted objects,
+ * restores retained tables, and restores object assignments.
+ * With `restore` set to `false` (a later destructive cleanup failed), previous state is not
+ * restored over objects that were not deleted: only the unreleased transports are deleted.
+ * Every independent operation is attempted; the first failure is thrown afterwards.
+ */
+function revertInstalledPackageCleanup(context_1) {
+    return __awaiter(this, arguments, void 0, function* (context, restore = true) {
+        let firstError;
+        if (restore) {
+            try {
+                yield restoreCleanupPackages(context);
+            }
+            catch (error) {
+                firstError = error;
+            }
+        }
+        try {
+            if (context.revert.dele) {
+                //check if it can be deleted -> the exception might have been raised before the transport release, we can still cleanup nicely
+                const transport = new transport_1.Transport(context.revert.dele.trkorr);
+                if (yield (transport.canBeDeleted())) {
+                    yield transport.delete();
+                }
+                else if (context.revert.deleImportStarted) {
+                    if (restore) {
+                        yield (0, restoreTransport_1.restoreTransport)(context.revert.dele);
+                    }
+                    else {
+                        trm_commons_1.Logger.warning(`Objects deleted by ${context.revert.dele.trkorr} were not restored, as the cleanup of the imported objects failed: manual restore might be necessary.`, { important: true });
+                    }
+                }
+                else {
+                    // Released but never imported: the objects were not deleted, re-importing the copy would overwrite them.
+                    trm_commons_1.Logger.log(`Deletion transport ${context.revert.dele.trkorr} was not imported, objects restore skipped`, true);
+                }
+            }
+            else if (context.revert.updateCleanupTransport
+                && (yield context.revert.updateCleanupTransport.canBeDeleted())) {
+                yield context.revert.updateCleanupTransport.delete();
+            }
+        }
+        catch (error) {
+            firstError || (firstError = error);
+        }
+        try {
+            if (context.revert.retainedTables) {
+                if (restore) {
+                    // Old table definitions are imported over the new ones: data is kept.
+                    yield (0, restoreTransport_1.restoreTransport)(context.revert.retainedTables);
+                }
+                else {
+                    trm_commons_1.Logger.warning(`Retained tables backup ${context.revert.retainedTables.trkorr} was not restored, as the cleanup of the imported objects failed: manual restore might be necessary.`, { important: true });
+                }
+            }
+            else if (context.revert.updateTablesBackupTransport
+                && (yield context.revert.updateTablesBackupTransport.canBeDeleted())) {
+                yield context.revert.updateTablesBackupTransport.delete();
+            }
+        }
+        catch (error) {
+            firstError || (firstError = error);
+        }
+        if (restore) {
+            try {
+                yield restoreCleanupAssignments(context, false);
+            }
+            catch (error) {
+                firstError || (firstError = error);
+            }
+        }
+        if (firstError) {
+            throw firstError;
+        }
+    });
+}