@dxos/plugin-space 0.8.4-main.74a063c4e0 → 0.8.4-main.765dc60934

package/src/capabilities/react-surface.tsx

@@ -5,32 +5,33 @@
 import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 import type * as Schema from 'effect/Schema';
-import React, { useCallback } from 'react';
+import * as SchemaAST from 'effect/SchemaAST';
+import React, { type ComponentProps, useCallback } from 'react';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { Surface, useAtomCapability, useOperationInvoker, useSettingsState } from '@dxos/app-framework/ui';
 import { AppSurface, useActiveSpace, useTypeOptions } from '@dxos/app-toolkit/ui';
-import { Database, Obj, type Ref } from '@dxos/echo';
-import { Collection, type View } from '@dxos/echo';
+import { Collection, Database, Obj } from '@dxos/echo';
 import { findAnnotation } from '@dxos/effect';
-import { type Space, SpaceState, getSpace, isSpace, useSpace, useSpaces } from '@dxos/react-client/echo';
+import { type Space, SpaceState, getSpace, isSpace, useSpaces } from '@dxos/react-client/echo';
 import { Input } from '@dxos/react-ui';
 import { type FormFieldComponentProps, SelectField } from '@dxos/react-ui-form';
 import { HuePicker, IconPicker } from '@dxos/react-ui-pickers';
 import { ViewAnnotation } from '@dxos/schema';
 
