fix(org-browser): deduplicate metadata list results to prevent tree registration errors (#7321)

* fix(org-browser): deduplicate metadata list results to prevent tree registration errors

The Metadata API can return duplicate FileProperties for the same component
(e.g. Account appearing twice in orgs with Person Account enabled). This causes
the Org Browser TreeView to crash with "Element with id CustomObject:Account is
already registered". Deduplicate after sorting since duplicates are adjacent.

Fixes #7212

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* refactor: dedupe listMetadata via Arr.dedupeAdjacentWith + Equivalence

Extract the fullName dedup into a named Effect Equivalence colocated
with FilePropertiesSchema, and use Arr.dedupeAdjacentWith instead of an
inline index filter. Decode now runs before sort/dedup so the
Equivalence operates on decoded values. Adds unit tests covering sort,
single-object coercion, dedup, and combined cases.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: mshanemc <shane.mclaughlin@salesforce.com>

Author: 3 people

packages/salesforcedx-vscode-services/src/core/metadataDescribeService.ts

@@ -6,6 +6,7 @@
  */
 
 import type { Connection } from '@salesforce/core';
+import * as Arr from 'effect/Array';
 import * as Cache from 'effect/Cache';
 import * as Chunk from 'effect/Chunk';
 import * as Duration from 'effect/Duration';
@@ -20,7 +21,7 @@ import { ExtensionContextService } from '../vscode/extensionContextService';
 import { SettingsService } from '../vscode/settingsService';
 import { ConnectionService } from './connectionService';
 import { getDefaultOrgRef } from './defaultOrgRef';
-import { FilePropertiesSchema } from './schemas/fileProperties';
+import { FilePropertiesByFullName, FilePropertiesSchema } from './schemas/fileProperties';
 import { unknownToErrorCause } from './shared';
 
 const NON_SUPPORTED_TYPES = new Set(['InstalledPackage', 'Profile', 'Scontrol']);
@@ -176,8 +177,9 @@ export class MetadataDescribeService extends Effect.Service<MetadataDescribeServ
         Effect.tap(result => Effect.annotateCurrentSpan({ result })),
         Effect.withSpan('listMetadata (API call)'),
         Effect.map(ensureArray),
-        Effect.map(arr => arr.toSorted((a, b) => a.fullName.localeCompare(b.fullName))),
         Effect.flatMap(arr => S.decodeUnknown(S.Array(FilePropertiesSchema))(arr)),
+        Effect.map(arr => arr.toSorted((a, b) => a.fullName.localeCompare(b.fullName))),
+        Effect.map(Arr.dedupeAdjacentWith(FilePropertiesByFullName)),
         Effect.mapError(e => {
           const { cause } = unknownToErrorCause(e);
           return new ListMetadataError({

packages/salesforcedx-vscode-services/src/core/schemas/fileProperties.ts

@@ -4,6 +4,7 @@
  * Licensed under the BSD 3-Clause license.
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
+import * as Equivalence from 'effect/Equivalence';
 import * as S from 'effect/Schema';
 
 /** Schema for FileProperties (metadata.list result) */
@@ -21,3 +22,9 @@ export const FilePropertiesSchema = S.Struct({
   manageableState: S.optional(S.String),
   namespacePrefix: S.optional(S.String)
 });
+
+/** Equivalence for FileProperties keyed on fullName — for deduping listMetadata results. */
+export const FilePropertiesByFullName = Equivalence.mapInput(
+  Equivalence.string,
+  (fp: S.Schema.Type<typeof FilePropertiesSchema>) => fp.fullName
+);

packages/salesforcedx-vscode-services/test/jest/core/metadataDescribeService.test.ts

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2026, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+import type { Connection } from '@salesforce/core';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as SubscriptionRef from 'effect/SubscriptionRef';
+import { ChannelService } from '../../../src/vscode/channelService';
+import { ConnectionService } from '../../../src/core/connectionService';
+import { getDefaultOrgRef } from '../../../src/core/defaultOrgRef';
+import { MetadataDescribeService } from '../../../src/core/metadataDescribeService';
+
+type ListItem = {
+  fullName: string;
+  type: string;
+  id?: string;
+  lastModifiedDate?: string;
+};
+
+const createMockConnectionService = (listResult: ListItem | ListItem[]): Layer.Layer<ConnectionService> =>
+  Layer.succeed(
+    ConnectionService,
+    ConnectionService.make({
+      getConnection: () =>
+        Effect.succeed({
+          version: '60.0',
+          metadata: {
+            list: jest.fn().mockResolvedValue(listResult)
+          }
+        } as unknown as Connection),
+      invalidateCachedConnections: () => Effect.void
+    })
+  );
+
+const seedDefaultOrg = Effect.gen(function* () {
+  const ref = yield* getDefaultOrgRef();
+  yield* SubscriptionRef.update(ref, () => ({ orgId: 'test-org' }));
+});
+
+const runListMetadata = (listResult: ListItem | ListItem[], type = 'ApexClass') =>
+  Effect.runPromise(
+    Effect.gen(function* () {
+      yield* seedDefaultOrg;
+      const service = yield* MetadataDescribeService;
+      return yield* service.listMetadata(type);
+    }).pipe(
+      Effect.provide(
+        Layer.provide(
+          MetadataDescribeService.DefaultWithoutDependencies,
+          Layer.mergeAll(createMockConnectionService(listResult), ChannelService.Default)
+        )
+      )
+    )
+  );
+
+describe('MetadataDescribeService.listMetadata', () => {
+  it('sorts an out-of-order array by fullName', async () => {
+    const result = await runListMetadata([
+      { fullName: 'Charlie', type: 'ApexClass' },
+      { fullName: 'Alpha', type: 'ApexClass' },
+      { fullName: 'Bravo', type: 'ApexClass' }
+    ]);
+
+    expect(result.map(r => r.fullName)).toEqual(['Alpha', 'Bravo', 'Charlie']);
+  });
+
+  it('wraps a non-array (single object) response into an array of one', async () => {
+    const result = await runListMetadata({ fullName: 'Solo', type: 'ApexClass' });
+
+    expect(result).toHaveLength(1);
+    expect(result[0].fullName).toBe('Solo');
+  });
+
+  it('deduplicates entries with the same fullName', async () => {
+    const result = await runListMetadata([
+      { fullName: 'Dup', type: 'ApexClass', id: '1' },
+      { fullName: 'Dup', type: 'ApexClass', id: '2' },
+      { fullName: 'Unique', type: 'ApexClass' }
+    ]);
+
+    expect(result.map(r => r.fullName)).toEqual(['Dup', 'Unique']);
+  });
+
+  it('handles out-of-order, duplicate, and single-fullName entries together', async () => {
+    const result = await runListMetadata([
+      { fullName: 'Charlie', type: 'ApexClass', id: 'c1' },
+      { fullName: 'Alpha', type: 'ApexClass', id: 'a1' },
+      { fullName: 'Charlie', type: 'ApexClass', id: 'c2' },
+      { fullName: 'Bravo', type: 'ApexClass' },
+      { fullName: 'Alpha', type: 'ApexClass', id: 'a2' }
+    ]);
+
+    expect(result.map(r => r.fullName)).toEqual(['Alpha', 'Bravo', 'Charlie']);
+  });
+});