Serialize cleanup with association loading

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 6b12d843-8011-4bfc-9ba9-f75761eadee2

Author: StellaHuang95

src/managers/builtin/inlineScript/envManager.ts

@@ -197,6 +197,7 @@ export class InlineScriptEnvManager implements EnvironmentManager, Disposable {
     private discoveryRetryTimer: ReturnType<typeof setTimeout> | undefined;
     private readonly subscriptions: Disposable[] = [];
     private persistenceQueue: Promise<void> = Promise.resolve();
+    private readonly persistedAssociationsLoaded: Promise<void>;
     private selectionQueue: Promise<void> = Promise.resolve();
     private cacheMaintenanceQueue: Promise<void> = Promise.resolve();
     private cacheMaintenanceBarrier: Deferred<void> | undefined;
@@ -246,12 +247,11 @@ export class InlineScriptEnvManager implements EnvironmentManager, Disposable {
                 });
             }),
         );
-        queueMicrotask(() => {
-            void this.initializePersistedAssociations().catch((error) => {
-                this.log.warn(
-                    `Failed to prime inline-script environment associations: ${getErrorMessage(error)}`,
-                );
-            });
+        this.persistedAssociationsLoaded = this.loadPersistedAssociations();
+        void this.initializePersistedAssociations().catch((error) => {
+            this.log.warn(
+                `Failed to prime inline-script environment associations: ${getErrorMessage(error)}`,
+            );
         });
     }
 
@@ -1812,12 +1812,16 @@ export class InlineScriptEnvManager implements EnvironmentManager, Disposable {
         this.lastValidatedMetadataIdentityProofs.delete(scriptPath);
     }
 
-    private initializePersistedAssociations(): Promise<void> {
+    private loadPersistedAssociations(): Promise<void> {
         return this.enqueuePersistence(async (state) => {
             const rawAssociations = await state.get<unknown>(INLINE_SCRIPT_ENVS_KEY);
             const parsed = this.parsePersistedAssociations(rawAssociations);
             this.applyPersistedAssociations(parsed?.records ?? {});
-        }).then(async () => {
+        });
+    }
+
+    private initializePersistedAssociations(): Promise<void> {
+        return this.persistedAssociationsLoaded.then(async () => {
             await Promise.all(
                 [...this.fsPathToPersistedAssociation.keys()].map(async (scriptPath) => {
                     const uri = this.routingRegistry.getUri(scriptPath);
@@ -2164,6 +2168,7 @@ export class InlineScriptEnvManager implements EnvironmentManager, Disposable {
 
     private clearAssociationsForScripts(scripts: readonly Uri[]): Promise<void> {
         return this.enqueueSelection(async () => {
+            await this.persistedAssociationsLoaded;
             const changes = scripts
                 .filter((uri) => uri.scheme === 'file')
                 .map((uri) => ({

src/test/managers/builtin/inlineScript/envManager.unit.test.ts

@@ -4946,6 +4946,58 @@ suite('InlineScriptEnvManager', () => {
             assert.strictEqual(routingRegistry.hasValidatedAssociation(uri), false);
         });
 
+        test('waits for persisted association initialization before handling a script deletion', async () => {
+            await nextTurn();
+            manager.dispose();
+            const uri = scriptUri();
+            const scriptPath = normalizePath(uri.fsPath);
+            persistedAssociations = {
+                [scriptPath]: matchedAssociationRecord(path.join(tempRoot, 'cached-python')),
+            };
+            let signalInitialRead!: () => void;
+            let releaseInitialRead!: () => void;
+            const initialReadStarted = new Promise<void>((resolve) => {
+                signalInitialRead = resolve;
+            });
+            const initialReadBarrier = new Promise<void>((resolve) => {
+                releaseInitialRead = resolve;
+            });
+            let associationReads = 0;
+            workspaceState.get.callsFake(async (key: string) => {
+                if (key !== INLINE_SCRIPT_ENVS_KEY) {
+                    return undefined;
+                }
+                associationReads += 1;
+                if (associationReads === 1) {
+                    signalInitialRead();
+                    await initialReadBarrier;
+                }
+                return persistedAssociations;
+            });
+            workspaceState.set.resetHistory();
+            manager = new InlineScriptEnvManager(
+                nativeFinder,
+                api,
+                baseManager,
+                globalStorageUri,
+                makeFakeLog(),
+                routingRegistry,
+            );
+            await initialReadStarted;
+
+            fireDelete(uri);
+            await nextTurn();
+            releaseInitialRead();
+            await waitForCondition(
+                () => workspaceStateSetCalls(INLINE_SCRIPT_ENVS_KEY).length === 1,
+                'deleted association should be persisted after initialization completes',
+            );
+
+            assert.deepStrictEqual(persistedAssociations, {});
+            assert.strictEqual(await manager.get(uri), undefined);
+            assert.strictEqual(routingRegistry.hasValidatedAssociation(uri), false);
+        });
+
         test('clears persisted association state for the old path when a script is renamed', async () => {
             const oldUri = scriptUri('old.py');
             const newUri = scriptUri('new.py');