@salesforce/packaging 4.21.12 → 4.22.1

package/lib/exported.d.ts

@@ -5,3 +5,5 @@ export * from './utils';
 export * from './package/packageBundle';
 export * from './package/packageBundleVersionCreate';
 export * from './package/packageBundleInstall';
+export * from './package/packageBundleInstalledList';
+export * from './package/packageBundleUninstall';

package/lib/exported.js

@@ -36,4 +36,6 @@ __exportStar(require("./utils"), exports);
 __exportStar(require("./package/packageBundle"), exports);
 __exportStar(require("./package/packageBundleVersionCreate"), exports);
 __exportStar(require("./package/packageBundleInstall"), exports);
+__exportStar(require("./package/packageBundleInstalledList"), exports);
+__exportStar(require("./package/packageBundleUninstall"), exports);
 //# sourceMappingURL=exported.js.map

package/lib/interfaces/bundleInterfacesAndType.d.ts

@@ -30,4 +30,13 @@ export type BundleInstallOptions = {
         frequency: Duration;
     };
 };
+export type BundleUninstallOptions = {
+    connection: Connection;
+    project: SfProject;
+    PackageBundleVersion: string;
+    polling?: {
+        timeout: Duration;
+        frequency: Duration;
+    };
+};
 export type BundleSaveResult = SaveResult;

package/lib/interfaces/bundleSObjects.d.ts

@@ -110,6 +110,18 @@ export declare namespace BundleSObjects {
         success = "Success",
         error = "Error"
     }
+    enum PkgBundleVersionUninstallReqStatus {
+        queued = "Queued",
+        inProgress = "InProgress",
+        success = "Success",
+        error = "Error"
+    }
+    enum PkgBundleVerCpntUnistlReqStatus {
+        queued = "Queued",
+        inProgress = "InProgress",
+        success = "Success",
+        error = "Error"
+    }
     type PkgBundleVersionQueryRecord = {
         Id: string;
         RequestStatus: BundleSObjects.PkgBundleVersionCreateReqStatus;
@@ -147,4 +159,114 @@ export declare namespace BundleSObjects {
         CreatedById: string;
         Error?: string[];
     } & Schema;
+    type PkgBundleVerUninstallReq = {
+        PackageBundleVersionId: string;
+        InstalledPkgBundleVersionId?: string;
+        ValidationError?: string;
+    };
+    type PkgBundleVerUninstallReqResult = PkgBundleVerUninstallReq & {
+        Id: string;
+        UninstallStatus: PkgBundleVersionUninstallReqStatus;
+        CreatedDate: string;
+        CreatedById: string;
+        Error?: string[];
+    };
+    type PkgBundleVerUninstallReqQueryRecord = {
+        Id: string;
+        UninstallStatus: PkgBundleVersionUninstallReqStatus;
+        PackageBundleVersionId: string;
+        InstalledPkgBundleVersionId?: string;
+        ValidationError?: string;
+        CreatedDate: string;
+        CreatedById: string;
+        Error?: string[];
+    } & Schema;
+    type PkgBundleVerCpntUnistlReqRecord = {
+        Id: string;
+        SequenceOrder: number;
+        UninstallStatus: PkgBundleVerCpntUnistlReqStatus;
+        PkgBundleVersionComponent?: {
+            Id: string;
+        };
+        Error?: string;
+    } & Schema;
+    type InstalledPackageBundleVersionComponent = {
+        ExpectedPackageName: string;
+        ExpectedPackageVersionNumber: string;
+        ActualPackageName: string;
+        ActualPackageVersionNumber: string;
+    };
+    type InstalledPackageBundleVersion = {
+        Id: string;
+        BundleName: string;
+        BundleId: string;
+        BundleVersionId: string;
+        BundleVersionName: string;
+        MajorVersion: number;
+        MinorVersion: number;
+        Description: string;
+        InstalledDate: string;
+        LastUpgradedDate: string;
+        Components: InstalledPackageBundleVersionComponent[];
+    };
+    type InstalledPackageBundleVersionQueryRecord = {
+        Id: string;
+        PackageBundleVersion: {
+            Id: string;
+            VersionName: string;
+            MajorVersion: number;
+            MinorVersion: number;
+            PackageBundle: {
+                Id: string;
+                BundleName: string;
+                Description: string;
+            };
+        };
+        InstalledDate: string;
+        LastUpgradedDate: string;
+    } & Schema;
+    type InstalledBundleRecord = {
+        Id: string;
+        PackageBundleId?: string;
+        PackageBundleVersionId?: string;
+        BundleName: string;
+        BundleVersionName: string;
+        MajorVersion: number;
+        MinorVersion: number;
+        CreatedDate?: string;
+        LastModifiedDate?: string;
+    } & Schema;
+    type InstallRequestRecord = {
+        Id: string;
+    } & Schema;
+    type BundleComponentInstallRecord = {
+        SubscriberPackageVersion: {
+            Id: string;
+            SubscriberPackageId: string;
+            MajorVersion: number;
+            MinorVersion: number;
+            PatchVersion: number;
+            BuildNumber: number;
+        };
+        InstalledComponent?: {
+            SubscriberPackage?: {
+                Name: string;
+            };
+        };
+        SequenceOrder: number;
+    } & Schema;
+    type InstalledPackageRecord = {
+        Id: string;
+        SubscriberPackageId: string;
+        SubscriberPackage: {
+            Name: string;
+        };
+        SubscriberPackageVersion: {
+            Id: string;
+            MajorVersion: number;
+            MinorVersion: number;
+            PatchVersion: number;
+            BuildNumber: number;
+        };
+    } & Schema;
 }

