Preserve explicit routing overrides

Keep overrides through manager refreshes and reject malformed association schema versions.

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

Author: StellaHuang95

src/features/envManagers.ts

@@ -580,7 +580,6 @@ export class PythonEnvironmentManagers implements EnvironmentManagers {
                     await manager.set(uris);
                     await Promise.all(
                         selections.map(async (selection) => {
-                            this.clearInlineRoutingOverride(selection.scope);
                             const newEnv = await manager.get(selection.scope);
                             if (!this.commitSelectionOperation(selection.key, selection.operation)) {
                                 return;
@@ -797,13 +796,6 @@ export class PythonEnvironmentManagers implements EnvironmentManagers {
         this._inlineRoutingOverrides.set(key, manager.id);
     }
 
-    private clearInlineRoutingOverride(scope: Uri): void {
-        if (!this.inlineScriptRouting) {
-            return;
-        }
-        this._inlineRoutingOverrides.delete(this.getInlineScriptSelectionKey(scope));
-    }
-
     private async publishEffectiveEnvironmentAfterOverrideClear(
         scope: Uri,
         previousManager: InternalEnvironmentManager,

src/managers/builtin/inlineScript/envManager.ts

@@ -2050,12 +2050,15 @@ export class InlineScriptEnvManager implements EnvironmentManager, Disposable {
         }
         const association = value as Record<string, unknown>;
         const schemaVersion = association.schemaVersion;
-        if (typeof schemaVersion !== 'number') {
+        if (typeof schemaVersion !== 'number' || !Number.isSafeInteger(schemaVersion) || schemaVersion <= 0) {
             return { kind: 'invalid' };
         }
-        if (schemaVersion !== PERSISTED_ASSOCIATION_SCHEMA_VERSION) {
+        if (schemaVersion > PERSISTED_ASSOCIATION_SCHEMA_VERSION) {
             return { kind: 'future' };
         }
+        if (schemaVersion !== PERSISTED_ASSOCIATION_SCHEMA_VERSION) {
+            return { kind: 'invalid' };
+        }
         const environmentPath = association.environmentPath;
         const metadataBinding = association.metadataBinding;
         if (typeof environmentPath !== 'string' || environmentPath.length === 0) {

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

@@ -535,6 +535,26 @@ suite('PythonEnvironmentManagers getLastKnownEnvironment', () => {
         assert.strictEqual(envManagers.getLastKnownEnvironment(script), selectedEnvironment);
     });
 
+    test('preserves an explicit non-inline override during a batch manager refresh', async () => {
+        const script = Uri.file('/workspace/project/script.py');
+        projectsByUri.set(script.toString(), { name: 'project', uri: Uri.file('/workspace/project') });
+        let selectedEnvironment: PythonEnvironment;
+        const selectedId = registerManager(async () => selectedEnvironment, async () => undefined, 'venv');
+        let inlineEnvironment: PythonEnvironment;
+        const inlineId = registerManager(async () => inlineEnvironment, 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 envManagers.setEnvironments([script], undefined, false);
+
+        assert.strictEqual(envManagers.getEnvironmentManager(script)?.id, selectedId);
+        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') });

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

@@ -3818,6 +3818,36 @@ suite('InlineScriptEnvManager', () => {
             assert.strictEqual(await manager.get(futureUri), undefined);
         });
 
+        for (const schemaVersion of [0, -1, 1.5, Number.NaN, Number.POSITIVE_INFINITY]) {
+            test(`repairs a malformed numeric schema version (${String(schemaVersion)})`, async () => {
+                const invalidUri = scriptUri('invalid.py');
+                const validUri = scriptUri('valid.py');
+                const invalidEnvironment = await createOwnedEnvironment('0011223344556677');
+                const validEnvironment = await createOwnedEnvironment('fedcba9876543210');
+                persistedAssociations = {
+                    [normalizePath(invalidUri.fsPath)]: {
+                        schemaVersion,
+                        environmentPath: invalidEnvironment.environmentPath.fsPath,
+                        metadataBinding: {
+                            kind: 'matched',
+                            sourceIdentity: VALID_METADATA_IDENTITY,
+                        },
+                    },
+                    [normalizePath(validUri.fsPath)]: matchedAssociationRecord(
+                        validEnvironment.environmentPath.fsPath,
+                    ),
+                };
+
+                assert.strictEqual(await manager.get(invalidUri), undefined);
+
+                assert.deepStrictEqual(persistedAssociations, {
+                    [normalizePath(validUri.fsPath)]: matchedAssociationRecord(
+                        validEnvironment.environmentPath.fsPath,
+                    ),
+                });
+            });
+        }
+
         test('removes a requested record with an unknown current binding kind without affecting unrelated entries', async () => {
             const invalidUri = scriptUri('invalid.py');
             const validUri = scriptUri('valid.py');