@mcp-abap-adt/adt-backup 0.1.2 → 1.1.0

package/dist/lib/restore/analyzeDependencies.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeDependencies = analyzeDependencies;
+const decodeBase64_1 = require("../crypto/decodeBase64");
+function nodeKey(node) {
+    return `${node.type}:${node.name}`.toUpperCase();
+}
+/**
+ * Robustly analyzes dependencies between objects by scanning both
+ * source code and XML metadata.
+ * Uses composite type:name keys to handle objects that share the same name
+ * (e.g. view and behaviorDefinition for the same CDS entity).
+ */
+function analyzeDependencies(nodes) {
+    const idToNode = new Map();
+    const nameToIds = new Map();
+    const allNames = new Set();
+    for (const node of nodes) {
+        const id = nodeKey(node);
+        const upperName = node.name.toUpperCase();
+        idToNode.set(id, node);
+        allNames.add(upperName);
+        const ids = nameToIds.get(upperName) || [];
+        ids.push(id);
+        nameToIds.set(upperName, ids);
+    }
+    const allIds = new Set(idToNode.keys());
+    const adj = new Map();
+    for (const node of nodes) {
+        const deps = new Set();
+        const id = nodeKey(node);
+        const nodeNameUpper = node.name.toUpperCase();
+        if (node.codeBase64) {
+            const decoded = (0, decodeBase64_1.decodeBase64)(node.codeBase64);
+            const contentUpper = decoded.toUpperCase();
+            // 1. Scan for all backup object names in the content
+            for (const targetName of allNames) {
+                if (targetName === nodeNameUpper)
+                    continue;
+                // Escape name for regex, specifically handling namespaces with /
+                const escapedTarget = targetName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                // Match only if surrounded by boundaries that are NOT part of an ABAP name
+                // (i.e. not letters, digits, _, or /)
+                const regex = new RegExp(`(?<=[^A-Z0-9_/]|^)${escapedTarget}(?=[^A-Z0-9_/]|$)`, 'g');
+                if (regex.test(contentUpper)) {
+                    // Resolve name to all node IDs with that name
+                    const targetIds = nameToIds.get(targetName) || [];
+                    for (const tid of targetIds) {
+                        if (tid !== id)
+                            deps.add(tid);
+                    }
+                }
+            }
+            // 2. Explicit structural dependencies (from config or XML properties)
+            // Behavior Definition <-> Implementation Class (bidirectional = same SCC group)
+            // From class source: "FOR BEHAVIOR OF <bdef_name>"
+            if (node.type === 'class' || node.type === 'behaviorImplementation') {
+                const bdefMatch = contentUpper.match(/FOR\s+BEHAVIOR\s+OF\s+([A-Z0-9_/]+)/);
+                if (bdefMatch) {
+                    const bdefId = `BEHAVIORDEFINITION:${bdefMatch[1]}`;
+                    if (allIds.has(bdefId) && bdefId !== id)
+                        deps.add(bdefId);
+                }
+            }
+            // From BDEF source: "IMPLEMENTATION IN CLASS <class_name>"
+            if (node.type === 'behaviorDefinition') {
+                for (const m of contentUpper.matchAll(/IMPLEMENTATION\s+IN\s+CLASS\s+([A-Z0-9_/]+)/g)) {
+                    const className = m[1];
+                    const classId = `CLASS:${className}`;
+                    if (allIds.has(classId))
+                        deps.add(classId);
+                    const bimpId = `BEHAVIORIMPLEMENTATION:${className}`;
+                    if (allIds.has(bimpId))
+                        deps.add(bimpId);
+                }
+            }
+            // Behavior Implementation -> Behavior Definition (from config)
+            if (node.type === 'behaviorImplementation' &&
+                node.config?.behaviorDefinition) {
+                const bdef = String(node.config.behaviorDefinition).toUpperCase();
+                const bdefId = `BEHAVIORDEFINITION:${bdef}`;
+                if (allIds.has(bdefId))
+                    deps.add(bdefId);
+            }
+            // Service Binding -> Service Definition
+            if (node.type === 'serviceBinding' &&
+                node.config?.serviceDefinitionName) {
+                const srvd = String(node.config.serviceDefinitionName).toUpperCase();
+                const srvdId = `SERVICEDEFINITION:${srvd}`;
+                if (allIds.has(srvdId))
+                    deps.add(srvdId);
+            }
+        }
+        adj.set(id, deps);
+    }
+    // Tarjan's algorithm for SCCs
+    let index = 0;
+    const stack = [];
+    const onStack = new Set();
+    const indices = new Map();
+    const lowlink = new Map();
+    const sccs = [];
+    function strongConnect(v) {
+        indices.set(v, index);
+        lowlink.set(v, index);
+        index++;
+        stack.push(v);
+        onStack.add(v);
+        const deps = adj.get(v) || new Set();
+        for (const w of deps) {
+            if (!indices.has(w)) {
+                strongConnect(w);
+                const lowV = lowlink.get(v);
+                const lowW = lowlink.get(w);
+                if (lowV !== undefined && lowW !== undefined) {
+                    lowlink.set(v, Math.min(lowV, lowW));
+                }
+            }
+            else if (onStack.has(w)) {
+                const lowV = lowlink.get(v);
+                const idxW = indices.get(w);
+                if (lowV !== undefined && idxW !== undefined) {
+                    lowlink.set(v, Math.min(lowV, idxW));
+                }
+            }
+        }
+        if (lowlink.get(v) === indices.get(v)) {
+            const scc = [];
+            let w;
+            do {
+                w = stack.pop() || '';
+                onStack.delete(w);
+                scc.push(w);
+            } while (w !== v);
+            sccs.push(scc);
+        }
+    }
+    for (const id of allIds) {
+        if (!indices.has(id)) {
+            strongConnect(id);
+        }
+    }
+    // Dependency graph of SCCs
+    const sccAdj = new Map();
+    const nodeToSccIndex = new Map();
+    sccs.forEach((scc, i) => {
+        for (const id of scc) {
+            nodeToSccIndex.set(id, i);
+        }
+    });
+    sccs.forEach((scc, i) => {
+        const deps = new Set();
+        for (const id of scc) {
+            const nodeDeps = adj.get(id) || new Set();
+            for (const depId of nodeDeps) {
+                const depSccIndex = nodeToSccIndex.get(depId);
+                if (depSccIndex !== undefined && depSccIndex !== i) {
+                    deps.add(depSccIndex);
+                }
+            }
+        }
+        sccAdj.set(i, deps);
+    });
+    // Topological sort
+    const visited = new Set();
+    const order = [];
+    function visit(i) {
+        if (visited.has(i))
+            return;
+        visited.add(i);
+        const deps = sccAdj.get(i) || new Set();
+        for (const d of deps) {
+            visit(d);
+        }
+        order.push(i);
+    }
+    for (let i = 0; i < sccs.length; i++) {
+        visit(i);
+    }
+    return order.map((i) => {
+        const ids = sccs[i];
+        return {
+            nodes: ids.map((id) => idToNode.get(id)),
+            isCircular: ids.length > 1,
+        };
+    });
+}

