trm-core 9.10.6 → 10.0.1

package/dist/actions/install/index.d.ts

@@ -1,113 +1,342 @@
-import { R3trans, R3transOptions } from "node-r3trans";
+import { Package } from "trm-registry-types";
+import { Lockfile } from "../../lockfile";
+import { AbstractRegistry } from "../../registry";
 import { Transport } from "../../transport";
-import { TransportBinary, TrmArtifact, TrmPackage, TrmPackageInstallTransport } from "../../trmPackage";
+import { TransportBinary, TrmPackage } from "../../trmPackage";
 import { TrmManifest, TrmManifestDependency } from "../../manifest";
-import { IActionContext } from "..";
-import { DEVCLASS, E071, NAMESPACE, TADIR, TDEVC, TDEVCT } from "../../client";
 import { PackageHierarchy } from "../../commons";
-import { AbstractRegistry } from "../../registry";
-import { Package } from "trm-registry-types";
-import { Lockfile } from "../../lockfile/Lockfile";
+import { IActionContext } from "../commons";
+import { DEVCLASS, E071, TADIR, TDEVC, TDEVCT, ZTRM_INSTALLDEVC } from "../../client";
+import { InstallTransport, TrmPackageUpdateData } from "../../systemConnector";
+import { ActionLockScope } from "../commons/utils";
+/** Maps a publisher ABAP package to the package that should receive its objects during installation. */
 export type InstallPackageReplacements = {
+    /**
+     * Original ABAP package name stored in the published artifact.
+     */
     originalDevclass: string;
+    /**
+     * Target ABAP package name to use on the receiving system.
+     */
     installDevclass: string;
 };
+/** Shared execution settings for package and dependency installation actions. */
 export type InstallActionInputContextData = {
+    /**
+     * Snapshot of packages installed on the target system. When omitted, the action queries SAP.
+     */
     systemPackages?: TrmPackage[];
-    r3transOptions?: R3transOptions;
-    noR3transInfo?: boolean;
+    /**
+     * Disable interactive prompts. Any required choice without an explicit value then causes an error.
+     */
     noInquirer?: boolean;
-    noStopWarning?: boolean;
+    /**
+     * Directory in which transport-release logs and temporary files are written.
+     */
+    logTemporaryFolder?: string;
+    /**
+     * Version of trm-core in use, checked against the `trm-core` engine of the package.
+     * Supply it when the client resolves trm-core itself; defaults to the version read from trm-core package.json.
+     */
+    coreVersion?: string;
 };
