@dxos/plugin-space 0.8.1 → 0.8.2-main.2f9c567

package/src/types/types.ts

@@ -2,17 +2,21 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Schema } from 'effect';
+
 import { type AnyIntentChain } from '@dxos/app-framework';
-import { S, type Expando, type BaseObject, type TypedObject } from '@dxos/echo-schema';
+import { type Expando, type BaseObject, type TypedObject } from '@dxos/echo-schema';
 import { type PublicKey } from '@dxos/react-client';
 // TODO(wittjosiah): This pulls in full client.
 import { EchoObjectSchema, ReactiveObjectSchema, type Space, SpaceSchema } from '@dxos/react-client/echo';
+import { CancellableInvitationObservable, Invitation } from '@dxos/react-client/invitations';
 import { type ComplexMap } from '@dxos/util';
 
 import { CollectionType } from './collection';
 import { SPACE_PLUGIN } from '../meta';
 
 export const SPACE_DIRECTORY_HANDLE = 'dxos.org/plugin/space/directory';
+export const SPACE_TYPE = 'dxos.org/type/Space';
 
 export type ObjectViewerProps = {
   lastSeen: number;
@@ -42,11 +46,6 @@ export type PluginState = {
    */
   spaceNames: Record<string, string>;
 
-  /**
-   * Which sections of the space settings are open.
-   */
-  spaceSettingsOpenSections: string[];
-
   /**
    * Which spaces have an SDK migration running currently.
    */
@@ -66,16 +65,16 @@ export type PluginState = {
   enabledEdgeReplication: boolean;
 };
 
-export const SpaceSettingsSchema = S.mutable(
-  S.Struct({
+export const SpaceSettingsSchema = Schema.mutable(
+  Schema.Struct({
     /**
      * Show closed spaces.
      */
-    showHidden: S.Boolean,
+    showHidden: Schema.Boolean,
   }),
 );
 
-export type SpaceSettingsProps = S.Schema.Type<typeof SpaceSettingsSchema>;
+export type SpaceSettingsProps = Schema.Schema.Type<typeof SpaceSettingsSchema>;
 
 // TODO(wittjosiah): Reconcile with graph export serializers.
 
@@ -92,18 +91,22 @@ export interface TypedObjectSerializer<T extends Expando = Expando> {
   deserialize(params: { content: string; space: Space; newId?: boolean }): Promise<T>;
 }
 
-export const SpaceForm = S.Struct({
-  name: S.optional(S.String.annotations({ title: 'Name' })),
-  icon: S.optional(S.String.annotations({ title: 'Icon' })),
-  hue: S.optional(S.String.annotations({ title: 'Color' })),
+// TODO(burdon): Move to FormatEnum or SDK.
+export const IconAnnotationId = Symbol.for('@dxos/plugin-space/annotation/Icon');
+export const HueAnnotationId = Symbol.for('@dxos/plugin-space/annotation/Hue');
+
+export const SpaceForm = Schema.Struct({
+  name: Schema.optional(Schema.String.annotations({ title: 'Name' })),
+  icon: Schema.optional(Schema.String.annotations({ title: 'Icon', [IconAnnotationId]: true })),
+  hue: Schema.optional(Schema.String.annotations({ title: 'Color', [HueAnnotationId]: true })),
   // TODO(wittjosiah): Make optional with default value.
-  edgeReplication: S.Boolean.annotations({ title: 'Enable EDGE Replication' }),
+  edgeReplication: Schema.Boolean.annotations({ title: 'Enable EDGE Replication' }),
 });
 
 export type ObjectForm<T extends BaseObject = BaseObject> = {
-  // TODO(dmaretskyi): Change to S.Schema.AnyNoContext
+  // TODO(dmaretskyi): Change to Schema.Schema.AnyNoContext
   objectSchema: TypedObject;
-  formSchema?: S.Schema<T, any>;
+  formSchema?: Schema.Schema<T, any>;
   hidden?: boolean;
   getIntent: (props: T, options: { space: Space }) => AnyIntentChain;
 };
@@ -113,165 +116,189 @@ export const defineObjectForm = <T extends BaseObject>(form: ObjectForm<T>) => f
 export const SPACE_ACTION = `${SPACE_PLUGIN}/action`;
 
 export namespace SpaceAction {
-  export class OpenCreateSpace extends S.TaggedClass<OpenCreateSpace>()(`${SPACE_ACTION}/open-create-space`, {
-    input: S.Void,
-    output: S.Void,
+  export class OpenCreateSpace extends Schema.TaggedClass<OpenCreateSpace>()(`${SPACE_ACTION}/open-create-space`, {
+    input: Schema.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Create extends S.TaggedClass<Create>()(`${SPACE_ACTION}/create`, {
+  export class Create extends Schema.TaggedClass<Create>()(`${SPACE_ACTION}/create`, {
     input: SpaceForm,
-    output: S.Struct({
-      id: S.String,
-      subject: S.Array(S.String),
+    output: Schema.Struct({
+      id: Schema.String,
+      subject: Schema.Array(Schema.String),
       space: SpaceSchema,
     }),
   }) {}
 
-  export class Join extends S.TaggedClass<Join>()(`${SPACE_ACTION}/join`, {
-    input: S.Struct({
-      invitationCode: S.optional(S.String),
-      onDone: S.optional(S.Any),
+  export class Join extends Schema.TaggedClass<Join>()(`${SPACE_ACTION}/join`, {
+    input: Schema.Struct({
+      invitationCode: Schema.optional(Schema.String),
+      onDone: Schema.optional(Schema.Any),
+    }),
+    output: Schema.Void,
+  }) {}
+
+  export class OpenMembers extends Schema.TaggedClass<OpenMembers>()(`${SPACE_ACTION}/open-members`, {
+    input: Schema.Struct({
+      space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Share extends S.TaggedClass<Share>()(`${SPACE_ACTION}/share`, {
-    input: S.Struct({
+  export class Share extends Schema.TaggedClass<Share>()(`${SPACE_ACTION}/share`, {
+    input: Schema.Struct({
       space: SpaceSchema,
+      type: Schema.Enums(Invitation.Type),
+      authMethod: Schema.Enums(Invitation.AuthMethod),
+      multiUse: Schema.Boolean,
+      target: Schema.optional(Schema.String),
     }),
-    output: S.Void,
+    output: Schema.instanceOf(CancellableInvitationObservable),
   }) {}
 
-  export class Lock extends S.TaggedClass<Lock>()(`${SPACE_ACTION}/lock`, {
-    input: S.Struct({
+  export class GetShareLink extends Schema.TaggedClass<GetShareLink>()(`${SPACE_ACTION}/get-share-link`, {
+    input: Schema.Struct({
       space: SpaceSchema,
+      target: Schema.optional(Schema.String),
+      copyToClipboard: Schema.optional(Schema.Boolean),
     }),
-    output: S.Void,
+    output: Schema.String,
   }) {}
 
-  export class Unlock extends S.TaggedClass<Unlock>()(`${SPACE_ACTION}/unlock`, {
-    input: S.Struct({
+  export class Lock extends Schema.TaggedClass<Lock>()(`${SPACE_ACTION}/lock`, {
+    input: Schema.Struct({
       space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Rename extends S.TaggedClass<Rename>()(`${SPACE_ACTION}/rename`, {
-    input: S.Struct({
+  export class Unlock extends Schema.TaggedClass<Unlock>()(`${SPACE_ACTION}/unlock`, {
+    input: Schema.Struct({
       space: SpaceSchema,
-      caller: S.optional(S.String),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class AddSpace extends S.TaggedClass<AddSpace>()(`${SPACE_ACTION}/add-space`, {
-    input: S.Void,
-    output: S.Void,
+  export class Rename extends Schema.TaggedClass<Rename>()(`${SPACE_ACTION}/rename`, {
+    input: Schema.Struct({
+      space: SpaceSchema,
+      caller: Schema.optional(Schema.String),
+    }),
+    output: Schema.Void,
   }) {}
 
-  export class AddSpaceMenuGroup extends S.TaggedClass<AddSpaceMenuGroup>()(`${SPACE_ACTION}/add-space-menu-group`, {
-    input: S.Void,
-    output: S.Void,
+  export class AddSpace extends Schema.TaggedClass<AddSpace>()(`${SPACE_ACTION}/add-space`, {
+    input: Schema.Void,
+    output: Schema.Void,
   }) {}
 
+  export class AddSpaceMenuGroup extends Schema.TaggedClass<AddSpaceMenuGroup>()(
+    `${SPACE_ACTION}/add-space-menu-group`,
+    {
+      input: Schema.Void,
+      output: Schema.Void,
+    },
+  ) {}
+
   // TODO(wittjosiah): Handle scrolling to section.
-  export class OpenSettings extends S.TaggedClass<OpenSettings>()(`${SPACE_ACTION}/open-settings`, {
-    input: S.Struct({ space: SpaceSchema }),
-    output: S.Void,
+  //   This maybe motivates making the space settings its own deck?
+  export class OpenSettings extends Schema.TaggedClass<OpenSettings>()(`${SPACE_ACTION}/open-settings`, {
+    input: Schema.Struct({ space: SpaceSchema }),
+    output: Schema.Void,
   }) {}
 
-  export class Open extends S.TaggedClass<Open>()(`${SPACE_ACTION}/open`, {
-    input: S.Struct({
+  export class Open extends Schema.TaggedClass<Open>()(`${SPACE_ACTION}/open`, {
+    input: Schema.Struct({
       space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Close extends S.TaggedClass<Close>()(`${SPACE_ACTION}/close`, {
-    input: S.Struct({
+  export class Close extends Schema.TaggedClass<Close>()(`${SPACE_ACTION}/close`, {
+    input: Schema.Struct({
       space: SpaceSchema,
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class Migrate extends S.TaggedClass<Migrate>()(`${SPACE_ACTION}/migrate`, {
-    input: S.Struct({
+  export class Migrate extends Schema.TaggedClass<Migrate>()(`${SPACE_ACTION}/migrate`, {
+    input: Schema.Struct({
       space: SpaceSchema,
-      version: S.optional(S.String),
+      version: Schema.optional(Schema.String),
     }),
-    output: S.Boolean,
+    output: Schema.Boolean,
   }) {}
 
-  export class OpenCreateObject extends S.TaggedClass<OpenCreateObject>()(`${SPACE_ACTION}/open-create-object`, {
-    input: S.Struct({
-      target: S.Union(SpaceSchema, CollectionType),
-      navigable: S.optional(S.Boolean),
+  export class OpenCreateObject extends Schema.TaggedClass<OpenCreateObject>()(`${SPACE_ACTION}/open-create-object`, {
+    input: Schema.Struct({
+      target: Schema.Union(SpaceSchema, CollectionType),
+      navigable: Schema.optional(Schema.Boolean),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class AddObject extends S.TaggedClass<AddObject>()(`${SPACE_ACTION}/add-object`, {
-    input: S.Struct({
+  export class AddObject extends Schema.TaggedClass<AddObject>()(`${SPACE_ACTION}/add-object`, {
+    input: Schema.Struct({
       object: ReactiveObjectSchema,
-      target: S.Union(SpaceSchema, CollectionType),
-      hidden: S.optional(S.Boolean),
+      target: Schema.Union(SpaceSchema, CollectionType),
+      hidden: Schema.optional(Schema.Boolean),
     }),
-    output: S.Struct({
-      id: S.String,
-      subject: S.Array(S.String),
+    output: Schema.Struct({
+      id: Schema.String,
+      subject: Schema.Array(Schema.String),
       object: EchoObjectSchema,
     }),
   }) {}
 
-  export const DeletionData = S.Struct({
-    objects: S.Array(EchoObjectSchema),
+  export const DeletionData = Schema.Struct({
+    objects: Schema.Array(EchoObjectSchema),
     parentCollection: CollectionType,
-    indices: S.Array(S.Number),
-    nestedObjectsList: S.Array(S.Array(EchoObjectSchema)),
-    wasActive: S.Array(S.String),
+    indices: Schema.Array(Schema.Number),
+    nestedObjectsList: Schema.Array(Schema.Array(EchoObjectSchema)),
+    wasActive: Schema.Array(Schema.String),
   });
 
-  export type DeletionData = S.Schema.Type<typeof DeletionData>;
+  export type DeletionData = Schema.Schema.Type<typeof DeletionData>;
 
-  export class RemoveObjects extends S.TaggedClass<RemoveObjects>()(`${SPACE_ACTION}/remove-objects`, {
-    input: S.Struct({
-      objects: S.Array(EchoObjectSchema),
-      target: S.optional(CollectionType),
-      deletionData: S.optional(DeletionData),
+  export class RemoveObjects extends Schema.TaggedClass<RemoveObjects>()(`${SPACE_ACTION}/remove-objects`, {
+    input: Schema.Struct({
+      objects: Schema.Array(EchoObjectSchema),
+      target: Schema.optional(CollectionType),
+      deletionData: Schema.optional(DeletionData),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class RenameObject extends S.TaggedClass<RenameObject>()(`${SPACE_ACTION}/rename-object`, {
-    input: S.Struct({
+  export class RenameObject extends Schema.TaggedClass<RenameObject>()(`${SPACE_ACTION}/rename-object`, {
+    input: Schema.Struct({
       object: EchoObjectSchema,
-      caller: S.optional(S.String),
+      caller: Schema.optional(Schema.String),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class DuplicateObject extends S.TaggedClass<DuplicateObject>()(`${SPACE_ACTION}/duplicate-object`, {
-    input: S.Struct({
+  export class DuplicateObject extends Schema.TaggedClass<DuplicateObject>()(`${SPACE_ACTION}/duplicate-object`, {
+    input: Schema.Struct({
       object: EchoObjectSchema,
-      target: S.Union(SpaceSchema, CollectionType),
+      target: Schema.Union(SpaceSchema, CollectionType),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 
-  export class WaitForObject extends S.TaggedClass<WaitForObject>()(`${SPACE_ACTION}/wait-for-object`, {
-    input: S.Struct({
-      id: S.optional(S.String),
+  export class WaitForObject extends Schema.TaggedClass<WaitForObject>()(`${SPACE_ACTION}/wait-for-object`, {
+    input: Schema.Struct({
+      id: Schema.optional(Schema.String),
     }),
-    output: S.Void,
+    output: Schema.Void,
   }) {}
 }
 
 export namespace CollectionAction {
-  export class Create extends S.TaggedClass<Create>()('dxos.org/plugin/collection/action/create', {
-    input: S.Struct({
-      name: S.optional(S.String),
+  export class Create extends Schema.TaggedClass<Create>()('dxos.org/plugin/collection/action/create', {
+    input: Schema.Struct({
+      name: Schema.optional(Schema.String),
     }),
-    output: S.Struct({
+    output: Schema.Struct({
       object: CollectionType,
     }),
   }) {}

package/src/util.tsx

@@ -2,12 +2,12 @@
 // Copyright 2023 DXOS.org
 //
 
-import { createIntent, type PromiseIntentDispatcher, LayoutAction } from '@dxos/app-framework';
-import { EXPANDO_TYPENAME, getTypeAnnotation, getTypename, type Expando } from '@dxos/echo-schema';
+import { createIntent, LayoutAction, type PromiseIntentDispatcher } from '@dxos/app-framework';
+import { EXPANDO_TYPENAME, getTypeAnnotation, getTypename, type BaseObject, type Expando } from '@dxos/echo-schema';
+import { getSchema } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
-import { getSchema, isReactiveObject, makeRef } from '@dxos/live-object';
+import { isLiveObject, makeRef } from '@dxos/live-object';
 import { Migrations } from '@dxos/migrations';
-import { ATTENDABLE_PATH_SEPARATOR } from '@dxos/plugin-deck/types';
 import {
   ACTION_GROUP_TYPE,
   ACTION_TYPE,
@@ -31,15 +31,15 @@ import {
   type FilterSource,
   type Query,
   type QueryOptions,
-  type ReactiveEchoObject,
+  type AnyLiveObject,
   type Space,
 } from '@dxos/react-client/echo';
+import { ATTENDABLE_PATH_SEPARATOR } from '@dxos/react-ui-attention';
 
 import { SPACE_PLUGIN } from './meta';
-import { CollectionType, SpaceAction } from './types';
+import { CollectionType, SpaceAction, SPACE_TYPE } from './types';
 
 export const SPACES = `${SPACE_PLUGIN}-spaces`;
-export const SPACE_TYPE = 'dxos.org/type/Space';
 export const COMPOSER_SPACE_LOCK = 'dxos.org/plugin/space/lock';
 // TODO(wittjosiah): Remove.
 export const SHARED = 'shared-spaces';
@@ -53,7 +53,7 @@ const EMPTY_ARRAY: never[] = [];
  * @param options
  * @returns
  */
-export const memoizeQuery = <T extends ReactiveEchoObject<any>>(
+export const memoizeQuery = <T extends BaseObject>(
   spaceOrEcho?: Space | Echo,
   filter?: FilterSource<T>,
   options?: QueryOptions,
@@ -109,7 +109,7 @@ const getCollectionGraphNodePartials = ({
       // Change on disk.
       collection.objects = nextOrder.filter(isEchoObject).map(makeRef);
     },
-    onTransferStart: (child: Node<ReactiveEchoObject<any>>, index?: number) => {
+    onTransferStart: (child: Node<AnyLiveObject<any>>, index?: number) => {
       // TODO(wittjosiah): Support transfer between spaces.
       // const childSpace = getSpace(child.data);
       // if (space && childSpace && !childSpace.key.equals(space.key)) {
@@ -138,7 +138,7 @@ const getCollectionGraphNodePartials = ({
 
       // }
     },
-    onTransferEnd: (child: Node<ReactiveEchoObject<any>>, destination: Node) => {
+    onTransferEnd: (child: Node<AnyLiveObject<any>>, destination: Node) => {
       // Remove child from origin collection.
       const index = collection.objects.findIndex((object) => object.target === child.data);
       if (index > -1) {
@@ -154,7 +154,7 @@ const getCollectionGraphNodePartials = ({
       //   childSpace.db.remove(child.data);
       // }
     },
-    onCopy: async (child: Node<ReactiveEchoObject<any>>, index?: number) => {
+    onCopy: async (child: Node<AnyLiveObject<any>>, index?: number) => {
       // Create clone of child and add to destination space.
       const newObject = await cloneObject(child.data, resolve, space);
       space.db.add(newObject);
@@ -215,24 +215,45 @@ export const constructSpaceNode = ({
     },
     nodes: [
       {
-        id: `${space.id}${ATTENDABLE_PATH_SEPARATOR}members`,
-        type: `${SPACE_PLUGIN}/members`,
-        data: space,
-        properties: {
-          label: ['members panel label', { ns: SPACE_PLUGIN }],
-          icon: 'ph--users--regular',
-          disposition: 'hidden',
-        },
-      },
-      {
-        id: `${space.id}${ATTENDABLE_PATH_SEPARATOR}settings`,
+        id: `settings${ATTENDABLE_PATH_SEPARATOR}${space.id}`,
         type: `${SPACE_PLUGIN}/settings`,
-        data: space,
+        data: null,
         properties: {
           label: ['settings panel label', { ns: SPACE_PLUGIN }],
-          icon: 'ph--gear--regular',
-          disposition: 'hidden',
+          icon: 'ph--faders--regular',
+          disposition: 'alternate-tree',
         },
+        nodes: [
+          {
+            id: `properties-settings${ATTENDABLE_PATH_SEPARATOR}${space.id}`,
+            type: `${SPACE_PLUGIN}/properties`,
+            data: `${SPACE_PLUGIN}/properties`,
+            properties: {
+              label: ['space settings properties label', { ns: SPACE_PLUGIN }],
+              icon: 'ph--sliders--regular',
+              position: 'hoist',
+            },
+          },
+          {
+            id: `members-settings${ATTENDABLE_PATH_SEPARATOR}${space.id}`,
+            type: `${SPACE_PLUGIN}/members`,
+            data: `${SPACE_PLUGIN}/members`,
+            properties: {
+              label: ['members panel label', { ns: SPACE_PLUGIN }],
+              icon: 'ph--users--regular',
+              position: 'hoist',
+            },
+          },
+          {
+            id: `schema-settings${ATTENDABLE_PATH_SEPARATOR}${space.id}`,
+            type: `${SPACE_PLUGIN}/schema`,
+            data: `${SPACE_PLUGIN}/schema`,
+            properties: {
+              label: ['space settings schema label', { ns: SPACE_PLUGIN }],
+              icon: 'ph--shapes--regular',
+            },
+          },
+        ],
       },
     ],
   };
@@ -271,7 +292,6 @@ export const constructSpaceActions = ({
   }
 
   if (state === SpaceState.SPACE_READY && !hasPendingMigration) {
-    const locked = space.properties[COMPOSER_SPACE_LOCK];
     actions.push(
       {
         id: getId(SpaceAction.OpenCreateObject._tag),
@@ -286,44 +306,6 @@ export const constructSpaceActions = ({
           testId: 'spacePlugin.createObject',
         },
       },
-      {
-        id: getId(SpaceAction.Share._tag),
-        type: ACTION_TYPE,
-        data: async () => {
-          if (locked) {
-            return;
-          }
-          await dispatch(createIntent(SpaceAction.Share, { space }));
-        },
-        properties: {
-          label: ['share space label', { ns: SPACE_PLUGIN }],
-          icon: 'ph--users--regular',
-          disabled: locked,
-          disposition: 'list-item-primary',
-          iconOnly: false,
-          variant: 'default',
-          testId: 'spacePlugin.shareSpace',
-          keyBinding: {
-            macos: 'meta+.',
-            windows: 'alt+.',
-          },
-        },
-      },
-      {
-        id: locked ? getId(SpaceAction.Unlock._tag) : getId(SpaceAction.Lock._tag),
-        type: ACTION_TYPE,
-        data: async () => {
-          if (locked) {
-            await dispatch(createIntent(SpaceAction.Unlock, { space }));
-          } else {
-            await dispatch(createIntent(SpaceAction.Lock, { space }));
-          }
-        },
-        properties: {
-          label: [locked ? 'unlock space label' : 'lock space label', { ns: SPACE_PLUGIN }],
-          icon: locked ? 'ph--lock-simple-open--regular' : 'ph--lock-simple--regular',
-        },
-      },
       {
         id: getId(SpaceAction.Rename._tag),
         type: ACTION_TYPE,
@@ -339,51 +321,9 @@ export const constructSpaceActions = ({
           },
         },
       },
-      {
-        id: getId(SpaceAction.OpenSettings._tag),
-        type: ACTION_TYPE,
-        data: async () => {
-          await dispatch(createIntent(SpaceAction.OpenSettings, { space }));
-        },
-        properties: {
-          label: ['open space settings label', { ns: SPACE_PLUGIN }],
-          icon: 'ph--gear--regular',
-        },
-      },
     );
   }
 
-  // TODO(wittjosiah): Consider moving close space into the space settings dialog.
-  if (state !== SpaceState.SPACE_INACTIVE && !hasPendingMigration) {
-    actions.push({
-      id: getId(SpaceAction.Close._tag),
-      type: ACTION_TYPE,
-      data: async () => {
-        await dispatch(createIntent(SpaceAction.Close, { space }));
-      },
-      properties: {
-        label: ['close space label', { ns: SPACE_PLUGIN }],
-        icon: 'ph--x--regular',
-        disabled: personal,
-      },
-    });
-  }
-
-  if (state === SpaceState.SPACE_INACTIVE) {
-    actions.push({
-      id: getId(SpaceAction.Open._tag),
-      type: ACTION_TYPE,
-      data: async () => {
-        await dispatch(createIntent(SpaceAction.Open, { space }));
-      },
-      properties: {
-        label: ['open space label', { ns: SPACE_PLUGIN }],
-        icon: 'ph--clock-counter-clockwise--regular',
-        disposition: 'list-item-primary',
-      },
-    });
-  }
-
   return actions;
 };
 
@@ -393,7 +333,7 @@ export const createObjectNode = ({
   navigable = false,
   resolve,
 }: {
-  object: ReactiveEchoObject<any>;
+  object: AnyLiveObject<any>;
   space: Space;
   navigable?: boolean;
   resolve: (typename: string) => Record<string, any>;
@@ -435,7 +375,7 @@ export const constructObjectActions = ({
   dispatch,
   navigable = false,
 }: {
-  node: Node<ReactiveEchoObject<any>>;
+  node: Node<AnyLiveObject<any>>;
   dispatch: PromiseIntentDispatcher;
   navigable?: boolean;
 }) => {
@@ -542,7 +482,7 @@ export const getActiveSpace = (graph: Graph, active?: string) => {
   }
 
   const node = graph.findNode(active);
-  if (!node || !isReactiveObject(node.data)) {
+  if (!node || !isLiveObject(node.data)) {
     return;
   }
 
@@ -553,9 +493,9 @@ export const getActiveSpace = (graph: Graph, active?: string) => {
  * @deprecated This is a temporary solution.
  */
 export const getNestedObjects = async (
-  object: ReactiveEchoObject<any>,
+  object: AnyLiveObject<any>,
   resolve: (typename: string) => Record<string, any>,
-): Promise<ReactiveEchoObject<any>[]> => {
+): Promise<AnyLiveObject<any>[]> => {
   const type = getTypename(object);
   if (!type) {
     return [];
@@ -567,7 +507,7 @@ export const getNestedObjects = async (
     return [];
   }
 
-  const objects: ReactiveEchoObject<any>[] = await loadReferences(object);
+  const objects: AnyLiveObject<any>[] = await loadReferences(object);
   const nested = await Promise.all(objects.map((object) => getNestedObjects(object, resolve)));
   return [...objects, ...nested.flat()];
 };