package/dist/lib/restore/restoreObjects.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"restoreObjects.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/restoreObjects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAI1D,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,YAAY,EAAE,EACvB,IAAI,EAAE,WAAW,EACjB,gBAAgB,EAAE,OAAO,EACzB,gBAAgB,CAAC,EAAE,MAAM,EACzB,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EACzC,gBAAgB,UAAO,GACtB,OAAO,CAAC,IAAI,CAAC,CA0Cf"}
+{"version":3,"file":"restoreObjects.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/restoreObjects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAmB,MAAM,2BAA2B,CAAC;AAE5E,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AA2B1D,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,YAAY,EAAE,EACvB,IAAI,EAAE,WAAW,EACjB,gBAAgB,EAAE,OAAO,EACzB,gBAAgB,CAAC,EAAE,MAAM,EACzB,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EACzC,gBAAgB,UAAO,GACtB,OAAO,CAAC,IAAI,CAAC,CA+Df"}

package/dist/lib/restore/restoreObjects.js

@@ -2,27 +2,66 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.restoreObjects = restoreObjects;
 const logVerbose_1 = require("../cli/logVerbose");
+const verifyObjectInSystem_1 = require("../verify/verifyObjectInSystem");
 const restoreObject_1 = require("./restoreObject");
 const sortByDependencies_1 = require("./sortByDependencies");
