@speckle/objectloader2 2.26.1 → 2.26.3

package/src/core/objectLoader2Factory.ts

@@ -1,5 +1,11 @@
-import { CustomLogger, getFeatureFlag, ObjectLoader2Flags } from '../types/functions.js'
-import { Base } from '../types/types.js'
+import { DefermentManager, MemoryOnlyDeferment } from '../deferment/defermentManager.js'
+import {
+  CustomLogger,
+  Fetcher,
+  getFeatureFlag,
+  ObjectLoader2Flags
+} from '../types/functions.js'
+import { Base, ObjectAttributeMask } from '../types/types.js'
 import { ObjectLoader2 } from './objectLoader2.js'
 import { IndexedDatabase } from './stages/indexedDatabase.js'
 import { MemoryDatabase } from './stages/memory/memoryDatabase.js'
@@ -10,6 +16,10 @@ export interface ObjectLoader2FactoryOptions {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
   keyRange?: { bound: Function; lowerBound: Function; upperBound: Function }
   indexedDB?: IDBFactory
+  fetch?: Fetcher
+  attributeMask?: ObjectAttributeMask
+  useCache?: boolean
+  debug?: boolean
   logger?: CustomLogger
 }
 
@@ -22,6 +32,7 @@ export class ObjectLoader2Factory {
     })
     const loader = new ObjectLoader2({
       rootId: root.id,
+      deferments: new MemoryOnlyDeferment(records),
       database: new MemoryDatabase({ items: records }),
       downloader: new MemoryDownloader(root.id, records)
     })
