testKit: configurable waitForLoading timeout + report all root unready APIs on timeout

The timeout message previously came from getRootUnreadyAPI(), which walks a
single dependency chain from an arbitrary first unready entry point - sibling
branches are dropped and only one API is reported even when several
independent APIs are missing. Compute all root unready APIs instead:
dependencies of unready entry points that are neither ready nor declared by
another unready entry point.

The hardcoded 3s timeout becomes an optional parameter (default unchanged), so
heavy hosts can raise it above their boot time and let this error surface
before the test runner's own opaque timeout.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: bodia-uz

packages/repluggable-core/test/testKit.spec.tsx

@@ -149,5 +149,47 @@ describe('App Host TestKit', () => {
             jest.runAllTimers()
             await expect(hostPromise).rejects.toThrow(new RegExp(MockPublicAPI.name))
         })
+
+        it('should report all root unready APIs of independent unready entry points', async () => {
+            const hostPromise = createAppHostAndWaitForLoading(
+                [
+                    {
+                        name: 'entryPoint A',
+                        declareAPIs: () => [{ name: 'API A' }],
+                        getDependencyAPIs: () => [{ name: 'missing A' }]
+                    },
+                    {
+                        name: 'entryPoint B',
+                        declareAPIs: () => [{ name: 'API B' }],
+                        getDependencyAPIs: () => [{ name: 'missing B' }]
+                    }
+                ],
+                []
+            )
+            jest.runAllTimers()
+            const error: Error = await hostPromise.then(
+                () => {
+                    throw new Error('expected hostPromise to reject')
+                },
+                e => e
+            )
+
+            expect(error.message).toContain('"missing A"')
+            expect(error.message).toContain('"missing B"')
+        })
+
+        it('should respect a custom loading timeout', async () => {
+            let settled = false
+            const hostPromise = createAppHostAndWaitForLoading([dependsOnMockPackageEntryPoint], [], 10000)
+            hostPromise.catch(() => (settled = true))
+
+            jest.advanceTimersByTime(9999)
+            await Promise.resolve()
+            await Promise.resolve()
+            expect(settled).toBe(false)
+
+            jest.advanceTimersByTime(1)
+            await expect(hostPromise).rejects.toThrow('timed out after 10000ms')
+        })
     })
 })

packages/repluggable-core/testKit/index.ts

@@ -81,7 +81,11 @@ export function createAppHostWithPacts(packages: EntryPointOrPackage[], pacts: P
     })
 }
 
-export async function createAppHostAndWaitForLoading(packages: EntryPointOrPackage[], pacts: PactAPIBase[]): Promise<AppHost> {
+export async function createAppHostAndWaitForLoading(
+    packages: EntryPointOrPackage[],
+    pacts: PactAPIBase[],
+    timeout: number = 3000
+): Promise<AppHost> {
     const appHost = createAppHostWithPacts(packages, pacts)
     const declaredAPIs = _(packages)
         .flatten()
@@ -92,17 +96,27 @@ export async function createAppHostAndWaitForLoading(packages: EntryPointOrPacka
         setTimeout(() => {
             const readyAPIs = Array.from(globalThis.repluggableAppDebug.readyAPIs)
             const unreadyAPIs = declaredAPIs.filter(api => !readyAPIs.some(readyAPI => readyAPI.name === api.name))
-            const rootUnreadyAPI = globalThis.repluggableAppDebug.utils.getRootUnreadyAPI()
+            const unreadyEntryPoints = globalThis.repluggableAppDebug.utils.unReadyEntryPoints()
+            const readyNames = new Set(readyAPIs.map(api => api.name))
+            const declaredByUnready = new Set(unreadyEntryPoints.flatMap(ep => (ep.declareAPIs?.() || []).map(key => key.name)))
+            const rootUnreadyAPIs = _.uniqBy(
+                unreadyEntryPoints
+                    .flatMap(ep => ep.getDependencyAPIs?.() || [])
+                    .filter(key => !readyNames.has(key.name) && !declaredByUnready.has(key.name)),
+                'name'
+            )
 
             reject(
                 new Error(
-                    `createAppHostAndWaitForLoading - waiting for loading timed out.
-there's a high chance this missing API is the main reason for it: ${JSON.stringify(rootUnreadyAPI)}
+                    `createAppHostAndWaitForLoading - waiting for loading timed out after ${timeout}ms.
+these root unready APIs are most likely the reason - unready entry points require them but nothing declares them (missing entry point or pact?): ${JSON.stringify(
+                        rootUnreadyAPIs
+                    )}
 
 in addition here's the full list of declared APIs that have not been contributed: ${JSON.stringify(unreadyAPIs)}`
                 )
             )
-        }, 3000)
+        }, timeout)
     })
 
     const loadingPromise = new Promise<void>(async resolve => {