+const ADT_TYPE_MAP = {
+    package: 'DEVC/K',
+    domain: 'DOMA/DT',
+    dataElement: 'DTEL/DE',
+    structure: 'TABL/DT',
+    table: 'TABL/DT',
+    tableType: 'TTYP/DT',
+    view: 'VIEW/DV',
+    class: 'CLAS/OC',
+    interface: 'INTF/OI',
+    program: 'PROG/P',
+    functionGroup: 'FUGR/FF',
+    functionModule: 'FUGR/I',
+    serviceDefinition: 'SRVD/SRV',
+    serviceBinding: 'SRVB/SRV',
+    metadataExtension: 'DDLX/PX',
+    behaviorDefinition: 'BDEF/B',
+    behaviorImplementation: 'CLAS/OC',
+    enhancement: 'ENHO/EI',
+    accessControl: 'DCLS/DL',
+};
 async function restoreObjects(client, objects, mode, activateOnUpdate, transportRequest, restoreActions, activateOnCreate = true) {
     const ordered = (0, sortByDependencies_1.sortByDependencies)(objects);
     (0, logVerbose_1.logVerbose)(2, `Restoring ${ordered.length} object(s) in flat mode (mode=${mode}, activate=${activateOnUpdate})`);
+    const activationList = [];
     for (const obj of ordered) {
         (0, logVerbose_1.logVerbose)(3, `Restore ${obj.type}:${obj.name}`);
-        const nodeMode = mode === 'upsert' && restoreActions?.has(obj.id)
+        let nodeMode = mode === 'upsert' && restoreActions?.has(obj.id)
             ? restoreActions.get(obj.id)
             : mode;
-        const effectiveActivate = nodeMode === 'create' ? activateOnCreate : activateOnUpdate;
         if (nodeMode === 'upsert') {
-            try {
-                await (0, restoreObject_1.restoreObject)(client, obj, 'create', effectiveActivate, transportRequest);
-            }
-            catch (_error) {
-                await (0, restoreObject_1.restoreObject)(client, obj, 'update', effectiveActivate, transportRequest);
-            }
+            const verifyResult = await (0, verifyObjectInSystem_1.verifyObjectInSystem)(client, {
+                type: obj.type,
+                name: obj.name,
+                functionGroupName: obj.functionGroupName,
+            });
+            nodeMode = verifyResult.status === 'missing' ? 'create' : 'update';
         }
-        else {
-            await (0, restoreObject_1.restoreObject)(client, obj, nodeMode || mode, effectiveActivate, transportRequest);
+        const isPackage = obj.type === 'package';
+        const shouldActivate = nodeMode === 'create' ? activateOnCreate : activateOnUpdate;
+        // Defer activation for non-package objects
+        const effectiveActivate = isPackage ? shouldActivate : false;
+        await (0, restoreObject_1.restoreObject)(client, obj, nodeMode || mode, effectiveActivate, transportRequest);
+        if (!isPackage && shouldActivate && ADT_TYPE_MAP[obj.type]) {
+            activationList.push({ name: obj.name, type: ADT_TYPE_MAP[obj.type] });
+        }
+    }
+    if (activationList.length > 0) {
+        (0, logVerbose_1.logVerbose)(2, `Activating ${activationList.length} object(s) in group...`);
+        try {
+            await client.getUtils().activateObjectsGroup(activationList, true);
+            (0, logVerbose_1.logVerbose)(2, 'Group activation completed successfully.');
+        }
+        catch (error) {
+            (0, logVerbose_1.logVerbose)(1, 'Group activation failed (this is common due to complex dependencies).');
+            (0, logVerbose_1.logVerbose)(1, `Error: ${error instanceof Error ? error.message : String(error)}`);
+            (0, logVerbose_1.logVerbose)(1, 'Objects are restored but might remain inactive. Please check and activate them manually in ADT.');
         }
     }
 }

package/dist/lib/restore/restoreTreeBackup.d.ts

@@ -1,4 +1,4 @@
 import type { AdtClient } from '@mcp-abap-adt/adt-clients';
 import type { BackupTreeNode, RestoreMode } from '../types';
-export declare function restoreTreeBackup(client: AdtClient, root: BackupTreeNode, mode: RestoreMode, activate: boolean, transportRequest?: string, restoreIds?: Set<string>, restoreActions?: Map<string, RestoreMode>, activateOnCreate?: boolean, softwareComponent?: string): Promise<void>;
+export declare function restoreTreeBackup(client: AdtClient, root: BackupTreeNode, mode: RestoreMode, activate: boolean, transportRequest?: string, restoreIds?: Set<string>, restoreActions?: Map<string, RestoreMode>, activateOnCreate?: boolean, softwareComponent?: string, superPackageOverride?: string, transportLayer?: string): Promise<void>;
 //# sourceMappingURL=restoreTreeBackup.d.ts.map

package/dist/lib/restore/restoreTreeBackup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"restoreTreeBackup.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/restoreTreeBackup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAmB,MAAM,2BAA2B,CAAC;AAK5E,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAI5D,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,OAAO,EACjB,gBAAgB,CAAC,EAAE,MAAM,EACzB,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EACzC,gBAAgB,UAAO,EACvB,iBAAiB,CAAC,EAAE,MAAM,GACzB,OAAO,CAAC,IAAI,CAAC,CAsGf"}
+{"version":3,"file":"restoreTreeBackup.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/restoreTreeBackup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAmB,MAAM,2BAA2B,CAAC;AAI5E,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAiB,MAAM,UAAU,CAAC;AAwD3E,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,OAAO,EACjB,gBAAgB,CAAC,EAAE,MAAM,EACzB,UAAU,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EACzC,gBAAgB,UAAO,EACvB,iBAAiB,CAAC,EAAE,MAAM,EAC1B,oBAAoB,CAAC,EAAE,MAAM,EAC7B,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC,CA2Pf"}

