refactor(loader): resolve config after injected services

scripts/test-invariants.spec.ts

@@ -39,18 +39,6 @@ function requiredConfig() {
   })
 }
 
-function queuedReadinessConfig(
-  ctx: Context,
-  onPublished: (dispose: () => void) => void,
-) {
-  return z.transform(z.any(), () => {
-    queueMicrotask(() => {
-      onPublished(ctx.provide(TEST_INVARIANT_READY_SERVICE, true))
-    })
-    return {}
-  }, true)
-}
-
 function invalidConfigApply(): never {
   throw new Error('invalid plugin apply executed')
 }
@@ -189,84 +177,55 @@ describe('global test invariant host', () => {
     expect(apply).not.toHaveBeenCalled()
   })
 
-  it('disposes invalid config when readiness refresh wins the rejection-handler race', async () => {
+  it('disposes invalid config after delayed invariant readiness', async () => {
     await withDelayedFirstCompanion(
       async ({ started, release }) => {
         const ctx = new Context()
         const apply = vi.fn(invalidConfigApply)
-        let disposeQueuedReadiness: (() => void) | undefined
         const plugin = {
           apply,
-          Config: z.intersect([
-            queuedReadinessConfig(ctx, (dispose) => {
-              disposeQueuedReadiness = dispose
-            }),
-            requiredConfig(),
-          ]),
+          Config: requiredConfig(),
         }
 
         const fiber = ctx.plugin(plugin, {})
-        const firstError = await rejectionOf(fiber)
-        expectRequiredConfigValidation(firstError)
-        expect(fiber.state).toBe(FiberState.DISPOSED)
+        const returnedError = rejectionOf(fiber)
+        await started
+        expect(fiber.state).toBe(FiberState.PENDING)
         expect(apply).not.toHaveBeenCalled()
 
-        await started
-        if (disposeQueuedReadiness === undefined) throw new Error('queued readiness was not published')
-        disposeQueuedReadiness()
         release()
-        await ctx.plugin(TestInvariantProbe)
-
-        const secondError = await rejectionOf(fiber)
-        expect(secondError).toBe(firstError)
+        expectRequiredConfigValidation(await returnedError)
         expect(fiber.state).toBe(FiberState.DISPOSED)
         expect(apply).not.toHaveBeenCalled()
       },
     )
   })
 
-  it('retains a valid plugin failure when readiness wins the initial-probe race', async () => {
+  it('retains a valid plugin failure after delayed invariant readiness', async () => {
     await withDelayedFirstCompanion(
       async ({ started, release }) => {
         const ctx = new Context()
         const failure = new Error('valid plugin apply failed')
-        const applied = deferred()
         const apply = vi.fn(function validConfigApply() {
-          applied.resolve()
           throw failure
         })
-        let disposeQueuedReadiness: (() => void) | undefined
         const plugin = {
           apply,
-          Config: queuedReadinessConfig(ctx, (dispose) => {
-            disposeQueuedReadiness = dispose
-          }),
+          Config: z.object({}),
         }
 
         const fiber = ctx.plugin(plugin, {})
         const returnedError = rejectionOf(fiber)
-        try {
-          await Promise.all([started, applied.promise])
-          expect(fiber.state).toBe(FiberState.FAILED)
-          expect(apply).toHaveBeenCalledOnce()
-          expect(ctx.registry.has(plugin)).toBe(true)
-          expect(ctx.registry.get(plugin)?.fibers).toHaveLength(1)
+        await started
+        expect(fiber.state).toBe(FiberState.PENDING)
+        expect(apply).not.toHaveBeenCalled()
 
-          if (disposeQueuedReadiness === undefined) throw new Error('queued readiness was not published')
-          Reflect.deleteProperty(fiber.inject, TEST_INVARIANT_READY_SERVICE)
-          disposeQueuedReadiness()
-          release()
-
-          expect(await returnedError).toBe(failure)
-          expect(fiber.state).toBe(FiberState.FAILED)
-          expect(apply).toHaveBeenCalledOnce()
-          expect(ctx.registry.has(plugin)).toBe(true)
-          expect(ctx.registry.get(plugin)?.fibers).toHaveLength(1)
-        } finally {
-          Reflect.deleteProperty(fiber.inject, TEST_INVARIANT_READY_SERVICE)
-          disposeQueuedReadiness?.()
-          release()
-        }
+        release()
+        expect(await returnedError).toBe(failure)
+        expect(fiber.state).toBe(FiberState.FAILED)
+        expect(apply).toHaveBeenCalledOnce()
+        expect(ctx.registry.has(plugin)).toBe(true)
+        expect(ctx.registry.get(plugin)?.fibers).toHaveLength(1)
       },
     )
   })

scripts/test-invariants.ts

@@ -6,7 +6,7 @@
  */
 
 import { expect } from 'vitest'
-import { FiberState, Inject, RegistryService } from '@deepseek-ai/cordis'
+import { FiberState, Inject, RegistryService, ValidationError } from '@deepseek-ai/cordis'
 import type { Context, Plugin } from '@deepseek-ai/cordis'
 import { AttachmentStore } from '@deepseek-ai/dsh-attachment'
 import type {
@@ -248,22 +248,25 @@ function withInvariantReadiness(plugin: Plugin, callback: PluginCallback): Plugi
 function joinInvariantStartup(
   fiber: PluginFiber,
   invariantReady: Promise<void>,
-  disposeInitialFailure = false,
+  disposePendingValidationFailure = false,
 ): PluginFiber {
   // RegistryService returns a thenable wrapper whose context still points to
   // the raw Fiber. Calling inherited await() on the wrapper would return and
   // assimilate that thenable, accidentally following later plugin startup.
   const rawFiber = fiber.ctx.fiber
-  const initialized = disposeInitialFailure
-    ? rawFiber.await().catch(async (error: unknown) => {
-      // Config validation is the only failure recorded while a gated fiber
-      // is initially PENDING. Dispose it even if queued readiness publication
-      // changes its state before this rejection handler runs.
-      await rawFiber.dispose()
+  const readiness = invariantReady.then(async () => {
+    try {
+      return await rawFiber.await()
+    } catch (error) {
+      // Config resolves only after the readiness injection activates. Dispose
+      // validation failures owned by an initially pending target; ordinary
+      // callback failures remain inspectable.
+      if (disposePendingValidationFailure && error instanceof ValidationError) {
+        await rawFiber.dispose()
+      }
       throw error
-    })
-    : Promise.resolve()
-  const readiness = initialized.then(() => invariantReady).then(() => rawFiber.await())
+    }
+  })
   const joined = Object.create(fiber) as PluginFiber
   joined.then = readiness.then.bind(readiness)
   return joined