diff --git a/ProcessMaker/Exception/BundleIntegrityException.php b/ProcessMaker/Exception/BundleIntegrityException.php
new file mode 100644
index 0000000000..f2d8f853cd
--- /dev/null
+++ b/ProcessMaker/Exception/BundleIntegrityException.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace ProcessMaker\Exception;
+
+use Illuminate\Http\JsonResponse;
+use Illuminate\Support\Collection;
+use ProcessMaker\Models\Bundle;
+use ProcessMaker\Models\BundleAsset;
+use RuntimeException;
+
+class BundleIntegrityException extends RuntimeException
+{
+    private array $invalidAssets;
+
+    public function __construct(Bundle $bundle, Collection $invalidAssets)
+    {
+        $this->invalidAssets = $invalidAssets
+            ->map(fn (BundleAsset $asset) => $asset->integrityDetails())
+            ->values()
+            ->all();
+
+        parent::__construct(__(
+            'The bundle :bundle contains unavailable assets and cannot be exported.',
+            ['bundle' => $bundle->name]
+        ));
+    }
+
+    public function invalidAssets(): array
+    {
+        return $this->invalidAssets;
+    }
+
+    public function render(): JsonResponse
+    {
+        return response()->json([
+            'error' => [
+                'code' => 422,
+                'message' => $this->getMessage(),
+            ],
+            'errors' => [
+                'assets' => $this->invalidAssets,
+            ],
+        ], 422);
+    }
+}
diff --git a/ProcessMaker/Exception/DevLinkRemoteBundleException.php b/ProcessMaker/Exception/DevLinkRemoteBundleException.php
new file mode 100644
index 0000000000..3d97f0c31c
--- /dev/null
+++ b/ProcessMaker/Exception/DevLinkRemoteBundleException.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace ProcessMaker\Exception;
+
+use RuntimeException;
+use Throwable;
+
+class DevLinkRemoteBundleException extends RuntimeException
+{
+    public function __construct(array $invalidAssets, ?Throwable $previous = null)
+    {
+        $assets = collect($invalidAssets)->map(function (array $asset) {
+            $type = class_basename($asset['asset_type'] ?? 'Asset');
+            $id = $asset['asset_id'] ?? '?';
+            $bundleAssetId = $asset['bundle_asset_id'] ?? '?';
+
+            return "$type #$id (bundle asset #$bundleAssetId)";
+        })->implode(', ');
+
+        parent::__construct(__(
+            'The remote bundle contains unavailable assets: :assets. Repair the bundle on the source instance and try again.',
+            ['assets' => $assets]
+        ), 0, $previous);
+    }
+}
diff --git a/ProcessMaker/Http/Controllers/Api/DevLinkController.php b/ProcessMaker/Http/Controllers/Api/DevLinkController.php
index 29825f4d38..988cc3f4ac 100644
--- a/ProcessMaker/Http/Controllers/Api/DevLinkController.php
+++ b/ProcessMaker/Http/Controllers/Api/DevLinkController.php
@@ -424,6 +424,15 @@ private function normalizeUrl(string $url): string
 
     public function deleteBundleAsset(BundleAsset $bundleAsset)
     {
+        if (
+            !$bundleAsset->bundle->editable()
+            && $bundleAsset->integrity_status === BundleAsset::INTEGRITY_VALID
+        ) {
+            throw ValidationException::withMessages([
+                '*' => __('Only unavailable assets can be removed from an installed bundle.'),
+            ]);
+        }
+
         $bundleAsset->delete();
 
         return response()->json(['message' => 'Bundle asset association deleted.'], 200);
diff --git a/ProcessMaker/Jobs/DevLinkInstall.php b/ProcessMaker/Jobs/DevLinkInstall.php
index c30519e201..15d30ead53 100644
--- a/ProcessMaker/Jobs/DevLinkInstall.php
+++ b/ProcessMaker/Jobs/DevLinkInstall.php
@@ -9,6 +9,8 @@
 use Illuminate\Queue\SerializesModels;
 use Illuminate\Support\Facades\Cache;
 use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+use ProcessMaker\Exception\DevLinkRemoteBundleException;
 use ProcessMaker\ImportExport\Logger;
 use ProcessMaker\Jobs\ImportV2;
 use ProcessMaker\Models\Bundle;
@@ -49,7 +51,7 @@ public function __construct(
     public function handle(): void
     {
         //log
-        \Log::info('DevLinkInstall job started: ' . $this->devLinkId);
+        Log::info('DevLinkInstall job started: ' . $this->devLinkId);
         $devLink = DevLink::findOrFail($this->devLinkId);
         $logger = new Logger($this->userId);
 
@@ -82,7 +84,13 @@ public function handle(): void
 
     public function failed(Throwable $exception): void
     {
-        (new Logger($this->userId))->exception($exception);
+        $logger = new Logger($this->userId);
+        if ($exception instanceof DevLinkRemoteBundleException) {
+            Log::error($exception->getMessage(), ['exception' => $exception]);
+            $logger->error($exception->getMessage());
+        } else {
+            $logger->exception($exception);
+        }
 
         // Unlock the job
         // We can't use $this->lock->release() here because this is run in a new instance
diff --git a/ProcessMaker/Models/Bundle.php b/ProcessMaker/Models/Bundle.php
index 98f6328ab5..3971c973a3 100644
--- a/ProcessMaker/Models/Bundle.php
+++ b/ProcessMaker/Models/Bundle.php
@@ -4,6 +4,7 @@
 
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Support\Facades\Http;
+use ProcessMaker\Exception\BundleIntegrityException;
 use ProcessMaker\Exception\ExporterNotSupported;
 use ProcessMaker\Exception\ValidationException;
 use ProcessMaker\ImportExport\Importer;
@@ -78,6 +79,8 @@ public function getAssetCountAttribute()
 
     public function export()
     {
+        $this->assertIntegrity();
+
         $exports = [];
 
         foreach ($this->assets as $bundleAsset) {
@@ -93,6 +96,21 @@ public function export()
         return $exports;
     }
 
+    public function invalidAssets()
+    {
+        return $this->assets->filter(
+            fn (BundleAsset $asset) => $asset->integrity_status !== BundleAsset::INTEGRITY_VALID
+        );
+    }
+
+    public function assertIntegrity(): void
+    {
+        $invalidAssets = $this->invalidAssets();
+        if ($invalidAssets->isNotEmpty()) {
+            throw new BundleIntegrityException($this, $invalidAssets);
+        }
+    }
+
     public function exportSettings()
     {
         $exports = [];
diff --git a/ProcessMaker/Models/BundleAsset.php b/ProcessMaker/Models/BundleAsset.php
index d0af2d536b..979e0f4003 100644
--- a/ProcessMaker/Models/BundleAsset.php
+++ b/ProcessMaker/Models/BundleAsset.php
@@ -3,15 +3,22 @@
 namespace ProcessMaker\Models;
 
 use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Support\Str;
 use ProcessMaker\Enums\ExporterMap;
 
 class BundleAsset extends ProcessMakerModel
 {
     use HasFactory;
 
+    public const INTEGRITY_VALID = 'valid';
+
+    public const INTEGRITY_MISSING = 'missing';
+
+    public const INTEGRITY_TYPE_UNAVAILABLE = 'type_unavailable';
+
     protected $guarded = ['id'];
 
-    protected $appends = ['name', 'url', 'type', 'owner_name', 'categories'];
+    protected $appends = ['name', 'url', 'type', 'owner_name', 'categories', 'integrity_status'];
 
     const DATA_SOURCE_CLASS = 'ProcessMaker\Packages\Connectors\DataSources\Models\DataSource';
 
@@ -23,9 +30,11 @@ class BundleAsset extends ProcessMakerModel
 
     const PM_BLOCK_CLASS = 'ProcessMaker\Package\PackagePmBlocks\Models\PmBlock';
 
-    public static function canExport(ProcessMakerModel $asset)
+    public static function canExport(?ProcessMakerModel $asset)
     {
-        return method_exists($asset, 'export') && ExporterMap::getExporterClassForModel($asset);
+        return $asset !== null
+            && method_exists($asset, 'export')
+            && ExporterMap::getExporterClassForModel($asset);
     }
 
     public function bundle()
@@ -50,18 +59,30 @@ public static function makeKey(ProcessMakerModel $asset)
 
     public function getNameAttribute()
     {
+        $asset = $this->resolvedAsset();
+        if ($asset === null) {
+            return __('Missing :type #:id', [
+                'type' => $this->typeLabel(),
+                'id' => $this->asset_id,
+            ]);
+        }
+
         if (
             $this->asset_type === Screen::class ||
             $this->asset_type === Script::class
         ) {
-            return $this->asset->title;
+            return $asset->title;
         }
 
-        return $this->asset->name;
+        return $asset->name;
     }
 
     public function getUrlAttribute()
     {
+        if ($this->integrity_status !== self::INTEGRITY_VALID) {
+            return null;
+        }
+
         switch($this->asset_type) {
             case Screen::class:
                 return "/designer/screen-builder/{$this->asset_id}/edit";
@@ -110,8 +131,9 @@ public function getTypeAttribute()
 
     public function getOwnerNameAttribute()
     {
-        if ($this->asset && method_exists($this->asset, 'user') && $this->asset->user) {
-            return $this->asset->user->firstname . ' ' . $this->asset->user->lastname;
+        $asset = $this->resolvedAsset();
+        if ($asset && method_exists($asset, 'user') && $asset->user) {
+            return $asset->user->firstname . ' ' . $asset->user->lastname;
         }
 
         return null;
@@ -123,10 +145,48 @@ public function getCategoriesAttribute()
             return [];
         }
 
-        if ($this->asset && method_exists($this->asset, 'categories')) {
-            return $this->asset->categories->pluck('name')->toArray();
+        $asset = $this->resolvedAsset();
+        if ($asset && method_exists($asset, 'categories')) {
+            return $asset->categories->pluck('name')->toArray();
         }
 
         return [];
     }
+
+    public function getIntegrityStatusAttribute(): string
+    {
+        if (!class_exists($this->asset_type)) {
+            return self::INTEGRITY_TYPE_UNAVAILABLE;
+        }
+
+        return $this->resolvedAsset() === null
+            ? self::INTEGRITY_MISSING
+            : self::INTEGRITY_VALID;
+    }
+
+    public function integrityDetails(): array
+    {
+        return [
+            'bundle_asset_id' => $this->id,
+            'asset_type' => $this->asset_type,
+            'asset_id' => $this->asset_id,
+            'integrity_status' => $this->integrity_status,
+        ];
+    }
+
+    private function resolvedAsset(): ?ProcessMakerModel
+    {
+        if (!class_exists($this->asset_type)) {
+            return null;
+        }
+
+        return $this->asset;
+    }
+
+    private function typeLabel(): string
+    {
+        $type = $this->type ?? class_basename($this->asset_type);
+
+        return Str::headline($type);
+    }
 }
diff --git a/ProcessMaker/Models/DevLink.php b/ProcessMaker/Models/DevLink.php
index e7ad53939d..7637d24253 100644
--- a/ProcessMaker/Models/DevLink.php
+++ b/ProcessMaker/Models/DevLink.php
@@ -3,8 +3,10 @@
 namespace ProcessMaker\Models;
 
 use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Http\Client\RequestException;
 use Illuminate\Support\Facades\Http;
 use Illuminate\Support\Str;
+use ProcessMaker\Exception\DevLinkRemoteBundleException;
 use ProcessMaker\ImportExport\Importer;
 use ProcessMaker\ImportExport\Logger;
 use ProcessMaker\ImportExport\Options;
@@ -143,19 +145,28 @@ public function installRemoteBundle($remoteBundleId, $updateType)
 
         $this->logger->status(__('Downloading bundle from remote instance'));
 
-        $bundleInfo = $this->remoteBundle($remoteBundleId)->json();
+        try {
+            $bundleInfo = $this->remoteBundle($remoteBundleId)->json();
 
-        $bundleExport = $this->client()->get(
-            route('api.devlink.export-local-bundle', ['bundle' => $remoteBundleId], false)
-        )->json();
+            $bundleExport = $this->client()->get(
+                route('api.devlink.export-local-bundle', ['bundle' => $remoteBundleId], false)
+            )->json();
 
-        $bundleSettingsExport = $this->client()->get(
-            route('api.devlink.export-local-bundle-settings', ['bundle' => $remoteBundleId], false)
-        )->json();
+            $bundleSettingsExport = $this->client()->get(
+                route('api.devlink.export-local-bundle-settings', ['bundle' => $remoteBundleId], false)
+            )->json();
 
-        $bundleSettingsPayloads = $this->client()->get(
-            route('api.devlink.export-local-bundle-setting-payloads', ['bundle' => $remoteBundleId], false)
-        )->json();
+            $bundleSettingsPayloads = $this->client()->get(
+                route('api.devlink.export-local-bundle-setting-payloads', ['bundle' => $remoteBundleId], false)
+            )->json();
+        } catch (RequestException $exception) {
+            $invalidAssets = $exception->response->json('errors.assets');
+            if (is_array($invalidAssets) && $invalidAssets !== []) {
+                throw new DevLinkRemoteBundleException($invalidAssets, $exception);
+            }
+
+            throw $exception;
+        }
 
         $bundle = Bundle::updateOrCreate(
             [
diff --git a/resources/js/admin/devlink/components/BundleAssetListing.vue b/resources/js/admin/devlink/components/BundleAssetListing.vue
index 0fc95db08d..dafd4bfe71 100644
--- a/resources/js/admin/devlink/components/BundleAssetListing.vue
+++ b/resources/js/admin/devlink/components/BundleAssetListing.vue
@@ -18,15 +18,21 @@ const loadAssets = async () => {
   loading.value = true;
   const response = await window.ProcessMaker.apiClient.get(`/api/1.0/devlink/local-bundles/${bundleId}`);
   bundle.value = response.data;
-  items.value = response.data.assets.filter(asset => asset.type.toUpperCase() === route.params.type.toUpperCase());
+  items.value = response.data.assets.filter(
+    (asset) => asset.type && asset.type.toUpperCase() === route.params.type.toUpperCase(),
+  );
   loading.value = false;
 };
 
 const remove = async (asset) => {
-  const confirm = await vue.$bvModal.msgBoxConfirm(vue.$t('Are you sure you want to remote this asset from the bundle?'), {
-    okTitle: vue.$t('Ok'),
-    cancelTitle: vue.$t('Cancel'),
-  });
+  const confirm = await vue.$bvModal.msgBoxConfirm(
+    vue.$t('Remove this association from the bundle? The underlying asset will not be deleted.'),
+    {
+      okTitle: vue.$t('Remove from bundle'),
+      okVariant: 'danger',
+      cancelTitle: vue.$t('Cancel'),
+    },
+  );
   if (!confirm) {
     return;
   }
@@ -108,12 +114,23 @@ const fields = [
             class="asset-listing-table"
           >
             <template #cell(name)="data">
-              <a :href="data.item.url">{{ data.item.name }}</a>
+              <a
+                v-if="data.item.integrity_status === 'valid'"
+                :href="data.item.url"
+              >
+                {{ data.item.name }}
+              </a>
+              <span v-else>
+                {{ data.item.name }}
+                <b-badge variant="warning">
+                  {{ $t('Unavailable') }}
+                </b-badge>
+              </span>
             </template>
             <template #cell(menu)="data">
               <div class="btn-menu-container">
                 <button
-                  v-if="bundle.remote_id === null"
+                  v-if="bundle.remote_id === null || data.item.integrity_status !== 'valid'"
                   class="btn install-asset-btn"
                   @click.prevent="remove(data.item)"
                 >
diff --git a/resources/js/admin/devlink/components/BundleAssets.vue b/resources/js/admin/devlink/components/BundleAssets.vue
index b0d4e28bc7..d3a975aedc 100644
--- a/resources/js/admin/devlink/components/BundleAssets.vue
+++ b/resources/js/admin/devlink/components/BundleAssets.vue
@@ -34,17 +34,19 @@ const props = defineProps({
 
 defineEmits(['view']);
 
-const getAssetCount = (type) => {
-  return props.assets?.filter(asset => asset.type.toUpperCase() === type.toUpperCase()).length;
-};
+const getAssetCount = (type) => props.assets?.filter(
+  (asset) => asset.type && asset.type.toUpperCase() === type.toUpperCase(),
+).length;
 
 const navigate = (type) => {
-  router.push({ 
-    name: 'bundle-asset-listing', 
+  router.push({
+    name: 'bundle-asset-listing',
     params: { type: type.type },
-    state: { assets: props.assets.filter(asset => 
-      asset.type.toUpperCase() === type.type.toUpperCase()
-    )}
+    state: {
+      assets: props.assets.filter(
+        (asset) => asset.type && asset.type.toUpperCase() === type.type.toUpperCase(),
+      ),
+    },
   });
 };
 </script>
diff --git a/resources/js/admin/devlink/components/BundleDetail.vue b/resources/js/admin/devlink/components/BundleDetail.vue
index fe2f7d822d..0baae8fd67 100644
--- a/resources/js/admin/devlink/components/BundleDetail.vue
+++ b/resources/js/admin/devlink/components/BundleDetail.vue
@@ -38,7 +38,7 @@
         <button
           v-if="bundle.dev_link_id !== null"
           class="btn btn-outline-secondary mr-2 dropdown-toggle"
-          :disabled="remoteAvailable !== true"
+          :disabled="remoteAvailable !== true || invalidAssets.length > 0"
           data-toggle="dropdown"
           data-offset="5, 5"
           aria-haspopup="true"
@@ -82,6 +82,7 @@
           v-if="bundle.dev_link_id === null"
           variant="primary"
           class="btn-publish"
+          :disabled="invalidAssets.length > 0"
           @click="publishBundle"
         >
           {{ $t('Publish') }}
@@ -89,6 +90,34 @@
       </div>
     </div>
 
+    <b-alert
+      v-if="invalidAssets.length > 0"
+      show
+      variant="warning"
+      class="integrity-alert"
+    >
+      <strong>{{ $t('This bundle contains unavailable assets and cannot be exported.') }}</strong>
+      <p class="mb-2">
+        {{ $t('Remove the unavailable associations from the bundle before trying again. The underlying assets will not be deleted.') }}
+      </p>
+      <ul class="mb-0 pl-3">
+        <li
+          v-for="asset in invalidAssets"
+          :key="asset.id"
+          class="integrity-asset"
+        >
+          <span>{{ asset.name }}</span>
+          <b-button
+            size="sm"
+            variant="outline-danger"
+            @click.prevent="removeInvalidAsset(asset)"
+          >
+            {{ $t('Remove from bundle') }}
+          </b-button>
+        </li>
+      </ul>
+    </b-alert>
+
     <!-- Description -->
     <div class="description-section">
       <div class="description-section-title">
@@ -218,6 +247,29 @@ const confirmPublishNewVersionText = computed(() => vue.$t(
   { bundleName: bundle.value?.name },
 ));
 
+const invalidAssets = computed(
+  () => bundle.value?.assets?.filter((asset) => asset.integrity_status !== "valid") || [],
+);
+
+const removeInvalidAsset = async (asset) => {
+  const confirm = await vue.$bvModal.msgBoxConfirm(
+    vue.$t("Remove this unavailable association from the bundle? The underlying asset will not be deleted."),
+    {
+      okTitle: vue.$t("Remove from bundle"),
+      okVariant: "danger",
+      cancelTitle: vue.$t("Cancel"),
+    },
+  );
+  if (!confirm) {
+    return;
+  }
+
+  await window.ProcessMaker.apiClient.delete(
+    `/api/1.0/devlink/local-bundles/assets/${asset.id}`,
+  );
+  await loadAssets();
+};
+
 const publishBundle = () => {
   selected.value = bundle.value;
   confirmPublishNewVersion.value.show();
@@ -277,6 +329,15 @@ width: 100%;
 .btn-publish {
   width: 104px;
 }
+.integrity-alert {
+  margin: 16px 24px;
+}
+.integrity-asset {
+  align-items: center;
+  display: flex;
+  justify-content: space-between;
+  margin-top: 8px;
+}
 .icon-button {
   background-color: #E9ECF1;
   width: 40px;
diff --git a/tests/Feature/Api/DevLinkTest.php b/tests/Feature/Api/DevLinkTest.php
index f0a0af7b0e..2d9c244d92 100644
--- a/tests/Feature/Api/DevLinkTest.php
+++ b/tests/Feature/Api/DevLinkTest.php
@@ -8,7 +8,9 @@
 use PHPUnit\Framework\Attributes\DataProvider;
 use ProcessMaker\Http\Controllers\Api\DevLinkController;
 use ProcessMaker\Models\Bundle;
+use ProcessMaker\Models\BundleAsset;
 use ProcessMaker\Models\DevLink;
+use ProcessMaker\Models\Process;
 use ProcessMaker\Models\Screen;
 use ProcessMaker\Package\PackageDynamicUI\Models\Dashboard;
 use ProcessMaker\Package\PackageDynamicUI\Models\Menu;
@@ -257,6 +259,82 @@ public function testShowBundle()
         $this->assertEquals($bundle->id, $response->json()['id']);
     }
 
+    public function testShowBundleReportsUnavailableAssetsWithoutFailing()
+    {
+        $bundle = Bundle::factory()->create();
+        $missingProcessId = Process::max('id') + 1000;
+        $bundleAsset = BundleAsset::factory()->create([
+            'bundle_id' => $bundle->id,
+            'asset_type' => Process::class,
+            'asset_id' => $missingProcessId,
+        ]);
+
+        $response = $this->apiCall('GET', route('api.devlink.local-bundle', ['bundle' => $bundle->id]));
+
+        $response->assertOk()
+            ->assertJsonPath('assets.0.id', $bundleAsset->id)
+            ->assertJsonPath('assets.0.name', "Missing Process #$missingProcessId")
+            ->assertJsonPath('assets.0.url', null)
+            ->assertJsonPath('assets.0.integrity_status', BundleAsset::INTEGRITY_MISSING);
+    }
+
+    public function testExportBundleRejectsUnavailableAssets()
+    {
+        $bundle = Bundle::factory()->create(['name' => 'Corrupt Bundle']);
+        $missingProcessId = Process::max('id') + 1000;
+        $bundleAsset = BundleAsset::factory()->create([
+            'bundle_id' => $bundle->id,
+            'asset_type' => Process::class,
+            'asset_id' => $missingProcessId,
+        ]);
+
+        $response = $this->apiCall('GET', route('api.devlink.export-local-bundle', [
+            'bundle' => $bundle->id,
+        ]));
+
+        $response->assertStatus(422)
+            ->assertJsonPath('error.code', 422)
+            ->assertJsonPath(
+                'error.message',
+                'The bundle Corrupt Bundle contains unavailable assets and cannot be exported.'
+            )
+            ->assertJsonPath('errors.assets.0.bundle_asset_id', $bundleAsset->id)
+            ->assertJsonPath('errors.assets.0.asset_type', Process::class)
+            ->assertJsonPath('errors.assets.0.asset_id', $missingProcessId)
+            ->assertJsonPath('errors.assets.0.integrity_status', BundleAsset::INTEGRITY_MISSING);
+    }
+
+    public function testInstalledBundleAllowsRemovingOnlyUnavailableAssets()
+    {
+        $devLink = DevLink::factory()->create();
+        $bundle = Bundle::factory()->create([
+            'dev_link_id' => $devLink->id,
+            'remote_id' => 123,
+        ]);
+        $screen = Screen::factory()->create();
+        $validBundleAsset = BundleAsset::factory()->create([
+            'bundle_id' => $bundle->id,
+            'asset_type' => Screen::class,
+            'asset_id' => $screen->id,
+        ]);
+        $missingProcessId = Process::max('id') + 1000;
+        $invalidBundleAsset = BundleAsset::factory()->create([
+            'bundle_id' => $bundle->id,
+            'asset_type' => Process::class,
+            'asset_id' => $missingProcessId,
+        ]);
+
+        $this->apiCall('DELETE', route('api.devlink.delete-bundle-asset', [
+            'bundle_asset' => $validBundleAsset->id,
+        ]))->assertStatus(422);
+        $this->assertDatabaseHas('bundle_assets', ['id' => $validBundleAsset->id]);
+
+        $this->apiCall('DELETE', route('api.devlink.delete-bundle-asset', [
+            'bundle_asset' => $invalidBundleAsset->id,
+        ]))->assertOk();
+        $this->assertDatabaseMissing('bundle_assets', ['id' => $invalidBundleAsset->id]);
+    }
+
     public function testGetBundleAllSettingsReturnsDashboardAndMenuOptions()
     {
         if (!hasPackage('package-dynamic-ui')) {
diff --git a/tests/Model/BundleAssetTest.php b/tests/Model/BundleAssetTest.php
index 88aa6b0184..42179b1042 100644
--- a/tests/Model/BundleAssetTest.php
+++ b/tests/Model/BundleAssetTest.php
@@ -6,6 +6,7 @@
 use ProcessMaker\Models\Bundle;
 use ProcessMaker\Models\BundleAsset;
 use ProcessMaker\Models\Group;
+use ProcessMaker\Models\Process;
 use ProcessMaker\Models\Screen;
 use Tests\TestCase;
 
@@ -16,6 +17,7 @@ public function testCanExport()
         $screen = Screen::factory()->create();
 
         $this->assertTrue(BundleAsset::canExport($screen));
+        $this->assertFalse(BundleAsset::canExport(null));
     }
 
     public function testExporterNotSupported()
@@ -26,4 +28,55 @@ public function testExporterNotSupported()
         $this->expectException(ExporterNotSupported::class);
         $bundle->addAsset($group);
     }
+
+    public function testMissingAssetCanBeSerialized()
+    {
+        $bundle = Bundle::factory()->create();
+        $missingProcessId = Process::max('id') + 1000;
+        $bundleAsset = BundleAsset::factory()->create([
+            'bundle_id' => $bundle->id,
+            'asset_type' => Process::class,
+            'asset_id' => $missingProcessId,
+        ]);
+
+        $serialized = $bundleAsset->toArray();
+
+        $this->assertSame(BundleAsset::INTEGRITY_MISSING, $serialized['integrity_status']);
+        $this->assertSame("Missing Process #$missingProcessId", $serialized['name']);
+        $this->assertNull($serialized['url']);
+        $this->assertNull($serialized['owner_name']);
+        $this->assertSame([], $serialized['categories']);
+    }
+
+    public function testUnavailableAssetTypeCanBeSerialized()
+    {
+        $bundleAsset = BundleAsset::factory()->create([
+            'asset_type' => 'ProcessMaker\Missing\Asset',
+            'asset_id' => 1234,
+        ]);
+
+        $serialized = $bundleAsset->toArray();
+
+        $this->assertSame(BundleAsset::INTEGRITY_TYPE_UNAVAILABLE, $serialized['integrity_status']);
+        $this->assertSame('Missing Asset #1234', $serialized['name']);
+        $this->assertNull($serialized['url']);
+    }
+
+    public function testDeletingAnAssetLeavesItsBundleAssociationForManualRepair()
+    {
+        $process = Process::factory()->create();
+        $bundleAsset = BundleAsset::factory()->create([
+            'asset_type' => Process::class,
+            'asset_id' => $process->id,
+        ]);
+
+        $process->delete();
+
+        $this->assertTrue($process->trashed());
+        $this->assertDatabaseHas('bundle_assets', ['id' => $bundleAsset->id]);
+        $this->assertSame(
+            BundleAsset::INTEGRITY_MISSING,
+            $bundleAsset->refresh()->integrity_status
+        );
+    }
 }
diff --git a/tests/Model/BundleTest.php b/tests/Model/BundleTest.php
index d0bee366ee..aa85265b30 100644
--- a/tests/Model/BundleTest.php
+++ b/tests/Model/BundleTest.php
@@ -3,6 +3,7 @@
 namespace Tests\Model;
 
 use Illuminate\Support\Facades\Storage;
+use ProcessMaker\Exception\BundleIntegrityException;
 use ProcessMaker\ImportExport\Exporters\ScreenExporter;
 use ProcessMaker\ImportExport\Logger;
 use ProcessMaker\Models\Bundle;
@@ -17,6 +18,10 @@ class BundleTest extends TestCase
 {
     use HelperTrait;
 
+    private const ALPHA_DASHBOARD_NAME = 'Alpha Dashboard';
+
+    private const ALPHA_MENU_NAME = 'Alpha Menu';
+
     public function testExport()
     {
         $this->addGlobalSignalProcess();
@@ -44,6 +49,52 @@ public function testExport()
         $this->assertEquals($screen->title, $payload[1]['name']);
     }
 
+    public function testExportRejectsBundleWithUnavailableAssetsBeforeExporting()
+    {
+        $bundle = Bundle::factory()->create(['name' => 'Corrupt Bundle']);
+        $screen = Screen::factory()->create();
+        $missingProcessId = Process::max('id') + 1000;
+        BundleAsset::factory()->create([
+            'bundle_id' => $bundle->id,
+            'asset_type' => Screen::class,
+            'asset_id' => $screen->id,
+        ]);
+        $missingBundleAsset = BundleAsset::factory()->create([
+            'bundle_id' => $bundle->id,
+            'asset_type' => Process::class,
+            'asset_id' => $missingProcessId,
+        ]);
+        $unavailableBundleAsset = BundleAsset::factory()->create([
+            'bundle_id' => $bundle->id,
+            'asset_type' => 'ProcessMaker\Missing\Asset',
+            'asset_id' => 1234,
+        ]);
+
+        try {
+            $bundle->export();
+            $this->fail('Expected bundle integrity validation to fail.');
+        } catch (BundleIntegrityException $exception) {
+            $this->assertSame(
+                'The bundle Corrupt Bundle contains unavailable assets and cannot be exported.',
+                $exception->getMessage()
+            );
+            $this->assertSame([
+                [
+                    'bundle_asset_id' => $missingBundleAsset->id,
+                    'asset_type' => Process::class,
+                    'asset_id' => $missingProcessId,
+                    'integrity_status' => BundleAsset::INTEGRITY_MISSING,
+                ],
+                [
+                    'bundle_asset_id' => $unavailableBundleAsset->id,
+                    'asset_type' => 'ProcessMaker\Missing\Asset',
+                    'asset_id' => 1234,
+                    'integrity_status' => BundleAsset::INTEGRITY_TYPE_UNAVAILABLE,
+                ],
+            ], $exception->invalidAssets());
+        }
+    }
+
     public function testSyncAssets()
     {
         $screen1 = Screen::factory()->create(['title' => 'Screen 1']);
@@ -166,8 +217,8 @@ public function testSettingPreviewUsesInstalledPayloadMetadata()
         $bundle->savePayloadsToFile([], [[
             self::settingPayload('dashboard_package', 'dashboard-zulu', 'Zulu Dashboard'),
             self::settingPayload('menu_package', 'menu-bravo', 'Bravo Menu'),
-            self::settingPayload('dashboard_package', 'dashboard-alpha', 'Alpha Dashboard'),
-            self::settingPayload('menu_package', 'menu-alpha', 'Alpha Menu'),
+            self::settingPayload('dashboard_package', 'dashboard-alpha', self::ALPHA_DASHBOARD_NAME),
+            self::settingPayload('menu_package', 'menu-alpha', self::ALPHA_MENU_NAME),
         ]]);
 
         $this->assertTrue($bundle->newestVersionFile()->getCustomProperty('settings_payloads_complete'));
@@ -177,7 +228,7 @@ public function testSettingPreviewUsesInstalledPayloadMetadata()
             'selection' => 'partial',
             'available' => true,
             'items' => [
-                ['key' => 'dashboard-alpha', 'name' => 'Alpha Dashboard'],
+                ['key' => 'dashboard-alpha', 'name' => self::ALPHA_DASHBOARD_NAME],
                 ['key' => 'dashboard-zulu', 'name' => 'Zulu Dashboard'],
             ],
         ], $bundle->settingPreview('ui_dashboards'));
@@ -187,7 +238,7 @@ public function testSettingPreviewUsesInstalledPayloadMetadata()
             'selection' => 'all',
             'available' => true,
             'items' => [
-                ['key' => 'menu-alpha', 'name' => 'Alpha Menu'],
+                ['key' => 'menu-alpha', 'name' => self::ALPHA_MENU_NAME],
                 ['key' => 'menu-bravo', 'name' => 'Bravo Menu'],
             ],
         ], $bundle->settingPreview('ui_menus'));
@@ -213,8 +264,8 @@ public function testSettingPreviewIsUnavailableForUnmarkedLegacySnapshot()
         $bundle->addSettings('ui_dashboards', null);
         $bundle->addSettings('ui_menus', json_encode(['id' => [9001]]));
         $bundle->addMediaFromString(gzencode(json_encode([
-            self::settingPayload('dashboard_package', 'dashboard-alpha', 'Alpha Dashboard'),
-            self::settingPayload('menu_package', 'menu-alpha', 'Alpha Menu'),
+            self::settingPayload('dashboard_package', 'dashboard-alpha', self::ALPHA_DASHBOARD_NAME),
+            self::settingPayload('menu_package', 'menu-alpha', self::ALPHA_MENU_NAME),
         ])))
             ->usingFileName('payloads.json.gz')
             ->withCustomProperties(['version' => $bundle->version])
diff --git a/tests/Model/DevLinkTest.php b/tests/Model/DevLinkTest.php
index dc6ca7e332..f0efaf12d3 100644
--- a/tests/Model/DevLinkTest.php
+++ b/tests/Model/DevLinkTest.php
@@ -4,6 +4,7 @@
 
 use Illuminate\Support\Facades\Http;
 use Illuminate\Support\Facades\Storage;
+use ProcessMaker\Exception\DevLinkRemoteBundleException;
 use ProcessMaker\Models\Bundle;
 use ProcessMaker\Models\DevLink;
 use ProcessMaker\Models\Screen;
@@ -23,6 +24,10 @@ class DevLinkTest extends TestCase
 
     private const SECOND_MENU_DESCRIPTION = 'Second menu description';
 
+    private const LOCAL_BUNDLE_API_PATH = 'local-bundles/123';
+
+    private const EXPORT_LOCAL_BUNDLE_API_PATH = 'export-local-bundle/123';
+
     public function testGetClientUrl()
     {
         $devLink = DevLink::factory()->create([
@@ -86,8 +91,8 @@ public function testInstallRemoteBundle()
         $bundle->delete();
 
         Http::fake([
-            self::remoteApiUrl('local-bundles/123') => Http::response(self::remoteBundleResponse('5')),
-            self::remoteApiUrl('export-local-bundle/123') => Http::response([
+            self::remoteApiUrl(self::LOCAL_BUNDLE_API_PATH) => Http::response(self::remoteBundleResponse('5')),
+            self::remoteApiUrl(self::EXPORT_LOCAL_BUNDLE_API_PATH) => Http::response([
                 'payloads' => $exports,
             ]),
             self::remoteApiUrl('export-local-bundle/123/settings') => Http::response([
@@ -123,6 +128,40 @@ public function testInstallRemoteBundle()
         $this->assertCount(3, $payloads);
     }
 
+    public function testInstallRemoteBundleReportsUnavailableRemoteAssets()
+    {
+        Http::preventStrayRequests();
+        Http::fake([
+            self::remoteApiUrl(self::LOCAL_BUNDLE_API_PATH) => Http::response(self::remoteBundleResponse('5')),
+            self::remoteApiUrl(self::EXPORT_LOCAL_BUNDLE_API_PATH) => Http::response([
+                'error' => [
+                    'code' => 422,
+                    'message' => 'The bundle contains unavailable assets.',
+                ],
+                'errors' => [
+                    'assets' => [[
+                        'bundle_asset_id' => 34,
+                        'asset_type' => 'ProcessMaker\Plugins\Collections\Models\Collection',
+                        'asset_id' => 20,
+                        'integrity_status' => 'missing',
+                    ]],
+                ],
+            ], 422),
+        ]);
+
+        $devLink = DevLink::factory()->create([
+            'url' => self::REMOTE_INSTANCE_URL,
+        ]);
+
+        $this->expectException(DevLinkRemoteBundleException::class);
+        $this->expectExceptionMessage(
+            'The remote bundle contains unavailable assets: Collection #20 (bundle asset #34). ' .
+            'Repair the bundle on the source instance and try again.'
+        );
+
+        $devLink->installRemoteBundle(123, 'update');
+    }
+
     public function testInstallRemoteBundleImportsAndReinstallsEverySelectedMenu()
     {
         if (!hasPackage('package-dynamic-ui')) {
@@ -310,13 +349,13 @@ public function testUpdateBundle()
         ]);
 
         Http::fake([
-            self::remoteApiUrl('local-bundles/123') => Http::sequence()
+            self::remoteApiUrl(self::LOCAL_BUNDLE_API_PATH) => Http::sequence()
                 ->push(self::remoteBundleResponse('2'), 200)
                 ->push(self::remoteBundleResponse('3'), 200)
                 ->push(self::remoteBundleResponse('4'), 200)
                 ->push(self::remoteBundleResponse('8'), 200)
                 ->push(self::remoteBundleResponse('9'), 200),
-            self::remoteApiUrl('export-local-bundle/123') => Http::sequence()
+            self::remoteApiUrl(self::EXPORT_LOCAL_BUNDLE_API_PATH) => Http::sequence()
                 ->push([
                     'payloads' => $exports,
                 ], 200)