@dxos/plugin-space 0.8.4-main.422d1c7879 → 0.8.4-main.4668b7de9b

package/src/operations/definitions.ts

@@ -7,8 +7,9 @@ import * as Schema from 'effect/Schema';
 import { Capability, Plugin } from '@dxos/app-framework';
 import { SpaceSchema } from '@dxos/client/echo';
 import { CancellableInvitationObservable, Invitation } from '@dxos/client/invitations';
-import { Collection, Database, Obj, QueryAST, Type, View } from '@dxos/echo';
-import { Operation } from '@dxos/operation';
+import { Operation } from '@dxos/compute';
+import { Collection, Database, Entity, Obj, QueryAST, Type, View, DXN } from '@dxos/echo';
+import { SpaceArchive } from '@dxos/protocols/proto/dxos/client/services';
 
 import { meta } from '#meta';
 
@@ -18,18 +19,18 @@ const COLLECTION_OPERATION = 'org.dxos.plugin.collection.operation';
 
 export namespace CollectionOperation {
   export const Create = Operation.make({
-    meta: { key: `${COLLECTION_OPERATION}.create`, name: 'Create Collection' },
+    meta: { key: DXN.make(`${COLLECTION_OPERATION}.create`), name: 'Create Collection', icon: 'ph--folder--regular' },
     services: [Capability.Service],
     input: Schema.Struct({
       name: Schema.optional(Schema.String),
     }),
     output: Schema.Struct({
-      object: Collection.Collection,
+      object: Type.getSchema(Collection.Collection),
     }),
   });
 }
 