+/** Options controlling package validation, transport import, and target package mapping. */
 export type InstallActionInputInstallData = {
+    /**
+     * Set by an install for the dependency installs it runs: the dependencies the user already
+     * confirmed. A dependency install doesn't ask again for these.
+     */
+    approvedDependencies?: string[];
+    /**
+     * Import-related data.
+     */
     import?: {
+        /**
+         * Skip the optional language transport. When unset, the user is asked (default: import);
+         * without prompts (`noInquirer`) the transport is imported.
+         */
         noLang?: boolean;
+        /**
+         * Skip all customizing transports. When unset, the user is asked for each transport
+         * (default: import); without prompts (`noInquirer`) all of them are imported.
+         * On update, the customizing of the installed release is then kept.
+         */
         noCust?: boolean;
-        replaceExistingTransports?: boolean;
     };
+    /**
+     * Optional checks to perform during installation.
+     */
     checks?: {
+        /**
+         * Lockfile used to pin the release and dependency versions and verify their integrity.
+         * The package must be the lockfile root: when `packageData.version` is omitted the root
+         * version is installed, and an explicit version, distribution tag, local artifact, registry,
+         * or integrity that doesn't match the root aborts the install before any change.
+         */
         lockfile?: Lockfile;
+        /**
+         * Skip validation of required SAP table entries. Defaults to `false`.
+         */
         noSapEntries?: boolean;
-        noObjectTypes?: boolean;
+        /**
+         * Skip validation of the manifest engines (SAP components, products, notes, tables). Defaults to `false`.
+         */
+        noEngines?: boolean;
+        /**
+         * Skip package dependency validation and installation. Defaults to `false`.
+         */
         noDependencies?: boolean;
+        /**
+         * Allow a dependency install to replace a newer installed release without confirmation.
+         * Defaults to `false`: the user is prompted, and without a prompt the install is aborted.
+         */
+        allowDowngrade?: boolean;
+        /**
+         * Skip the safety check for repository objects that would be overwritten. Defaults to `false`.
+         */
         noExistingObjects?: boolean;
     };
+    /**
+     * Options related to the devclass installation.
+     */
     installDevclass?: {
+        /**
+         * Preserve publisher package names instead of mapping objects into an install package.
+         */
         keepOriginal?: boolean;
+        /**
+         * Transport layer assigned to generated transportable target packages. When omitted, the system default
+         * is resolved only if such packages have to be created.
+         */
         transportLayer?: string;
+        /**
+         * Explicit publisher-to-target package mappings. Ignored when `keepOriginal` is `true`.
+         */
         replacements?: InstallPackageReplacements[];
+        /**
+         * Do not register the package namespace on the target system. When unset and the namespace
+         * is missing, the user is asked (default: import); without prompts (`noInquirer`) it is imported.
+         */
         skipNamespace?: boolean;
     };
-    installTransport?: {
-        create?: boolean;
+    /**
+     * Landscape transport-related options.
+     */
+    landscapeTransport?: {
+        /**
+         * TMS target for the generated landscape transport. It is selected interactively when omitted.
+         * When omitted and the system has no transport targets, it is treated as the final system
+         * of the landscape and no landscape transport is generated.
+         */
         targetSystem?: string;
     };
+    /**
+     * Skip every post-install activity declared in the manifest. Defaults to `false`.
+     */
     skipPostActivities?: boolean;
 };
+/** Input required to install a TRM package release into the connected SAP system. */
 export interface InstallActionInput {
+    /** Optional shared execution settings. */
     contextData?: InstallActionInputContextData;
+    /**
+     * Data related to the package being installed.
+     */
     packageData: {
+        /**
+         * Registry package name. For local registries, the manifest name becomes authoritative.
+         */
         name: string;
+        /**
+         * Release version or registry selector. Defaults to the lockfile root version when
+         * `installData.checks.lockfile` is set, otherwise to `latest`.
+         */
         version?: string;
+        /**
+         * Registry from which metadata and the release artifact are fetched.
+         */
         registry: AbstractRegistry;
+        /**
+         * Allow reinstalling the same version. Defaults to `false`; dirty local changes still
+         * require interactive confirmation and therefore abort when prompts are disabled.
+         */
         overwrite?: boolean;
+        /**
+         * Expected release integrity (SHA-512, base64), for example from a lockfile. When set, the
+         * install aborts before any change unless the release fetched from the registry matches it.
+         */
+        integrity?: string;
     };
+    /** Optional validation, import, package-mapping, and post-activity settings. */
     installData?: InstallActionInputInstallData;
+    /**
+     * Set by a dependency install: the release is selected by the dependency range and the
+     * lockfile dependency entries, so the lockfile root (`name`, `version`, `registry`, `integrity`)
+     * is not applied to it.
+     */
+    dependency?: boolean;
 }
 type TransportRuntime = {
     binaries?: TransportBinary;
     instance?: Transport;
 };
 type WorkflowRuntime = {
-    stopWarningShown: boolean;
-    registry: AbstractRegistry;
-    update: boolean;
     isTrmServer: boolean;
     isTrmRest: boolean;
-    remotePackageData: {
+    isLocal: boolean;
+    update: TrmPackage;
+    package: {
         data: Package;
-        manifest: TrmManifest;
-        artifact: TrmArtifact;
-        contents: boolean;
+        hierarchy: PackageHierarchy;
     };
-    packageTransports: {
+    transports: {
         devc: TransportRuntime;
         tadir: TransportRuntime;
-        lang: TransportRuntime;
-        cust: TransportRuntime[];
+        lang?: TransportRuntime;
+        cust?: TransportRuntime[];
     };
-    packageTransportsData: {
-        tdevc: TDEVC[];
+    dele?: Transport;
+    transportEntries: {
         tdevct: TDEVCT[];
-        tadir: TADIR[];
-        e071: E071[];
     };
-    dependenciesToInstall: TrmManifestDependency[];
-    r3trans: R3trans;
-    originalData: {
-        hierarchy: PackageHierarchy;
-    };
-    installData: {
-        namespace: string;
-        entries: E071[];
-        transports: TrmPackageInstallTransport[];
-        upgradingPackage?: TrmPackage;
+    dependencies: InstallDependencyEntry[];
+    namespace: string;
+    /** Registry the package is recorded under: the real registry of a local (.trm) artifact. */
+    installRegistry: AbstractRegistry;
+    previousInstallPackages: InstallPackageReplacements[];
+    /** Transports recorded for the installed release being updated. */
+    previousInstallTransports: InstallTransport[];
+    dependencyRollbacks: Array<() => Promise<void>>;
+    dependencyReleases: Array<() => Promise<void>>;
+    /** Packages installed by the dependency installs, transitive ones included, merged into the package snapshot. */
+    installedDependencies: TrmPackage[];
+    /** Package snapshot before the dependency installs, restored after they are rolled back. */
+    systemPackagesBeforeDependencies?: TrmPackage[];
+    rootDevclassBeforeImport?: TDEVC;
+    stopWarningShown: boolean;
+    /** Customizing transports of the release the user chose not to import (or skipped by noCust / non-interactive mode). */
+    skippedCust?: string[];
+    /** Release objects found on the system by check-transports, accepted before locking. */
+    existingObjects?: TADIR[];
+    /** Custom namespaces locked by this install or by the install it is a dependency of. */
+    lockedNamespaces?: string[];
+    /** Required SAP entries missing on the system: the install is aborted by check-engines, with the unmet engines. */
+    missingSapEntries?: number;
+};
+/** Dependency queued for install: missing from the system, or installed in an incompatible version. */
+export type InstallDependencyEntry = {
+    dependency: TrmManifestDependency;
+    status: 'notFound' | 'versionMismatch';
+    /** Version on the system; set for `versionMismatch`. */
+    installedVersion?: string;
+};
+type WorkflowRevert = {
+    transports: {
+        devc: TransportBinary;
+        tadir: TransportBinary;
+        lang?: TransportBinary;
+        cust?: TransportBinary[];
     };
-    generatedData: {
-        devclass: DEVCLASS[];
-        namespace: NAMESPACE;
-        tmsTxtRefresh: Transport[];
+    cleanupTransport?: Transport;
+    cleanupImported?: boolean;
+    cleanupSucceeded?: boolean;
+    importStarted?: boolean;
+    importedEntries?: E071[];
+    /** Imported customizing transports, copied into the rollback cleanup transport with their keys. */
+    importedCustomizing?: Transport[];
+    /**
+     * Imported objects, SAP packages included, that were already on the system before the import,
+     * with their previous TADIR row. The rollback cleanup never deletes them.
+     */
+    existingObjectsTadir?: TADIR[];
+    /** Transport of copies backing up {@link WorkflowRevert.existingObjectsTadir}, tracked before it is released. */
+    existingObjectsBackupTransport?: Transport;
+    /** Previous version of the existing objects, re-imported once the rollback cleanup succeeded. */
+    existingObjectsBackup?: TransportBinary;
+    packageHierarchy?: TDEVC[];
+    packageTransportLayers?: Array<{
+        devclass: DEVCLASS;
+        transportLayer: string;
+    }>;
+    createdTransports?: {
+        devc?: Transport;
+        tadir?: Transport;
+        lang?: Transport;
+        cust: Transport[];
     };
+    sapPackages: DEVCLASS[];
+    stagingPackages?: DEVCLASS[];
+    dele?: TransportBinary;
+    deleImportStarted?: boolean;
+    deleInTargetTms?: boolean;
+    /** Set before the landscape transport is released, as SAP may export it and still fail. */
+    landscapeReleaseStarted?: boolean;
+    cleanupOriginalTadir?: TADIR[];
+    cleanupTemporaryPackages?: TDEVC[];
+    updateCleanupTransport?: Transport;
+    updateTablesBackupTransport?: Transport;
+    retainedTables?: TransportBinary;
+    retainedTableObjects?: Pick<E071, 'pgmid' | 'object' | 'objName'>[];
+    metadataWriteStarted?: boolean;
+    /** Set before the install transports are written, as SAP may commit them and still fail. */
+    metadataTransportsWriteStarted?: boolean;
+    metadataPackageRegistry?: string;
+    /** Install package mappings written by this install. */
+    metadataInstallDevc?: ZTRM_INSTALLDEVC[];
+    metadataPackageRow?: TrmPackageUpdateData;
+    /** TRM packages table row stored before an upgrade wrote its own; undefined when none was stored. */
+    metadataPreviousPackageRow?: TrmPackageUpdateData;
+    /** Set once the stored row was read: only then can an upgrade revert restore the metadata. */
+    metadataPreviousPackageRead?: boolean;
+    namespace?: string;
 };
+/** Result of a successful {@link install} action. */
 export type InstallActionOutput = {
+    /** Normalized manifest of the installed release. */
     manifest: TrmManifest;
-    registry: AbstractRegistry;
-    installTransports?: TrmPackageInstallTransport[];
+    /** Generated landscape transport, when the installation produced one. */
+    transport?: Transport;
 };
+/** Internal state shared by package-install workflow steps and rollback handlers. */
 export interface InstallWorkflowContext extends IActionContext {
+    lockScope?: ActionLockScope;
+    /** Custom namespaces already locked by the parent installs of a dependency install. */
+    inheritedNamespaceLocks?: string[];
+    /** Original action input; optional groups are normalized during initialization. */
     rawInput: InstallActionInput;
+    /** Resolved release, package hierarchy, transports, dependencies, and system metadata. */
     runtime?: WorkflowRuntime;
+    /** Data retained so completed steps can be rolled back after a later failure. */
+    revert?: WorkflowRevert;
+    /** Installation result assembled by the workflow. */
     output?: InstallActionOutput;
 }
+/**
+ * Installs a TRM package release into the currently connected SAP system.
+ *
+ * The workflow authorizes the user, fetches and validates the release, checks dependencies
+ * (aborting on cyclic dependency graphs before anything is installed) and required SAP entries, maps ABAP packages, imports the artifact transports, executes
+ * post-install activities, and records the installed package. Completed reversible steps are
+ * rolled back when a later step fails.
+ *
+ * This operation changes the target SAP system. Do not interrupt it while transports are being
+ * generated, imported, or released.
+ *
+ * @param inputData Package identity, registry, and installation options.
+ * @returns The installed release manifest and, when generated, its landscape transport.
+ * @throws When authorization, release validation, safety checks, dependency installation,
+ * transport processing, or post-install work fails.
+ */
 export declare function install(inputData: InstallActionInput): Promise<InstallActionOutput>;
+/**
+ * Internal transactional entry point used when a parent install must retain rollback ownership.
+ * `inheritedNamespaceLocks` are the namespaces the parent installs hold locked until they finish.
+ */
+export declare function installWithRollback(inputData: InstallActionInput, inheritedNamespaceLocks?: string[]): Promise<{
+    output: InstallActionOutput;
+    /** Packages installed by the install's own dependency installs, transitive ones included. */
+    installedPackages: TrmPackage[];
+    rollback: () => Promise<void>;
+    release: () => Promise<void>;
+}>;
 export {};

package/dist/actions/install/index.js

@@ -8,81 +8,161 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.install = install;
-const sammarksworkflow_1 = __importDefault(require("@simonegaffurini/sammarksworkflow"));
-const util_1 = require("util");
-const trm_commons_1 = require("trm-commons");
+exports.installWithRollback = installWithRollback;
+const commons_1 = require("../commons");
 const init_1 = require("./init");
-const __1 = require("..");
-const setSystemPackages_1 = require("../commons/setSystemPackages");
-const checkAlreadyInstalled_1 = require("./checkAlreadyInstalled");
+const checkTransports_1 = require("./checkTransports");
 const checkSapEntries_1 = require("./checkSapEntries");
+const checkEngines_1 = require("./checkEngines");
 const checkDependencies_1 = require("./checkDependencies");
+const checkDependencyCycles_1 = require("./checkDependencyCycles");
 const installDependencies_1 = require("./installDependencies");
-const checkTransports_1 = require("./checkTransports");
-const readDevc_1 = require("./readDevc");
 const setInstallDevclass_1 = require("./setInstallDevclass");
-const checkObjectTypes_1 = require("./checkObjectTypes");
-const generateDevclass_1 = require("./generateDevclass");
-const readTadir_1 = require("./readTadir");
-const importDevcTransport_1 = require("./importDevcTransport");
+const checkInstallDevclass_1 = require("./checkInstallDevclass");
 const addNamespace_1 = require("./addNamespace");
-const importTadirTransport_1 = require("./importTadirTransport");
-const importLangTransport_1 = require("./importLangTransport");
-const importCustTransport_1 = require("./importCustTransport");
+const generateDevclass_1 = require("./generateDevclass");
+const prepareDevc_1 = require("./prepareDevc");
+const prepareTadir_1 = require("./prepareTadir");
+const prepareLang_1 = require("./prepareLang");
+const prepareCust_1 = require("./prepareCust");
+const importBatch_1 = require("./importBatch");
+const generateLandscapeTransport_1 = require("./generateLandscapeTransport");
 const updatePackageData_1 = require("./updatePackageData");
-const generateInstallTransports_1 = require("./generateInstallTransports");
-const refreshTmsTxt_1 = require("./refreshTmsTxt");
 const executePostActivities_1 = require("./executePostActivities");
-const checkObjectsLock_1 = require("./checkObjectsLock");
-const releaseInstallTransport_1 = require("./releaseInstallTransport");
+const releaseLandscapeTransport_1 = require("./releaseLandscapeTransport");
+const generateUpdateTransport_1 = require("./generateUpdateTransport");
+const checkDependants_1 = require("./checkDependants");
+const utils_1 = require("../commons/utils");
+const utils_2 = require("../commons/utils");
+const lockResources_1 = require("./lockResources");
+const cleanupCheckpoint_1 = require("./cleanupCheckpoint");
 ;
 const WORKFLOW_NAME = 'install';
+/**
+ * Installs a TRM package release into the currently connected SAP system.
+ *
+ * The workflow authorizes the user, fetches and validates the release, checks dependencies
+ * (aborting on cyclic dependency graphs before anything is installed) and required SAP entries, maps ABAP packages, imports the artifact transports, executes
+ * post-install activities, and records the installed package. Completed reversible steps are
+ * rolled back when a later step fails.
+ *
+ * This operation changes the target SAP system. Do not interrupt it while transports are being
+ * generated, imported, or released.
+ *
+ * @param inputData Package identity, registry, and installation options.
+ * @returns The installed release manifest and, when generated, its landscape transport.
+ * @throws When authorization, release validation, safety checks, dependency installation,
+ * transport processing, or post-install work fails.
+ */
 function install(inputData) {
     return __awaiter(this, void 0, void 0, function* () {
-        const workflow = [
-            __1.checkServerAuth,
-            init_1.init,
-            setSystemPackages_1.setSystemPackages,
-            __1.trmServerPa,
-            checkAlreadyInstalled_1.checkAlreadyInstalled,
-            checkSapEntries_1.checkSapEntries,
-            checkDependencies_1.checkDependencies,
-            installDependencies_1.installDependencies,
-            checkTransports_1.checkTransports,
-            checkObjectTypes_1.checkObjectTypes,
-            checkObjectsLock_1.checkObjectsLock,
-            readDevc_1.readDevc,
-            readTadir_1.readTadir,
-            setInstallDevclass_1.setInstallDevclass,
-            addNamespace_1.addNamespace,
-            generateDevclass_1.generateDevclass,
-            importDevcTransport_1.importDevcTransport,
-            importTadirTransport_1.importTadirTransport,
-            importLangTransport_1.importLangTransport,
-            importCustTransport_1.importCustTransport,
-            refreshTmsTxt_1.refreshTmsTxt,
-            generateInstallTransports_1.generateInstallTransports,
-            updatePackageData_1.updatePackageData,
-            executePostActivities_1.executePostActivities,
-            releaseInstallTransport_1.releaseInstallTransports
-        ];
-        trm_commons_1.Logger.log(`Ready to execute workflow ${WORKFLOW_NAME}, input data: ${(0, util_1.inspect)(inputData, { breakLength: Infinity, compact: true })}`, true);
-        const result = yield (0, sammarksworkflow_1.default)(WORKFLOW_NAME, workflow, {
-            rawInput: inputData
+        return (yield runInstall(inputData, false)).output;
+    });
+}
+const installWorkflow = [
+    commons_1.checkServerAuth,
+    commons_1.setSystemPackages,
+    init_1.init,
+    checkDependants_1.checkDependants,
+    checkTransports_1.checkTransports,
+    checkSapEntries_1.checkSapEntries,
+    checkEngines_1.checkEngines,
+    checkDependencies_1.checkDependencies,
+    checkDependencyCycles_1.checkDependencyCycles,
+    setInstallDevclass_1.setInstallDevclass,
+    checkInstallDevclass_1.checkInstallDevclass,
+    lockResources_1.lockResources,
+    installDependencies_1.installDependencies,
+    cleanupCheckpoint_1.cleanupCheckpoint,
+    addNamespace_1.addNamespace,
+    generateDevclass_1.generateDevclass,
+    generateUpdateTransport_1.generateUpdateTransport,
+    prepareDevc_1.prepareDevc,
+    prepareTadir_1.prepareTadir,
+    prepareLang_1.prepareLang,
+    prepareCust_1.prepareCust,
+    importBatch_1.importBatch,
+    generateLandscapeTransport_1.generateLandscapeTransport,
+    executePostActivities_1.executePostActivities,
+    releaseLandscapeTransport_1.releaseLandscapeTransport,
+    updatePackageData_1.updatePackageData
+];
+function runInstall(inputData_1, retainRollback_1) {
+    return __awaiter(this, arguments, void 0, function* (inputData, retainRollback, inheritedNamespaceLocks = []) {
+        var _a;
+        const lockScope = new utils_2.ActionLockScope(WORKFLOW_NAME);
+        const context = { rawInput: inputData, lockScope, inheritedNamespaceLocks };
+        //a local artifact is locked under the package it installs, as a remote install of it would be
+        const lockPackage = yield (0, utils_2.resolveInstallPackage)(inputData.packageData.registry, inputData.packageData.name);
+        yield lockScope.acquire([(0, utils_2.packageLockResource)(lockPackage.registry, lockPackage.name)]);
+        const release = () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let firstError;
+            for (const releaseDependency of [...(((_a = context.runtime) === null || _a === void 0 ? void 0 : _a.dependencyReleases) || [])].reverse()) {
+                try {
+                    yield releaseDependency();
+                }
+                catch (error) {
+                    firstError || (firstError = error);
+                }
+            }
+            try {
+                yield lockScope.release();
+            }
+            catch (error) {
+                firstError || (firstError = error);
+            }
+            if (firstError)
+                throw firstError;
         });
-        trm_commons_1.Logger.log(`Workflow ${WORKFLOW_NAME} result: ${(0, util_1.inspect)(result, { breakLength: Infinity, compact: true })}`, true);
-        const manifest = result.runtime.remotePackageData.manifest;
-        const registry = result.runtime.registry;
-        const installTransports = result.runtime.installData.transports;
+        if (!retainRollback) {
+            return (0, utils_2.withLockRelease)(release, () => __awaiter(this, void 0, void 0, function* () {
+                const result = yield (0, commons_1.executeWorkflow)(WORKFLOW_NAME, installWorkflow, context, commons_1.workflowCallbacks);
+                return { output: result.output };
+            }));
+        }
+        let retained;
+        try {
+            retained = yield (0, utils_1.executeRetainedWorkflow)(WORKFLOW_NAME, installWorkflow, context, commons_1.workflowCallbacks);
+        }
+        catch (error) {
+            yield (0, utils_2.releaseLogged)(release);
+            throw error;
+        }
+        // The locks stay held until the parent calls release (or rollback).
         return {
-            manifest,
-            registry,
-            installTransports
+            output: retained.context.output,
+            installedPackages: ((_a = retained.context.runtime) === null || _a === void 0 ? void 0 : _a.installedDependencies) || [],
+            release,
+            rollback: () => __awaiter(this, void 0, void 0, function* () {
+                let firstError;
+                try {
+                    yield retained.rollback();
+                }
+                catch (error) {
+                    firstError = error;
+                }
+                try {
+                    yield release();
+                }
+                catch (error) {
+                    firstError || (firstError = error);
+                }
+                if (firstError)
+                    throw firstError;
+            })
         };
     });
 }
+/**
+ * Internal transactional entry point used when a parent install must retain rollback ownership.
+ * `inheritedNamespaceLocks` are the namespaces the parent installs hold locked until they finish.
+ */
+function installWithRollback(inputData_1) {
+    return __awaiter(this, arguments, void 0, function* (inputData, inheritedNamespaceLocks = []) {
+        const retained = yield runInstall(inputData, true, inheritedNamespaceLocks);
+        return { output: retained.output, installedPackages: retained.installedPackages, rollback: retained.rollback, release: retained.release };
+    });
+}

package/dist/actions/install/init.d.ts

@@ -1,3 +1,17 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { InstallWorkflowContext } from ".";
+/**
+ * Workflow step that fetches the release, validates install settings, and initializes rollback state.
+ *
+ * 1- fill context data
+ *
+ * 2- fill missing input data
+ *
+ * 3- check install transport layer
+ *
+ * 4- check/set system target
+ *
+ * 5- check if already installed
+ *
+*/
 export declare const init: Step<InstallWorkflowContext>;