@dxos/plugin-space 0.10.0 → 0.11.1

package/src/containers/TypeArticle/duplicatesGroup.tsx

@@ -0,0 +1,150 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import React, { useCallback, useMemo } from 'react';
+
+import { useAtomCapabilityState } from '@dxos/app-framework/ui';
+import { type ActionGroupBuilderFn } from '@dxos/react-ui-menu';
+
+import { meta } from '#meta';
+
+import { SpaceCapabilities } from '../../types';
+import { type UseDuplicatesResult, buildMergePreview } from './useDuplicates';
+
+export type UseDuplicatesGroupOptions = {
+  /** URI of the type under review; scopes the staged preview to this article. */
+  typeUri: string;
+  typename: string;
+  duplicates: UseDuplicatesResult;
+};
+
+/**
+ * Toolbar subgraph for the duplicates review: Merge stages a preview into the companion, Skip and
+ * the arrows walk the groups, and the trailing gap separator pushes whatever follows (the layout
+ * toggle) to the far end. Merge never writes — it stages a detached preview the companion confirms,
+ * so backing out of a review leaves the space untouched.
+ *
+ * Compose via `MenuBuilder.subgraph(...)` so the whole toolbar is one action graph rather than
+ * several nested `Toolbar.Root`s.
+ */
+export const useDuplicatesGroup = ({
+  typeUri,
+  typename,
+  duplicates,
+}: UseDuplicatesGroupOptions): ActionGroupBuilderFn => {
+  const [, updateEphemeral] = useAtomCapabilityState(SpaceCapabilities.EphemeralState);
+  const { spec, current, position, total, scanning, next, previous, refresh } = duplicates;
+
+  // Every control that changes which group is under review drops the staged preview: it belongs to
+  // the group it was raised from, and leaving it up would show the companion previewing one group
+  // while the article shows another.
+  const clearPreview = useCallback(
+    () => updateEphemeral((state) => ({ ...state, mergePreview: undefined })),
+    [updateEphemeral],
+  );
+
+  const handleMerge = useCallback(() => {
+    const preview = buildMergePreview(spec, current);
+    if (!preview) {
+      return;
+    }
+    updateEphemeral((state) => ({
+      ...state,
+      mergePreview: { typeUri, typename, objectIds: current.map((object) => object.id), preview },
+    }));
+  }, [updateEphemeral, spec, current, typeUri, typename]);
+
+  // Skip and the next arrow are the same move — advance past the group without writing.
+  const handleAdvance = useCallback(() => {
+    clearPreview();
+    next();
+  }, [clearPreview, next]);
+
+  const handlePrevious = useCallback(() => {
+    clearPreview();
+    previous();
+  }, [clearPreview, previous]);
+
+  const handleRefresh = useCallback(() => {
+    clearPreview();
+    refresh();
+  }, [clearPreview, refresh]);
+
+  return useMemo(
+    () => (builder) => {
+      builder
+        .action(
+          'merge',
+          {
+            label: ['merge-duplicates.label', { ns: meta.profile.key }],
+            icon: 'ph--arrows-merge--regular',
+            variant: 'primary',
+            iconOnly: false,
+            disabled: current.length < 2,
+          },
+          handleMerge,
+        )
+        .action(
+          'skip',
+          {
+            label: ['skip-duplicates.label', { ns: meta.profile.key }],
+            iconOnly: false,
+            // Same bound as the next arrow: skipping past the last group left the counter out of range.
+            disabled: position >= total,
+          },
+          handleAdvance,
+        )
+        .action(
+          'rescan',
+          {
+            label: ['rescan-duplicates.label', { ns: meta.profile.key }],
+            icon: 'ph--arrows-clockwise--regular',
+            disabled: scanning,
+            spin: scanning,
+          },
+          handleRefresh,
+        )
+        .subgraph((builder) =>
+          total === 0
+            ? []
+            : builder
+                .action(
+                  'previous',
+                  {
+                    label: ['previous-duplicate.label', { ns: meta.profile.key }],
+                    icon: 'ph--caret-left--regular',
+                    disabled: position <= 1,
+                  },
+                  handlePrevious,
+                )
+                .action(
+                  'position',
+                  {
+                    // The group counter is not an action; `custom` lets the graph carry it so the toolbar stays
+                    // a single menu rather than a menu plus a hand-rolled toolbar for one label.
+                    variant: 'custom',
+                    label: ['duplicates-position.label', { ns: meta.profile.key }],
+                    render: () => (
+                      <span className='text-description text-sm tabular-nums'>
+                        {position} / {total}
+                      </span>
+                    ),
+                  },
+                  () => {},
+                )
+                .action(
+                  'next',
+                  {
+                    label: ['next-duplicate.label', { ns: meta.profile.key }],
+                    icon: 'ph--caret-right--regular',
+                    disabled: position >= total,
+                  },
+                  handleAdvance,
+                ),
+        )
+        .separator();
+    },
+    [current.length, position, total, scanning, handleMerge, handleAdvance, handlePrevious, handleRefresh],
+  );
+};

