@dxos/plugin-space 0.8.4-main.72ec0f3 → 0.8.4-main.8360d9e660

package/src/containers/ObjectCardStack/ObjectCardStack.tsx

@@ -0,0 +1,82 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { forwardRef, useState } from 'react';
+
+import { Obj } from '@dxos/echo';
+import { type View } from '@dxos/echo';
+import { Filter, useQuery, useSchema } from '@dxos/react-client/echo';
+import { Card, Message, Panel, ScrollArea, Toolbar, useTranslation } from '@dxos/react-ui';
+import { useSelected } from '@dxos/react-ui-attention';
+import { Mosaic } from '@dxos/react-ui-mosaic';
+import { getTypenameFromQuery } from '@dxos/schema';
+import { isNonNullable } from '@dxos/util';
+
+import { ObjectForm } from '../../components';
+import { meta } from '../../meta';
+
+export type ObjectCardStackProps = {
+  view: View.View;
+  objectId: string;
+};
+
+/**
+ * @deprecated Use Mosaic Board components.
+ */
+export const ObjectCardStack = forwardRef<HTMLDivElement, ObjectCardStackProps>(({ objectId, view }, forwardedRef) => {
+  const { t } = useTranslation(meta.id);
+  const db = Obj.getDatabase(view);
+  const typename = view.query ? getTypenameFromQuery(view.query.ast) : undefined;
+  const schema = useSchema(db, typename);
+
+  const queriedObjects = useQuery(db, schema ? Filter.type(schema) : Filter.nothing());
+  const selectedRows = useSelected(objectId, 'multi');
+  const selectedObjects = selectedRows.map((id) => queriedObjects.find((obj) => obj.id === id)).filter(isNonNullable);
+
+  const [viewport, setViewport] = useState<HTMLElement | null>(null);
+
+  if (!schema) {
+    return null;
+  }
+
+  return (
+    <Panel.Root className='dx-document' ref={forwardedRef}>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root />
+      </Panel.Toolbar>
+      <Panel.Content>
+        {selectedObjects.length === 0 ? (
+          <Message.Root>
+            <Message.Title>{t('row details no selection label')}</Message.Title>
+          </Message.Root>
+        ) : (
+          <Mosaic.Root>
+            <Mosaic.Container
+              asChild
+              orientation='vertical'
+              autoScroll={viewport}
+              eventHandler={{ id: objectId, canDrop: () => true }}
+            >
+              <ScrollArea.Root orientation='vertical'>
+                <ScrollArea.Viewport ref={setViewport}>
+                  <Mosaic.Stack
+                    items={selectedObjects}
+                    getId={(obj) => obj.id}
+                    Tile={({ ...props }) => (
+                      <Mosaic.Tile {...props}>
+                        <Card.Root>
+                          <ObjectForm object={props.data} schema={schema} />
+                        </Card.Root>
+                      </Mosaic.Tile>
+                    )}
+                  />
+                </ScrollArea.Viewport>
+              </ScrollArea.Root>
+            </Mosaic.Container>
+          </Mosaic.Root>
+        )}
+      </Panel.Content>
+    </Panel.Root>
+  );
+});

package/src/containers/ObjectCardStack/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ObjectCardStack } from './ObjectCardStack';
+
+export default ObjectCardStack;

package/src/containers/ObjectDetails/ObjectDetails.tsx

@@ -0,0 +1,36 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { forwardRef, useMemo } from 'react';
+
+import { Surface } from '@dxos/app-framework/ui';
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { type Obj } from '@dxos/echo';
+import { Panel, Toolbar } from '@dxos/react-ui';
+
+import { BaseObjectSettings } from '../../components';
+
+export type ObjectDetailsProps = SurfaceComponentProps<Obj.Unknown>;
+
+export const ObjectDetails = forwardRef<HTMLDivElement, ObjectDetailsProps>(
+  ({ role, subject: object }, forwardedRef) => {
+    const data = useMemo(() => ({ subject: object }), [object]);
+
+    return (
+      <Panel.Root role={role} className='dx-document' ref={forwardedRef}>
+        <Panel.Toolbar asChild>
+          <Toolbar.Root />
+        </Panel.Toolbar>
+        <Panel.Content asChild>
+          <BaseObjectSettings object={object}>
+            <Surface.Surface role='base-object-settings' data={data} />
+            <Surface.Surface role='object-settings' data={data} />
+            {/* TODO(wittjosiah): Remove (or add as surface)? */}
+            {/* <AdvancedObjectSettings object={object} /> */}
+          </BaseObjectSettings>
+        </Panel.Content>
+      </Panel.Root>
+    );
+  },
+);

