musora-content-services 2.107.8 → 2.110.3

package/src/services/railcontent.js

@@ -11,97 +11,6 @@ import { GET, POST, PUT, DELETE } from '../infrastructure/http/HttpClient.ts'
  */
 const excludeFromGeneratedIndex = ['fetchUserPermissionsData']
 
-/**
- * Fetches the completion status of a specific lesson for the current user.
- *
- * @param {string} content_id - The ID of the lesson content to check.
- * @returns {Promise<Object|null>} - Returns the completion status object if found, otherwise null.
- * @example
- * fetchCurrentSongComplete('user123', 'lesson456', 'csrf-token')
- *   .then(status => console.log(status))
- *   .catch(error => console.error(error));
- */
-export async function fetchCompletedState(content_id) {
-  const url = `/content/user_progress/${globalConfig.sessionConfig.userId}?content_ids[]=${content_id}`
-  const result = await GET(url)
-
-  if (result && result[content_id]) {
-    return result[content_id]
-  }
-  return null
-}
-
-/**
- * Fetches the completion status for multiple songs for the current user.
- *
- * @param {Array<string>} contentIds - An array of content IDs to check.
- * @returns {Promise<Object|null>} - Returns an object containing completion statuses keyed by content ID, or null if an error occurs.
- * @example
- * fetchAllCompletedStates('user123', ['song456', 'song789'], 'csrf-token')
- *   .then(statuses => console.log(statuses))
- *   .catch(error => console.error(error));
- */
-export async function fetchAllCompletedStates(contentIds) {
-  const url = `/content/user_progress/${globalConfig.sessionConfig.userId}?${contentIds.map((id) => `content_ids[]=${id}`).join('&')}`
-  return await GET(url)
-}
-
-/**
- * Fetches a list of songs that are currently in progress for the current user.
- *
- * @param {string} brand - The brand associated with the songs.
- * @returns {Promise<Object|null>} - Returns an object containing in-progress songs if found, otherwise null.
- * @example
- * fetchSongsInProgress('drumeo')
- *   .then(songs => console.log(songs))
- *   .catch(error => console.error(error));
- */
-export async function fetchSongsInProgress(brand) {
-  const url = `/content/in_progress/${globalConfig.sessionConfig.userId}?content_type=song&brand=${brand}`
-  return await GET(url)
-}
-
-/**
- * Fetches a list of content that is currently in progress for the current user.
- *
- * @param {string} type - The content type associated with the content.
- * @param {string} brand - The brand associated with the content.
- * @param {number} [options.limit=20] - The limit of results per page.
- * @param {number} [options.page=1] - The page number for pagination.
- * @returns {Promise<Object|null>} - Returns an object containing in-progress content if found, otherwise null.
- * @example
- * fetchContentInProgress('song', 'drumeo')
- *   .then(songs => console.log(songs))
- *   .catch(error => console.error(error));
- */
-export async function fetchContentInProgress(type = 'all', brand, { page, limit } = {}) {
-  const limitString = limit ? `&limit=${limit}` : ''
-  const pageString = page ? `&page=${page}` : ''
-  const contentTypeParam = type === 'all' ? '' : `content_type=${type}&`
-  const url = `/content/in_progress/${globalConfig.sessionConfig.userId}?${contentTypeParam}brand=${brand}${limitString}${pageString}`
-  return await GET(url)
-}
-
-/**
- * Fetches a list of content that has been completed for the current user.
- *
- * @param {string} type - The content type associated with the content.
- * @param {string} brand - The brand associated with the content.
- * @param {number} [options.limit=20] - The limit of results per page.
- * @param {number} [options.page=1] - The page number for pagination.
- * @returns {Promise<Object|null>} - Returns an object containing in-progress content if found, otherwise null.
- * @example
- * fetchCompletedContent('song', 'drumeo')
- *   .then(songs => console.log(songs))
- *   .catch(error => console.error(error));
- */
-export async function fetchCompletedContent(type = 'all', brand, { page, limit } = {}) {
-  const limitString = limit ? `&limit=${limit}` : ''
-  const pageString = page ? `&page=${page}` : ''
-  const contentTypeParam = type === 'all' ? '' : `content_type=${type}&`
-  const url = `/content/completed/${globalConfig.sessionConfig.userId}?${contentTypeParam}brand=${brand}${limitString}${pageString}`
-  return await GET(url)
-}
 
 /**
  * Fetches user context data for a specific piece of content.
@@ -118,18 +27,6 @@ export async function fetchContentPageUserData(contentId) {
   return await GET(url)
 }
 
-/**
- * Fetches the ID and Type of the piece of content that would be the next one for the user
- *
- * @param {int} contentId - The id of the parent (method, level, or course) piece of content.
- * @returns {Promise<Object|null>} - Returns and Object with the id and type of the next piece of content if found, otherwise null.
- */
-export async function fetchNextContentDataForParent(contentId) {
-  const url = `/content/${contentId}/next/${globalConfig.sessionConfig.userId}`
-  const result = await GET(url)
-  return result?.next ?? null
-}
-
 export async function fetchUserPermissionsData() {
   const url = `/content/user/permissions`
   return (await GET(url)) ?? []
@@ -145,40 +42,6 @@ export async function postPlaylistContentEngaged(playlistItemId) {
   return await POST(url, null)
 }
 
-/**
- * Fetch the user's best award for this challenge
- *
- * @param contentId - railcontent id of the challenge
- * @returns {Promise<any|null>} - streamed PDF
- */
-export async function fetchUserAward(contentId) {
-  const url = `/challenges/download_award/${contentId}`
-  return await GET(url)
-}
-
-/**
- * Fetch All Carousel Card Data
- *
- * @returns {Promise<any|null>}
- */
-export async function fetchCarouselCardData(brand = null) {
-  const brandParam = brand ? `?brand=${brand}` : ''
-  const url = `/api/v2/content/carousel${brandParam}`
-  return await GET(url)
-}
-
-/**
- * Fetch all completed badges for the user ordered by completion date descending
- *
- * @param {string|null} brand -
- * @returns {Promise<any|null>}
- */
-export async function fetchUserBadges(brand = null) {
-  const brandParam = brand ? `?brand=${brand}` : ''
-  const url = `/challenges/user_badges/get${brandParam}`
-  return await GET(url)
-}
-
 /**
  * Set a user's StudentView Flag
  *
@@ -473,32 +336,6 @@ export async function fetchUserPracticeNotes(date) {
   return await GET(url)
 }
 
-/**
- * Get the id and slug of last interacted child. Only valid for certain content types
- *
- * @async
- * @function fetchLastInteractedChild
- * @param {array} content_ids - Content ids of to get the last interacted child of
- *
- *
- * @returns {Promise<Object>} - keyed object per valid content ids with the child
- *
- * @example
- * try {
- *   const response = await fetchLastInteractedChild([191369, 410427]);
- *   console.log('child id', response[191369].content_id)
- *   console.log('child slug', response[191369].slug)
- * } catch (error) {
- *   console.error('Failed to get children', error);
- * }
- */
-export async function fetchLastInteractedChild(content_ids) {
-  const params = new URLSearchParams()
-  content_ids.forEach((id) => params.append('content_ids[]', id))
-  const url = `/api/content/v1/user/last_interacted_child?${params.toString()}`
-  return await GET(url)
-}
-
 /**
  * @typedef {Object} Activity
  * @property {string} id - Unique identifier for the activity.

package/src/services/sanity.js

@@ -17,18 +17,27 @@ import {
   getNewReleasesTypes,
   getUpcomingEventsTypes,
   instructorField,
+  lessonTypesMapping,
+  individualLessonsTypes,
+  coursesLessonTypes,
+  skillLessonTypes,
+  entertainmentLessonTypes,
+  filterTypes,
+  tutorialsLessonTypes,
+  transcriptionsLessonTypes,
+  playAlongLessonTypes,
+  jamTrackLessonTypes,
   resourcesField,
   showsTypes,
   SONG_TYPES,
   SONG_TYPES_WITH_CHILDREN,
 } from '../contentTypeConfig.js'
-import { fetchSimilarItems } from './recommendations.js'
+import { fetchSimilarItems, recommendations } from './recommendations.js'
 import { processMetadata } from '../contentMetaData.js'
 import { GET } from '../infrastructure/http/HttpClient.ts'
 
 import { globalConfig } from './config.js'
 
-import { fetchNextContentDataForParent } from './railcontent.js'
 import { arrayToStringRepresentation, FilterBuilder } from '../filterBuilder.js'
 import { getPermissionsAdapter } from './permissions/index.ts'
 import { getAllCompleted, getAllStarted, getAllStartedOrCompleted } from './contentProgress.js'
@@ -41,6 +50,29 @@ import { fetchRecentActivitiesActiveTabs } from './userActivity.js'
  */
 const excludeFromGeneratedIndex = ['fetchRelatedByLicense']
 
+/**
+ * Song/Lesson tabs that are always visible.
+ *
+ * @type {string[]}
+ */
+const ALWAYS_VISIBLE_TABS = ['For You', 'Explore All'];
+
+/**
+ * Mapping from tab names to their underlying Sanity content types.
+ * Used to determine if a tab has any content available.
+ * @type {Object.<string, string[]>}
+ */
+const TAB_TO_CONTENT_TYPES = {
+  'Single Lessons': individualLessonsTypes,
+  'Courses': coursesLessonTypes,
+  'Skill Packs': skillLessonTypes,
+  'Entertainment': entertainmentLessonTypes,
+  'Tutorials': tutorialsLessonTypes,
+  'Transcriptions': transcriptionsLessonTypes,
+  'Play-Alongs': playAlongLessonTypes,
+  'Jam Tracks': jamTrackLessonTypes,
+};
+
 /**
  * Fetch a song by its document ID from Sanity.
  *
@@ -1597,21 +1629,52 @@ export async function fetchShowsData(brand) {
  *
  * @param {string} brand - The brand for which to fetch metadata.
  * @param {string} type - The type for which to fetch metadata.
+ * @param {Object|boolean} [options={}] - Options object or legacy boolean for withFilters
+ * @param {boolean} [options.skipTabFiltering=false] - Skip dynamic tab filtering (internal use)
  * @returns {Promise<{name, description, type: *, thumbnailUrl}>}
  *
  * @example
+ * // Standard usage (with tab filtering)
+ * fetchMetadata('drumeo', 'lessons')
  *
- * fetchMetadata('drumeo','song')
- *   .then(data => console.log(data))
- *   .catch(error => console.error(error));
+ * @example
+ * // Internal usage (skip tab filtering to prevent recursion)
+ * fetchMetadata('drumeo', 'lessons', { skipTabFiltering: true })
  */
-export async function fetchMetadata(brand, type) {
-  let processedData = processMetadata(brand, type, true)
+export async function fetchMetadata(brand, type, options = {}) {
+  // Handle backward compatibility - type was previously the 3rd param (boolean)
+  const withFilters = typeof options === 'boolean' ? options : true;
+  const skipTabFiltering = options.skipTabFiltering || false;
+  let processedData = processMetadata(brand, type, withFilters)
+
   if (processedData?.onlyAvailableTabs === true) {
     const activeTabs = await fetchRecentActivitiesActiveTabs()
     processedData.tabs = activeTabs
   }
 
+  if ((type === 'lessons' || type === 'songs') && !skipTabFiltering) {
+    try {
+      // Single API call to get all content type counts
+      const contentTypeCounts = await fetchContentTypeCounts(brand, type);
+
+      // Filter tabs based on counts
+      processedData.tabs = filterTabsByContentCounts(
+        processedData.tabs,
+        contentTypeCounts
+      );
+
+      // Filter Type options based on counts
+      if (processedData.filters) {
+        processedData.filters = filterTypeOptionsByContentCounts(
+          processedData.filters,
+          contentTypeCounts
+        );
+      }
+    } catch (error) {
+      console.error('Error fetching content type counts, using all tabs/filters:', error);
+      // Fail open - show all tabs and filters
+    }
+  }
   return processedData ? processedData : {}
 }
 
@@ -2107,3 +2170,191 @@ export async function fetchBrandsByContentIds(contentIds) {
   })
   return brandMap
 }