-import { SpacePluginSettings } from '#components';
+import { SpaceSettings } from '#components';
 import {
   CollectionArticle,
   CollectionSection,
   CreateObjectDialog,
   CreateSpaceDialog,
+  ImportSpaceDialog,
   InlineSyncStatus,
   JoinDialog,
   MembersContainer,
   MenuFooter,
   ObjectCardStack,
-  ObjectDetails,
+  ObjectProperties,
   ObjectRenamePopover,
   RecordArticle,
   RelatedArticle,
@@ -56,6 +57,7 @@ import {
 import {
   CREATE_OBJECT_DIALOG,
   CREATE_SPACE_DIALOG,
+  IMPORT_SPACE_DIALOG,
   JOIN_DIALOG,
   OBJECT_RENAME_POPOVER,
   SPACE_RENAME_POPOVER,
@@ -70,28 +72,25 @@ export default Capability.makeModule(
     return Capability.contributes(Capabilities.ReactSurface, [
       Surface.create({
         id: 'collection-fallback',
-        role: 'article',
         position: 'fallback',
-        filter: AppSurface.objectArticle(Collection.Collection),
+        filter: AppSurface.object(AppSurface.Article, Collection.Collection),
         component: ({ data }) => <CollectionArticle attendableId={data.attendableId} subject={data.subject} />,
       }),
       Surface.create({
         id: 'record-article',
-        role: 'article',
         position: 'fallback',
-        filter: AppSurface.anyObjectSection(),
+        filter: AppSurface.subject(AppSurface.Article, Obj.isObject),
         component: ({ data }) => <RecordArticle subject={data.subject} />,
       }),
       Surface.create({
         id: 'plugin-settings',
-        role: 'article',
-        filter: AppSurface.settingsArticle(meta.id),
+        filter: AppSurface.settings(AppSurface.Article, meta.id),
         component: ({ data: { subject } }) => {
           const { settings, updateSettings } = useSettingsState<Settings.Settings>(subject.atom);
           const spaces = useSpaces({ all: settings.showHidden });
           const { invokePromise } = useOperationInvoker();
           return (
-            <SpacePluginSettings
+            <SpaceSettings
               settings={settings}
               onSettingsChange={updateSettings}
               spaces={spaces}
@@ -101,21 +100,24 @@ export default Capability.makeModule(
         },
       }),
       Surface.create({
-        id: 'companion.object-settings',
-        role: 'article',
-        filter: AppSurface.and(AppSurface.literalArticle('settings'), AppSurface.companionArticle()),
-        component: ({ ref, data, role }) => <ObjectDetails role={role} subject={data.companionTo} ref={ref} />,
+        id: 'companion.object-properties',
+        filter: AppSurface.allOf(
+          AppSurface.literal(AppSurface.Article, 'settings'),
+          AppSurface.companion(AppSurface.Article),
+        ),
+        component: ({ ref, data, role }) => <ObjectProperties role={role} subject={data.companionTo} ref={ref} />,
       }),
       Surface.create({
         id: 'companion.related',
-        role: 'article',
-        filter: AppSurface.and(AppSurface.literalArticle('related'), AppSurface.companionArticle()),
+        filter: AppSurface.allOf(
+          AppSurface.literal(AppSurface.Article, 'related'),
+          AppSurface.companion(AppSurface.Article),
+        ),
         component: ({ data, role }) => <RelatedArticle role={role} companionTo={data.companionTo} />,
       }),
       Surface.create({
         id: 'space-settings-properties',
-        role: 'article',
-        filter: AppSurface.literalSection(`${meta.id}.general`),
+        filter: AppSurface.literal(AppSurface.Article, `${meta.id}.general`),
         component: ({ ref }) => {
           const space = useActiveSpace();
           if (!space) {
@@ -127,9 +129,8 @@ export default Capability.makeModule(
       }),
       Surface.create({
         id: 'space-settings-members',
-        role: 'article',
         position: 'hoist',
-        filter: AppSurface.literalSection(`${meta.id}.members`),
+        filter: AppSurface.literal(AppSurface.Article, `${meta.id}.members`),
         component: () => {
           const space = useActiveSpace();
           if (!space) {
@@ -141,8 +142,7 @@ export default Capability.makeModule(
       }),
       Surface.create({
         id: 'space-settings-schema',
-        role: 'article',
-        filter: AppSurface.literalSection(`${meta.id}.schema`),
+        filter: AppSurface.literal(AppSurface.Article, `${meta.id}.schema`),
         component: () => {
           const space = useActiveSpace();
           if (!space) {
@@ -155,59 +155,74 @@ export default Capability.makeModule(
       Surface.create({
         id: 'selected-objects',
         role: 'article',
-        filter: (
-          data,
-        ): data is { companionTo: Obj.OfShape<{ view: Ref.Ref<View.View> }>; subject: 'selected-objects' } => {
+        filter: (data): data is { companionTo: Obj.Unknown; subject: 'selected-objects' } => {
           if (data.subject !== 'selected-objects' || !Obj.isObject(data.companionTo)) {
             return false;
           }
 
-          // TODO(burdon): Check companionTo.view.target is valid.
           const schema = Obj.getSchema(data.companionTo);
-          return Option.fromNullable(schema).pipe(
-            Option.flatMap((schema) => ViewAnnotation.get(schema)),
-            Option.getOrElse(() => false),
-          );
+          const path = schema ? Option.getOrElse(ViewAnnotation.get(schema), () => [] as readonly string[]) : [];
+          const viewTarget = path.length > 0 ? ViewAnnotation.tryGetTargetAlongPath(data.companionTo, path) : undefined;
+          return !!viewTarget;
         },
         // TODO(burdon): Replace with mosaic.
-        component: ({ data, ref }) => (
-          <ObjectCardStack
-            key={Obj.getDXN(data.companionTo).toString()}
-            objectId={Obj.getDXN(data.companionTo).toString()}
-            view={data.companionTo.view.target!}
-            ref={ref}
-          />
-        ),
+        component: ({ data, ref }) => {
+          const schema = Obj.getSchema(data.companionTo);
+          const path = schema ? Option.getOrElse(ViewAnnotation.get(schema), () => [] as readonly string[]) : [];
+          const view = path.length > 0 ? ViewAnnotation.tryGetTargetAlongPath(data.companionTo, path) : undefined;
+          if (!view) {
+            return null;
+          }
+
+          return (
+            <ObjectCardStack
+              key={Obj.getDXN(data.companionTo).toString()}
+              objectId={Obj.getDXN(data.companionTo).toString()}
+              view={view}
+              ref={ref}
+            />
+          );
+        },
       }),
       Surface.create({
         id: JOIN_DIALOG,
-        role: 'dialog',
-        filter: AppSurface.componentDialog(JOIN_DIALOG),
+        filter: AppSurface.component<ComponentProps<typeof JoinDialog>>(AppSurface.Dialog, JOIN_DIALOG),
         component: ({ data }) => <JoinDialog {...data.props} />,
       }),
       Surface.create({
         id: CREATE_SPACE_DIALOG,
-        role: 'dialog',
-        filter: AppSurface.componentDialog(CREATE_SPACE_DIALOG),
+        filter: AppSurface.component(AppSurface.Dialog, CREATE_SPACE_DIALOG),
         component: () => <CreateSpaceDialog />,
       }),
+      Surface.create({
+        id: IMPORT_SPACE_DIALOG,
+        filter: AppSurface.component(AppSurface.Dialog, IMPORT_SPACE_DIALOG),
+        component: () => <ImportSpaceDialog />,
+      }),
       Surface.create({
         id: CREATE_OBJECT_DIALOG,
-        role: 'dialog',
-        filter: AppSurface.componentDialog(CREATE_OBJECT_DIALOG),
+        filter: AppSurface.component<ComponentProps<typeof CreateObjectDialog>>(
+          AppSurface.Dialog,
+          CREATE_OBJECT_DIALOG,
+        ),
         component: ({ data }) => <CreateObjectDialog {...data.props} />,
       }),
       Surface.create({
         id: 'create-initial-space-form-[hue]',
         role: 'form-input',
-        filter: (data): data is { prop: string; schema: Schema.Schema<any> } => {
+        filter: (data): data is { prop: string; schema: Schema.Schema<any>; fieldPropertyAst?: SchemaAST.AST } => {
           const annotation = findAnnotation<boolean>((data.schema as Schema.Schema.All).ast, HueAnnotationId);
           return !!annotation;
         },
-        component: ({ data: _, ...inputProps }) => {
-          const { label, readonly, type, getValue, onValueChange } = inputProps as any as FormFieldComponentProps;
-          const handleChange = useCallback((nextHue: string) => onValueChange(type, nextHue), [onValueChange]);
-          const handleReset = useCallback(() => onValueChange(type, undefined), [onValueChange]);
+        component: ({ data, ...inputProps }) => {
+          const ast = data.fieldPropertyAst;
+          if (!ast) {
+            return null;
+          }
+
+          const { label, readonly, getValue, onValueChange } = inputProps as any as FormFieldComponentProps;
+          const handleChange = useCallback((nextHue: string) => onValueChange(ast, nextHue), [ast, onValueChange]);
+          const handleReset = useCallback(() => onValueChange(ast, undefined), [ast, onValueChange]);
           return (
             <Input.Root>
               <Input.Label>{label}</Input.Label>
@@ -219,14 +234,19 @@ export default Capability.makeModule(
       Surface.create({
         id: 'create-initial-space-form-[icon]',
         role: 'form-input',
-        filter: (data): data is { prop: string; schema: Schema.Schema<any> } => {
+        filter: (data): data is { prop: string; schema: Schema.Schema<any>; fieldPropertyAst?: SchemaAST.AST } => {
           const annotation = findAnnotation<boolean>((data.schema as Schema.Schema.All).ast, IconAnnotationId);
           return !!annotation;
         },
-        component: ({ data: _, ...inputProps }) => {
-          const { label, readonly, type, getValue, onValueChange } = inputProps as any as FormFieldComponentProps;
-          const handleChange = useCallback((nextIcon: string) => onValueChange(type, nextIcon), [onValueChange]);
-          const handleReset = useCallback(() => onValueChange(type, undefined), [onValueChange]);
+        component: ({ data, ...inputProps }) => {
+          const ast = data.fieldPropertyAst;
+          if (!ast) {
+            return null;
+          }
+
+          const { label, readonly, getValue, onValueChange } = inputProps as any as FormFieldComponentProps;
+          const handleChange = useCallback((nextIcon: string) => onValueChange(ast, nextIcon), [ast, onValueChange]);
+          const handleReset = useCallback(() => onValueChange(ast, undefined), [ast, onValueChange]);
           return (
             <Input.Root>
               <Input.Label>{label}</Input.Label>
@@ -249,6 +269,7 @@ export default Capability.makeModule(
           prop: string;
           schema: Schema.Schema.Any;
           target: Database.Database | Collection.Collection | undefined;
+          fieldPropertyAst?: SchemaAST.AST;
         } => {
           if (data.prop !== 'typename') {
             return false;
@@ -257,32 +278,38 @@ export default Capability.makeModule(
           const annotation = findAnnotation((data.schema as Schema.Schema.All).ast, TypeInputOptionsAnnotationId);
           return !!annotation;
         },
-        component: ({ data: { schema, target }, ...inputProps }) => {
-          const props = inputProps as any as FormFieldComponentProps;
+        component: ({ data: { schema, target, fieldPropertyAst }, ...inputProps }) => {
+          const ast = fieldPropertyAst;
+          if (!ast) {
+            return null;
+          }
+
+          const props = { ...inputProps, type: ast } as any as FormFieldComponentProps;
           const db = Database.isDatabase(target) ? target : target && Obj.getDatabase(target);
-          const space = useSpace(db?.spaceId);
           const annotation = findAnnotation<TypeInputOptions>(schema.ast, TypeInputOptionsAnnotationId)!;
-          const options = useTypeOptions({ space, annotation });
+          const options = useTypeOptions({ db, annotation });
 
           return <SelectField {...props} options={options} />;
         },
       }),
       Surface.create({
-        id: 'object-settings',
-        role: 'object-settings',
-        filter: (data): data is { subject: { view: Ref.Ref<View.View> } } => {
+        id: 'object-properties',
+        role: 'object-properties',
+        filter: (data): data is { subject: Obj.Unknown } => {
           if (!Obj.isObject(data.subject)) {
             return false;
           }
 
           const schema = Obj.getSchema(data.subject);
-          return Option.fromNullable(schema).pipe(
-            Option.flatMap((schema) => ViewAnnotation.get(schema)),
-            Option.getOrElse(() => false),
-          );
+          const path = schema ? Option.getOrElse(ViewAnnotation.get(schema), () => [] as readonly string[]) : [];
+          const viewTarget = path.length > 0 ? ViewAnnotation.tryGetTargetAlongPath(data.subject, path) : undefined;
+          return !!viewTarget;
         },
         component: ({ data }) => {
-          const view = data.subject.view.target;
+          const schema = Obj.getSchema(data.subject);
+          const path = schema ? Option.getOrElse(ViewAnnotation.get(schema), () => [] as readonly string[]) : [];
+          const view = path.length > 0 ? ViewAnnotation.tryGetTargetAlongPath(data.subject, path) : undefined;
+
           if (!view) {
             return null;
           }
@@ -305,8 +332,7 @@ export default Capability.makeModule(
       }),
       Surface.create({
         id: 'menu-footer',
-        role: 'menu-footer',
-        filter: AppSurface.anyObjectSection(),
+        filter: AppSurface.subject(AppSurface.MenuFooter, Obj.isObject),
         component: ({ data }) => <MenuFooter object={data.subject} />,
       }),
       Surface.create({
@@ -352,8 +378,7 @@ export default Capability.makeModule(
       }),
       Surface.create({
         id: 'collection-section',
-        role: 'section',
-        filter: AppSurface.objectSection(Collection.Collection),
+        filter: AppSurface.object(AppSurface.Section, Collection.Collection),
         component: ({ data }) => <CollectionSection subject={data.subject} />,
       }),
       Surface.create({

package/src/capabilities/repair.ts

@@ -33,8 +33,8 @@ const removeQueryCollections = async (space: Space) => {
     return;
   }
 
-  Obj.change(rootCollection, (obj) => {
-    obj.objects = objects
+  Obj.update(rootCollection, (rootCollection) => {
+    rootCollection.objects = objects
       .filter((object) => Obj.getTypename(object) !== 'org.dxos.type.queryCollection')
       .map((object) => Ref.make(object));
   });

package/src/capabilities/spaces-ready.ts

@@ -6,16 +6,23 @@ import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
-import { AppCapabilities, LayoutOperation, getPersonalSpace, getSpacePath, setPersonalSpace } from '@dxos/app-toolkit';
+import {
+  AppCapabilities,
+  LayoutOperation,
+  getSpacePath,
+  resolvePersonalSpace,
+  setPersonalSpace,
+} from '@dxos/app-toolkit';
 import { SubscriptionList } from '@dxos/async';
 import { Filter, Obj } from '@dxos/echo';
+import { SPACE_ID_LENGTH, parseId } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { AttentionCapabilities } from '@dxos/plugin-attention/types';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { AttentionCapabilities } from '@dxos/plugin-attention';
+import { ClientCapabilities } from '@dxos/plugin-client';
 import { Graph } from '@dxos/plugin-graph';
 import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
 import { PublicKey } from '@dxos/react-client';
-import { type Space, SPACE_ID_LENGTH, SpaceState, parseId } from '@dxos/react-client/echo';
+import { type Space, SpaceState } from '@dxos/react-client/echo';
 import { Expando } from '@dxos/schema';
 import { ComplexMap, reduceGroupBy } from '@dxos/util';
 
@@ -30,34 +37,6 @@ const WAIT_FOR_OBJECT_TIMEOUT = 5_000;
 // E.g., dxn:echo:BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE:01J00J9B45YHYSGZQTQMSKMGJ6
 const ECHO_DXN_LENGTH = 3 + 1 + 4 + 1 + 33 + 1 + 26;
 
-/**
- * Resolve the personal space, migrating from legacy DefaultSpace credential if needed.
- * Returns undefined for new users who haven't created an identity yet.
- */
-const resolvePersonalSpace = (client: {
-  spaces: { get(): Space[]; get(id: any): Space | undefined };
-  halo: { queryCredentials(options: { type: string }): any[] };
-}): { space: Space; fromCredential: boolean } | undefined => {
-  // Check for personal space via tags or __DEFAULT__ property.
-  const found = getPersonalSpace(client);
-  if (found) {
-    return { space: found, fromCredential: false };
-  }
-
-  // Migration: read the legacy DefaultSpace credential from HALO.
-  const defaultSpaceCredential = client.halo.queryCredentials({
-    type: 'dxos.halo.credentials.DefaultSpace',
-  })[0];
-  if (!defaultSpaceCredential) {
-    // New user — no credential, no personal space yet.
-    return undefined;
-  }
-
-  const defaultSpaceId = defaultSpaceCredential.subject.assertion.spaceId;
-  const space = client.spaces.get(defaultSpaceId);
-  return space ? { space, fromCredential: true } : undefined;
-};
-
 export default Capability.makeModule(
   Effect.fnUntraced(function* () {
     const subscriptions = new SubscriptionList();
@@ -81,12 +60,11 @@ export default Capability.makeModule(
       if (personalSpaceInitialized) {
         return;
       }
+      // Set before any await so concurrent subscribe callbacks don't start a second initialization.
+      personalSpaceInitialized = true;
 
       await personalSpace.waitUntilReady();
-      personalSpaceInitialized = true;
 
-      // Only set the __DEFAULT__ property when migrating from the legacy credential.
-      // Spaces created with the personal tag don't need it.
       if (fromCredential) {
         setPersonalSpace(personalSpace);
       }
@@ -114,14 +92,13 @@ export default Capability.makeModule(
     if (resolved) {
       void initializePersonalSpace(resolved.space, resolved);
     } else {
-      subscriptions.add(
-        client.spaces.subscribe(() => {
-          const resolved = resolvePersonalSpace(client);
-          if (resolved) {
-            void initializePersonalSpace(resolved.space, resolved);
-          }
-        }).unsubscribe,
-      );
+      const personalSpaceSub = client.spaces.subscribe(() => {
+        const resolved = resolvePersonalSpace(client);
+        if (resolved) {
+          void initializePersonalSpace(resolved.space, resolved);
+        }
+      });
+      subscriptions.add(() => personalSpaceSub.unsubscribe());
     }
 
     //
@@ -165,37 +142,38 @@ export default Capability.makeModule(
     subscriptions.add(() => lastActiveCleanup?.());
 
     // Cache space names.
-    subscriptions.add(
-      client.spaces.subscribe(async (spaces) => {
-        // TODO(wittjosiah): Remove. This is a hack to be able to migrate the personal space properties.
-        const resolved = resolvePersonalSpace(client);
-        if (resolved?.space && resolved.space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION) {
-          const personalSpace = resolved.space;
-          await personalSpace.internal.migrate();
-        }
+    const spaceNamesSub = client.spaces.subscribe(async (spaces) => {
+      // TODO(wittjosiah): Remove. This is a hack to be able to migrate the personal space properties.
+      const personalSpaceForMigration = resolvePersonalSpace(client);
+      if (
+        personalSpaceForMigration?.space &&
+        personalSpaceForMigration.space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION
+      ) {
+        await personalSpaceForMigration.space.internal.migrate();
+      }
 
-        spaces
-          .filter((space) => space.state.get() === SpaceState.SPACE_READY)
-          .forEach((space) => {
-            const updateSpaceName = () => {
-              const name = space.properties.name;
-              if (!name) {
-                registry.update(stateAtom, (current) => {
-                  const { [space.id]: _, ...rest } = current.spaceNames;
-                  return { ...current, spaceNames: rest };
-                });
-              } else {
-                registry.update(stateAtom, (current) => ({
-                  ...current,
-                  spaceNames: { ...current.spaceNames, [space.id]: name },
-                }));
-              }
-            };
-            updateSpaceName();
-            subscriptions.add(Obj.subscribe(space.properties, updateSpaceName));
-          });
-      }).unsubscribe,
-    );
+      spaces
+        .filter((space) => space.state.get() === SpaceState.SPACE_READY)
+        .forEach((space) => {
+          const updateSpaceName = () => {
+            const name = space.properties.name;
+            if (!name) {
+              registry.update(stateAtom, (current) => {
+                const { [space.id]: _, ...rest } = current.spaceNames;
+                return { ...current, spaceNames: rest };
+              });
+            } else {
+              registry.update(stateAtom, (current) => ({
+                ...current,
+                spaceNames: { ...current.spaceNames, [space.id]: name },
+              }));
+            }
+          };
+          updateSpaceName();
+          subscriptions.add(Obj.subscribe(space.properties, updateSpaceName));
+        });
+    });
+    subscriptions.add(() => spaceNamesSub.unsubscribe());
 
     // Broadcast active node to other peers in the space - subscribe to both layout and attention.
     let broadcastCleanup: (() => void) | undefined;
@@ -277,56 +255,55 @@ export default Capability.makeModule(
     subscriptions.add(() => broadcastCleanup?.());
 
     // Listen for active nodes from other peers in the space.
-    subscriptions.add(
-      client.spaces.subscribe((spaces) => {
-        spaceSubscriptions.clear();
-        spaces.forEach((space) => {
-          spaceSubscriptions.add(
-            space.listen('viewing', (message) => {
-              const { added, removed, attended } = message.payload;
-
-              const identityKey = PublicKey.safeFrom(message.payload.identityKey);
-              const currentIdentity = client.halo.identity.get();
-              if (
-                identityKey &&
-                !currentIdentity?.identityKey.equals(identityKey) &&
-                Array.isArray(added) &&
-                Array.isArray(removed)
-              ) {
-                // TODO(wittjosiah): Stop using (Complex)Map inside reactive object.
-                registry.update(ephemeralAtom, (ephemeral) => {
-                  added.forEach((id) => {
-                    if (typeof id === 'string') {
-                      if (!(id in ephemeral.viewersByObject)) {
-                        ephemeral.viewersByObject[id] = new ComplexMap(PublicKey.hash);
-                      }
-                      ephemeral.viewersByObject[id]!.set(identityKey, {
-                        lastSeen: Date.now(),
-                        currentlyAttended: new Set(attended).has(id),
-                      });
-                      if (!ephemeral.viewersByIdentity.has(identityKey)) {
-                        ephemeral.viewersByIdentity.set(identityKey, new Set());
-                      }
-                      ephemeral.viewersByIdentity.get(identityKey)!.add(id);
+    const viewingSub = client.spaces.subscribe((spaces) => {
+      spaceSubscriptions.clear();
+      spaces.forEach((space) => {
+        spaceSubscriptions.add(
+          space.listen('viewing', (message) => {
+            const { added, removed, attended } = message.payload;
+
+            const identityKey = PublicKey.safeFrom(message.payload.identityKey);
+            const currentIdentity = client.halo.identity.get();
+            if (
+              identityKey &&
+              !currentIdentity?.identityKey.equals(identityKey) &&
+              Array.isArray(added) &&
+              Array.isArray(removed)
+            ) {
+              // TODO(wittjosiah): Stop using (Complex)Map inside reactive object.
+              registry.update(ephemeralAtom, (ephemeral) => {
+                added.forEach((id) => {
+                  if (typeof id === 'string') {
+                    if (!(id in ephemeral.viewersByObject)) {
+                      ephemeral.viewersByObject[id] = new ComplexMap(PublicKey.hash);
                     }
-                  });
-
-                  removed.forEach((id) => {
-                    if (typeof id === 'string') {
-                      ephemeral.viewersByObject[id]?.delete(identityKey);
-                      ephemeral.viewersByIdentity.get(identityKey)?.delete(id);
-                      // It's okay for these to be empty sets/maps, reduces churn.
+                    ephemeral.viewersByObject[id]!.set(identityKey, {
+                      lastSeen: Date.now(),
+                      currentlyAttended: new Set(attended).has(id),
+                    });
+                    if (!ephemeral.viewersByIdentity.has(identityKey)) {
+                      ephemeral.viewersByIdentity.set(identityKey, new Set());
                     }
-                  });
+                    ephemeral.viewersByIdentity.get(identityKey)!.add(id);
+                  }
+                });
 
-                  return { ...ephemeral };
+                removed.forEach((id) => {
+                  if (typeof id === 'string') {
+                    ephemeral.viewersByObject[id]?.delete(identityKey);
+                    ephemeral.viewersByIdentity.get(identityKey)?.delete(id);
+                    // It's okay for these to be empty sets/maps, reduces churn.
+                  }
                 });
-              }
-            }),
-          );
-        });
-      }).unsubscribe,
-    );
+
+                return { ...ephemeral };
+              });
+            }
+          }),
+        );
+      });
+    });
+    subscriptions.add(() => viewingSub.unsubscribe());
 
     // Enable edge replication for all spaces.
     try {

package/src/capabilities/state.ts

@@ -44,7 +44,7 @@ export default Capability.makeModule(
     const updateNavigableCollections = () => {
       const enabled =
         manager.getEnabled().includes('org.dxos.plugin.stack') ||
-        manager.getEnabled().includes('org.dxos.plugin.simple-layout');
+        manager.getEnabled().includes('org.dxos.plugin.simpleLayout');
       const current = registry.get(ephemeralAtom);
       if (enabled !== current.navigableCollections) {
         registry.update(ephemeralAtom, (c) => ({ ...c, navigableCollections: enabled }));

package/src/capabilities/undo-mappings.ts

@@ -39,7 +39,6 @@ export default Capability.makeModule(
             objects: output.objects,
             parentCollection: output.parentCollection,
             indices: output.indices,
-            nestedObjectsList: output.nestedObjectsList,
             wasActive: output.wasActive,
           }),
           message: (input, _output) => {