@@ -40,13 +51,21 @@ export class ObjectLoader2Factory {
     token?: string
     headers?: Headers
     options?: ObjectLoader2FactoryOptions
+    attributeMask?: ObjectAttributeMask
   }): ObjectLoader2 {
     const log = ObjectLoader2Factory.getLogger(params.options?.logger)
     let database
-    if (getFeatureFlag(ObjectLoader2Flags.DEBUG) === 'true') {
+    if (
+      params.options?.debug === true ||
+      getFeatureFlag(ObjectLoader2Flags.DEBUG) === 'true'
+    ) {
       this.logger('Using DEBUG mode for ObjectLoader2Factory')
     }
-    if (getFeatureFlag(ObjectLoader2Flags.USE_CACHE) === 'true') {
+    const useCache = params.options?.useCache ?? true
+    const flag = getFeatureFlag(ObjectLoader2Flags.USE_CACHE)
+    const flagAllowsCache = flag !== 'false'
+
+    if (useCache && flagAllowsCache) {
       database = new IndexedDatabase({
         indexedDB: params.options?.indexedDB,
         keyRange: params.options?.keyRange
@@ -59,18 +78,22 @@ export class ObjectLoader2Factory {
         'Disabled persistent caching for ObjectLoader2.  Using MemoryDatabase'
       )
     }
+    const logger = log || (((): void => {}) as CustomLogger)
     const loader = new ObjectLoader2({
       rootId: params.objectId,
+      deferments: new DefermentManager(logger),
       downloader: new ServerDownloader({
         serverUrl: params.serverUrl,
         streamId: params.streamId,
         objectId: params.objectId,
         token: params.token,
         headers: params.headers,
-        logger: log || ((): void => {})
+        fetch: params.options?.fetch,
+        attributeMask: params.attributeMask,
+        logger
       }),
       database,
-      logger: log
+      logger
     })
     return loader
   }

package/src/core/options.ts

@@ -1,9 +1,11 @@
+import { Deferment } from '../deferment/defermentManager.js'
 import { CustomLogger } from '../types/functions.js'
 import { Base } from '../types/types.js'
 import { Downloader, Database } from './interfaces.js'
 
 export interface ObjectLoader2Options {
   rootId: string
+  deferments: Deferment
   downloader: Downloader
   database: Database
   logger?: CustomLogger

package/src/core/stages/cacheReader.spec.ts

@@ -10,7 +10,7 @@ describe('CacheReader testing', () => {
     const i1: Item = { baseId: 'id1', base: { id: 'id', speckle_type: 'type' } }
 
     const cache = new MemoryCache({ maxSizeInMb: 1, ttlms: 1 }, () => {})
-    const deferments = new DefermentManager(cache, () => {})
+    const deferments = new DefermentManager(() => {}, cache)
     const cacheReader = new CacheReader(
       new MemoryDatabase({
         items: new Map<string, Base>([[i1.baseId, i1.base!]])

package/src/core/stages/cacheReader.ts

@@ -1,4 +1,4 @@
-import { DefermentManager } from '../../deferment/defermentManager.js'
+import { Deferment } from '../../deferment/defermentManager.js'
 import BatchingQueue from '../../queues/batchingQueue.js'
 import Queue from '../../queues/queue.js'
 import { CustomLogger } from '../../types/functions.js'
@@ -8,7 +8,7 @@ import { CacheOptions } from '../options.js'
 
 export class CacheReader {
   #database: Database
-  #defermentManager: DefermentManager
+  #defermentManager: Deferment
   #logger: CustomLogger
   #options: CacheOptions
   #readQueue: BatchingQueue<string> | undefined
@@ -17,7 +17,7 @@ export class CacheReader {
 
   constructor(
     database: Database,
-    defermentManager: DefermentManager,
+    defermentManager: Deferment,
     logger: CustomLogger,
     options: CacheOptions
   ) {

package/src/core/stages/cacheWriter.spec.ts

@@ -42,7 +42,7 @@ describe('CacheWriter', () => {
       ttlms: 60000
     }
     memoryCache = new MemoryCache(memoryCacheOptions, logger)
-    defermentManager = new DefermentManager(memoryCache, logger)
+    defermentManager = new DefermentManager(logger, memoryCache)
     requestItemMock = vi.fn()
 
     options = {

package/src/core/stages/cacheWriter.ts

@@ -1,4 +1,4 @@
-import { DefermentManager } from '../../deferment/defermentManager.js'
+import { Deferment } from '../../deferment/defermentManager.js'
 import BatchingQueue from '../../queues/batchingQueue.js'
 import Queue from '../../queues/queue.js'
 import { CustomLogger } from '../../types/functions.js'
@@ -9,7 +9,7 @@ import { CacheOptions } from '../options.js'
 export class CacheWriter implements Queue<Item> {
   #writeQueue: BatchingQueue<Item> | undefined
   #database: Database
-  #defermentManager: DefermentManager
+  #deferment: Deferment
   #requestItem: (id: string) => void
   #logger: CustomLogger
   #options: CacheOptions
@@ -18,14 +18,14 @@ export class CacheWriter implements Queue<Item> {
   constructor(
     database: Database,
     logger: CustomLogger,
-    defermentManager: DefermentManager,
+    deferment: Deferment,
     options: CacheOptions,
     requestItem: (id: string) => void
   ) {
     this.#database = database
     this.#options = options
     this.#logger = logger
-    this.#defermentManager = defermentManager
+    this.#deferment = deferment
     this.#requestItem = requestItem
   }
 
@@ -40,7 +40,7 @@ export class CacheWriter implements Queue<Item> {
       })
     }
     this.#writeQueue.add(item.baseId, item)
-    this.#defermentManager.undefer(item, this.#requestItem)
+    this.#deferment.undefer(item, this.#requestItem)
   }
 
   async writeAll(items: Item[]): Promise<void> {

package/src/core/stages/serverDownloader.spec.ts

@@ -257,4 +257,126 @@ describe('downloader', () => {
     })
     await downloader.disposeAsync()
   })
+
+  test('nothing is frozen when validateResponse returns 403', async () => {
+    const fetchMocker = createFetchMock(vi)
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+    // Mock a 403 Forbidden response
+    fetchMocker.mockResponseOnce('', { status: 403, statusText: 'Forbidden' })
+
+    const gathered = new AsyncGeneratorQueue<Item>()
+    const downloader = new ServerDownloader({
+      serverUrl: 'http://speckle.test',
+      streamId: 'streamId',
+      objectId: 'objectId',
+      token: 'invalid-token',
+      fetch: fetchMocker,
+      logger: (): void => {}
+    })
+
+    try {
+      downloader.initialize({
+        results: gathered,
+        total: 2,
+        maxDownloadBatchWait: 100
+      })
+
+      // Add items to trigger batch processing
+      downloader.add('id1')
+      downloader.add('id2')
+
+      // Wait for the batch to be processed and fail with 403
+      await new Promise((resolve) => setTimeout(resolve, 200))
+
+      // Verify that the error was logged (indicating the batch processing failed)
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'Batch processing failed:',
+        expect.any(Error)
+      )
+
+      // The key test: verify we can still dispose the downloader properly
+      // This ensures the system isn't frozen and can clean up resources
+      const disposePromise = downloader.disposeAsync()
+
+      // Add a timeout to ensure disposal doesn't hang indefinitely
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error('Disposal timed out')), 5000)
+      })
+
+      // This should complete without timing out or throwing
+      await Promise.race([disposePromise, timeoutPromise])
+
+      // Additional verification: the batching queue should be marked as disposed
+      // We can't directly access the private field, but we can verify disposal completed
+      expect(true).toBe(true) // If we reach here, disposal succeeded
+    } finally {
+      consoleErrorSpy.mockRestore()
+    }
+  })
+
+  test('system remains functional after 403 error and can be properly cleaned up', async () => {
+    const fetchMocker = createFetchMock(vi)
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+    // First call returns 403, subsequent calls should not be made due to queue disposal
+    fetchMocker.mockResponseOnce('', { status: 403, statusText: 'Forbidden' })
+
+    const gathered = new AsyncGeneratorQueue<Item>()
+    const downloader = new ServerDownloader({
+      serverUrl: 'http://speckle.test',
+      streamId: 'streamId',
+      objectId: 'objectId',
+      token: 'invalid-token',
+      fetch: fetchMocker,
+      logger: (): void => {}
+    })
+
+    try {
+      downloader.initialize({
+        results: gathered,
+        total: 5,
+        maxDownloadBatchWait: 50
+      })
+
+      // Add first batch that will trigger the 403 error
+      downloader.add('id1')
+      downloader.add('id2')
+
+      // Wait for first batch to fail
+      await new Promise((resolve) => setTimeout(resolve, 100))
+
+      // Verify error was logged
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'Batch processing failed:',
+        expect.any(Error)
+      )
+
+      // Try to add more items after the failure
+      // These should be ignored since the queue is now disposed
+      downloader.add('id3')
+      downloader.add('id4')
+      downloader.add('id5')
+
+      // Wait a bit more to ensure no additional processing attempts
+      await new Promise((resolve) => setTimeout(resolve, 100))
+
+      // Note: The batching queue might make multiple attempts before disposal
+      // The key is that disposal should still work regardless of how many calls were made
+      expect(fetchMocker).toHaveBeenCalled()
+
+      // Critical test: disposal should complete without hanging
+      const start = Date.now()
+      await downloader.disposeAsync()
+      const elapsed = Date.now() - start
+
+      // Disposal should be quick (under 1 second) and not hang
+      expect(elapsed).toBeLessThan(1000)
+
+      // Verify that the results queue can also be disposed properly
+      await gathered.disposeAsync()
+    } finally {
+      consoleErrorSpy.mockRestore()
+    }
+  })
 })

package/src/core/stages/serverDownloader.ts

@@ -2,7 +2,7 @@ import BatchingQueue from '../../queues/batchingQueue.js'
 import Queue from '../../queues/queue.js'
 import { ObjectLoaderRuntimeError } from '../../types/errors.js'
 import { CustomLogger, Fetcher, indexOf, isBase, take } from '../../types/functions.js'
-import { Item } from '../../types/types.js'
+import { Item, ObjectAttributeMask } from '../../types/types.js'
 import { Downloader } from '../interfaces.js'
 
 export interface ServerDownloaderOptions {
@@ -13,6 +13,7 @@ export interface ServerDownloaderOptions {
   headers?: Headers
   logger: CustomLogger
   fetch?: Fetcher
+  attributeMask?: ObjectAttributeMask
 }
 
 const MAX_SAFARI_DECODE_BYTES = 2 * 1024 * 1024 * 1024 - 1024 * 1024 // 2GB minus a margin
@@ -51,9 +52,10 @@ export default class ServerDownloader implements Downloader {
     if (this.#options.token) {
       this.#headers['Authorization'] = `Bearer ${this.#options.token}`
     }
-    this.#requestUrlChildren = `${this.#options.serverUrl}/api/getobjects/${
+    this.#requestUrlChildren = `${this.#options.serverUrl}/api/v2/projects/${
       this.#options.streamId
-    }`
+    }/object-stream/`
+
     this.#requestUrlRootObj = `${this.#options.serverUrl}/objects/${
       this.#options.streamId
     }/${this.#options.objectId}/single`
@@ -117,11 +119,12 @@ Chrome's behavior: Chrome generally handles larger data sizes without this speci
 
     const start = performance.now()
     this.#logger(`Downloading batch of ${batch.length} items...`)
+    const attributeMask = this.#options.attributeMask
     const keys = new Set<string>(batch)
     const response = await this.#fetch(url, {
       method: 'POST',
       headers: { ...headers, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ objects: JSON.stringify(batch) })
+      body: JSON.stringify({ objectIds: batch, attributeMask })
     })
 
     this.#validateResponse(response)

package/src/deferment/defermentManager.test.ts

@@ -9,9 +9,10 @@ describe('DefermentManager', () => {
     const mockLogger: CustomLogger = vi.fn()
     const mockCache = {
       get: vi.fn(),
-      add: vi.fn()
+      add: vi.fn(),
+      dispose: vi.fn()
     } as unknown as MemoryCache
-    const defermentManager = new DefermentManager(mockCache, mockLogger)
+    const defermentManager = new DefermentManager(mockLogger, mockCache)
     expect(defermentManager).toBeDefined()
   })
 
@@ -24,7 +25,7 @@ describe('DefermentManager', () => {
         get,
         add
       } as unknown as MemoryCache
-      const defermentManager = new DefermentManager(mockCache, mockLogger)
+      const defermentManager = new DefermentManager(mockLogger, mockCache)
 
       const item: Item = {
         // eslint-disable-next-line camelcase
@@ -49,7 +50,7 @@ describe('DefermentManager', () => {
         get,
         add
       } as unknown as MemoryCache
-      const defermentManager = new DefermentManager(mockCache, mockLogger)
+      const defermentManager = new DefermentManager(mockLogger, mockCache)
 
       const [promise1, wasInCache1] = defermentManager.defer({ id: 'testId' })
       const [promise2, wasInCache2] = defermentManager.defer({ id: 'testId' })
@@ -67,7 +68,7 @@ describe('DefermentManager', () => {
         get,
         add
       } as unknown as MemoryCache
-      const defermentManager = new DefermentManager(mockCache, mockLogger)
+      const defermentManager = new DefermentManager(mockLogger, mockCache)
 
       const [promise, wasInCache] = defermentManager.defer({ id: 'testId' })
 
@@ -81,9 +82,10 @@ describe('DefermentManager', () => {
       const add = vi.fn()
       const mockCache = {
         get,
-        add
+        add,
+        dispose: vi.fn()
       } as unknown as MemoryCache
-      const defermentManager = new DefermentManager(mockCache, mockLogger)
+      const defermentManager = new DefermentManager(mockLogger, mockCache)
 
       defermentManager.dispose()
       expect(() => defermentManager.defer({ id: 'testId' })).toThrow(
@@ -101,7 +103,7 @@ describe('DefermentManager', () => {
         get,
         add
       } as unknown as MemoryCache
-      const defermentManager = new DefermentManager(mockCache, mockLogger)
+      const defermentManager = new DefermentManager(mockLogger, mockCache)
       const requestItem = vi.fn()
 
       const [promise] = defermentManager.defer({ id: 'testId' })
@@ -125,7 +127,7 @@ describe('DefermentManager', () => {
         get,
         add
       } as unknown as MemoryCache
-      const defermentManager = new DefermentManager(mockCache, mockLogger)
+      const defermentManager = new DefermentManager(mockLogger, mockCache)
       const requestItem = vi.fn()
 
       const item: Item = { baseId: 'testId' }
@@ -141,7 +143,7 @@ describe('DefermentManager', () => {
         get,
         add
       } as unknown as MemoryCache
-      const defermentManager = new DefermentManager(mockCache, mockLogger)
+      const defermentManager = new DefermentManager(mockLogger, mockCache)
       const requestItem = vi.fn()
 
       const item: Item = {
@@ -165,9 +167,10 @@ describe('DefermentManager', () => {
       const add = vi.fn()
       const mockCache = {
         get,
-        add
+        add,
+        dispose: vi.fn()
       } as unknown as MemoryCache
-      const defermentManager = new DefermentManager(mockCache, mockLogger)
+      const defermentManager = new DefermentManager(mockLogger, mockCache)
       const requestItem = vi.fn()
 
       defermentManager.dispose()
@@ -189,9 +192,10 @@ describe('DefermentManager', () => {
       const add = vi.fn()
       const mockCache = {
         get,
-        add
+        add,
+        dispose: vi.fn()
       } as unknown as MemoryCache
-      const defermentManager = new DefermentManager(mockCache, mockLogger)
+      const defermentManager = new DefermentManager(mockLogger, mockCache)
 
       void defermentManager.defer({ id: 'testId' })
       defermentManager.dispose()
@@ -205,9 +209,10 @@ describe('DefermentManager', () => {
       const add = vi.fn()
       const mockCache = {
         get,
-        add
+        add,
+        dispose: vi.fn()
       } as unknown as MemoryCache
-      const defermentManager = new DefermentManager(mockCache, mockLogger)
+      const defermentManager = new DefermentManager(mockLogger, mockCache)
 
       defermentManager.dispose()
       // @ts-expect-error - accessing private property for testing

package/src/deferment/defermentManager.ts

@@ -3,15 +3,50 @@ import { CustomLogger } from '../types/functions.js'
 import { Item, Base } from '../types/types.js'
 import { MemoryCache } from './MemoryCache.js'
 
-export class DefermentManager {
+export interface Deferment {
+  defer(params: { id: string }): [Promise<Base>, boolean]
+  undefer(item: Item, requestItem: (id: string) => void): void
+  dispose(): void
+}
+
+export class MemoryOnlyDeferment implements Deferment {
+  private items: Map<string, Base>
+
+  constructor(items: Map<string, Base>) {
+    this.items = items
+  }
+  defer(params: { id: string }): [Promise<Base>, boolean] {
+    const item = this.items.get(params.id)
+    if (item) {
+      return [Promise.resolve(item), true]
+    }
+    return [Promise.reject(new Error('Not found in cache: ' + params.id)), false]
+  }
+  undefer(): void {
+    //no-op
+  }
+  dispose(): void {
+    //no-op
+  }
+}
+
+export class DefermentManager implements Deferment {
   private outstanding: Map<string, DeferredBase> = new Map()
   private logger: CustomLogger
   private disposed = false
   private cache: MemoryCache
 
-  constructor(cache: MemoryCache, logger: CustomLogger) {
-    this.cache = cache
+  constructor(logger: CustomLogger, cache?: MemoryCache) {
     this.logger = logger
+    this.cache =
+      cache ||
+      new MemoryCache(
+        {
+          maxSizeInMb: 500, // 500 MB
+          ttlms: 5_000 // 5 seconds
+        },
+        logger
+      )
   }
 
   defer(params: { id: string }): [Promise<Base>, boolean] {
@@ -55,5 +90,6 @@ export class DefermentManager {
     this.disposed = true
     this.logger('cleared deferments, left', this.outstanding.size)
     this.outstanding.clear()
+    this.cache.dispose()
   }
 }

package/src/queues/batchingQueue.dispose.test.ts

@@ -17,7 +17,7 @@ describe('BatchingQueue disposal', () => {
 
     await queue.disposeAsync()
 
-    expect(processFunction).toHaveBeenCalledWith(items)
+    expect(processFunction).toHaveBeenCalled()
     expect(queue.count()).toBe(0)
     expect(queue.isDisposed()).toBe(true)
   })
@@ -52,8 +52,6 @@ describe('BatchingQueue disposal', () => {
     resolveProcess()
     await disposePromise
 
-    expect(processFunction).toHaveBeenCalledTimes(2)
-    expect(processFunction).toHaveBeenCalledWith(items2)
     expect(queue.count()).toBe(0)
     expect(queue.isDisposed()).toBe(true)
   })

package/src/queues/batchingQueue.test.ts

@@ -146,4 +146,125 @@ describe('BatchingQueue', () => {
       await queue.disposeAsync()
     }
   })
+
+  test('should handle processFunction throwing an exception during flush and is disposed', async () => {
+    const errorMessage = 'Process function failed'
+    const processFunction = vi.fn().mockRejectedValue(new Error(errorMessage))
+
+    const queue = new BatchingQueue<{ id: string }>({
+      batchSize: 5,
+      maxWaitTime: 1000,
+      processFunction
+    })
+
+    const items = Array.from({ length: 3 }, (_, i) => ({ id: `item-${i}` }))
+    items.forEach((item) => queue.add(item.id, item))
+
+    expect(queue.count()).toBe(3)
+
+    // flush should not throw even if processFunction rejects
+    await expect(queue.flush()).resolves.not.toThrow()
+
+    expect(processFunction).toHaveBeenCalled()
+    expect(queue.count()).toBe(0)
+    expect(queue.isDisposed()).toBe(false)
+    expect(queue.isErrored()).toBe(true)
+    // Add more items after the exception
+    queue.add('key3', { id: `item-3` })
+    queue.add('key4', { id: `item-4` })
+
+    // Wait to see if second batch gets processed (it shouldn't due to errored state)
+    await new Promise((resolve) => setTimeout(resolve, 200))
+
+    expect(queue.count()).toBe(0) // Items were not added due to errored state
+    await queue.disposeAsync()
+  })
+
+  test('should drain remaining items when disposed', async () => {
+    const processSpy = vi.fn()
+    const queue = new BatchingQueue({
+      batchSize: 5, // Large batch size to prevent automatic processing
+      maxWaitTime: 10000, // Long timeout to prevent timeout-based processing
+      processFunction: async (batch: string[]): Promise<void> => {
+        await new Promise((resolve) => setTimeout(resolve, 10))
+        processSpy(batch)
+      }
+    })
+
+    // Add items that won't trigger automatic processing (less than batch size)
+    queue.add('key1', 'item1')
+    queue.add('key2', 'item2')
+    queue.add('key3', 'item3')
+
+    // Verify items are in queue but haven't been processed yet
+    expect(queue.count()).toBe(3)
+    expect(processSpy).not.toHaveBeenCalled()
+
+    // Dispose should drain the remaining items
+    await queue.disposeAsync()
+
+    // Verify all items were processed during disposal
+    expect(processSpy).toHaveBeenCalledTimes(1)
+    expect(processSpy).toHaveBeenCalledWith(['item1', 'item2', 'item3'])
+    expect(queue.count()).toBe(0)
+    expect(queue.isDisposed()).toBe(true)
+  })
+
+  test('should drain items even with ongoing processing during dispose', async () => {
+    const processSpy = vi.fn()
+    let firstBatchStarted = false
+    let allowFirstBatchToComplete: (() => void) | null = null
+
+    const queue = new BatchingQueue({
+      batchSize: 2,
+      maxWaitTime: 100,
+      processFunction: async (batch: string[]): Promise<void> => {
+        processSpy(batch)
+
+        // Make the first batch wait for our signal
+        if (!firstBatchStarted) {
+          firstBatchStarted = true
+          await new Promise<void>((resolve) => {
+            allowFirstBatchToComplete = resolve
+          })
+        } else {
+          // Other batches process normally
+          await new Promise((resolve) => setTimeout(resolve, 10))
+        }
+      }
+    })
+
+    // Add first batch that will trigger processing but will be blocked
+    queue.add('key1', 'item1')
+    queue.add('key2', 'item2')
+
+    // Wait for first batch to start processing and allowFirstBatchToComplete to be assigned
+    await new Promise((resolve) => setTimeout(resolve, 50))
+    expect(firstBatchStarted).toBe(true)
+    expect(processSpy).toHaveBeenCalledTimes(1)
+    expect(allowFirstBatchToComplete).not.toBeNull()
+
+    // Add more items while first batch is still processing
+    queue.add('key3', 'item3')
+    queue.add('key4', 'item4')
+
+    // Verify the additional items are queued
+    expect(queue.count()).toBe(2)
+
+    // Start disposal (this should wait for ongoing processing and then drain)
+    const disposePromise = queue.disposeAsync()
+
+    // Allow the first batch to complete
+    allowFirstBatchToComplete!()
+
+    // Wait for disposal to complete
+    await disposePromise
+
+    // Verify all batches were processed
+    expect(processSpy).toHaveBeenCalledTimes(2)
+    expect(processSpy).toHaveBeenCalledWith(['item1', 'item2'])
+    expect(processSpy).toHaveBeenCalledWith(['item3', 'item4'])
+    expect(queue.count()).toBe(0)
+    expect(queue.isDisposed()).toBe(true)
+  })
 })