+
+/**
+ * Get all possible content types for a page type (lessons or songs).
+ * Returns unique array of Sanity content type strings.
+ * Uses the existing filterTypes mapping from contentTypeConfig.
+ *
+ * @param {string} pageName - Page name ('lessons' or 'songs')
+ * @returns {string[]} - Array of content type strings
+ *
+ * @example
+ * getAllContentTypesForPage('lessons')
+ * // Returns: ['lesson', 'quick-tips', 'course', 'guided-course', ...]
+ */
+function getAllContentTypesForPage(pageName) {
+  return filterTypes[pageName] || [];
+}
+
+/**
+ * Fetch counts for all content types on a page (lessons/songs) in a single query.
+ * Uses GROQ aggregation to efficiently get counts for multiple content types.
+ * Only returns types with count > 0.
+ *
+ * @param {string} brand - Brand identifier (e.g., 'drumeo', 'playbass')
+ * @param {string} pageName - Page name ('lessons' or 'songs')
+ * @returns {Promise<Object.<string, number>>} - Object mapping content types to counts
+ *
+ * @example
+ * await fetchContentTypeCounts('playbass', 'lessons')
+ * // Returns: { 'guided-course': 45, 'skill-pack': 12, 'special': 8 }
+ */
+export async function fetchContentTypeCounts(brand, pageName) {
+  const allContentTypes = getAllContentTypesForPage(pageName);
+
+  if (allContentTypes.length === 0) {
+    return {};
+  }
+
+  // Build array of type objects for GROQ query
+  const typesString = allContentTypes
+    .map(type => `{"type": "${type}"}`)
+    .join(', ');
+
+  const query = `{
+    "typeCounts": [${typesString}]{
+      type,
+      'count': count(*[
+        _type == ^.type
+        && brand == "${brand}"
+        && status == "published"
+      ])
+    }[count > 0]
+  }`;
+
+  const results = await fetchSanity(query, true, { processNeedAccess: false });
+
+  // Convert array to object for easier lookup: { 'guided-course': 45, ... }
+  const countsMap = {};
+  if (results.typeCounts) {
+    results.typeCounts.forEach(item => {
+      countsMap[item.type] = item.count;
+    });
+  }
+
+  return countsMap;
+}
+
+/**
+ * Filter tabs based on which content types have content.
+ * Always keeps 'For You' and 'Explore All' tabs.
+ *
+ * @param {Array} tabs - Array of tab objects from metadata
+ * @param {Object.<string, number>} contentTypeCounts - Content type counts
+ * @returns {Array} - Filtered array of tabs with content
+ */
+function filterTabsByContentCounts(tabs, contentTypeCounts) {
+  return tabs.filter(tab => {
+    if (ALWAYS_VISIBLE_TABS.includes(tab.name)) {
+      return true;
+    }
+
+    const tabContentTypes = TAB_TO_CONTENT_TYPES[tab.name] || [];
+
+    if (tabContentTypes.length === 0) {
+      // Unknown tab - show it to be safe
+      console.warn(`Unknown tab "${tab.name}" - showing by default`);
+      return true;
+    }
+
+    // Tab has content if ANY of its content types have count > 0
+    return tabContentTypes.some(type => contentTypeCounts[type] > 0);
+  });
+}
+
+/**
+ * Filter Type filter options based on content type counts.
+ * Removes parent/child options that have no content available.
+ * Returns a new filters array (does not mutate original).
+ *
+ * @param {Array} filters - Filter groups array from metadata
+ * @param {Object.<string, number>} contentTypeCounts - Content type counts
+ * @returns {Array} - Filtered filter groups
+ */
+function filterTypeOptionsByContentCounts(filters, contentTypeCounts) {
+  return filters.map(filter => {
+    // Only process Type filter
+    if (filter.key !== 'type') {
+      return filter;
+    }
+
+    const filteredItems = filter.items.map(item => {
+      // For hierarchical filters (parent with children)
+      if (item.isParent && item.items) {
+        // Filter children based on their content types
+        const availableChildren = item.items.filter(child => {
+          const childTypes = getContentTypesForFilterName(child.name);
+
+          if (!childTypes || childTypes.length === 0) {
+            console.warn(`Unknown filter child "${child.name}" - showing by default`);
+            return true;
+          }
+
+          // Child has content if ANY of its types have count > 0
+          return childTypes.some(type => contentTypeCounts[type] > 0);
+        });
+
+        // Keep parent only if it has available children
+        if (availableChildren.length > 0) {
+          // Return NEW object to avoid mutation
+          return { ...item, items: availableChildren };
+        }
+        return null;
+      }
+
+      // For flat items (no children)
+      const itemTypes = getContentTypesForFilterName(item.name);
+
+      if (!itemTypes || itemTypes.length === 0) {
+        console.warn(`Unknown filter item "${item.name}" - showing by default`);
+        return item;
+      }
+
+      // Item has content if ANY of its types have count > 0
+      const hasContent = itemTypes.some(type => contentTypeCounts[type] > 0);
+      return hasContent ? item : null;
+    }).filter(Boolean); // Remove nulls
+
+    // Return new filter object with filtered items
+    return {
+      ...filter,
+      items: filteredItems
+    };
+  }).filter(filter => {
+    if (filter.key === 'type' && filter.items.length === 0) {
+      return false;
+    }
+    return true;
+  });
+}
+
+/**
+ * Maps a display name to its corresponding content types from lessonTypesMapping.
+ * @param {string} displayName - The display name from filter metadata
+ * @returns {string[]|undefined} - Array of content types or undefined if not found
+ */
+function getContentTypesForFilterName(displayName) {
+  const displayNameToKey = {
+    'Lessons': 'lessons',
+    'Practice Alongs': 'practice alongs',
+    'Live Archives': 'live archives',
+    'Student Archives': 'student archives',
+    'Courses': 'courses',
+    'Guided Courses': 'guided courses',
+    'Tiered Courses': 'tiered courses',
+    'Specials': 'specials',
+    'Documentaries': 'documentaries',
+    'Shows': 'shows',
+    'Skill Packs': 'skill packs',
+    'Tutorials': 'tutorials',
+    'Transcriptions': 'transcriptions',
+    'Sheet Music': 'sheet music',
+    'Tabs': 'tabs',
+    'Play-Alongs': 'play-alongs',
+    'Jam Tracks': 'jam tracks',
+  };
+
+  const mappingKey = displayNameToKey[displayName];
+  return mappingKey ? lessonTypesMapping[mappingKey] : undefined;
+}