package/src/containers/ObjectDetails/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ObjectDetails } from './ObjectDetails';
+
+export default ObjectDetails;

package/src/{components → containers}/ObjectRenamePopover/ObjectRenamePopover.tsx

@@ -4,35 +4,31 @@
 
 import React, { useCallback, useRef, useState } from 'react';
 
-import { LayoutAction, createIntent } from '@dxos/app-framework';
-import { useIntentDispatcher } from '@dxos/app-framework/react';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { LayoutOperation } from '@dxos/app-toolkit';
 import { Obj } from '@dxos/echo';
 import { log } from '@dxos/log';
 import { Button, Input, useTranslation } from '@dxos/react-ui';
+import { osTranslations } from '@dxos/ui-theme';
 
 import { meta } from '../../meta';
 
-export const OBJECT_RENAME_POPOVER = `${meta.id}/ObjectRenamePopover`;
+export const OBJECT_RENAME_POPOVER = `${meta.id}.ObjectRenamePopover`;
 
-export const ObjectRenamePopover = ({ object }: { object: Obj.Any }) => {
+export const ObjectRenamePopover = ({ object }: { object: Obj.Unknown }) => {
   const { t } = useTranslation(meta.id);
   const doneButton = useRef<HTMLButtonElement>(null);
   const [name, setName] = useState(Obj.getLabel(object));
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const { invokePromise } = useOperationInvoker();
 
   const handleDone = useCallback(() => {
     try {
-      name && Obj.setLabel(object, name);
+      name && Obj.change(object, () => Obj.setLabel(object, name));
     } catch (err) {
       log.error('Failed to rename object', { err });
     }
-    void dispatch(
-      createIntent(LayoutAction.UpdatePopover, {
-        part: 'popover',
-        options: { variant: 'react', anchorId: '', state: false },
-      }),
-    );
-  }, [object, name]);
+    void invokePromise(LayoutOperation.UpdatePopover, { anchorId: '', state: false });
+  }, [object, name, invokePromise]);
 
   return (
     <div role='none' className='p-2 flex gap-2'>
@@ -49,7 +45,7 @@ export const ObjectRenamePopover = ({ object }: { object: Obj.Any }) => {
         </Input.Root>
       </div>
       <Button ref={doneButton} classNames='self-stretch' onClick={handleDone}>
-        {t('done label', { ns: 'os' })}
+        {t('done label', { ns: osTranslations })}
       </Button>
     </div>
   );

package/src/containers/ObjectRenamePopover/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { ObjectRenamePopover } from './ObjectRenamePopover';
+
+export default ObjectRenamePopover;

package/src/containers/RecordArticle/RecordArticle.tsx

@@ -0,0 +1,140 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import React, { useMemo } from 'react';
+
+import { Surface } from '@dxos/app-framework/ui';
+import { type SurfaceComponentProps, useObjectMenuItems } from '@dxos/app-toolkit/ui';
+import { Annotation, type Database, Entity, Filter, Obj, Ref, Relation } from '@dxos/echo';
+import { useQuery } from '@dxos/react-client/echo';
+import { Card, Panel, ScrollArea, Toolbar, useTranslation } from '@dxos/react-ui';
+import { Masonry } from '@dxos/react-ui-masonry';
+import { Menu } from '@dxos/react-ui-menu';
+import { mx } from '@dxos/ui-theme';
+import { isNonNullable } from '@dxos/util';
+
+import { meta } from '../../meta';
+
+export const RecordArticle = ({ role, subject }: SurfaceComponentProps) => {
+  const { t } = useTranslation(meta.id);
+  const db = Obj.getDatabase(subject);
+  const related = useRelatedObjects(db, subject, {
+    references: true,
+    relations: true,
+  });
+  const singleColumn = related.length === 1;
+
+  return (
+    <Panel.Root role={role} className='dx-document'>
+      <Panel.Content asChild>
+        <ScrollArea.Root orientation='vertical'>
+          <ScrollArea.Viewport classNames='p-4 gap-4'>
+            <ObjectCard data={subject} classNames='dx-card-max-width' />
+
+            {related.length > 0 && (
+              <div role='none' className={mx('flex flex-col gap-1', singleColumn ? 'dx-card-max-width' : 'w-full')}>
+                <label className='mt-2 text-sm text-description'>{t('related objects label')}</label>
+                <Masonry.Root<Entity.Unknown>
+                  items={related}
+                  render={ObjectCard}
+                  columnCount={singleColumn ? 1 : undefined}
+                  intrinsicHeight
+                />
+              </div>
+            )}
+          </ScrollArea.Viewport>
+        </ScrollArea.Root>
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const ObjectCard = ({ data: subject, classNames }: { data: Entity.Unknown; classNames?: string }) => {
+  const objectMenuItems = useObjectMenuItems(subject);
+  const data = useMemo(() => ({ subject }), [subject]);
+  const icon = Function.pipe(
+    Obj.getSchema(subject),
+    Option.fromNullable,
+    Option.flatMap(Annotation.IconAnnotation.get),
+    Option.map(({ icon }) => icon),
+    Option.getOrElse(() => 'ph--placeholder--regular'),
+  );
+
+  return (
+    <Menu.Root>
+      <Card.Root classNames={classNames}>
+        <Card.Toolbar>
+          <Card.Icon icon={icon} />
+          <Card.Title>{Entity.getLabel(subject)}</Card.Title>
+          <Menu.Trigger asChild disabled={!objectMenuItems?.length}>
+            <Toolbar.IconButton iconOnly variant='ghost' icon='ph--dots-three-vertical--regular' label='Actions' />
+          </Menu.Trigger>
+          <Menu.Content items={objectMenuItems} />
+        </Card.Toolbar>
+        <Card.Content>
+          <Surface.Surface role='card--content' data={data} limit={1} />
+        </Card.Content>
+      </Card.Root>
+    </Menu.Root>
+  );
+};
+
+// TODO(wittjosiah): This is a hack. ECHO needs to have a back reference index to easily query for related objects.
+const useRelatedObjects = (
+  db?: Database.Database,
+  record?: Obj.Unknown,
+  options: { references?: boolean; relations?: boolean } = {},
+) => {
+  const objects = useQuery(db, Filter.everything());
+  return useMemo(() => {
+    if (!record) {
+      return [];
+    }
+
+    const related: Entity.Unknown[] = [];
+
+    // TODO(burdon): Change Person => Organization to relations.
+    if (options.references) {
+      const getReferences = (obj: Entity.Unknown): Ref.Unknown[] => {
+        return Object.getOwnPropertyNames(obj)
+          .map((name) => obj[name as keyof Obj.Unknown])
+          .filter((value) => Ref.isRef(value)) as Ref.Unknown[];
+      };
+
+      const references = getReferences(record);
+      const referenceTargets = references.map((ref) => ref.target).filter(isNonNullable);
+      const referenceSources = objects.filter((obj) => {
+        const refs = getReferences(obj);
+        return refs.some((ref) => ref.target === record);
+      });
+
+      related.push(...referenceTargets, ...referenceSources);
+    }
+
+    if (options.relations) {
+      // TODO(dmaretskyi): Workaround until https://github.com/dxos/dxos/pull/10100 lands.
+      const isValidRelation = (obj: Relation.Unknown) => {
+        try {
+          return Relation.isRelation(obj) && Relation.getSource(obj) && Relation.getTarget(obj);
+        } catch {
+          return false;
+        }
+      };
+
+      const relations = objects.filter(Relation.isRelation).filter((obj) => isValidRelation(obj));
+      const targetObjects = relations
+        .filter((relation) => Relation.getTarget(relation) === record)
+        .map((relation) => Relation.getSource(relation));
+      const sourceObjects = relations
+        .filter((relation) => Relation.getSource(relation) === record)
+        .map((relation) => Relation.getTarget(relation));
+
+      related.push(...targetObjects, ...sourceObjects);
+    }
+
+    return Array.from(new Set(related));
+  }, [record, objects]);
+};

package/src/containers/RecordArticle/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { RecordArticle } from './RecordArticle';
+
+export default RecordArticle;

package/src/containers/SchemaContainer/SchemaContainer.tsx

@@ -0,0 +1,60 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useEffect, useState } from 'react';
+
+import { type Type } from '@dxos/echo';
+import { type Space } from '@dxos/react-client/echo';
+import { useTranslation } from '@dxos/react-ui';
+import { Settings } from '@dxos/react-ui-form';
+import { mx } from '@dxos/ui-theme';
+
+import { meta } from '../../meta';
+
+type SchemaPanelProps = { space: Space };
+
+export const SchemaContainer = ({ space }: SchemaPanelProps) => {
+  const { t } = useTranslation(meta.id);
+  const schemas = useQuerySpaceSchemas(space);
+
+  return (
+    <Settings.Root>
+      <Settings.Section title={t('schema verbose label')} description={t('schema description')}>
+        <div
+          role='none'
+          className={mx([
+            'grid md:col-span-2 grid-cols-subgrid gap-trim-sm items-center',
+            '*:first:mt-0! *:last:mb-0! px-trim-md py-trim-md',
+            'border border-separator rounded-md',
+          ])}
+        >
+          {schemas.length === 0 && <div className='text-center py-4'>{t('no schemas found message')}</div>}
+          {schemas.map((schema) => (
+            <div role='none' key={schema.id}>
+              {schema.typename}
+            </div>
+          ))}
+        </div>
+      </Settings.Section>
+    </Settings.Root>
+  );
+};
+
+/**
+ * Subscribe to and retrieve all schemas from a space's schema registry.
+ */
+export const useQuerySpaceSchemas = (space: Space): Type.RuntimeType[] => {
+  const [schemas, setSchemas] = useState<Type.RuntimeType[]>([]);
+
+  useEffect(() => {
+    const query = space.db.schemaRegistry.query();
+    const initialResults = query.runSync();
+    setSchemas(initialResults);
+
+    const unsubscribe = query.subscribe(() => setSchemas(query.results));
+    return () => unsubscribe();
+  }, [space]);
+
+  return schemas;
+};

package/src/containers/SchemaContainer/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { SchemaContainer } from './SchemaContainer';
+
+export default SchemaContainer;

package/src/containers/SmallPresenceLive/index.ts

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

package/src/containers/SpacePluginSettings/SpacePluginSettings.tsx

@@ -0,0 +1,65 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import React from 'react';
+
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { useClient } from '@dxos/react-client';
+import { useSpaces } from '@dxos/react-client/echo';
+import { IconButton, Input, List, ListItem, toLocalizedString, useTranslation } from '@dxos/react-ui';
+import { Settings } from '@dxos/react-ui-form';
+
+import { meta } from '../../meta';
+import { SpaceOperation, type SpaceSettingsProps } from '../../types';
+import { getSpaceDisplayName } from '../../util';
+
+export type SpacePluginSettingsComponentProps = {
+  settings: SpaceSettingsProps;
+  onSettingsChange: (fn: (current: SpaceSettingsProps) => SpaceSettingsProps) => void;
+};
+
+export const SpacePluginSettings = ({ settings, onSettingsChange }: SpacePluginSettingsComponentProps) => {
+  const { t } = useTranslation(meta.id);
+  const client = useClient();
+  const spaces = useSpaces({ all: settings.showHidden });
+  const { invokePromise } = useOperationInvoker();
+
+  return (
+    <Settings.Root>
+      <Settings.Section title={t('space settings label')} description={t('space settings description')}>
+        <Settings.Group>
+          <Settings.ItemInput title={t('show hidden spaces label')}>
+            <Input.Switch
+              checked={settings.showHidden}
+              onCheckedChange={(checked) => onSettingsChange((state) => ({ ...state, showHidden: !!checked }))}
+            />
+          </Settings.ItemInput>
+        </Settings.Group>
+
+        <Settings.Container>
+          <List classNames='flex flex-col gap-trim-sm'>
+            {spaces.map((space) => (
+              <ListItem.Root key={space.id} classNames='w-full items-center'>
+                {/* TODO(burdon): Should auto center and truncate; NOTE truncate doesn't work with flex grow. */}
+                <ListItem.Heading classNames='grow truncate min-h-0!'>
+                  {toLocalizedString(
+                    getSpaceDisplayName(space, {
+                      personal: space === client.spaces.default,
+                    }),
+                    t,
+                  )}
+                </ListItem.Heading>
+                <IconButton
+                  icon='ph--faders--regular'
+                  onClick={() => invokePromise(SpaceOperation.OpenSettings, { space })}
+                  label={t('open space settings label')}
+                />
+              </ListItem.Root>
+            ))}
+          </List>
+        </Settings.Container>
+      </Settings.Section>
+    </Settings.Root>
+  );
+};

package/src/containers/SpacePluginSettings/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { SpacePluginSettings } from './SpacePluginSettings';
+
+export default SpacePluginSettings;

package/src/{components → containers}/SpacePresence/SpacePresence.stories.tsx

@@ -23,8 +23,8 @@ const viewers = (n: number, currentlyAttended = true): Member[] =>
   }));
 
 const meta = {
-  title: 'plugins/plugin-space/SpacePresence',
-  decorators: [withTheme],
+  title: 'plugins/plugin-space/containers/SpacePresence',
+  decorators: [withTheme()],
   parameters: {
     translations,
   },

package/src/{components → containers}/SpacePresence/SpacePresence.tsx

@@ -2,14 +2,13 @@
 // Copyright 2023 DXOS.org
 //
 
-import * as Option from 'effect/Option';
 import React, { forwardRef, useCallback, useEffect, useState } from 'react';
 
-import { useAppGraph, useCapability } from '@dxos/app-framework/react';
+import { useAtomCapability } from '@dxos/app-framework/ui';
 import { generateName } from '@dxos/display-name';
-import { Obj, type Type } from '@dxos/echo';
-import { PublicKey, useClient } from '@dxos/react-client';
-import { type SpaceMember, getSpace, useMembers } from '@dxos/react-client/echo';
+import { type Key, Obj } from '@dxos/echo';
+import { PublicKey } from '@dxos/react-client';
+import { type SpaceMember, useMembers, useSpace } from '@dxos/react-client/echo';
 import { type Identity, useIdentity } from '@dxos/react-client/halo';
 import {
   Avatar,
@@ -24,13 +23,11 @@ import {
   useDefaultValue,
   useTranslation,
 } from '@dxos/react-ui';
-import { AttentionGlyph, type AttentionGlyphProps, useAttended, useAttention } from '@dxos/react-ui-attention';
+import { AttentionGlyph, type AttentionGlyphProps, useAttention } from '@dxos/react-ui-attention';
 import { ComplexMap, keyToFallback } from '@dxos/util';
 
-import { SpaceCapabilities } from '../../capabilities';
-import { usePath } from '../../hooks';
 import { meta } from '../../meta';
-import { type ObjectViewerProps } from '../../types';
+import { type ObjectViewerProps, SpaceCapabilities } from '../../types';
 
 // TODO(thure): Get/derive these values from protocol
 const REFRESH_INTERVAL = 5000;
@@ -43,17 +40,16 @@ const noViewers = new ComplexMap<PublicKey, ObjectViewerProps>(PublicKey.hash);
 const getName = (identity: Identity) => identity.profile?.displayName ?? generateName(identity.identityKey.toHex());
 
 export type SpacePresenceProps = {
-  object: Type.Expando;
-  spaceKey?: PublicKey;
+  object: Obj.Unknown;
+  spaceId?: Key.SpaceId;
 };
 
-export const SpacePresence = ({ object, spaceKey }: SpacePresenceProps) => {
-  // TODO(wittjosiah): Doesn't need to be mutable but readonly type messes with ComplexMap.
-  const spaceState = useCapability(SpaceCapabilities.MutableState);
-  const client = useClient();
+export const SpacePresence = ({ object, spaceId }: SpacePresenceProps) => {
+  const ephemeral = useAtomCapability(SpaceCapabilities.EphemeralState);
   const identity = useIdentity();
-  const space = spaceKey ? client.spaces.get(spaceKey) : getSpace(object);
-  const spaceMembers = useMembers(space?.key);
+  const db = Obj.getDatabase(object);
+  const space = useSpace(spaceId ?? db?.spaceId);
+  const spaceMembers = useMembers(spaceId ?? db?.spaceId);
 
   const [_moment, setMoment] = useState(Date.now());
 
@@ -71,11 +67,11 @@ export const SpacePresence = ({ object, spaceKey }: SpacePresenceProps) => {
 
   // TODO(thure): Could it be a smell to return early when there are interactions with `deepSignal` later, since it
   //  prevents reactivity?
-  if (!identity || !spaceState || !space) {
+  if (!identity || !ephemeral || !space) {
     return null;
   }
 
-  const currentObjectViewers = spaceState.viewersByObject[Obj.getDXN(object).toString()] ?? noViewers;
+  const currentObjectViewers = ephemeral.viewersByObject[Obj.getDXN(object).toString()] ?? noViewers;
 
   const membersForObject = spaceMembers
     .filter((member) => memberOnline(member) && memberIsNotSelf(member))
@@ -126,7 +122,7 @@ export const FullPresence = (props: MemberPresenceProps) => {
           key={member.identity.identityKey.toHex()}
           side='bottom'
           content={getName(member.identity)}
-          className='grid focus:outline-none'
+          className='grid focus:outline-hidden'
         >
           <PresenceAvatar
             identity={member.identity}
@@ -140,7 +136,7 @@ export const FullPresence = (props: MemberPresenceProps) => {
 
       {members.length > 3 && (
         <Popover.Root>
-          <Popover.Trigger className='grid focus:outline-none'>
+          <Popover.Trigger className='grid focus:outline-hidden'>
             <Avatar.Root>
               {/* TODO(wittjosiah): Make text fit. */}
               <Avatar.Content
@@ -154,12 +150,12 @@ export const FullPresence = (props: MemberPresenceProps) => {
           <Popover.Portal>
             <Popover.Content side='bottom'>
               <Popover.Arrow />
-              <Popover.Viewport classNames='max-bs-56'>
+              <Popover.Viewport classNames='max-h-56'>
                 <List>
                   {members.map((member) => (
                     <ListItem.Root
                       key={member.identity.identityKey.toHex()}
-                      classNames='flex gap-2 items-center cursor-pointer mbe-2'
+                      classNames='flex gap-2 items-center cursor-pointer mb-2'
                       onClick={() => onMemberClick?.(member)}
                       data-testid='identity-list-item'
                     >
@@ -207,7 +203,7 @@ const PresenceAvatar = forwardRef<DxAvatar, PresenceAvatarProps>(
           fallback={identity.profile?.data?.emoji || fallbackValue.emoji}
           ref={forwardedRef}
         />
-        <Avatar.Label classNames={showName ? 'text-sm truncate pli-2' : 'sr-only'}>{getName(identity)}</Avatar.Label>
+        <Avatar.Label classNames={showName ? 'text-sm truncate px-2' : 'sr-only'}>{getName(identity)}</Avatar.Label>
       </Avatar.Root>
     );
   },
@@ -221,17 +217,8 @@ export type SmallPresenceLiveProps = {
 
 export const SmallPresenceLive = ({ id, open, viewers }: SmallPresenceLiveProps) => {
   const { hasAttention, isAncestor, isRelated } = useAttention(id);
-  const isAttended = hasAttention || isAncestor || isRelated;
-
-  // TODO(wittjosiah): If the attended node is deep in the graph and the graph is not fully loaded
-  //   this will result in an empty path until the graph is connected.
-  // TODO(wittjosiah): Consider using this indicator for all open nodes instead of just attended.
-  const { graph } = useAppGraph();
-  const attended = useAttended();
-  const startOfAttention = attended.at(-1);
-  const path = usePath(graph, startOfAttention);
-  const containsAttended = !open && !isAttended && id && Option.isSome(path) ? path.value.includes(id) : false;
-
+  const attended = hasAttention || isRelated;
+  const containsAttended = isAncestor && !open;
   const getActiveViewers = (viewers: ComplexMap<PublicKey, ObjectViewerProps>): ObjectViewerProps[] => {
     const moment = Date.now();
     return Array.from<ObjectViewerProps>(viewers.values()).filter(
@@ -251,7 +238,7 @@ export const SmallPresenceLive = ({ id, open, viewers }: SmallPresenceLiveProps)
     }
   }, [viewers]);
 
-  return <SmallPresence count={activeViewers.length} attended={isAttended} containsAttended={containsAttended} />;
+  return <SmallPresence count={activeViewers.length} attended={attended} containsAttended={containsAttended} />;
 };
 
 export type SmallPresenceProps = {
@@ -267,7 +254,7 @@ export const SmallPresence = ({ count = 0, attended, containsAttended }: SmallPr
         attended={attended}
         containsAttended={containsAttended}
         presence={count > 1 ? 'many' : count === 1 ? 'one' : 'none'}
-        classNames='self-center mie-1'
+        classNames='self-center mx-1'
       />
     </Tooltip.Trigger>
   );

package/src/containers/SpacePresence/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export { SpacePresence, SmallPresenceLive } from './SpacePresence';
+export { SpacePresence as default } from './SpacePresence';