-const SPACE_OPERATION = `${meta.id}.operation`;
+const makeKey = (name: string) => DXN.make(`${meta.id}.operation.${name}`);
 
 /**
  * Operations for the Space plugin.
@@ -37,9 +38,10 @@ const SPACE_OPERATION = `${meta.id}.operation`;
 export namespace SpaceOperation {
   export const Create = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.create`,
+      key: makeKey('create'),
       name: 'Create Space',
       description: 'Create a new space.',
+      icon: 'ph--plus--regular',
     },
     services: [Capability.Service, Plugin.Service],
     input: SpaceForm,
@@ -52,9 +54,10 @@ export namespace SpaceOperation {
 
   export const Join = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.join`,
+      key: makeKey('join'),
       name: 'Join Space',
       description: 'Join a space via invitation.',
+      icon: 'ph--sign-in--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
@@ -66,9 +69,10 @@ export namespace SpaceOperation {
 
   export const Open = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.open`,
+      key: makeKey('open'),
       name: 'Open Space',
       description: 'Open a space.',
+      icon: 'ph--arrow-square-out--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
@@ -79,9 +83,24 @@ export namespace SpaceOperation {
 
   export const Close = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.close`,
+      key: makeKey('close'),
       name: 'Close Space',
       description: 'Close a space.',
+      icon: 'ph--x-circle--regular',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      space: SpaceSchema,
+    }),
+    output: Schema.Void,
+  });
+
+  export const Delete = Operation.make({
+    meta: {
+      key: makeKey('delete'),
+      name: 'Delete Space',
+      description: 'Delete a space. The deletion replicates to all of your devices.',
+      icon: 'ph--trash--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
@@ -92,9 +111,10 @@ export namespace SpaceOperation {
 
   export const Share = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.share`,
+      key: makeKey('share'),
       name: 'Share Space',
       description: 'Share a space.',
+      icon: 'ph--share-network--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
@@ -109,9 +129,10 @@ export namespace SpaceOperation {
 
   export const OpenSettings = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.open-settings`,
+      key: makeKey('openSettings'),
       name: 'Open Space Settings',
       description: 'Open space settings.',
+      icon: 'ph--gear--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
@@ -122,9 +143,10 @@ export namespace SpaceOperation {
 
   export const WaitForObject = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.wait-for-object`,
+      key: makeKey('waitForObject'),
       name: 'Wait For Object',
       description: 'Wait for an object to be available.',
+      icon: 'ph--clock-countdown--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
@@ -135,14 +157,15 @@ export namespace SpaceOperation {
 
   export const AddObject = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.add-object`,
+      key: makeKey('addObject'),
       name: 'Add Object',
       description: 'Add an object to a space.',
+      icon: 'ph--plus--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
       object: Obj.Unknown.annotations({ description: 'The object to add.' }),
-      target: Schema.Union(Database.Database, Collection.Collection).annotations({
+      target: Schema.Union(Database.Database, Type.getSchema(Collection.Collection)).annotations({
         description: 'The database or collection to add to.',
       }),
       hidden: Schema.optional(Schema.Boolean),
@@ -157,13 +180,13 @@ export namespace SpaceOperation {
     }),
   });
 
+  // TODO(wittjosiah): Rename `objects` to `entities` (covers objects, relations, and persisted types).
   export const RemoveObjectsOutput = Schema.Struct({
-    objects: Schema.Array(Obj.Unknown).annotations({ description: 'The removed objects.' }),
-    parentCollection: Collection.Collection.annotations({ description: 'The collection removed from.' }),
-    indices: Schema.Array(Schema.Number).annotations({ description: 'The indices the objects were at.' }),
-    nestedObjectsList: Schema.Array(Schema.Array(Obj.Unknown)).annotations({
-      description: 'Nested objects that were removed.',
+    objects: Schema.Array(Entity.Unknown).annotations({ description: 'The removed entities.' }),
+    parentCollection: Type.getSchema(Collection.Collection).annotations({
+      description: 'The collection removed from.',
     }),
+    indices: Schema.Array(Schema.Number).annotations({ description: 'The indices the objects were at.' }),
     wasActive: Schema.Array(Schema.String).annotations({
       description: 'IDs of objects that were active before removal.',
     }),
@@ -173,14 +196,17 @@ export namespace SpaceOperation {
 
   export const RemoveObjects = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.remove-objects`,
+      key: makeKey('removeObjects'),
       name: 'Remove Objects',
-      description: 'Remove objects from a space.',
+      description: 'Remove entities (objects, relations, or persisted types) from a space.',
+      icon: 'ph--trash--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
-      objects: Schema.Array(Obj.Unknown).annotations({ description: 'The objects to remove.' }),
-      target: Schema.optional(Collection.Collection).annotations({ description: 'The collection to remove from.' }),
+      objects: Schema.Array(Entity.Unknown).annotations({ description: 'The entities to remove.' }),
+      target: Schema.optional(Type.getSchema(Collection.Collection)).annotations({
+        description: 'The collection to remove from.',
+      }),
     }),
     output: RemoveObjectsOutput,
   });
@@ -196,13 +222,14 @@ export namespace SpaceOperation {
 
   export const DeleteField = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.delete-field`,
+      key: makeKey('deleteField'),
       name: 'Delete Field',
       description: 'Delete a field from a view.',
+      icon: 'ph--minus-circle--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
-      view: View.View.annotations({ description: 'The view to delete the field from.' }),
+      view: Type.getSchema(View.View).annotations({ description: 'The view to delete the field from.' }),
       fieldId: Schema.String,
     }),
     output: DeleteFieldOutput,
@@ -210,13 +237,14 @@ export namespace SpaceOperation {
 
   export const OpenCreateObject = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.open-create-object`,
+      key: makeKey('openCreateObject'),
       name: 'Open Create Object Dialog',
       description: 'Open the create object dialog.',
+      icon: 'ph--plus--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
-      target: Schema.Union(Database.Database, Collection.Collection).annotations({
+      target: Schema.Union(Database.Database, Type.getSchema(Collection.Collection)).annotations({
         description: 'The database or collection to create in.',
       }),
       views: Schema.optional(Schema.Boolean),
@@ -234,20 +262,69 @@ export namespace SpaceOperation {
 
   export const OpenCreateSpace = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.open-create-space`,
+      key: makeKey('openCreateSpace'),
       name: 'Open Create Space Dialog',
       description: 'Open the create space dialog.',
+      icon: 'ph--plus--regular',
     },
     services: [Capability.Service],
     input: Schema.Void,
     output: Schema.Void,
   });
 
+  export const OpenImportSpace = Operation.make({
+    meta: {
+      key: makeKey('openImportSpace'),
+      name: 'Open Import Space Dialog',
+      description: 'Open the import space dialog to create a new space from a backup.',
+      icon: 'ph--download--regular',
+    },
+    services: [Capability.Service],
+    input: Schema.Void,
+    output: Schema.Void,
+  });
+
+  export const ImportSpace = Operation.make({
+    meta: {
+      key: makeKey('importSpace'),
+      name: 'Import Space',
+      description: 'Import a space archive as a new space.',
+      icon: 'ph--upload--regular',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      archive: Schema.Struct({
+        filename: Schema.String,
+        contents: Schema.instanceOf(Uint8Array),
+      }),
+      tags: Schema.Array(Schema.String).pipe(Schema.optional),
+    }),
+    output: Schema.Struct({
+      space: SpaceSchema,
+    }),
+  });
+
+  export const ExportSpace = Operation.make({
+    meta: {
+      key: makeKey('exportSpace'),
+      name: 'Export Space',
+      description: 'Export a space as a backup and download the archive.',
+      icon: 'ph--download--regular',
+    },
+    services: [Capability.Service],
+    input: Schema.Struct({
+      space: SpaceSchema,
+      format: Schema.Enums(SpaceArchive.Format),
+    }),
+    output: Schema.Void,
+  });
+
   export const Migrate = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.migrate`,
+      key: makeKey('migrate'),
       name: 'Migrate Space',
       description: 'Migrate a space to a new version.',
+      icon: 'ph--arrows-clockwise--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
@@ -259,9 +336,10 @@ export namespace SpaceOperation {
 
   export const Snapshot = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.snapshot`,
+      key: makeKey('snapshot'),
       name: 'Create Snapshot',
       description: 'Create a snapshot of the space.',
+      icon: 'ph--camera--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
@@ -275,9 +353,10 @@ export namespace SpaceOperation {
 
   export const Rename = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.rename`,
+      key: makeKey('rename'),
       name: 'Rename Space',
       description: 'Rename a space.',
+      icon: 'ph--pencil-simple--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
@@ -289,13 +368,14 @@ export namespace SpaceOperation {
 
   export const RenameObject = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.rename-object`,
+      key: makeKey('renameObject'),
       name: 'Rename Object',
-      description: 'Rename an object.',
+      description: 'Rename an entity (object, relation, or persisted type).',
+      icon: 'ph--pencil-simple--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
-      object: Obj.Unknown,
+      object: Entity.Unknown,
       caller: Schema.optional(Schema.String),
     }),
     output: Schema.Void,
@@ -303,9 +383,10 @@ export namespace SpaceOperation {
 
   export const OpenMembers = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.open-members`,
+      key: makeKey('openMembers'),
       name: 'Open Members',
       description: 'Open the members panel for a space.',
+      icon: 'ph--users--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
@@ -316,9 +397,10 @@ export namespace SpaceOperation {
 
   export const GetShareLink = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.get-share-link`,
+      key: makeKey('getShareLink'),
       name: 'Get Share Link',
       description: 'Get a shareable link for a space.',
+      icon: 'ph--link--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
@@ -333,11 +415,12 @@ export namespace SpaceOperation {
     name: Schema.optional(Schema.String),
   });
 
-  export const AddSchema = Operation.make({
+  export const AddType = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.add-schema`,
-      name: 'Add Schema',
-      description: 'Add a schema to the space.',
+      key: makeKey('addType'),
+      name: 'Add Type',
+      description: 'Add a type to the space.',
+      icon: 'ph--code--regular',
     },
     services: [Capability.Service, Plugin.Service],
     input: Schema.Struct({
@@ -345,22 +428,22 @@ export namespace SpaceOperation {
       name: Schema.optional(Schema.String),
       typename: Schema.optional(Schema.String),
       version: Schema.optional(Schema.String),
-      // TODO(wittjosiah): Schema for schema?
-      schema: Schema.Any,
+      // TODO(wittjosiah): Schema for type?
+      type: Schema.Any,
       show: Schema.optional(Schema.Boolean),
     }),
     output: Schema.Struct({
       id: Schema.String,
-      object: Type.PersistentType,
-      schema: Schema.instanceOf(Type.RuntimeType),
+      object: Type.getSchema(Type.Type),
     }),
   });
 
   export const AddRelation = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.add-relation`,
+      key: makeKey('addRelation'),
       name: 'Add Relation',
       description: 'Add a relation between objects.',
+      icon: 'ph--link--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
@@ -380,14 +463,15 @@ export namespace SpaceOperation {
   // TODO(wittjosiah): This appears to be unused.
   export const DuplicateObject = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.duplicate-object`,
+      key: makeKey('duplicateObject'),
       name: 'Duplicate Object',
       description: 'Duplicate an object.',
+      icon: 'ph--file--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
       object: Obj.Unknown,
-      target: Schema.Union(Database.Database, Collection.Collection),
+      target: Schema.Union(Database.Database, Type.getSchema(Collection.Collection)),
     }),
     output: Schema.Void,
   });
@@ -397,13 +481,14 @@ export namespace SpaceOperation {
    */
   export const RestoreField = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.restore-field`,
+      key: makeKey('restoreField'),
       name: 'Restore Field',
       description: 'Restore a deleted field to a view.',
+      icon: 'ph--clock-counter-clockwise--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
-      view: View.View.annotations({ description: 'The view to restore the field to.' }),
+      view: Type.getSchema(View.View).annotations({ description: 'The view to restore the field to.' }),
       field: View.FieldSchema.annotations({ description: 'The field schema to restore.' }),
       // TODO(wittjosiah): This creates a type error with PropertySchema.
       props: Schema.Any.annotations({ description: 'The field properties to restore.' }),
@@ -413,22 +498,22 @@ export namespace SpaceOperation {
   });
 
   /**
-   * Restore deleted objects to a space (inverse of RemoveObjects).
+   * Restore deleted entities to a space (inverse of RemoveObjects).
    */
   export const RestoreObjects = Operation.make({
     meta: {
-      key: `${SPACE_OPERATION}.restore-objects`,
+      key: makeKey('restoreObjects'),
       name: 'Restore Objects',
-      description: 'Restore deleted objects to a space.',
+      description: 'Restore deleted entities to a space.',
+      icon: 'ph--clock-counter-clockwise--regular',
     },
     services: [Capability.Service],
     input: Schema.Struct({
-      objects: Schema.Array(Obj.Unknown).annotations({ description: 'The objects to restore.' }),
-      parentCollection: Collection.Collection.annotations({ description: 'The collection to restore to.' }),
-      indices: Schema.Array(Schema.Number).annotations({ description: 'The indices to restore at.' }),
-      nestedObjectsList: Schema.Array(Schema.Array(Obj.Unknown)).annotations({
-        description: 'Nested objects to restore.',
+      objects: Schema.Array(Entity.Unknown).annotations({ description: 'The entities to restore.' }),
+      parentCollection: Type.getSchema(Collection.Collection).annotations({
+        description: 'The collection to restore to.',
       }),
+      indices: Schema.Array(Schema.Number).annotations({ description: 'The indices to restore at.' }),
       wasActive: Schema.Array(Schema.String).annotations({
         description: 'IDs of objects that were active before deletion.',
       }),

package/src/operations/delete-field.ts

@@ -3,9 +3,9 @@
 import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
-import { Obj } from '@dxos/echo';
+import { Operation } from '@dxos/compute';
+import { Filter, JsonSchema, Obj, Type } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
-import { Operation } from '@dxos/operation';
 import { ProjectionModel, createEchoChangeCallback, getTypenameFromQuery } from '@dxos/schema';
 
 import { SpaceOperation } from './definitions';
@@ -19,13 +19,14 @@ const handler: Operation.WithHandler<typeof SpaceOperation.DeleteField> = SpaceO
       invariant(db);
       const typename = getTypenameFromQuery(view.query.ast);
       invariant(typename);
-      const schema = yield* Effect.promise(() => db.schemaRegistry.query({ typename }).firstOrUndefined());
+      const types = yield* Effect.promise(() => db.query(Filter.type(Type.Type)).run());
+      const schema = types.find((t) => Type.getTypename(t) === typename);
       invariant(schema);
 
       const projection = new ProjectionModel({
         registry,
         view,
-        baseSchema: schema.jsonSchema,
+        baseSchema: JsonSchema.toJsonSchema(schema),
         change: createEchoChangeCallback(view, schema),
       });
 

package/src/operations/delete.ts

@@ -0,0 +1,18 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.Delete> = SpaceOperation.Delete.pipe(
+  Operation.withHandler((input) =>
+    Effect.promise(async () => {
+      await input.space.delete();
+    }),
+  ),
+);
+export default handler;

package/src/operations/duplicate-object.ts

@@ -2,28 +2,15 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Capability } from '@dxos/app-framework';
-import { AppCapabilities } from '@dxos/app-toolkit';
-import { Obj } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { Operation } from '@dxos/operation';
+import { Operation } from '@dxos/compute';
 
-import { cloneObject } from '../util';
 import { SpaceOperation } from './definitions';
 
+// TODO(wittjosiah): Implement object duplication without serializer.
 const handler: Operation.WithHandler<typeof SpaceOperation.DuplicateObject> = SpaceOperation.DuplicateObject.pipe(
   Operation.withHandler(
-    Effect.fnUntraced(function* (input) {
-      const capabilityManager = yield* Capability.Service;
-      const resolve = (typename: string) =>
-        capabilityManager.getAll(AppCapabilities.Metadata).find(({ id }: { id: string }) => id === typename)
-          ?.metadata ?? {};
-
-      const object = input.object as Obj.Unknown;
-      const db = Obj.getDatabase(object);
-      invariant(db, 'Database not found.');
-      const newObject = yield* Effect.promise(() => cloneObject(object, resolve, db));
-      yield* Operation.invoke(SpaceOperation.AddObject, { object: newObject, target: db });
+    Effect.fnUntraced(function* () {
+      yield* Effect.fail(new Error('DuplicateObject is not yet implemented.'));
     }),
   ),
 );

package/src/operations/export-space.ts

@@ -0,0 +1,30 @@
+// Copyright 2026 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.ExportSpace> = SpaceOperation.ExportSpace.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ space, format }) {
+      yield* Effect.promise(() => space.waitUntilReady());
+      const archive = yield* Effect.promise(() => space.internal.export({ format }));
+      yield* Effect.sync(() => {
+        downloadArchive(new Blob([archive.contents as Uint8Array<ArrayBuffer>]), archive.filename);
+      });
+    }),
+  ),
+);
+export default handler;
+
+const downloadArchive = (data: Blob, filename: string): void => {
+  const url = URL.createObjectURL(data);
+  const element = document.createElement('a');
+  element.setAttribute('href', url);
+  element.setAttribute('download', filename);
+  element.setAttribute('target', 'download');
+  element.click();
+  URL.revokeObjectURL(url);
+};

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

@@ -3,7 +3,7 @@
 import * as Effect from 'effect/Effect';
 
 import { Capability } from '@dxos/app-framework';
-import { Operation } from '@dxos/operation';
+import { Operation } from '@dxos/compute';
 
 import { SpaceOperation } from './definitions';
 import { SpaceOperationConfig } from './helpers';

package/src/operations/import-space.ts

@@ -0,0 +1,23 @@
+// Copyright 2026 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { ClientCapabilities } from '@dxos/plugin-client';
+
+import { SpaceOperation } from './definitions';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.ImportSpace> = SpaceOperation.ImportSpace.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ archive, tags }) {
+      const client = yield* Capability.get(ClientCapabilities.Client);
+      const space = yield* Effect.promise(() =>
+        client.spaces.import(archive, tags && tags.length > 0 ? { tags: [...tags] } : undefined),
+      );
+      yield* Effect.promise(() => space.waitUntilReady());
+      return { space };
+    }),
+  ),
+);
+export default handler;

package/src/operations/index.ts

@@ -1,23 +1,27 @@
 // Copyright 2025 DXOS.org
 
-import { OperationHandlerSet } from '@dxos/operation';
+import { OperationHandlerSet } from '@dxos/compute';
 
 export { SpaceOperation } from './definitions';
 
 export const SpaceOperationHandlerSet = OperationHandlerSet.lazy(
   () => import('./add-object'),
   () => import('./add-relation'),
-  () => import('./add-schema'),
+  () => import('./add-type'),
   () => import('./close'),
   () => import('./create'),
+  () => import('./delete'),
   () => import('./delete-field'),
   () => import('./duplicate-object'),
+  () => import('./export-space'),
   () => import('./get-share-link'),
+  () => import('./import-space'),
   () => import('./join'),
   () => import('./migrate'),
   () => import('./open'),
   () => import('./open-create-object'),
   () => import('./open-create-space'),
+  () => import('./open-import-space'),
   () => import('./open-members'),
   () => import('./open-settings'),
   () => import('./remove-objects'),

package/src/operations/join.ts

@@ -3,7 +3,7 @@
 import * as Effect from 'effect/Effect';
 
 import { LayoutOperation } from '@dxos/app-toolkit';
-import { Operation } from '@dxos/operation';
+import { Operation } from '@dxos/compute';
 
 import { JOIN_DIALOG } from '../constants';
 import { type JoinDialogProps } from '../containers/JoinDialog';