package/src/containers/TypeArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { TypeArticle as default } from './TypeArticle';

package/src/containers/TypeArticle/useDuplicates.ts

@@ -0,0 +1,119 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+
+import { useAtomCapability, useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
+import { Obj, Type } from '@dxos/echo';
+import { type IdentitySpec, planMerge } from '@dxos/extractor';
+import { type Space } from '@dxos/react-client/echo';
+
+import { SpaceOperation } from '../../operations/definitions';
+import { SpaceCapabilities } from '../../types';
+
+export type UseDuplicatesProps = {
+  space: Space;
+  type: Type.AnyEntity;
+  /** Live query results, so a group resolves to reactive objects rather than the scan's snapshots. */
+  objects: readonly Obj.Unknown[];
+  /** Scan only while the duplicates layout is showing. */
+  enabled: boolean;
+};
+
+export type UseDuplicatesResult = {
+  /** `undefined` when no plugin registered an identity rule for this type — the tab is then hidden. */
+  spec: IdentitySpec<any> | undefined;
+  /** Members of the group under review, or `[]` when the review is finished. */
+  current: Obj.Unknown[];
+  /** 1-based position of the current group, for the toolbar counter. */
+  position: number;
+  total: number;
+  scanning: boolean;
+  next: () => void;
+  previous: () => void;
+  /** Re-runs the scan (after a merge, or when re-entering the tab). */
+  refresh: () => void;
+};
+
+/**
+ * Drives the duplicates review: runs `FindDuplicates` for the type, then walks the returned groups
+ * one at a time. Groups are held as ids and resolved against the live query on every render, so a
+ * merged-away member disappears from the current group without a rescan.
+ */
+export const useDuplicates = ({ space, type, objects, enabled }: UseDuplicatesProps): UseDuplicatesResult => {
+  const { invokePromise } = useOperationInvoker();
+  const specs = useCapabilities(SpaceCapabilities.IdentitySpec);
+  const typename = Type.getTypename(type);
+  const spec = useMemo(
+    () => specs.find((candidate) => Type.getTypename(candidate.type) === typename),
+    [specs, typename],
+  );
+
+  const [groups, setGroups] = useState<readonly SpaceOperation.DuplicateGroupResult[]>([]);
+  const [index, setIndex] = useState(0);
+  const [scanning, setScanning] = useState(false);
+  // Rescan is a button a user can hit repeatedly, and a merge triggers its own refresh, so responses
+  // can land out of order; only the newest request is allowed to write.
+  const request = useRef(0);
+  const { lastMergeAt } = useAtomCapability(SpaceCapabilities.EphemeralState);
+
+  const refresh = useCallback(() => {
+    if (!spec) {
+      return;
+    }
+    setScanning(true);
+    const current = ++request.current;
+    void invokePromise(SpaceOperation.FindDuplicates, { typename }, { spaceId: space.id })
+      .then(({ data }) => {
+        if (current !== request.current) {
+          return;
+        }
+        setGroups(data?.groups ?? []);
+        setIndex(0);
+      })
+      .finally(() => {
+        if (current === request.current) {
+          setScanning(false);
+        }
+      });
+  }, [invokePromise, spec, typename, space.id]);
+
+  // `lastMergeAt` is a dependency, not a read: a committed merge invalidates the scan.
+  useEffect(() => {
+    if (enabled) {
+      refresh();
+    }
+  }, [enabled, refresh, lastMergeAt]);
+
+  const byId = useMemo(() => new Map(objects.map((object) => [object.id, object])), [objects]);
+  const current = useMemo(() => {
+    const group = groups[index];
+    return group ? group.objectIds.flatMap((id) => byId.get(id) ?? []) : [];
+  }, [groups, index, byId]);
+
+  return {
+    spec,
+    current,
+    position: groups.length === 0 ? 0 : index + 1,
+    total: groups.length,
+    scanning,
+    // Clamp at the last valid index, not at `groups.length`: `position` is `index + 1`, so one past
+    // the end rendered an impossible counter ("4 / 3") when Skip was pressed on the last group.
+    next: useCallback(() => setIndex((value) => Math.min(value + 1, Math.max(groups.length - 1, 0))), [groups.length]),
+    previous: useCallback(() => setIndex((value) => Math.max(value - 1, 0)), []),
+    refresh,
+  };
+};
+
+/** Builds the detached preview for the group under review; `undefined` when there is nothing to merge. */
+export const buildMergePreview = (
+  spec: IdentitySpec<any> | undefined,
+  objects: readonly Obj.Unknown[],
+): Obj.Unknown | undefined => {
+  if (!spec || objects.length < 2) {
+    return undefined;
+  }
+  const { preview } = planMerge(spec, { keys: [], objects });
+  return Obj.isObject(preview) ? preview : undefined;
+};

package/src/containers/ViewEditor/ViewEditor.tsx

@@ -8,9 +8,9 @@ import { useOperationInvoker } from '@dxos/app-framework/ui';
 import { resolveSchemaWithRegistry } from '@dxos/app-toolkit/query';
 import { useTypeOptions } from '@dxos/app-toolkit/ui';
 import { EID, Filter, Obj, Query, type QueryAST, Scope, Tag, Type, type View } from '@dxos/echo';
+import { useQuery } from '@dxos/echo-react';
 import { type Mutable } from '@dxos/echo/Obj';
 import { useClient } from '@dxos/react-client';
-import { useQuery } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 import { ViewEditor as NaturalViewEditor } from '@dxos/react-ui-form';
 import { ViewModel } from '@dxos/schema';
@@ -98,3 +98,5 @@ export const ViewEditor = ({ view }: ViewEditorProps) => {
     />
   );
 };
