Harden inline routing transitions

Invalidate changed metadata immediately, restore the effective manager after override removal, and align persisted validation with cache invariants.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 6b12d843-8011-4bfc-9ba9-f75761eadee2

Author: StellaHuang95

src/common/inlineScript/routingRegistry.ts

@@ -55,6 +55,8 @@ export class InlineScriptRoutingRegistry implements Disposable {
                     metadata,
                     metadataIdentity,
                     metadataRevision,
+                    validatedAssociation:
+                        state.metadataIdentity === metadataIdentity ? state.validatedAssociation : false,
                 };
             },
             true,

src/features/envManagers.ts

@@ -376,12 +376,22 @@ export class PythonEnvironmentManagers implements EnvironmentManagers {
         const project = scope ? this.pm.get(scope) : undefined;
         const key = this.getActiveSelectionKey(scope, manager, project);
         const operation = this.beginSelectionOperation(key);
+        const clearingInlineRoutingOverride =
+            scope instanceof Uri &&
+            environment === undefined &&
+            this.getInlineRoutingOverrideManager(scope)?.id === manager.id;
         const publishInlineSelection =
             !(scope instanceof Uri) || this.shouldPublishInlineSelectionImmediately(scope, manager);
         const inlineClearOperation =
             scope instanceof Uri && manager.id !== INLINE_SCRIPT_MANAGER_ID
                 ? this.beginSelectionOperation(this.getInlineScriptSelectionKey(scope))
                 : undefined;
+        const inlineOverrideHandoffOperation =
+            clearingInlineRoutingOverride &&
+            scope instanceof Uri &&
+            this.inlineScriptRouting?.shouldRoute(scope)
+                ? this.beginSelectionOperation(this.getInlineScriptSelectionKey(scope))
+                : undefined;
         await manager.set(scope, environment);
 
         // Only persist to settings when explicitly requested
@@ -412,6 +422,18 @@ export class PythonEnvironmentManagers implements EnvironmentManagers {
         if (scope instanceof Uri) {
             this.updateInlineRoutingOverride(scope, manager, environment);
             this.clearInlineActiveSelection(scope, manager, inlineClearOperation);
+            if (
+                clearingInlineRoutingOverride &&
+                (await this.publishEffectiveEnvironmentAfterOverrideClear(
+                    scope,
+                    manager,
+                    key,
+                    operation,
+                    inlineOverrideHandoffOperation,
+                ))
+            ) {
+                return;
+            }
         }
         if (!publishInlineSelection) {
             return;
@@ -782,6 +804,57 @@ export class PythonEnvironmentManagers implements EnvironmentManagers {
         this._inlineRoutingOverrides.delete(this.getInlineScriptSelectionKey(scope));
     }
 
+    private async publishEffectiveEnvironmentAfterOverrideClear(
+        scope: Uri,
+        previousManager: InternalEnvironmentManager,
+        previousKey: string,
+        previousOperation: number,
+        reservedInlineOperation: number | undefined,
+    ): Promise<boolean> {
+        const effectiveManager = this.getEnvironmentManager(scope);
+        if (!effectiveManager || effectiveManager.id === previousManager.id) {
+            return false;
+        }
+        if (!this.commitSelectionOperation(previousKey, previousOperation)) {
+            return true;
+        }
+
+        const oldEnvironment = this._activeSelection.get(previousKey);
+        const project = this.pm.get(scope);
+        const effectiveKey = this.getActiveSelectionKey(scope, effectiveManager, project);
+        const effectiveOperation =
+            effectiveManager.id === INLINE_SCRIPT_MANAGER_ID && reservedInlineOperation !== undefined
+                ? reservedInlineOperation
+                : this.beginSelectionOperation(effectiveKey);
+        if (!this.isLatestSelectionOperation(effectiveKey, effectiveOperation)) {
+            return true;
+        }
+        const newEnvironment = await effectiveManager.get(scope);
+        if (
+            this.getEnvironmentManager(scope) !== effectiveManager ||
+            !this.isLatestSelectionOperation(effectiveKey, effectiveOperation) ||
+            !this.commitSelectionOperation(effectiveKey, effectiveOperation)
+        ) {
+            return true;
+        }
+
+        this._activeSelection.set(effectiveKey, newEnvironment);
+        if (!this.isSameEnvironment(oldEnvironment, newEnvironment)) {
+            await this.fireActiveEnvironmentEvents([
+                {
+                    uri: this.getActiveSelectionUri(scope, effectiveManager, project),
+                    old: oldEnvironment,
+                    new: newEnvironment,
+                },
+            ]);
+        }
+        return true;
+    }
+
+    private isLatestSelectionOperation(key: string, operation: number): boolean {
+        return (this._selectionOperationCounters.get(key) ?? 0) === operation;
+    }
+
     private async handleInlineScriptRouteabilityChange(
         event: InlineScriptRouteabilityChangeEvent,
     ): Promise<void> {

src/managers/builtin/inlineScript/envManager.ts

@@ -1155,11 +1155,12 @@ export class InlineScriptEnvManager implements EnvironmentManager, Disposable {
                 if (metadataMatch === 'mismatched') {
                     return undefined;
                 }
-                const metadataIdentityProven = await this.currentCacheEntryProvesSourceMetadataIdentity(
-                    resolved,
-                    metadataIdentity,
-                    metadata,
-                );
+                const sidecar = await this.readCurrentCacheEntrySidecar(resolved);
+                if (sidecar && !this.cacheEntryMatchesRuntimeAndMetadata(sidecar, resolved, metadata)) {
+                    return undefined;
+                }
+                const metadataIdentityProven =
+                    !!sidecar && this.cacheEntryProvesSourceMetadataIdentity(sidecar, resolved, metadataIdentity, metadata);
                 if (!this.isCurrentAssociationRevision(scriptPath, revision)) {
                     return this.fsPathToEnv.get(scriptPath);
                 }
@@ -1335,11 +1336,12 @@ export class InlineScriptEnvManager implements EnvironmentManager, Disposable {
         if (metadataMatch === 'mismatched') {
             return undefined;
         }
-        const metadataIdentityProven = await this.currentCacheEntryProvesSourceMetadataIdentity(
-            resolved,
-            metadataIdentity,
-            metadata,
-        );
+        const sidecar = await this.readCurrentCacheEntrySidecar(resolved);
+        if (sidecar && !this.cacheEntryMatchesRuntimeAndMetadata(sidecar, resolved, metadata)) {
+            return undefined;
+        }
+        const metadataIdentityProven =
+            !!sidecar && this.cacheEntryProvesSourceMetadataIdentity(sidecar, resolved, metadataIdentity, metadata);
         if (!this.isCurrentAssociationRevision(scriptPath, revision)) {
             return this.fsPathToEnv.get(scriptPath);
         }
@@ -1624,12 +1626,27 @@ export class InlineScriptEnvManager implements EnvironmentManager, Disposable {
         metadataIdentity: string,
         metadata: InlineScriptMetadata,
     ): boolean {
+        if (!this.cacheEntryMatchesRuntimeAndMetadata(sidecar, environment, metadata)) {
+            return false;
+        }
         return (
             this.sidecarProvesSourceMetadataIdentity(sidecar, metadataIdentity) ||
             this.isMetadataOnlyCacheEntryForMetadata(sidecar, environment, metadata)
         );
     }
 
+    private cacheEntryMatchesRuntimeAndMetadata(
+        sidecar: InlineScriptEnvMeta,
+        environment: PythonEnvironment,
+        metadata: InlineScriptMetadata,
+    ): boolean {
+        if (!this.areEqualPythonReleases(environment.version, sidecar.baseInterpreterVersion)) {
+            return false;
+        }
+        const requiresPython = metadata.requiresPython?.trim();
+        return !requiresPython || this.matchesInstallConstraint(requiresPython, environment.version);
+    }
+
     private async resolveVerifiedSourceMetadataIdentity(
         script: ScriptReference,
         environment: PythonEnvironment,
@@ -1976,7 +1993,9 @@ export class InlineScriptEnvManager implements EnvironmentManager, Disposable {
         if (!sourceMetadataIdentity) {
             return {
                 environmentPath,
-                metadataBinding: { kind: 'legacy' },
+                metadataBinding: currentMetadataIdentity
+                    ? { kind: 'pending', sourceIdentity: currentMetadataIdentity }
+                    : { kind: 'legacy' },
             };
         }
         return {

src/test/common/inlineScript/routingRegistry.unit.test.ts

@@ -15,6 +15,41 @@ const METADATA = {
 };
 
 suite('InlineScriptRoutingRegistry', () => {
+    test('invalidates a validated association synchronously when metadata identity changes', () => {
+        const registry = new InlineScriptRoutingRegistry();
+        const uri = Uri.file('/workspace/script.py');
+        const routeabilityEvents: boolean[] = [];
+        registry.onDidChangeRouteability((event) => routeabilityEvents.push(event.routeable));
+        registry.setMetadata(uri, METADATA);
+        registry.setValidatedAssociation(uri, true);
+
+        registry.setMetadata(uri, {
+            ...METADATA,
+            dependencies: ['httpx'],
+        });
+
+        assert.strictEqual(registry.hasValidatedAssociation(uri), false);
+        assert.strictEqual(registry.shouldRoute(uri), false);
+        assert.deepStrictEqual(routeabilityEvents, [true, false]);
+        registry.dispose();
+    });
+
+    test('preserves validation when saved metadata has the same routing identity', () => {
+        const registry = new InlineScriptRoutingRegistry();
+        const uri = Uri.file('/workspace/script.py');
+        registry.setMetadata(uri, METADATA);
+        registry.setValidatedAssociation(uri, true);
+
+        registry.setMetadata(uri, {
+            ...METADATA,
+            dependencies: ['Requests'],
+        });
+
+        assert.strictEqual(registry.hasValidatedAssociation(uri), true);
+        assert.strictEqual(registry.shouldRoute(uri), true);
+        registry.dispose();
+    });
+
     test('keeps metadata revisions monotonic after an empty state is removed', () => {
         const registry = new InlineScriptRoutingRegistry();
         const uri = Uri.file('/workspace/script.py');

src/test/features/envManagers.lastKnown.unit.test.ts

@@ -535,6 +535,107 @@ suite('PythonEnvironmentManagers getLastKnownEnvironment', () => {
         assert.strictEqual(envManagers.getLastKnownEnvironment(script), selectedEnvironment);
     });
 
+    test('publishes through the inline manager after an explicit override is cleared', async () => {
+        const script = Uri.file('/workspace/project/script.py');
+        projectsByUri.set(script.toString(), { name: 'project', uri: Uri.file('/workspace/project') });
+        const selectedSet = sinon.stub().resolves();
+        let selectedEnvironment: PythonEnvironment;
+        const selectedId = registerManager(async () => selectedEnvironment, selectedSet, 'venv');
+        let inlineEnvironment: PythonEnvironment;
+        const inlineGet = sinon.stub().callsFake(async () => inlineEnvironment);
+        const inlineId = registerManager(inlineGet, async () => undefined, 'inline-script');
+        selectedEnvironment = { ...makeEnv('selected'), envId: { id: 'selected', managerId: selectedId } };
+        inlineEnvironment = { ...makeEnv('inline'), envId: { id: 'inline', managerId: inlineId } };
+        defaultManagerId = selectedId;
+        markInlineScript(script);
+        await envManagers.setEnvironment(script, inlineEnvironment, false);
+        await envManagers.setEnvironment(script, selectedEnvironment, false);
+        await new Promise((resolve) => setImmediate(resolve));
+        selectedSet.resetHistory();
+        inlineGet.resetHistory();
+        const events: DidChangeEnvironmentEventArgs[] = [];
+        envManagers.onDidChangeActiveEnvironment((event) => events.push(event));
+
+        await envManagers.setEnvironment(script, undefined, false);
+
+        sinon.assert.calledOnceWithExactly(selectedSet, script, undefined);
+        sinon.assert.calledOnceWithExactly(inlineGet, script);
+        assert.strictEqual(envManagers.getEnvironmentManager(script)?.id, inlineId);
+        assert.strictEqual(envManagers.getLastKnownEnvironment(script), inlineEnvironment);
+        assert.deepStrictEqual(events, [
+            {
+                uri: script,
+                old: selectedEnvironment,
+                new: inlineEnvironment,
+            },
+        ]);
+    });
+
+    test('does not let override clearing overwrite a newer inline selection', async () => {
+        const script = Uri.file('/workspace/project/script.py');
+        projectsByUri.set(script.toString(), { name: 'project', uri: Uri.file('/workspace/project') });
+        let releaseOverrideClear: (() => void) | undefined;
+        let signalOverrideClear: (() => void) | undefined;
+        const overrideClearStarted = new Promise<void>((resolve) => {
+            signalOverrideClear = resolve;
+        });
+        const overrideClearGate = new Promise<void>((resolve) => {
+            releaseOverrideClear = resolve;
+        });
+        const selectedSet = sinon.stub();
+        selectedSet.onFirstCall().resolves();
+        selectedSet.onSecondCall().callsFake(async () => {
+            signalOverrideClear!();
+            await overrideClearGate;
+        });
+        let selectedEnvironment: PythonEnvironment;
+        const selectedId = registerManager(async () => selectedEnvironment, selectedSet, 'venv');
+
+        let releaseNewInline: (() => void) | undefined;
+        let signalNewInline: (() => void) | undefined;
+        const newInlineStarted = new Promise<void>((resolve) => {
+            signalNewInline = resolve;
+        });
+        const newInlineGate = new Promise<void>((resolve) => {
+            releaseNewInline = resolve;
+        });
+        const inlineSet = sinon.stub();
+        inlineSet.onFirstCall().resolves();
+        inlineSet.onSecondCall().callsFake(async () => {
+            signalNewInline!();
+            await newInlineGate;
+        });
+        let inlineEnvironment: PythonEnvironment;
+        const inlineId = registerManager(async () => inlineEnvironment, inlineSet, 'inline-script');
+        const oldInline = {
+            ...makeEnv('old-inline'),
+            envId: { id: 'old-inline', managerId: inlineId },
+        };
+        const newInline = {
+            ...makeEnv('new-inline'),
+            envId: { id: 'new-inline', managerId: inlineId },
+        };
+        inlineEnvironment = oldInline;
+        selectedEnvironment = { ...makeEnv('selected'), envId: { id: 'selected', managerId: selectedId } };
+        defaultManagerId = selectedId;
+        markInlineScript(script);
+        await envManagers.setEnvironment(script, oldInline, false);
+        await envManagers.setEnvironment(script, selectedEnvironment, false);
+
+        const clearOverride = envManagers.setEnvironment(script, undefined, false);
+        await overrideClearStarted;
+        inlineEnvironment = newInline;
+        const newerSelection = envManagers.setEnvironment(script, newInline, false);
+        await newInlineStarted;
+        releaseOverrideClear!();
+        await clearOverride;
+        releaseNewInline!();
+        await newerSelection;
+
+        assert.strictEqual(envManagers.getEnvironmentManager(script)?.id, inlineId);
+        assert.strictEqual(envManagers.getLastKnownEnvironment(script), newInline);
+    });
+
     test('clears inline routing after a no-op inline refresh during settings persistence', async () => {
         const script = Uri.file('/workspace/project/script.py');
         projectsByUri.set(script.toString(), { name: 'project', uri: Uri.file('/workspace/project') });