package/dist/lib/restore/restoreTreeBackup.js

@@ -2,12 +2,50 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.restoreTreeBackup = restoreTreeBackup;
 const logVerbose_1 = require("../cli/logVerbose");
-const typeOrder_1 = require("../constants/typeOrder");
 const flattenTree_1 = require("../tree/flattenTree");
 const getNodeObjectId_1 = require("../tree/getNodeObjectId");
+const analyzeDependencies_1 = require("./analyzeDependencies");
 const restoreTreeNode_1 = require("./restoreTreeNode");
-const sortTreeNodesByDependencies_1 = require("./sortTreeNodesByDependencies");
-async function restoreTreeBackup(client, root, mode, activate, transportRequest, restoreIds, restoreActions, activateOnCreate = true, softwareComponent) {
+const RESTORE_PHASES = [
+    { name: 'Domains', types: ['domain'], activation: 'individual' },
+    { name: 'Data Elements', types: ['dataElement'], activation: 'individual' },
+    { name: 'Structures', types: ['structure'], activation: 'individual' },
+    { name: 'Tables', types: ['table'], activation: 'individual' },
+    { name: 'Table Types', types: ['tableType'], activation: 'individual' },
+    { name: 'CDS Views', types: ['view'], activation: 'cluster' },
+    {
+        name: 'Behavior',
+        types: ['behaviorDefinition', 'behaviorImplementation'],
+        activation: 'bulk',
+    },
+    { name: 'Classes', types: ['class'], activation: 'individual' },
+    { name: 'Interfaces', types: ['interface'], activation: 'individual' },
+    { name: 'Programs', types: ['program'], activation: 'individual' },
+    {
+        name: 'Function Groups',
+        types: ['functionGroup'],
+        activation: 'individual',
+    },
+    {
+        name: 'Function Modules',
+        types: ['functionModule'],
+        activation: 'individual',
+    },
+    { name: 'Access Control', types: ['accessControl'], activation: 'bulk' },
+    {
+        name: 'Metadata Extensions',
+        types: ['metadataExtension'],
+        activation: 'bulk',
+    },
+    {
+        name: 'Service Definitions',
+        types: ['serviceDefinition'],
+        activation: 'bulk',
+    },
+    { name: 'Service Bindings', types: ['serviceBinding'], activation: 'bulk' },
+    { name: 'Enhancements', types: ['enhancement'], activation: 'individual' },
+];
+async function restoreTreeBackup(client, root, mode, activate, transportRequest, restoreIds, restoreActions, activateOnCreate = true, softwareComponent, superPackageOverride, transportLayer) {
     const allNodes = (0, flattenTree_1.flattenTree)(root).filter((node) => node.type && node.restoreStatus === 'ok');
     const nodes = restoreIds
         ? allNodes.filter((node) => {
@@ -15,55 +53,167 @@ async function restoreTreeBackup(client, root, mode, activate, transportRequest,
             return id ? restoreIds.has(id) : false;
         })
         : allNodes;
-    // Separate packages from non-packages
-    // Packages keep their tree order (parent before children)
     const packageNodes = nodes.filter((node) => node.type === 'package');
     const nonPackageNodes = nodes.filter((node) => node.type !== 'package');
-    // Sort non-packages by dependencies or typeOrder
-    const priority = new Map(typeOrder_1.typeOrder.map((type, index) => [type, index]));
-    const hasDependencies = nonPackageNodes.some((node) => Array.isArray(node.usedBy) && node.usedBy.length > 0);
-    const sortedNonPackages = hasDependencies
-        ? (0, sortTreeNodesByDependencies_1.sortTreeNodesByDependencies)(nonPackageNodes)
-        : nonPackageNodes.sort((a, b) => {
-            const aOrder = a.type ? (priority.get(a.type) ?? 999) : 999;
-            const bOrder = b.type ? (priority.get(b.type) ?? 999) : 999;
-            return aOrder - bOrder || a.name.localeCompare(b.name);
-        });
-    // Packages first (in tree order), then sorted non-packages
-    const orderedNodes = [...packageNodes, ...sortedNonPackages];
-    // Collect package names from backup tree for inheritance logic
     const backupPackageNames = new Set(packageNodes.map((node) => node.name));
-    (0, logVerbose_1.logVerbose)(2, `Restoring ${orderedNodes.length} node(s) from tree (mode=${mode}, activate=${activate})`);
-    (0, logVerbose_1.logVerbose)(2, `  Packages: ${packageNodes.length}, Other objects: ${sortedNonPackages.length}`);
-    const activationList = [];
-    for (const node of orderedNodes) {
-        (0, logVerbose_1.logVerbose)(3, `Restore ${node.type}:${node.name}`);
+    const rootPackageName = root.name;
+    (0, logVerbose_1.logVerbose)(1, `\n>>> STARTING TYPE-PHASE RESTORE: ${nodes.length} objects`);
+    const failures = [];
+    // Phase 1: Packages (recursive hierarchy)
+    if (packageNodes.length > 0) {
+        (0, logVerbose_1.logVerbose)(1, '[PHASE 1] Restoring package hierarchy...');
+        const restorePackageRecursive = async (node, parentName) => {
+            const nodeId = (0, getNodeObjectId_1.getNodeObjectId)(node);
+            if (node.type === 'package' &&
+                nodeId &&
+                (!restoreIds || restoreIds.has(nodeId))) {
+                const isRootNode = node.name === rootPackageName;
+                const nodeMode = (restoreActions?.get(nodeId) || mode);
+                const effectiveMode = isRootNode ? 'update' : nodeMode;
+                if (effectiveMode === 'skip') {
+                    (0, logVerbose_1.logVerbose)(2, `  [SKIP] package:${node.name}`);
+                }
+                else {
+                    (0, logVerbose_1.logVerbose)(2, `  [PACKAGE] ${node.name}`);
+                    try {
+                        await (0, restoreTreeNode_1.restoreTreeNode)(client, node, effectiveMode, false, transportRequest, softwareComponent, backupPackageNames, parentName || superPackageOverride, transportLayer);
+                    }
+                    catch (e) {
+                        if (isRootNode) {
+                            (0, logVerbose_1.logVerbose)(1, `  ! Warning: Root package ${node.name} already exists or update skipped.`);
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                }
+            }
+            if (node.children) {
+                for (const child of node.children) {
+                    await restorePackageRecursive(child, node.type === 'package' ? node.name : parentName);
+                }
+            }
+        };
+        await restorePackageRecursive(root, undefined);
+    }
+    // Phase 2: Analyze dependencies for processing order
+    (0, logVerbose_1.logVerbose)(1, `[PHASE 2] Analyzing dependencies for ${nonPackageNodes.length} objects...`);
+    const restoreGroups = (0, analyzeDependencies_1.analyzeDependencies)(nonPackageNodes);
+    const orderedNodes = restoreGroups.flatMap((g) => g.nodes);
+    (0, logVerbose_1.logVerbose)(1, `Dependency analysis complete: ${restoreGroups.length} groups → ${orderedNodes.length} ordered nodes.`);
+    // Helper to bulk activate a list of refs
+    const bulkActivate = async (phaseName, refs) => {
+        if (refs.length === 0)
+            return;
+        (0, logVerbose_1.logVerbose)(2, `  [*] Bulk activating ${phaseName} (${refs.length} objects)...`);
+        try {
+            await client.getUtils().activateObjectsGroup(refs, true);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            (0, logVerbose_1.logVerbose)(1, `  [!] WARNING: ${phaseName} activation failed: ${message}`);
+            (0, logVerbose_1.logVerbose)(1, '  Objects are created but might be inactive. Continuing...');
+        }
+    };
+    // Phase 3: Process by granular type phases with per-type activation strategy
+    const knownTypes = new Set(RESTORE_PHASES.flatMap((p) => p.types));
+    const uncategorizedNodes = orderedNodes.filter((n) => n.type && !knownTypes.has(n.type) && n.type !== 'package');
+    // Helper: process a single node (create/update without activation)
+    const processNode = async (node, activateFlag) => {
         const nodeId = (0, getNodeObjectId_1.getNodeObjectId)(node);
-        const nodeMode = mode === 'upsert' && nodeId && restoreActions?.has(nodeId)
-            ? restoreActions.get(nodeId)
-            : mode;
+        if (!nodeId)
+            return null;
+        const nodeMode = (restoreActions?.get(nodeId) || mode);
+        if (nodeMode === 'skip') {
+            (0, logVerbose_1.logVerbose)(2, `  [SKIP] ${node.type}:${node.name}`);
+            return null;
+        }
         const shouldActivate = nodeMode === 'create' ? activateOnCreate : activate;
-        const isPackage = node.type === 'package';
-        // Defer activation for non-package objects if activation is requested
-        const effectiveActivate = isPackage ? shouldActivate : false;
-        if (nodeMode === 'upsert') {
-            try {
-                await (0, restoreTreeNode_1.restoreTreeNode)(client, node, 'create', effectiveActivate, transportRequest, softwareComponent, backupPackageNames);
+        (0, logVerbose_1.logVerbose)(2, `  -> Process [${node.type?.toUpperCase()}] ${node.name} (${nodeMode})`);
+        try {
+            await (0, restoreTreeNode_1.restoreTreeNode)(client, node, nodeMode, activateFlag, transportRequest, softwareComponent, backupPackageNames, undefined, transportLayer);
+            if (shouldActivate && node.adtType) {
+                return { name: node.name, type: node.adtType };
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes('status code 403')) {
+                (0, logVerbose_1.logVerbose)(1, `  [SKIP] ${node.type}:${node.name} — no authorization`);
             }
-            catch (_error) {
-                await (0, restoreTreeNode_1.restoreTreeNode)(client, node, 'update', effectiveActivate, transportRequest, softwareComponent, backupPackageNames);
+            else {
+                (0, logVerbose_1.logVerbose)(1, `  [FAIL] ${node.type}:${node.name} — ${message}`);
+                failures.push({ node, error: message });
             }
         }
-        else {
-            await (0, restoreTreeNode_1.restoreTreeNode)(client, node, nodeMode || mode, effectiveActivate, transportRequest, softwareComponent, backupPackageNames);
+        return null;
+    };
+    const allProcessedRefs = [];
+    for (const phase of RESTORE_PHASES) {
+        const phaseTypeSet = new Set(phase.types);
+        const phaseNodes = orderedNodes.filter((n) => n.type && phaseTypeSet.has(n.type));
+        if (phaseNodes.length === 0)
+            continue;
+        (0, logVerbose_1.logVerbose)(1, `[${phase.name.toUpperCase()}] Processing ${phaseNodes.length} object(s) (${phase.activation})...`);
+        if (phase.activation === 'individual') {
+            // Activate each object at creation/update time
+            for (const node of phaseNodes) {
+                const ref = await processNode(node, true);
+                if (ref)
+                    allProcessedRefs.push(ref);
+            }
         }
-        if (!isPackage && shouldActivate && node.adtType) {
-            activationList.push({ name: node.name, type: node.adtType });
+        else if (phase.activation === 'bulk') {
+            // Create/update all without activation, then bulk activate together
+            const refs = [];
+            for (const node of phaseNodes) {
+                const ref = await processNode(node, false);
+                if (ref)
+                    refs.push(ref);
+            }
+            await bulkActivate(phase.name, refs);
+            allProcessedRefs.push(...refs);
+        }
+        else if (phase.activation === 'cluster') {
+            // Cluster by dependencies (SCC groups), bulk activate per cluster
+            const groups = (0, analyzeDependencies_1.analyzeDependencies)(phaseNodes);
+            (0, logVerbose_1.logVerbose)(2, `  Dependency clustering: ${groups.length} cluster(s)`);
+            for (let gi = 0; gi < groups.length; gi++) {
+                const group = groups[gi];
+                const clusterRefs = [];
+                for (const node of group.nodes) {
+                    const ref = await processNode(node, false);
+                    if (ref)
+                        clusterRefs.push(ref);
+                }
+                if (clusterRefs.length > 0) {
+                    await bulkActivate(`${phase.name} cluster ${gi + 1}/${groups.length}${group.isCircular ? ' (circular)' : ''}`, clusterRefs);
+                }
+                allProcessedRefs.push(...clusterRefs);
+            }
+        }
+    }
+    // Uncategorized types (future types not in RESTORE_PHASES) — individual activation
+    if (uncategorizedNodes.length > 0) {
+        (0, logVerbose_1.logVerbose)(1, `[OTHER] Processing ${uncategorizedNodes.length} uncategorized object(s) (individual)...`);
+        for (const node of uncategorizedNodes) {
+            const ref = await processNode(node, true);
+            if (ref)
+                allProcessedRefs.push(ref);
+        }
+    }
+    // Final activation sweep — safety net for objects left inactive
+    if (allProcessedRefs.length > 0) {
+        (0, logVerbose_1.logVerbose)(1, `[FINAL] Activation sweep (${allProcessedRefs.length} objects)...`);
+        await bulkActivate('Final sweep', allProcessedRefs);
+    }
+    if (failures.length > 0) {
+        (0, logVerbose_1.logVerbose)(1, `\n>>> RESTORE COMPLETED WITH ${failures.length} FAILURE(S):`);
+        for (const f of failures) {
+            (0, logVerbose_1.logVerbose)(1, `  - ${f.node.type}:${f.node.name}: ${f.error}`);
         }
     }
-    if (activationList.length > 0) {
-        (0, logVerbose_1.logVerbose)(2, `Activating ${activationList.length} object(s)...`);
-        // Pass true for preauditRequested to check before activating
-        await client.getUtils().activateObjectsGroup(activationList, true);
+    else {
+        (0, logVerbose_1.logVerbose)(1, '\n>>> RESTORE COMPLETED SUCCESSFULLY.');
     }
 }

package/dist/lib/restore/restoreTreeNode.d.ts

@@ -1,4 +1,4 @@
 import type { AdtClient } from '@mcp-abap-adt/adt-clients';
 import type { BackupTreeNode, RestoreMode } from '../types';
-export declare function restoreTreeNode(client: AdtClient, node: BackupTreeNode, mode: RestoreMode, activate: boolean, transportRequest?: string, softwareComponentOverride?: string, backupPackageNames?: Set<string>): Promise<void>;
+export declare function restoreTreeNode(client: AdtClient, node: BackupTreeNode, mode: RestoreMode, activate: boolean, transportRequest?: string, softwareComponentOverride?: string, backupPackageNames?: Set<string>, superPackageOverride?: string, transportLayerOverride?: string): Promise<void>;
 //# sourceMappingURL=restoreTreeNode.d.ts.map

package/dist/lib/restore/restoreTreeNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"restoreTreeNode.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/restoreTreeNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAmBV,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAK5D,wBAAsB,eAAe,CACnC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,OAAO,EACjB,gBAAgB,CAAC,EAAE,MAAM,EACzB,yBAAyB,CAAC,EAAE,MAAM,EAClC,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAC/B,OAAO,CAAC,IAAI,CAAC,CAkVf"}
+{"version":3,"file":"restoreTreeNode.d.ts","sourceRoot":"","sources":["../../../src/lib/restore/restoreTreeNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAoBV,MAAM,2BAA2B,CAAC;AAGnC,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAO5D,wBAAsB,eAAe,CACnC,MAAM,EAAE,SAAS,EACjB,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,OAAO,EACjB,gBAAgB,CAAC,EAAE,MAAM,EACzB,yBAAyB,CAAC,EAAE,MAAM,EAClC,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAChC,oBAAoB,CAAC,EAAE,MAAM,EAC7B,sBAAsB,CAAC,EAAE,MAAM,GAC9B,OAAO,CAAC,IAAI,CAAC,CA8Zf"}