@salesforce/packaging 4.11.0 → 4.13.0

package/lib/exported.d.ts

@@ -2,3 +2,6 @@ export * from './interfaces';
 export * from './package';
 export * from './package1';
 export * from './utils';
+export * from './package/packageBundle';
+export * from './package/packageBundleVersionCreate';
+export * from './package/packageBundleInstall';

package/lib/exported.js

@@ -24,4 +24,7 @@ __exportStar(require("./interfaces"), exports);
 __exportStar(require("./package"), exports);
 __exportStar(require("./package1"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./package/packageBundle"), exports);
+__exportStar(require("./package/packageBundleVersionCreate"), exports);
+__exportStar(require("./package/packageBundleInstall"), exports);
 //# sourceMappingURL=exported.js.map

package/lib/interfaces/bundleInterfacesAndType.d.ts

@@ -0,0 +1,33 @@
+import { Nullable } from '@salesforce/ts-types';
+import { Connection, SfProject } from '@salesforce/core';
+import { Duration } from '@salesforce/kit';
+import { SaveResult } from '@jsforce/jsforce-node';
+export type BundleCreateOptions = {
+    BundleName: string;
+    Description: string;
+};
+export type BundleVersionCreateOptions = {
+    connection: Connection;
+    project: SfProject;
+    PackageBundle: string;
+    MajorVersion: string;
+    MinorVersion: string;
+    Ancestor: Nullable<string>;
+    BundleVersionComponentsPath: string;
+    Description?: string;
+    polling?: {
+        timeout: Duration;
+        frequency: Duration;
+    };
+};
+export type BundleInstallOptions = {
+    connection: Connection;
+    project: SfProject;
+    PackageBundleVersion: string;
+    DevelopmentOrganization: string;
+    polling?: {
+        timeout: Duration;
+        frequency: Duration;
+    };
+};
+export type BundleSaveResult = SaveResult;

package/lib/interfaces/bundleInterfacesAndType.js

@@ -0,0 +1,9 @@
+"use strict";
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=bundleInterfacesAndType.js.map

package/lib/interfaces/bundleSObjects.d.ts

@@ -0,0 +1,146 @@
+import { Nullable } from '@salesforce/ts-types';
+import { BundleEntry } from '@salesforce/schemas';
+import type { Schema } from '@jsforce/jsforce-node';
+export { BundleEntry };
+export type QueryRecord = Schema & {
+    Id: string;
+    PackageBundle?: {
+        Id: string;
+        BundleName: string;
+        Description?: string;
+        IsDeleted: boolean;
+        CreatedDate: string;
+        CreatedById: string;
+        LastModifiedDate: string;
+        LastModifiedById: string;
+        SystemModstamp: string;
+    };
+    VersionName: string;
+    MajorVersion: string;
+    MinorVersion: string;
+    IsReleased: boolean;
+    Ancestor?: {
+        Id: string;
+        PackageBundle?: {
+            Id: string;
+            BundleName: string;
+            Description?: string;
+            IsDeleted: boolean;
+            CreatedDate: string;
+            CreatedById: string;
+            LastModifiedDate: string;
+            LastModifiedById: string;
+            SystemModstamp: string;
+        };
+        VersionName: string;
+        MajorVersion: string;
+        MinorVersion: string;
+        IsReleased: boolean;
+    };
+};
+export type AncestorRecord = {
+    Id: string;
+    PackageBundle?: {
+        Id: string;
+        BundleName: string;
+        Description?: string;
+        IsDeleted: boolean;
+        CreatedDate: string;
+        CreatedById: string;
+        LastModifiedDate: string;
+        LastModifiedById: string;
+        SystemModstamp: string;
+    };
+    VersionName: string;
+    MajorVersion: string;
+    MinorVersion: string;
+    IsReleased: boolean;
+};
+export declare namespace BundleSObjects {
+    type Bundle = {
+        BundleName: string;
+        Description?: string;
+        Id: string;
+        IsDeleted: boolean;
+        CreatedDate: string;
+        CreatedById: string;
+        LastModifiedDate: string;
+        LastModifiedById: string;
+        SystemModstamp: string;
+    };
+    type BundleVersion = {
+        Id: string;
+        PackageBundle: Bundle;
+        VersionName: string;
+        MajorVersion: string;
+        MinorVersion: string;
+        Ancestor: Nullable<BundleVersion>;
+        IsReleased: boolean;
+        CreatedDate: string;
+        CreatedById: string;
+        LastModifiedDate: string;
+        LastModifiedById: string;
+    };
+    type PkgBundleVersionCreateReq = {
+        PackageBundleId: string;
+        VersionName: string;
+        MajorVersion: string;
+        MinorVersion: string;
+        BundleVersionComponents: string;
+        Ancestor?: string | null;
+    };
+    type PackageBundleVersionCreateRequestResult = PkgBundleVersionCreateReq & {
+        Id: string;
+        PackageBundleVersionId: string;
+        RequestStatus: PkgBundleVersionCreateReqStatus;
+        CreatedDate: string;
+        CreatedById: string;
+        Error?: string[];
+    };
+    enum PkgBundleVersionCreateReqStatus {
+        queued = "Queued",
+        success = "Success",
+        error = "Error"
+    }
+    enum PkgBundleVersionInstallReqStatus {
+        queued = "Queued",
+        success = "Success",
+        error = "Error"
+    }
+    type PkgBundleVersionQueryRecord = {
+        Id: string;
+        RequestStatus: BundleSObjects.PkgBundleVersionCreateReqStatus;
+        PackageBundle: Bundle;
+        PackageBundleVersion: BundleVersion;
+        VersionName: string;
+        MajorVersion: string;
+        MinorVersion: string;
+        Ancestor: BundleVersion;
+        BundleVersionComponents: string;
+        CreatedDate: string;
+        CreatedById: string;
+        Error?: string[];
+    } & Schema;
+    type PkgBundleVersionInstallReq = {
+        PackageBundleVersionID: string;
+        DevelopmentOrganization: string;
+    };
+    type PkgBundleVersionInstallReqResult = PkgBundleVersionInstallReq & {
+        Id: string;
+        InstallStatus: PkgBundleVersionInstallReqStatus;
+        ValidationError: string;
+        CreatedDate: string;
+        CreatedById: string;
+        Error?: string[];
+    };
+    type PkgBundleVersionInstallQueryRecord = {
+        Id: string;
+        InstallStatus: BundleSObjects.PkgBundleVersionInstallReqStatus;
+        PackageBundleVersionID: string;
+        DevelopmentOrganization: string;
+        ValidationError: string;
+        CreatedDate: string;
+        CreatedById: string;
+        Error?: string[];
+    } & Schema;
+}

package/lib/interfaces/bundleSObjects.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BundleSObjects = void 0;
+var BundleSObjects;
+(function (BundleSObjects) {
+    let PkgBundleVersionCreateReqStatus;
+    (function (PkgBundleVersionCreateReqStatus) {
+        PkgBundleVersionCreateReqStatus["queued"] = "Queued";
+        PkgBundleVersionCreateReqStatus["success"] = "Success";
+        PkgBundleVersionCreateReqStatus["error"] = "Error";
+    })(PkgBundleVersionCreateReqStatus = BundleSObjects.PkgBundleVersionCreateReqStatus || (BundleSObjects.PkgBundleVersionCreateReqStatus = {}));
+    let PkgBundleVersionInstallReqStatus;
+    (function (PkgBundleVersionInstallReqStatus) {
+        PkgBundleVersionInstallReqStatus["queued"] = "Queued";
+        PkgBundleVersionInstallReqStatus["success"] = "Success";
+        PkgBundleVersionInstallReqStatus["error"] = "Error";
+    })(PkgBundleVersionInstallReqStatus = BundleSObjects.PkgBundleVersionInstallReqStatus || (BundleSObjects.PkgBundleVersionInstallReqStatus = {}));
+})(BundleSObjects || (exports.BundleSObjects = BundleSObjects = {}));
+//# sourceMappingURL=bundleSObjects.js.map

package/lib/interfaces/index.d.ts

@@ -1,2 +1,4 @@
 export * from './packagingInterfacesAndType';
 export * from './packagingSObjects';
+export * from './bundleInterfacesAndType';
+export * from './bundleSObjects';

package/lib/interfaces/index.js

@@ -22,4 +22,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 __exportStar(require("./packagingInterfacesAndType"), exports);
 __exportStar(require("./packagingSObjects"), exports);
+__exportStar(require("./bundleInterfacesAndType"), exports);
+__exportStar(require("./bundleSObjects"), exports);
 //# sourceMappingURL=index.js.map

package/lib/package/index.d.ts

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

package/lib/package/index.js

@@ -27,4 +27,7 @@ __exportStar(require("./subscriberPackageVersion"), exports);
 __exportStar(require("./packagePushUpgrade"), exports);
 var versionNumber_1 = require("./versionNumber");
 Object.defineProperty(exports, "VersionNumber", { enumerable: true, get: function () { return versionNumber_1.VersionNumber; } });
+__exportStar(require("./packageBundle"), exports);
+__exportStar(require("./packageBundleVersion"), exports);
+__exportStar(require("./packageBundleInstall"), exports);
 //# sourceMappingURL=index.js.map

package/lib/package/packageBundle.d.ts

@@ -0,0 +1,37 @@
+import { Connection, SfProject } from '@salesforce/core';
+import { SaveResult } from '@jsforce/jsforce-node';
+import { Duration } from '@salesforce/kit';
+import { BundleCreateOptions, BundleSObjects, BundleVersionCreateOptions } from '../interfaces';
+export declare class PackageBundle {
+    /**
+     * Create a new package bundle.
+     *
+     * @param connection - instance of Connection
+     * @param project - instance of SfProject
+     * @param options - options for creating a bundle - see BundleCreateOptions
+     * @returns PackageBundle
+     */
+    static create(connection: Connection, project: SfProject, options: BundleCreateOptions): Promise<{
+        Id: string;
+    }>;
+    /**
+     * Create a new package bundle version.
+     *
+     * @param connection - instance of Connection
+     * @param project - instance of SfProject
+     * @param options - options for creating a bundle version - see BundleVersionCreateOptions
+     * @returns PackageBundle
+     */
+    static createVersion(options: BundleVersionCreateOptions, polling?: {
+        frequency: Duration;
+        timeout: Duration;
+    }): Promise<BundleSObjects.PackageBundleVersionCreateRequestResult>;
+    static delete(connection: Connection, project: SfProject, idOrAlias: string): Promise<SaveResult>;
+    /**
+     * Returns all the package bundles that are available in the org, up to 10,000. If more records are
+     * needed use the `SF_ORG_MAX_QUERY_LIMIT` env var.
+     *
+     * @param connection
+     */
+    static list(connection: Connection): Promise<BundleSObjects.Bundle[]>;
+}

package/lib/package/packageBundle.js

@@ -0,0 +1,76 @@
+"use strict";
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageBundle = void 0;
+const core_1 = require("@salesforce/core");
+const kit_1 = require("@salesforce/kit");
+const packageBundleCreate_1 = require("./packageBundleCreate");
+const packageBundleVersion_1 = require("./packageBundleVersion");
+const BundleFields = [
+    'BundleName',
+    'Description',
+    'Id',
+    'IsDeleted',
+    'CreatedDate',
+    'CreatedById',
+    'LastModifiedDate',
+    'LastModifiedById',
+    'SystemModstamp',
+];
+class PackageBundle {
+    /**
+     * Create a new package bundle.
+     *
+     * @param connection - instance of Connection
+     * @param project - instance of SfProject
+     * @param options - options for creating a bundle - see BundleCreateOptions
+     * @returns PackageBundle
+     */
+    static async create(connection, project, options) {
+        return (0, packageBundleCreate_1.createBundle)(connection, project, options);
+    }
+    /**
+     * Create a new package bundle version.
+     *
+     * @param connection - instance of Connection
+     * @param project - instance of SfProject
+     * @param options - options for creating a bundle version - see BundleVersionCreateOptions
+     * @returns PackageBundle
+     */
+    static async createVersion(options, polling = {
+        frequency: kit_1.Duration.seconds(0),
+        timeout: kit_1.Duration.seconds(0),
+    }) {
+        return packageBundleVersion_1.PackageBundleVersion.create(options, polling);
+    }
+    static async delete(connection, project, idOrAlias) {
+        // Check if it's already an ID (1Fl followed by 15 characters)
+        if (/^1Fl.{15}$/.test(idOrAlias)) {
+            return connection.tooling.sobject('PackageBundle').delete(idOrAlias);
+        }
+        // Validate that project is provided when using aliases
+        if (!project) {
+            throw new core_1.SfError('Project instance is required when deleting package bundle by alias');
+        }
+        // eslint-disable-next-line no-param-reassign
+        idOrAlias = project.getPackageBundleIdFromAlias(idOrAlias) ?? idOrAlias;
+        return connection.tooling.sobject('PackageBundle').delete(idOrAlias);
+    }
+    /**
+     * Returns all the package bundles that are available in the org, up to 10,000. If more records are
+     * needed use the `SF_ORG_MAX_QUERY_LIMIT` env var.
+     *
+     * @param connection
+     */
+    static async list(connection) {
+        const query = `select ${BundleFields.join(', ')} from PackageBundle ORDER BY BundleName`;
+        return (await connection.autoFetchQuery(query, { tooling: true }))?.records;
+    }
+}
+exports.PackageBundle = PackageBundle;
+//# sourceMappingURL=packageBundle.js.map

package/lib/package/packageBundleCreate.d.ts

@@ -0,0 +1,7 @@
+import { Connection, SfProject } from '@salesforce/core';
+import { BundleEntry } from '@salesforce/schemas';
+import { BundleCreateOptions } from '../interfaces';
+export declare function createPackageDirEntry(project: SfProject, options: BundleCreateOptions): BundleEntry;
+export declare function createBundle(connection: Connection, project: SfProject, options: BundleCreateOptions): Promise<{
+    Id: string;
+}>;

package/lib/package/packageBundleCreate.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPackageDirEntry = createPackageDirEntry;
+exports.createBundle = createBundle;
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+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_create');
+function createPackageDirEntry(project, options) {
+    return {
+        versionName: 'ver 0.1',
+        versionNumber: '0.1',
+        name: options.BundleName,
+        versionDescription: options.Description,
+    };
+}
+async function createBundle(connection, project, options) {
+    const request = { BundleName: options.BundleName, Description: options.Description };
+    let createResult;
+    try {
+        createResult = await connection.tooling.sobject('PackageBundle').create(request);
+    }
+    catch (err) {
+        const error = err instanceof Error
+            ? err
+            : new Error(typeof err === 'string' ? err : messages.getMessage('failedToCreatePackageBundle'));
+        throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+    }
+    if (!createResult?.success) {
+        throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(new Error(messages.getMessage('failedToCreatePackageBundle'))));
+    }
+    const bundleEntry = createPackageDirEntry(project, options);
+    project.getSfProjectJson().addPackageBundle(bundleEntry);
+    project.getSfProjectJson().addPackageBundleAlias(bundleEntry.name, createResult.id);
+    await project.getSfProjectJson().write();
+    return { Id: createResult.id };
+}
+//# sourceMappingURL=packageBundleCreate.js.map

package/lib/package/packageBundleInstall.d.ts

@@ -0,0 +1,9 @@
+import { Connection, SfProject } from '@salesforce/core';
+import { BundleSObjects, BundleInstallOptions } from '../interfaces';
+export declare class PackageBundleInstall {
+    static getInstallStatus(installRequestId: string, connection: Connection): Promise<BundleSObjects.PkgBundleVersionInstallReqResult>;
+    static getInstallStatuses(connection: Connection, status?: BundleSObjects.PkgBundleVersionInstallReqStatus, createdLastDays?: number): Promise<BundleSObjects.PkgBundleVersionInstallReqResult[]>;
+    static installBundle(connection: Connection, project: SfProject, options: BundleInstallOptions): Promise<BundleSObjects.PkgBundleVersionInstallReqResult>;
+    private static parsePackageBundleVersionId;
+    private static pollInstallStatus;
+}

package/lib/package/packageBundleInstall.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageBundleInstall = void 0;
+/*
+ * Copyright (c) 2025, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+const core_1 = require("@salesforce/core");
+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_install');
+class PackageBundleInstall {
+    static async getInstallStatus(installRequestId, connection) {
+        try {
+            const result = await connection.tooling.sobject('PkgBundleVersionInstallReq').retrieve(installRequestId);
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(messages.getMessage('failedToGetPackageBundleInstallStatus'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+    }
+    static async getInstallStatuses(connection, status, createdLastDays) {
+        let query = 'SELECT Id, InstallStatus, PackageBundleVersionID, DevelopmentOrganization, ValidationError, ' +
+            'CreatedDate, CreatedById ' +
+            'FROM PkgBundleVersionInstallReq';
+        if (status && createdLastDays) {
+            query += ` WHERE InstallStatus = '${status}' AND CreatedDate = LAST_N_DAYS: ${createdLastDays}`;
+        }
+        else if (status) {
+            query += ` WHERE InstallStatus = '${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,
+            InstallStatus: record.InstallStatus,
+            PackageBundleVersionID: record.PackageBundleVersionID ?? '',
+            DevelopmentOrganization: record.DevelopmentOrganization ?? '',
+            ValidationError: record.ValidationError ?? '',
+            CreatedDate: record.CreatedDate ?? '',
+            CreatedById: record.CreatedById ?? '',
+        }));
+    }
+    static async installBundle(connection, project, options) {
+        const packageBundleVersionId = PackageBundleInstall.parsePackageBundleVersionId(options.PackageBundleVersion, project);
+        const request = {
+            PackageBundleVersionID: packageBundleVersionId,
+            DevelopmentOrganization: options.DevelopmentOrganization,
+        };
+        let installResult;
+        try {
+            installResult = await connection.tooling.sobject('PkgBundleVersionInstallReq').create(request);
+        }
+        catch (err) {
+            const error = err instanceof Error
+                ? err
+                : new Error(typeof err === 'string' ? err : messages.getMessage('failedToInstallPackageBundle'));
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(error));
+        }
+        if (!installResult?.success) {
+            throw core_1.SfError.wrap((0, bundleUtils_1.massageErrorMessage)(new Error(messages.getMessage('failedToInstallPackageBundle'))));
+        }
+        if (options.polling) {
+            return PackageBundleInstall.pollInstallStatus(installResult.id, connection, options.polling);
+        }
+        return {
+            Id: installResult.id,
+            PackageBundleVersionID: packageBundleVersionId,
+            DevelopmentOrganization: options.DevelopmentOrganization,
+            InstallStatus: interfaces_1.BundleSObjects.PkgBundleVersionInstallReqStatus.queued,
+            ValidationError: '',
+            CreatedDate: new Date().toISOString(),
+            CreatedById: connection.getUsername() ?? 'unknown',
+        };
+    }
+    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(messages.getMessage('noPackageBundleVersionFoundWithAlias', [packageBundleVersion]));
+        }
+        return packageBundleVersionId;
+    }
+    static async pollInstallStatus(installRequestId, connection, polling) {
+        if (polling.timeout?.milliseconds <= 0) {
+            return PackageBundleInstall.getInstallStatus(installRequestId, connection);
+        }
+        const pollingClient = await core_1.PollingClient.create({
+            poll: async () => {
+                const status = await PackageBundleInstall.getInstallStatus(installRequestId, connection);
+                if (status.InstallStatus === interfaces_1.BundleSObjects.PkgBundleVersionInstallReqStatus.success) {
+                    return { completed: true, payload: status };
+                }
+                return { completed: false, payload: status };
+            },
+            frequency: polling.frequency,
+            timeout: polling.timeout,
+        });
+        try {
+            return await pollingClient.subscribe();
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                throw new Error('Install request timed out');
+            }
+            throw err;
+        }
+    }
+}
+exports.PackageBundleInstall = PackageBundleInstall;
+//# sourceMappingURL=packageBundleInstall.js.map

package/lib/package/packageBundleVersion.d.ts

@@ -0,0 +1,21 @@
+import { Connection } from '@salesforce/core';
+import { SfProject } from '@salesforce/core';
+import { Duration } from '@salesforce/kit';
+import { BundleVersionCreateOptions, BundleSObjects, PackagingSObjects } from '../interfaces';
+export declare class PackageBundleVersion {
+    static create(options: BundleVersionCreateOptions, polling?: {
+        frequency: Duration;
+        timeout: Duration;
+    }): Promise<BundleSObjects.PackageBundleVersionCreateRequestResult>;
+    static pollCreateStatus(createPackageVersionRequestId: string, connection: Connection, project: SfProject, polling: {
+        frequency: Duration;
+        timeout: Duration;
+    }): Promise<BundleSObjects.PackageBundleVersionCreateRequestResult>;
+    static report(connection: Connection, id: string): Promise<BundleSObjects.BundleVersion | null>;
+    static list(connection: Connection): Promise<BundleSObjects.BundleVersion[]>;
+    static getComponentPackages(connection: Connection, id: string): Promise<PackagingSObjects.SubscriberPackageVersion[]>;
+    private static mapRecordToBundleVersion;
+    private static mapPackageBundle;
+    private static mapAncestor;
+    private static mapAncestorPackageBundle;
+}