package/lib/interfaces/bundleSObjects.js

@@ -17,5 +17,19 @@ var BundleSObjects;
         PkgBundleVersionInstallReqStatus["success"] = "Success";
         PkgBundleVersionInstallReqStatus["error"] = "Error";
     })(PkgBundleVersionInstallReqStatus = BundleSObjects.PkgBundleVersionInstallReqStatus || (BundleSObjects.PkgBundleVersionInstallReqStatus = {}));
+    let PkgBundleVersionUninstallReqStatus;
+    (function (PkgBundleVersionUninstallReqStatus) {
+        PkgBundleVersionUninstallReqStatus["queued"] = "Queued";
+        PkgBundleVersionUninstallReqStatus["inProgress"] = "InProgress";
+        PkgBundleVersionUninstallReqStatus["success"] = "Success";
+        PkgBundleVersionUninstallReqStatus["error"] = "Error";
+    })(PkgBundleVersionUninstallReqStatus = BundleSObjects.PkgBundleVersionUninstallReqStatus || (BundleSObjects.PkgBundleVersionUninstallReqStatus = {}));
+    let PkgBundleVerCpntUnistlReqStatus;
+    (function (PkgBundleVerCpntUnistlReqStatus) {
+        PkgBundleVerCpntUnistlReqStatus["queued"] = "Queued";
+        PkgBundleVerCpntUnistlReqStatus["inProgress"] = "InProgress";
+        PkgBundleVerCpntUnistlReqStatus["success"] = "Success";
+        PkgBundleVerCpntUnistlReqStatus["error"] = "Error";
+    })(PkgBundleVerCpntUnistlReqStatus = BundleSObjects.PkgBundleVerCpntUnistlReqStatus || (BundleSObjects.PkgBundleVerCpntUnistlReqStatus = {}));
 })(BundleSObjects || (exports.BundleSObjects = BundleSObjects = {}));
 //# sourceMappingURL=bundleSObjects.js.map

package/lib/package/index.d.ts

@@ -6,3 +6,4 @@ export { VersionNumber } from './versionNumber';
 export * from './packageBundle';
 export * from './packageBundleVersion';
 export * from './packageBundleInstall';
+export * from './packageBundleUninstall';

package/lib/package/index.js