+
+ViewEditor.displayName = 'ViewEditor';

package/src/containers/index.ts

@@ -16,7 +16,7 @@ export const ImportSpaceDialog: ComponentType<any> = lazy(() => import('./Import
 export const InlineSyncStatus: ComponentType<any> = lazy(() => import('./InlineSyncStatus'));
 export const JoinDialog: ComponentType<any> = lazy(() => import('./JoinDialog'));
 export const MembersContainer: ComponentType<any> = lazy(() => import('./MembersContainer'));
-export const MenuFooter: ComponentType<any> = lazy(() => import('./MenuFooter'));
+export const MergePreview: ComponentType<any> = lazy(() => import('./MergePreview'));
 export const ObjectCardStack: ComponentType<any> = lazy(() => import('./ObjectCardStack'));
 export const RecordArticle: ComponentType<any> = lazy(() => import('./RecordArticle'));
 export const RelatedArticle: ComponentType<any> = lazy(() => import('./RelatedArticle'));
@@ -25,9 +25,10 @@ export const SchemaContainer: ComponentType<any> = lazy(() => import('./SchemaCo
 export const SmallPresenceLive: ComponentType<any> = lazy(() => import('./SmallPresenceLive'));
 export const SpacePresence: ComponentType<any> = lazy(() => import('./SpacePresence'));
 export const SpaceHomeArticle: ComponentType<any> = lazy(() => import('./SpaceHomeArticle'));
+export const SpaceHomeDashboard: ComponentType<any> = lazy(() => import('./SpaceHomeDashboard'));
 export const SpaceHomeRecent: ComponentType<any> = lazy(() => import('./SpaceHomeRecent'));
 export const SpaceSettings: ComponentType<any> = lazy(() => import('./SpaceSettings'));
 export const SpaceSettingsContainer: ComponentType<any> = lazy(() => import('./SpaceSettingsContainer'));
 export const SyncStatus: ComponentType<any> = lazy(() => import('./SyncStatus'));
-export const TypeCollectionArticle: ComponentType<any> = lazy(() => import('./TypeCollectionArticle'));
+export const TypeArticle: ComponentType<any> = lazy(() => import('./TypeArticle'));
 export const ViewEditor: ComponentType<any> = lazy(() => import('./ViewEditor'));

package/src/errors.ts

@@ -9,3 +9,9 @@ export class NoIdentityError extends BaseError.extend(
   'NoIdentityError',
   'A local identity is required to accept a space invitation.',
 ) {}
+
+/** The space's properties object never became available, so it cannot be safely used yet. */
+export class SpaceNotReadyError extends BaseError.extend(
+  'SpaceNotReadyError',
+  'Timed out waiting for the space to finish initializing.',
+) {}

package/src/hooks/index.ts

@@ -2,6 +2,8 @@
 // Copyright 2024 DXOS.org
 //
 
+export * from './useEdgeStatus';
 export * from './useInputSurfaceLookup';
 export * from './usePath';
 export * from './useRelatedObjects';
+export * from './useStalled';

package/src/hooks/useEdgeStatus.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useEffect, useState } from 'react';
+
+import { log } from '@dxos/log';
+import { EdgeStatus } from '@dxos/protocols/proto/dxos/client/services';
+import { useClient } from '@dxos/react-client';
+
+const NOT_CONNECTED: EdgeStatus = {
+  state: EdgeStatus.ConnectionState.NOT_CONNECTED,
+  rtt: 0,
+  uptime: 0,
+  rateBytesUp: 0,
+  rateBytesDown: 0,
+  messagesSent: 0,
+  messagesReceived: 0,
+};
+
+/**
+ * Subscribes to the EDGE connection status, which the client refreshes about once a second while connected.
+ */
+export const useEdgeStatus = (): EdgeStatus => {
+  const client = useClient();
+  const [status, setStatus] = useState<EdgeStatus>(NOT_CONNECTED);
+  useEffect(() => {
+    const stream = client.services.services.EdgeAgentService?.queryEdgeStatus();
+    stream?.subscribe(
+      ({ status }) => setStatus(status),
+      (err) => err && log.catch(err),
+    );
+
+    return () => {
+      void stream?.close();
+    };
+  }, [client]);
+
+  return status;
+};

package/src/hooks/useInputSurfaceLookup.tsx

@@ -4,7 +4,7 @@
 
 import React, { useCallback } from 'react';
 
-import { Surface, usePluginManager } from '@dxos/app-framework/ui';
+import { Surface } from '@dxos/app-framework/ui';
 import { AppSurface } from '@dxos/app-toolkit/ui';
 import { type FormFieldProvider } from '@dxos/react-ui-form';
 
@@ -15,7 +15,7 @@ import { type FormFieldProvider } from '@dxos/react-ui-form';
  */
 // TODO(burdon): Factor out?
 export const useInputSurfaceLookup = (baseData?: Record<string, any>): FormFieldProvider => {
-  const pluginManager = usePluginManager();
+  const isSurfaceAvailable = Surface.useIsAvailable();
   return useCallback<FormFieldProvider>(
     ({ schema, prop, fieldProps }) => {
       const data = {
@@ -25,11 +25,12 @@ export const useInputSurfaceLookup = (baseData?: Record<string, any>): FormField
         fieldPropertyAst: fieldProps.type,
         ...baseData,
       };
+
       const { type: _fieldPropertyAstExcluded, ...surfaceFieldProps } = fieldProps as Record<string, any>;
-      if (Surface.isAvailable(pluginManager.capabilities, { type: AppSurface.FormInput, data })) {
+      if (isSurfaceAvailable({ type: AppSurface.FormInput, data })) {
         return <Surface.Surface type={AppSurface.FormInput} data={data} {...surfaceFieldProps} />;
       }
     },
-    [pluginManager, baseData],
+    [isSurfaceAvailable, baseData],
   );
 };

package/src/hooks/useRelatedObjects.ts

@@ -6,8 +6,8 @@ import * as Option from 'effect/Option';
 import { useMemo } from 'react';
 
 import { type Database, Entity, Filter, Obj, Ref, Relation, Type } from '@dxos/echo';
+import { useQuery } from '@dxos/echo-react';
 import { HiddenAnnotation } from '@dxos/echo/Annotation';
-import { useQuery } from '@dxos/react-client/echo';
 import { isNonNullable } from '@dxos/util';
 
 /**

package/src/hooks/useStalled.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { useEffect, useState } from 'react';
+
+import { log } from '@dxos/log';
+
+export const STALLED_TIMEOUT = 5_000;
+
+export type UseStalledOptions = {
+  /** Whether work is outstanding; the timer only runs while true. */
+  active: boolean;
+  /** Any change re-arms the timer, so slow-but-advancing work is never reported as stalled. */
+  progress: number;
+  timeout?: number;
+};
+
+/**
+ * Reports true once active work has made no progress for `timeout`.
+ */
+export const useStalled = ({ active, progress, timeout = STALLED_TIMEOUT }: UseStalledOptions): boolean => {
+  const [stalled, setStalled] = useState(false);
+  useEffect(() => {
+    setStalled(false);
+    if (!active) {
+      return;
+    }
+
+    const timer = setTimeout(() => {
+      log.warn('stalled', { progress, timeout });
+      setStalled(true);
+    }, timeout);
+
+    return () => clearTimeout(timer);
+  }, [active, progress, timeout]);
+
+  return stalled;
+};

package/src/operations/add-object.ts

@@ -3,7 +3,7 @@
 import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 
-import { AppNode, CollectionModel, Paths } from '@dxos/app-toolkit';
+import { AppNode, CollectionModel, GraphPath } from '@dxos/app-toolkit';
 import { Operation } from '@dxos/compute';
 import { Database, Filter, Obj, Query, Scope, Type } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
@@ -54,7 +54,7 @@ const handler: Operation.WithHandler<typeof SpaceOperation.AddObject> = SpaceOpe
       // Graph type nodes are keyed by a slash-free slug (entity id for stored types, typename for
       // static); resolve the object's own type slug rather than filing it under its (human) typename.
       const objectType = Obj.getType(object);
-      const typeSlug = objectType ? Paths.getTypeSlug(objectType) : typename;
+      const typeSlug = objectType ? GraphPath.getTypeSlug(objectType) : typename;
       const subject = getSubjectPathForNewObject({
         spaceId: db.spaceId,
         objectId: object.id,
@@ -62,7 +62,7 @@ const handler: Operation.WithHandler<typeof SpaceOperation.AddObject> = SpaceOpe
         object,
         typename,
         typeSlug,
-        viewTargetSlug: viewTargetUri ? Paths.getTypeSlugFromUri(viewTargetUri) : undefined,
+        viewTargetSlug: viewTargetUri ? GraphPath.getTypeSlugFromUri(viewTargetUri) : undefined,
       });
 
       return {
@@ -88,13 +88,13 @@ const getSubjectPathForNewObject = (props: {
 }): string => {
   const { nodeId, object, typeSlug, viewTargetSlug, spaceId, objectId } = props;
   if (typeof nodeId === 'string') {
-    return Paths.getCollectionObjectPath(nodeId, objectId);
+    return GraphPath.getCollectionObjectPath(nodeId, objectId);
   }
   if (AppNode.isCollectionItem(object)) {
-    return Paths.getCollectionsPath(spaceId, objectId);
+    return GraphPath.getCollectionsPath(spaceId, objectId);
   }
   if (viewTargetSlug) {
-    return Paths.getTypePath(spaceId, viewTargetSlug, objectId);
+    return GraphPath.getTypePath(spaceId, viewTargetSlug, objectId);
   }
-  return Paths.getObjectPath(spaceId, typeSlug, objectId);
+  return GraphPath.getObjectPath(spaceId, typeSlug, objectId);
 };

package/src/operations/create.ts

@@ -1,5 +1,6 @@
 // Copyright 2025 DXOS.org
 
+import * as Duration from 'effect/Duration';
 import * as Effect from 'effect/Effect';
 
 import { Capability, Plugin } from '@dxos/app-framework';
@@ -10,13 +11,17 @@ import { Migrations, MigrationVersionAnnotation } from '@dxos/migrations';
 import { ClientCapabilities } from '@dxos/plugin-client';
 import { ObservabilityOperation } from '@dxos/plugin-observability';
 import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
-import { iconValues } from '@dxos/react-ui-pickers/icons';
-import { hues } from '@dxos/ui-theme';
+import { hues } from '@dxos/ui-types';
+import { iconValues } from '@dxos/ui-types';
 
+import { SpaceNotReadyError } from '../errors';
 import { SpaceCapabilities, SpaceEvents } from '../types';
 import { SpaceOperation } from './definitions';
 import { SpaceOperationConfig } from './helpers';
 
+/** Bounds how long space creation waits for the new space's properties object to become available. */
+const SPACE_READY_TIMEOUT = Duration.seconds(10);
+
 const handler: Operation.WithHandler<typeof SpaceOperation.Create> = SpaceOperation.Create.pipe(
   Operation.withHandler(
     Effect.fnUntraced(function* ({ name, hue: hue_, icon: icon_, edgeReplication }) {
@@ -33,7 +38,10 @@ const handler: Operation.WithHandler<typeof SpaceOperation.Create> = SpaceOperat
       if (edgeReplication) {
         yield* Effect.promise(() => space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED));
       }
-      yield* Effect.promise(() => space.waitUntilReady());
+      yield* Effect.tryPromise({
+        try: () => space.waitUntilReady(),
+        catch: SpaceNotReadyError.wrap(),
+      }).pipe(Effect.timeoutFail({ duration: SPACE_READY_TIMEOUT, onTimeout: () => new SpaceNotReadyError() }));
 
       const collection = Obj.make(Collection.Collection, { objects: [] });
       Obj.update(space.properties, (properties) => {

package/src/operations/definitions.ts

@@ -13,7 +13,9 @@ import { SpaceArchive } from '@dxos/protocols/proto/dxos/client/services';
 
 import { meta } from '#meta';
 
-import { SpaceForm } from '../types';
+// Direct module import: the `../types` barrel re-exports `capabilities.ts`, which pulls React UI
+// into any worker bundle that registers these operations.
+import { SpaceForm } from '../types/types';
 
 const COLLECTION_OPERATION = 'org.dxos.plugin.collection.operation';
 
@@ -519,4 +521,55 @@ export namespace SpaceOperation {
     }),
     output: Schema.Void,
   });
+
+  /** A duplicate tuple, addressed by id so the group crosses the operation boundary. */
+  export const DuplicateGroupResult = Schema.Struct({
+    keys: Schema.Array(Schema.String).annotations({ description: 'Identity keys shared by the members.' }),
+    objectIds: Schema.Array(Schema.String).annotations({ description: 'Members, in EntityId order.' }),
+  });
+
+  export type DuplicateGroupResult = Schema.Schema.Type<typeof DuplicateGroupResult>;
+
+  /**
+   * Groups objects of a type that share an identity key. The rule is the `IdentitySpec` the owning
+   * plugin contributes for that typename — the same rule the extractor uses to decide create vs
+   * merge, so a scan never disagrees with what extraction would have done.
+   */
+  export const FindDuplicates = Operation.make({
+    meta: {
+      key: makeKey('findDuplicates'),
+      name: 'Find Duplicates',
+      description: 'Group objects of a type that share an identity key (e.g. an email address).',
+      icon: 'ph--copy--regular',
+    },
+    services: [Capability.Service, Database.Service],
+    input: Schema.Struct({
+      typename: Schema.String.annotations({ description: 'ECHO typename to scan.' }),
+    }),
+    output: Schema.Struct({
+      groups: Schema.Array(DuplicateGroupResult).annotations({ description: 'Largest group first.' }),
+    }),
+  });
+
+  /** Merges a duplicate group into its lowest-EntityId member and removes the others. */
+  export const MergeDuplicates = Operation.make({
+    meta: {
+      key: makeKey('mergeDuplicates'),
+      name: 'Merge Duplicates',
+      description: 'Merge a duplicate group into a single object.',
+      icon: 'ph--arrows-merge--regular',
+    },
+    services: [Capability.Service, Database.Service],
+    input: Schema.Struct({
+      typename: Schema.String,
+      objectIds: Schema.Array(Schema.String).annotations({ description: 'Members of the group to merge.' }),
+      overrides: Schema.optional(Obj.Unknown).annotations({
+        description: 'User-edited preview; folded in last so confirmed edits win.',
+      }),
+    }),
+    output: Schema.Struct({
+      survivorId: Schema.String,
+      removedIds: Schema.Array(Schema.String),
+    }),
+  });
 }

package/src/operations/find-duplicates.ts

@@ -0,0 +1,33 @@
+// Copyright 2026 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+import { Database, Filter, Query } from '@dxos/echo';
+import { findDuplicates } from '@dxos/extractor';
+
+import { SpaceOperation } from './definitions';
+import { resolveIdentitySpec } from './helpers';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.FindDuplicates> = SpaceOperation.FindDuplicates.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ typename }) {
+      const spec = yield* resolveIdentitySpec(typename);
+      if (!spec) {
+        return { groups: [] };
+      }
+
+      // Query through the spec's own type entity rather than the bare typename, so the filter uses
+      // the same type identity the spec was registered under.
+      const objects = yield* Database.query(Query.select(Filter.type(spec.type))).run;
+      return {
+        groups: findDuplicates(spec, objects).map((group) => ({
+          keys: group.keys,
+          objectIds: group.objects.map((object) => object.id),
+        })),
+      };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/get-share-link.ts

@@ -11,7 +11,7 @@ import { SpaceOperationConfig } from './helpers';
 const handler: Operation.WithHandler<typeof SpaceOperation.GetShareLink> = SpaceOperation.GetShareLink.pipe(
   Operation.withHandler(
     Effect.fnUntraced(function* (input) {
-      const { Invitation, InvitationEncoder } = yield* Effect.promise(() => import('@dxos/react-client/invitations'));
+      const { Invitation, InvitationEncoder } = yield* Effect.promise(() => import('@dxos/client/invitations'));
 
       const invitation = yield* Operation.invoke(SpaceOperation.Share, {
         space: input.space,