package/src/services/sync/adapters/factory.ts

@@ -3,6 +3,8 @@ import schema from '../schema'
 import type SQLiteAdapter from '@nozbe/watermelondb/adapters/sqlite'
 import type LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs'
 
+import { SyncTelemetry } from '../telemetry'
+
 export type DatabaseAdapter = SQLiteAdapter | LokiJSAdapter
 
 type SQLiteAdapterOptions = ConstructorParameters<typeof SQLiteAdapter>[0]
@@ -12,15 +14,13 @@ type DatabaseAdapterOptions = SQLiteAdapterOptions & LokiJSAdapterOptions
 
 export default function syncAdapterFactory<T extends DatabaseAdapter>(
   AdapterClass: new (options: DatabaseAdapterOptions) => T,
-  namespace: string,
+  _namespace: string,
   opts: Omit<DatabaseAdapterOptions, 'schema' | 'migrations'>
 ): () => T {
-  const options = {
+  return () => new AdapterClass({
     ...opts,
-    dbName: `sync:${namespace}`,
+    dbName: `sync`, // don't use user namespace for now
     schema,
     migrations: undefined
-  }
-
-  return () => new AdapterClass(options)
+  })
 }

package/src/services/sync/adapters/lokijs.ts

@@ -1 +1,174 @@
-export { default } from '@nozbe/watermelondb/adapters/lokijs'
+import { SyncTelemetry } from '../telemetry'
+
+import LokiJSAdapter from '@nozbe/watermelondb/adapters/lokijs'
+export { LokiJSAdapter as default }
+
+import { deleteDatabase } from '@nozbe/watermelondb/adapters/lokijs/worker/lokiExtensions'
+
+/**
+ * Mute impending driver errors that are expected after sync adapter failure
+ */
+export function muteImpendingDriverErrors() {
+  SyncTelemetry.getInstance()?.ignoreLike(
+    'Cannot run actions because driver is not set up',
+    /The reader you're trying to run \(.+\) can't be performed yet/
+  )
+}
+
+/**
+ * Patch IndexedDB open to listen for specifically definitely asynchronous errors
+ */
+export function patchIndexedDBOpenErrors(
+  onAnyError: (error: Error | DOMException | null, event: Event) => void
+) {
+  const idb = window.indexedDB as any
+  const originalOpen = idb.open
+
+  idb.open = function(...args: any[]) {
+    let onerror: ((ev: Event) => any) | undefined
+
+    const realRequest = originalOpen.apply(this, args)
+    const proxyRequest = new Proxy(realRequest, {
+      get(target, prop) {
+        if (prop === 'onerror') return onerror
+        return target[prop]
+      },
+      set(target, prop, value) {
+        if (prop === 'onerror') {
+          onerror = value
+          return true
+        }
+        target[prop] = value
+        return true
+      },
+    })
+
+    realRequest.onerror = event => {
+      onAnyError((event.target as any).error, event)
+      onerror?.call(proxyRequest, event)
+    }
+
+    return proxyRequest
+  }
+}
+
+export function simulateIndexedDBDelay(minDelayMs = 2000) {
+  patchIndexedDBOpen({ delay: minDelayMs })
+}
+export function simulateIndexedDBUnavailable() {
+  patchIndexedDBOpen({
+    forceError: () => new DOMException('Simulated IndexedDB unavailable error', 'UnknownError'),
+  })
+}
+
+export function simulateIndexedDBFailure(minDelayMs = 2000) {
+  patchIndexedDBOpen({
+    delay: minDelayMs,
+    forceError: () => new DOMException('Simulated IndexedDB failure error', 'UnknownError')
+  })
+}
+
+export function simulateIndexedDBQuotaExceeded() {
+  patchIndexedDBOpen({
+    delay: 0,
+    forceError: () => new DOMException('Simulated quota exceeded', 'QuotaExceededError')
+  })
+}
+
+/**
+ * Completely destroy database, as opposed to watermelon's reset
+ * (which merely clears all records but re-initializes the database schema)
+ * Haven't encountered live issues related to this yet, but theoretically provides
+ * the cleanest slate for a user to recover from schema issues?
+ */
+export function destroyDatabase(dbName: string, adapter: LokiJSAdapter): Promise<void> {
+  return new Promise(async (resolve, reject) => {
+    if (adapter._driver) {
+      // try {
+      //   // good manners to clear the cache, even though this adapter will likely be discarded
+      //   adapter._clearCachedRecords();
+      // } catch (err: unknown) {
+      //   SyncTelemetry.getInstance()?.capture(err)
+      // }
+
+      try {
+        await deleteDatabase(adapter._driver.loki)
+        return resolve();
+      } catch (err: unknown) {
+        SyncTelemetry.getInstance()?.capture(err as Error)
+        return reject(err);
+      }
+    }
+
+    destroyIndexedDBDatabase(dbName).then(() => resolve()).catch((err) => reject(err));
+  });
+}
+
+function patchIndexedDBOpen({ delay, forceError }: { delay?: number, forceError?: () => void }) {
+  const idb = window.indexedDB as any
+  const originalOpen = idb.open
+
+  const startTime = Date.now()
+
+  // Wrap open function and proxy success and error handlers
+  idb.open = function(...args: any[]) {
+    if (forceError && typeof delay === 'undefined') {
+      throw forceError()
+    }
+
+    let onsuccess: ((ev: Event) => any) | undefined
+    let onerror: ((ev: Event) => any) | undefined
+
+    const realRequest = originalOpen.apply(this, args)
+    const proxyRequest = new Proxy(realRequest, {
+      get(target, prop) {
+        if (prop === 'onsuccess') return onsuccess
+        if (prop === 'onerror') return onerror
+        return target[prop]
+      },
+      set(target, prop, value) {
+        if (prop === 'onsuccess') {
+          onsuccess = value
+          return true
+        }
+        if (prop === 'onerror') {
+          onerror = value
+          return true
+        }
+        target[prop] = value
+        return true
+      },
+    })
+
+    // trigger success after provided delay, only if no error is forced
+    realRequest.onsuccess = event => {
+      if (!forceError) {
+        setTimeout(() => onsuccess?.call(proxyRequest, event), Math.max(0, delay - (Date.now() - startTime)))
+      }
+    }
+
+    // force error after provided delay
+    if (forceError) {
+      setTimeout(() => {
+        const error = forceError()
+        const event = new Event('error')
+        Object.defineProperty(event, 'target', { value: { error } })
+        onerror?.call(proxyRequest, event)
+      }, Math.max(0, delay - (Date.now() - startTime)))
+    }
+
+    return proxyRequest
+  }
+}
+
+function destroyIndexedDBDatabase(dbName: string) {
+  return new Promise<void>((resolve, reject) => {
+    const request = indexedDB.deleteDatabase(dbName);
+
+    request.onsuccess = () => resolve();
+    request.onblocked = () => {
+      reject(new Error(`IndexedDB deletion blocked for "${dbName}"`));
+    };
+    request.onerror = () => reject(request.error ?? new Error("Manual IndexedDB deletion failed"));
+  })
+}