@@ -39,4 +39,5 @@ Object.defineProperty(exports, "VersionNumber", { enumerable: true, get: functio
 __exportStar(require("./packageBundle"), exports);
 __exportStar(require("./packageBundleVersion"), exports);
 __exportStar(require("./packageBundleInstall"), exports);
+__exportStar(require("./packageBundleUninstall"), exports);
 //# sourceMappingURL=index.js.map

package/lib/package/packageBundleInstalledList.d.ts

@@ -0,0 +1,19 @@
+import { Connection } from '@salesforce/core';
+import { BundleSObjects } from '../interfaces';
+export declare class PackageBundleInstalledList {
+    /**
+     * Get all installed package bundles in the target org
+     *
+     * @param connection - Connection to the target org (where bundles are installed)
+     * @returns Array of installed bundle versions with their component packages
+     */
+    static getInstalledBundles(connection: Connection): Promise<BundleSObjects.InstalledPackageBundleVersion[]>;
+    /**
+     * Get the component packages for a specific installed bundle
+     *
+     * @param connection - Connection to the target org
+     * @param installedBundleVersionId - The InstalledPackageBundleVersion ID
+     * @returns Array of components with expected and actual package versions
+     */
+    private static getBundleComponents;
+}

package/lib/package/packageBundleInstalledList.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageBundleInstalledList = void 0;
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const core_1 = require("@salesforce/core");
+const bundleUtils_1 = require("../utils/bundleUtils");
+core_1.Messages.importMessagesDirectory(__dirname);
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'bundle_installed_list');
+class PackageBundleInstalledList {
+    /**
+     * Get all installed package bundles in the target org
+     *
+     * @param connection - Connection to the target org (where bundles are installed)
+     * @returns Array of installed bundle versions with their component packages
+     */
+    static async getInstalledBundles(connection) {
+        try {
+            // Query InstalledPkgBundleVersion directly from the target org
+            // Note: PackageBundle and PackageBundleVersion are CROSSORGFOREIGNKEY fields
+            // Use CreatedDate and LastModifiedDate as proxies for InstalledDate and LastUpgradedDate
+            const query = 'SELECT Id, BundleName, BundleVersionName, MajorVersion, MinorVersion, ' +
+                'PackageBundleId, PackageBundleVersionId, CreatedDate, LastModifiedDate ' +
+                'FROM InstalledPkgBundleVersion ' +
+                'ORDER BY CreatedDate DESC';
+            const queryResult = await connection.autoFetchQuery(query, {
+                tooling: true,
+            });
+            if (!queryResult.records || queryResult.records.length === 0) {
+                return [];
+            }
+            // For each installed bundle, get component details
+            const installedBundles = await Promise.all(queryResult.records.map(async (record) => {
+                // Get component details from PkgBundleVersionComponentInstallReq
+                // We need to find the install request that corresponds to this installed bundle
+                const components = await PackageBundleInstalledList.getBundleComponents(connection, record.Id);
+                return {
+                    Id: record.Id,
+                    BundleName: record.BundleName,
+                    BundleId: record.PackageBundleId ?? '',
+                    BundleVersionId: record.PackageBundleVersionId ?? '',
+                    BundleVersionName: record.BundleVersionName,
+                    MajorVersion: record.MajorVersion,
+                    MinorVersion: record.MinorVersion,
+                    Description: '',
+                    InstalledDate: record.CreatedDate ?? '',
+                    LastUpgradedDate: record.LastModifiedDate ?? record.CreatedDate ?? '',
+                    Components: components,
+                };
+            }));
+            // Filter out any null results
+            return installedBundles.filter((bundle) => bundle !== null);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(messages.getMessage('failedToGetInstalledBundles'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+    }
+    /**
+     * Get the component packages for a specific installed bundle
+     *
+     * @param connection - Connection to the target org
+     * @param installedBundleVersionId - The InstalledPackageBundleVersion ID
+     * @returns Array of components with expected and actual package versions
+     */
+    static async getBundleComponents(connection, installedBundleVersionId) {
+        // First find the install request that created this installed bundle
+        const installRequestQuery = 'SELECT Id ' +
+            'FROM PkgBundleVersionInstallReq ' +
+            `WHERE InstalledPkgBundleVersionId = '${installedBundleVersionId}' ` +
+            'ORDER BY CreatedDate DESC LIMIT 1';
+        const installRequestResult = await connection.autoFetchQuery(installRequestQuery, {
+            tooling: true,
+        });
+        if (!installRequestResult.records || installRequestResult.records.length === 0) {
+            return [];
+        }
+        const installRequestId = installRequestResult.records[0].Id;
+        // Query expected packages from PkgBundleVerCpntIstlReq (abbreviated name)
+        // These have SubscriberPackageVersion as a foreign key showing what was expected
+        // Use InstalledComponent to get the actual package name from InstalledSubscriberPackage
+        const componentQuery = 'SELECT SubscriberPackageVersion.Id, SubscriberPackageVersion.SubscriberPackageId, ' +
+            'SubscriberPackageVersion.MajorVersion, SubscriberPackageVersion.MinorVersion, ' +
+            'SubscriberPackageVersion.PatchVersion, SubscriberPackageVersion.BuildNumber, ' +
+            'InstalledComponent.SubscriberPackage.Name, ' +
+            'SequenceOrder ' +
+            'FROM PkgBundleVerCpntIstlReq ' +
+            `WHERE PkgBundleVersionInstallReqId = '${installRequestId}' ` +
+            'ORDER BY SequenceOrder';
+        const componentResult = await connection.autoFetchQuery(componentQuery, {
+            tooling: true,
+        });
+        if (!componentResult.records || componentResult.records.length === 0) {
+            return [];
+        }
+        // Query actual installed packages from the org
+        const installedPackagesQuery = 'SELECT Id, SubscriberPackageId, SubscriberPackage.Name, SubscriberPackageVersion.Id, ' +
+            'SubscriberPackageVersion.MajorVersion, SubscriberPackageVersion.MinorVersion, ' +
+            'SubscriberPackageVersion.PatchVersion, SubscriberPackageVersion.BuildNumber ' +
+            'FROM InstalledSubscriberPackage ' +
+            'ORDER BY SubscriberPackageId';
+        const installedResult = await connection.autoFetchQuery(installedPackagesQuery, {
+            tooling: true,
+        });
+        // Create a map of actually installed packages by subscriber package ID
+        const installedMap = new Map();
+        if (installedResult.records) {
+            installedResult.records.forEach((pkg) => {
+                const versionNumber = `${pkg.SubscriberPackageVersion.MajorVersion}.${pkg.SubscriberPackageVersion.MinorVersion}.${pkg.SubscriberPackageVersion.PatchVersion}.${pkg.SubscriberPackageVersion.BuildNumber}`;
+                installedMap.set(pkg.SubscriberPackageId, {
+                    name: pkg.SubscriberPackage.Name,
+                    version: versionNumber,
+                });
+            });
+        }
+        // Compare expected vs actual
+        return componentResult.records.map((record) => {
+            // Expected (what the bundle was supposed to install)
+            const expectedVersion = `${record.SubscriberPackageVersion.MajorVersion}.${record.SubscriberPackageVersion.MinorVersion}.${record.SubscriberPackageVersion.PatchVersion}.${record.SubscriberPackageVersion.BuildNumber}`;
+            const expectedName = record.InstalledComponent?.SubscriberPackage?.Name ?? 'Unknown';
+            const subscriberPackageId = record.SubscriberPackageVersion.SubscriberPackageId;
+            // Actual (what's currently installed in the org)
+            const installed = installedMap.get(subscriberPackageId);
+            return {
+                ExpectedPackageName: expectedName,
+                ExpectedPackageVersionNumber: expectedVersion,
+                ActualPackageName: installed ? installed.name : 'Uninstalled',
+                ActualPackageVersionNumber: installed ? installed.version : 'N/A',
+            };
+        });
+    }
+}
+exports.PackageBundleInstalledList = PackageBundleInstalledList;
+//# sourceMappingURL=packageBundleInstalledList.js.map

package/lib/package/packageBundleUninstall.d.ts

@@ -0,0 +1,9 @@
+import { Connection, SfProject } from '@salesforce/core';
+import { BundleSObjects, BundleUninstallOptions } from '../interfaces';
+export declare class PackageBundleUninstall {
+    static getUninstallStatus(uninstallRequestId: string, connection: Connection): Promise<BundleSObjects.PkgBundleVerUninstallReqResult>;
+    static getUninstallStatuses(connection: Connection, status?: BundleSObjects.PkgBundleVersionUninstallReqStatus, createdLastDays?: number): Promise<BundleSObjects.PkgBundleVerUninstallReqResult[]>;
+    static uninstallBundle(connection: Connection, project: SfProject, options: BundleUninstallOptions): Promise<BundleSObjects.PkgBundleVerUninstallReqResult>;
+    private static parsePackageBundleVersionId;
+    private static pollUninstallStatus;
+}

package/lib/package/packageBundleUninstall.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageBundleUninstall = void 0;
+/*
+ * Copyright 2026, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const core_1 = require("@salesforce/core");
+const kit_1 = require("@salesforce/kit");
+const interfaces_1 = require("../interfaces");
+const bundleUtils_1 = require("../utils/bundleUtils");
+core_1.Messages.importMessagesDirectory(__dirname);
+const messages = core_1.Messages.loadMessages('@salesforce/packaging', 'bundle_uninstall');
+const installMessages = core_1.Messages.loadMessages('@salesforce/packaging', 'bundle_install');
+class PackageBundleUninstall {
+    static async getUninstallStatus(uninstallRequestId, connection) {
+        try {
+            const query = 'SELECT Id, UninstallStatus, PackageBundleVersionId, InstalledPkgBundleVersionId, ValidationError, ' +
+                'CreatedDate, CreatedById ' +
+                `FROM PkgBundleVerUninstallReq WHERE Id = '${uninstallRequestId}'`;
+            const queryResult = await connection.autoFetchQuery(query, {
+                tooling: true,
+            });
+            if (!queryResult.records || queryResult.records.length === 0) {
+                throw new Error(messages.getMessage('failedToGetPackageBundleUninstallStatus'));
+            }
+            const record = queryResult.records[0];
+            return {
+                Id: record.Id,
+                UninstallStatus: record.UninstallStatus,
+                PackageBundleVersionId: record.PackageBundleVersionId ?? '',
+                InstalledPkgBundleVersionId: record.InstalledPkgBundleVersionId ?? '',
+                ValidationError: record.ValidationError ?? '',
+                CreatedDate: record.CreatedDate ?? '',
+                CreatedById: record.CreatedById ?? '',
+                Error: record.Error,
+            };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(messages.getMessage('failedToGetPackageBundleUninstallStatus'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+    }
+    static async getUninstallStatuses(connection, status, createdLastDays) {
+        let query = 'SELECT Id, UninstallStatus, PackageBundleVersionId, InstalledPkgBundleVersionId, ValidationError, ' +
+            'CreatedDate, CreatedById ' +
+            'FROM PkgBundleVerUninstallReq';
+        if (status && createdLastDays) {
+            query += ` WHERE UninstallStatus = '${status}' AND CreatedDate = LAST_N_DAYS: ${createdLastDays}`;
+        }
+        else if (status) {
+            query += ` WHERE UninstallStatus = '${status}'`;
+        }
+        else if (createdLastDays) {
+            query += ` WHERE CreatedDate = LAST_N_DAYS: ${createdLastDays}`;
+        }
+        const queryResult = await connection.autoFetchQuery(query, {
+            tooling: true,
+        });
+        return queryResult.records.map((record) => ({
+            Id: record.Id,
+            UninstallStatus: record.UninstallStatus,
+            PackageBundleVersionId: record.PackageBundleVersionId ?? '',
+            InstalledPkgBundleVersionId: record.InstalledPkgBundleVersionId ?? '',
+            ValidationError: record.ValidationError ?? '',
+            CreatedDate: record.CreatedDate ?? '',
+            CreatedById: record.CreatedById ?? '',
+            Error: record.Error,
+        }));
+    }
+    static async uninstallBundle(connection, project, options) {
+        const packageBundleVersionId = PackageBundleUninstall.parsePackageBundleVersionId(options.PackageBundleVersion, project);
+        const request = {
+            PackageBundleVersionId: packageBundleVersionId,
+        };
+        let uninstallResult;
+        try {
+            uninstallResult = await connection.tooling.sobject('PkgBundleVerUninstallReq').create(request);
+        }
+        catch (err) {
+            const error = err instanceof Error
+                ? err
+                : new Error(typeof err === 'string' ? err : messages.getMessage('failedToUninstallPackageBundle'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+        if (!uninstallResult?.success) {
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(new Error(messages.getMessage('failedToUninstallPackageBundle'))));
+        }
+        if (options.polling) {
+            return PackageBundleUninstall.pollUninstallStatus(uninstallResult.id, connection, options.polling);
+        }
+        // When not polling, query the actual status from the server to get accurate information
+        return PackageBundleUninstall.getUninstallStatus(uninstallResult.id, connection);
+    }
+    static parsePackageBundleVersionId(packageBundleVersion, project) {
+        // Check if it's already an ID (starts with appropriate prefix)
+        if (/^1Q8.{15}$/.test(packageBundleVersion)) {
+            return packageBundleVersion;
+        }
+        // Otherwise, treat it as an alias and resolve it from sfdx-project.json
+        const packageBundleVersionId = project.getPackageBundleIdFromAlias(packageBundleVersion);
+        if (!packageBundleVersionId) {
+            throw new core_1.SfError(installMessages.getMessage('noPackageBundleVersionFoundWithAlias', [packageBundleVersion]));
+        }
+        return packageBundleVersionId;
+    }
+    static async pollUninstallStatus(uninstallRequestId, connection, polling) {
+        if (polling.timeout?.milliseconds <= 0) {
+            return PackageBundleUninstall.getUninstallStatus(uninstallRequestId, connection);
+        }
+        let remainingWaitTime = polling.timeout;
+        const pollingClient = await core_1.PollingClient.create({
+            poll: async () => {
+                const report = await PackageBundleUninstall.getUninstallStatus(uninstallRequestId, connection);
+                switch (report.UninstallStatus) {
+                    case interfaces_1.BundleSObjects.PkgBundleVersionUninstallReqStatus.queued:
+                    case interfaces_1.BundleSObjects.PkgBundleVersionUninstallReqStatus.inProgress:
+                        // Emit progress event for UI updates
+                        await core_1.Lifecycle.getInstance().emit('bundle-uninstall-progress', { ...report, remainingWaitTime });
+                        remainingWaitTime = kit_1.Duration.seconds(remainingWaitTime.seconds - polling.frequency.seconds);
+                        return {
+                            completed: false,
+                            payload: report,
+                        };
+                    case interfaces_1.BundleSObjects.PkgBundleVersionUninstallReqStatus.success:
+                        return { completed: true, payload: report };
+                    case interfaces_1.BundleSObjects.PkgBundleVersionUninstallReqStatus.error:
+                        return { completed: true, payload: report };
+                    default:
+                        await core_1.Lifecycle.getInstance().emit('bundle-uninstall-progress', { ...report, remainingWaitTime });
+                        remainingWaitTime = kit_1.Duration.seconds(remainingWaitTime.seconds - polling.frequency.seconds);
+                        return {
+                            completed: false,
+                            payload: report,
+                        };
+                }
+            },
+            frequency: polling.frequency,
+            timeout: polling.timeout,
+        });
+        try {
+            return await pollingClient.subscribe();
+        }
+        catch (err) {
+            const report = await PackageBundleUninstall.getUninstallStatus(uninstallRequestId, connection);
+            if (err instanceof Error) {
+                const timeoutError = new core_1.SfError(messages.getMessage('uninstallTimedOut', [uninstallRequestId]), 'BundleUninstallTimeout');
+                timeoutError.setData({ UninstallRequestId: uninstallRequestId, ...report });
+                throw timeoutError;
+            }
+            throw err;
+        }
+    }
+}
+exports.PackageBundleUninstall = PackageBundleUninstall;
+//# sourceMappingURL=packageBundleUninstall.js.map

package/messages/bundle_installed_list.md

@@ -0,0 +1,3 @@
+# failedToGetInstalledBundles
+
+Failed to get installed package bundles from the target org.

package/messages/bundle_uninstall.md

@@ -0,0 +1,12 @@
+# failedToGetPackageBundleUninstallStatus
+
+Failed to get package bundle uninstall status
+
+# failedToUninstallPackageBundle
+
+Failed to uninstall package bundle
+
+# uninstallTimedOut
+
+Uninstall request %s timed out while waiting for completion.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/packaging",
-  "version": "4.21.12",
+  "version": "4.22.1",
   "description": "Packaging library for the Salesforce packaging platform",
   "main": "lib/exported",
   "types": "lib/exported.d.ts",
@@ -43,7 +43,7 @@
   ],
   "dependencies": {
     "@jsforce/jsforce-node": "^3.10.14",
-    "@salesforce/core": "^8.27.1",
+    "@salesforce/core": "^8.28.1",
     "@salesforce/kit": "^3.2.6",
     "@salesforce/schemas": "^1.10.3",
     "@salesforce/source-deploy-retrieve": "^12.31.30",
@@ -58,7 +58,7 @@
     "object-treeify": "^2"
   },
   "devDependencies": {
-    "@salesforce/cli-plugins-testkit": "^5.3.41",
+    "@salesforce/cli-plugins-testkit": "^5.3.49",
     "@salesforce/dev-scripts": "^11.0.4",
     "@types/globby": "^9.1.0",
     "@types/jszip": "^3.4.1",