@@ -30,21 +30,29 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/In
3030
3131export const use = serviceUse ( Service )
3232
33- interface Entry {
33+ /**
34+ * A directory-global teardown in flight. Every cached entry carries one; an uncached `dispose`
35+ * creates a standalone tracker so a concurrent `reload` still serializes with its disposers
36+ * (NEW-V13-06).
37+ */
38+ interface TeardownTracker {
39+ /**
40+ * Resolves when the directory-global `runDisposers` settles, even if the teardown fiber was
41+ * interrupted while it was in flight.
42+ */
43+ readonly teardown : Deferred . Deferred < void >
44+ /** Whether the teardown reached `runDisposers`, so `teardown` settles on its own. */
45+ teardownStarted : boolean
46+ }
47+
48+ interface Entry extends TeardownTracker {
3449 readonly deferred : Deferred . Deferred < InstanceContext >
3550 /** Outstanding `provide` leases; a leased entry is never evicted (D-P1-05). */
3651 uses : number
3752 /** Set synchronously once a teardown claims the entry; a `provide` that observes it reloads. */
3853 disposed : boolean
3954 /** Resolves when a claimed teardown finished and the entry left the cache. */
4055 readonly closed : Deferred . Deferred < void >
41- /**
42- * Resolves when this entry's directory-global `runDisposers` settles, even if the teardown
43- * fiber was interrupted while it was in flight.
44- */
45- readonly teardown : Deferred . Deferred < void >
46- /** Whether this entry's claim reached `runDisposers`, so `teardown` settles on its own. */
47- teardownStarted : boolean
4856}
4957
5058const makeEntry = ( ) : Entry => ( {
@@ -68,8 +76,9 @@ const layer: Layer.Layer<Service, never, Project.Service | InstanceBootstrap.Ser
6876 const cache = new Map < string , Entry > ( )
6977 // Disposers are directory-global and keep running after an interrupt, even though the
7078 // interrupted entry has already left `cache`. Track those in-flight teardowns by directory
71- // so a `reload` can wait for them before booting a replacement (NEW-V12-06).
72- const teardowns = new Map < string , Set < Entry > > ( )
79+ // so a `reload` can wait for them before booting a replacement (NEW-V12-06). Trackers can
80+ // outlive their entry (uncached `dispose`), so the set holds trackers, not entries.
81+ const teardowns = new Map < string , Set < TeardownTracker > > ( )
7382
7483 const boot = ( input : LoadInput & { directory : string } ) =>
7584 Effect . gen ( function * ( ) {
@@ -133,34 +142,50 @@ const layer: Layer.Layer<Service, never, Project.Service | InstanceBootstrap.Ser
133142
134143 const disposeContext = Effect . fn ( "InstanceStore.disposeContext" ) ( function * ( ctx : InstanceContext , entry ?: Entry ) {
135144 yield * Effect . logInfo ( "disposing instance" , { directory : ctx . directory } )
145+ // Track every directory-global teardown, including one started for a context that was never
146+ // cached (`dispose` on a foreign context), so a concurrent `reload` cannot boot a
147+ // replacement while its disposers still run (NEW-V13-06).
148+ const tracker : TeardownTracker = entry ?? { teardown : Deferred . makeUnsafe < void > ( ) , teardownStarted : false }
136149 const teardown = yield * Effect . sync ( ( ) => {
137150 const promise = runDisposers ( ctx . directory )
138- if ( entry ) {
139- entry . teardownStarted = true
140- const pending = teardowns . get ( ctx . directory ) ?? new Set < Entry > ( )
141- pending . add ( entry )
142- teardowns . set ( ctx . directory , pending )
143- const settle = ( ) => {
144- const active = teardowns . get ( ctx . directory )
145- if ( active ) {
146- active . delete ( entry )
147- if ( active . size === 0 ) teardowns . delete ( ctx . directory )
148- }
149- Deferred . doneUnsafe ( entry . teardown , Effect . void )
151+ tracker . teardownStarted = true
152+ const pending = teardowns . get ( ctx . directory ) ?? new Set < TeardownTracker > ( )
153+ pending . add ( tracker )
154+ teardowns . set ( ctx . directory , pending )
155+ const settle = ( ) => {
156+ const active = teardowns . get ( ctx . directory )
157+ if ( active ) {
158+ active . delete ( tracker )
159+ if ( active . size === 0 ) teardowns . delete ( ctx . directory )
150160 }
151- promise . then ( settle , settle )
161+ Deferred . doneUnsafe ( tracker . teardown , Effect . void )
152162 }
163+ promise . then ( settle , settle )
153164 return promise
154165 } )
155166 yield * Effect . promise ( ( ) => teardown )
156167 yield * emitDisposed ( { directory : ctx . directory , project : ctx . project . id } )
157168 } )
158169
170+ // Bounded so a disposer that never settles cannot wedge the directory forever
171+ // (REGRESSION-V13-01): past the bound the replacement boots anyway and the deviation is
172+ // logged. The normal interrupted-teardown path still waits for the real disposers
173+ // (NEW-V12-06). `load`/`provide` stay ungated on purpose (REGRESSION-2 fast-alive).
174+ const TEARDOWN_DRAIN_TIMEOUT_MS = 2_000
159175 const awaitTeardowns = ( directory : string ) =>
160176 Effect . gen ( function * ( ) {
161- const pending = teardowns . get ( directory )
162- if ( ! pending || pending . size === 0 ) return
163- yield * Effect . forEach ( [ ...pending ] , ( entry ) => Deferred . await ( entry . teardown ) , { discard : true } )
177+ const deadline = Date . now ( ) + TEARDOWN_DRAIN_TIMEOUT_MS
178+ while ( teardowns . has ( directory ) ) {
179+ const pending = [ ...( teardowns . get ( directory ) ?? [ ] ) ]
180+ if ( pending . length === 0 ) return
181+ const settled = yield * Effect . forEach ( pending , ( tracker ) => Deferred . isDone ( tracker . teardown ) )
182+ if ( settled . every ( Boolean ) ) return
183+ if ( Date . now ( ) >= deadline ) {
184+ yield * Effect . logWarning ( "instance teardown did not settle before reload" , { directory : directory } )
185+ return
186+ }
187+ yield * Effect . sleep ( "25 millis" )
188+ }
164189 } )
165190
166191 // Release a claimed entry: drop it from the cache (only if it is still the cached one, so a
0 commit comments