@dxos/plugin-space 0.7.4 → 0.7.5-labs.071a3e2

package/src/capabilities/react-surface.tsx

@@ -0,0 +1,226 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useCallback } from 'react';
+
+import {
+  Capabilities,
+  contributes,
+  createSurface,
+  Surface,
+  useCapability,
+  useCapabilities,
+  usePluginManager,
+} from '@dxos/app-framework';
+import { SettingsStore } from '@dxos/local-storage';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import {
+  getSpace,
+  isEchoObject,
+  isReactiveObject,
+  isSpace,
+  SpaceState,
+  type ReactiveEchoObject,
+  type Space,
+} from '@dxos/react-client/echo';
+import { type JoinPanelProps } from '@dxos/shell/react';
+
+import { SpaceCapabilities } from './capabilities';
+import {
+  AdvancedObjectSettings,
+  BaseObjectSettings,
+  CollectionMain,
+  CollectionSection,
+  CREATE_OBJECT_DIALOG,
+  CREATE_SPACE_DIALOG,
+  CreateObjectDialog,
+  CreateSpaceDialog,
+  InlineSyncStatus,
+  JOIN_DIALOG,
+  JoinDialog,
+  MenuFooter,
+  POPOVER_RENAME_OBJECT,
+  POPOVER_RENAME_SPACE,
+  PopoverRenameObject,
+  PopoverRenameSpace,
+  SmallPresenceLive,
+  SPACE_SETTINGS_DIALOG,
+  SpacePluginSettings,
+  SpacePresence,
+  SpaceSettingsDialog,
+  SpaceSettingsPanel,
+  SyncStatus,
+  type CreateObjectDialogProps,
+  type SpaceSettingsDialogProps,
+} from '../components';
+import { SPACE_PLUGIN } from '../meta';
+import { CollectionType, type SpaceSettingsProps } from '../types';
+
+type ReactSurfaceOptions = {
+  createInvitationUrl: (invitationCode: string) => string;
+};
+
+export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
+  contributes(Capabilities.ReactSurface, [
+    createSurface({
+      id: `${SPACE_PLUGIN}/article`,
+      role: 'article',
+      filter: (data): data is { subject: Space } =>
+        // TODO(wittjosiah): Need to avoid shotgun parsing space state everywhere.
+        isSpace(data.subject) && data.subject.state.get() === SpaceState.SPACE_READY,
+      component: ({ data, role, ...rest }) => (
+        <Surface
+          data={{ id: data.subject.id, subject: data.subject.properties[CollectionType.typename]?.target }}
+          role={role}
+          {...rest}
+        />
+      ),
+    }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/collection-fallback`,
+      role: 'article',
+      position: 'fallback',
+      filter: (data): data is { subject: CollectionType } => data.subject instanceof CollectionType,
+      component: ({ data }) => <CollectionMain collection={data.subject} />,
+    }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/settings-panel`,
+      // TODO(burdon): Add role name syntax to minimal plugin docs.
+      role: 'complementary--settings',
+      filter: (data): data is { subject: Space } => isSpace(data.subject),
+      component: ({ data }) => <SpaceSettingsPanel space={data.subject} />,
+    }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/object-settings-base-panel`,
+      role: 'complementary--settings',
+      position: 'hoist',
+      filter: (data): data is { subject: ReactiveEchoObject<any> } => isEchoObject(data.subject),
+      component: ({ data }) => <BaseObjectSettings object={data.subject} />,
+    }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/object-settings-advanced-panel`,
+      role: 'complementary--settings',
+      position: 'fallback',
+      filter: (data): data is { subject: ReactiveEchoObject<any> } => isEchoObject(data.subject),
+      component: ({ data }) => <AdvancedObjectSettings object={data.subject} />,
+    }),
+    createSurface({
+      id: SPACE_SETTINGS_DIALOG,
+      role: 'dialog',
+      filter: (data): data is { props: SpaceSettingsDialogProps } => data.component === SPACE_SETTINGS_DIALOG,
+      component: ({ data }) => <SpaceSettingsDialog {...data.props} createInvitationUrl={createInvitationUrl} />,
+    }),
+    createSurface({
+      id: JOIN_DIALOG,
+      role: 'dialog',
+      filter: (data): data is { props: JoinPanelProps } => data.component === JOIN_DIALOG,
+      component: ({ data }) => <JoinDialog {...data.props} />,
+    }),
+    createSurface({
+      id: CREATE_SPACE_DIALOG,
+      role: 'dialog',
+      filter: (data): data is any => data.component === CREATE_SPACE_DIALOG,
+      component: () => <CreateSpaceDialog />,
+    }),
+    createSurface({
+      id: CREATE_OBJECT_DIALOG,
+      role: 'dialog',
+      filter: (data): data is { props: Partial<CreateObjectDialogProps> } => data.component === CREATE_OBJECT_DIALOG,
+      component: ({ data }) => {
+        const schemas = useCapabilities(ClientCapabilities.Schema).flat();
+        const manager = usePluginManager();
+
+        const resolve = useCallback(
+          (typename: string) => {
+            return (
+              manager.context.requestCapabilities(Capabilities.Metadata).find(({ id }) => id === typename)?.metadata ??
+              {}
+            );
+          },
+          [manager],
+        );
+
+        return <CreateObjectDialog schemas={schemas} resolve={resolve} {...data.props} />;
+      },
+    }),
+    createSurface({
+      id: POPOVER_RENAME_SPACE,
+      role: 'popover',
+      filter: (data): data is { props: Space } => data.component === POPOVER_RENAME_SPACE && isSpace(data.props),
+      component: ({ data }) => <PopoverRenameSpace space={data.props} />,
+    }),
+    createSurface({
+      id: POPOVER_RENAME_OBJECT,
+      role: 'popover',
+      filter: (data): data is { props: ReactiveEchoObject<any> } =>
+        data.component === POPOVER_RENAME_OBJECT && isReactiveObject(data.props),
+      component: ({ data }) => <PopoverRenameObject object={data.props} />,
+    }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/navtree-presence`,
+      role: 'navtree-item-end',
+      filter: (data): data is { id: string; subject: ReactiveEchoObject<any>; open?: boolean } =>
+        typeof data.id === 'string' && isEchoObject(data.subject),
+      component: ({ data }) => {
+        // TODO(wittjosiah): Doesn't need to be mutable but readonly type messes with ComplexMap.
+        const state = useCapability(SpaceCapabilities.MutableState);
+        return <SmallPresenceLive id={data.id} open={data.open} viewers={state.viewersByObject[data.id]} />;
+      },
+    }),
+    createSurface({
+      // TODO(wittjosiah): Attention glyph for non-echo items should be handled elsewhere.
+      id: `${SPACE_PLUGIN}/navtree-presence-fallback`,
+      role: 'navtree-item-end',
+      position: 'fallback',
+      filter: (data): data is { id: string; open?: boolean } => typeof data.id === 'string',
+      component: ({ data }) => <SmallPresenceLive id={data.id} open={data.open} />,
+    }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/navtree-sync-status`,
+      role: 'navtree-item-end',
+      filter: (data): data is { subject: Space; open?: boolean } => isSpace(data.subject),
+      component: ({ data }) => <InlineSyncStatus space={data.subject} open={data.open} />,
+    }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/navbar-presence`,
+      role: 'navbar-end',
+      position: 'hoist',
+      filter: (data): data is { subject: Space | ReactiveEchoObject<any> } =>
+        isSpace(data.subject) || isEchoObject(data.subject),
+      component: ({ data }) => {
+        const space = isSpace(data.subject) ? data.subject : getSpace(data.subject);
+        const object = isSpace(data.subject)
+          ? data.subject.state.get() === SpaceState.SPACE_READY
+            ? (space?.properties[CollectionType.typename]?.target as CollectionType)
+            : undefined
+          : data.subject;
+
+        return object ? <SpacePresence object={object} /> : null;
+      },
+    }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/collection-section`,
+      role: 'section',
+      filter: (data): data is { subject: CollectionType } => data.subject instanceof CollectionType,
+      component: ({ data }) => <CollectionSection collection={data.subject} />,
+    }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/settings`,
+      role: 'article',
+      filter: (data): data is { subject: SettingsStore<SpaceSettingsProps> } =>
+        data.subject instanceof SettingsStore && data.subject.prefix === SPACE_PLUGIN,
+      component: ({ data: { subject } }) => <SpacePluginSettings settings={subject.value} />,
+    }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/menu-footer`,
+      role: 'menu-footer',
+      filter: (data): data is { subject: ReactiveEchoObject<any> } => isEchoObject(data.subject),
+      component: ({ data }) => <MenuFooter object={data.subject} />,
+    }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/status`,
+      role: 'status',
+      component: () => <SyncStatus />,
+    }),
+  ]);

package/src/capabilities/settings.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capabilities, contributes } from '@dxos/app-framework';
+import { create } from '@dxos/live-object';
+
+import { SPACE_PLUGIN } from '../meta';
+import { type SpaceSettingsProps, SpaceSettingsSchema } from '../types';
+
+export default () => {
+  const settings = create<SpaceSettingsProps>({
+    showHidden: false,
+  });
+
+  return contributes(Capabilities.Settings, { schema: SpaceSettingsSchema, prefix: SPACE_PLUGIN, value: settings });
+};

package/src/capabilities/spaces-ready.ts

@@ -0,0 +1,230 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { contributes, createIntent, type PluginsContext, Capabilities, LayoutAction } from '@dxos/app-framework';
+import { EventSubscriptions } from '@dxos/async';
+import { Expando } from '@dxos/echo-schema';
+import { scheduledEffect } from '@dxos/echo-signals/core';
+import { create } from '@dxos/live-object';
+import { log } from '@dxos/log';
+import { AttentionCapabilities } from '@dxos/plugin-attention';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { DeckCapabilities } from '@dxos/plugin-deck';
+import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
+import { PublicKey } from '@dxos/react-client';
+import { Filter, FQ_ID_LENGTH, parseFullyQualifiedId, SpaceState } from '@dxos/react-client/echo';
+import { ComplexMap, reduceGroupBy } from '@dxos/util';
+
+import { SpaceCapabilities } from './capabilities';
+import { SpaceAction } from '../types';
+import { COMPOSER_SPACE_LOCK, SHARED } from '../util';
+
+const ACTIVE_NODE_BROADCAST_INTERVAL = 30_000;
+const WAIT_FOR_OBJECT_TIMEOUT = 1000;
+
+export default async (context: PluginsContext) => {
+  const subscriptions = new EventSubscriptions();
+  const spaceSubscriptions = new EventSubscriptions();
+
+  const { dispatchPromise: dispatch } = context.requestCapability(Capabilities.IntentDispatcher);
+  const { graph } = context.requestCapability(Capabilities.AppGraph);
+  const layout = context.requestCapability(Capabilities.Layout);
+  const deck = context.requestCapability(DeckCapabilities.DeckState);
+  const attention = context.requestCapability(AttentionCapabilities.Attention);
+  const state = context.requestCapability(SpaceCapabilities.MutableState);
+  const client = context.requestCapability(ClientCapabilities.Client);
+
+  const defaultSpace = client.spaces.default;
+  await defaultSpace.waitUntilReady();
+
+  if (deck.activeDeck === 'default') {
+    await dispatch(createIntent(LayoutAction.SwitchWorkspace, { part: 'workspace', subject: defaultSpace.id }));
+  }
+
+  // Initialize space sharing lock in default space.
+  if (typeof defaultSpace.properties[COMPOSER_SPACE_LOCK] !== 'boolean') {
+    defaultSpace.properties[COMPOSER_SPACE_LOCK] = true;
+  }
+
+  const {
+    objects: [spacesOrder],
+  } = await defaultSpace.db.query(Filter.schema(Expando, { key: SHARED })).run();
+  if (!spacesOrder) {
+    // TODO(wittjosiah): Cannot be a Folder because Spaces are not TypedObjects so can't be saved in the database.
+    //  Instead, we store order as an array of space ids.
+    defaultSpace.db.add(create({ key: SHARED, order: [] }));
+  }
+
+  // Await missing objects.
+  subscriptions.add(
+    scheduledEffect(
+      () => ({ active: layout.active }),
+      ({ active }) => {
+        if (active.length !== 1) {
+          return;
+        }
+
+        const node = graph.findNode(active[0]);
+        if (!node && active[0].length === FQ_ID_LENGTH) {
+          const timeout = setTimeout(async () => {
+            const node = graph.findNode(active[0]);
+            if (!node) {
+              await dispatch(createIntent(SpaceAction.WaitForObject, { id: active[0] }));
+            }
+          }, WAIT_FOR_OBJECT_TIMEOUT);
+
+          return () => clearTimeout(timeout);
+        }
+      },
+    ),
+  );
+
+  // Cache space names.
+  subscriptions.add(
+    client.spaces.subscribe(async (spaces) => {
+      // TODO(wittjosiah): Remove. This is a hack to be able to migrate the default space properties.
+      if (defaultSpace.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION) {
+        await defaultSpace.internal.migrate();
+      }
+
+      spaces
+        .filter((space) => space.state.get() === SpaceState.SPACE_READY)
+        .forEach((space) => {
+          subscriptions.add(
+            scheduledEffect(
+              () => ({ name: space.properties.name }),
+              ({ name }) => (state.spaceNames[space.id] = name),
+            ),
+          );
+        });
+    }).unsubscribe,
+  );
+
+  // Broadcast active node to other peers in the space.
+  subscriptions.add(
+    scheduledEffect(
+      () => ({ current: attention.current, active: layout.active, inactive: layout.inactive }),
+      ({ current, active, inactive }) => {
+        const send = () => {
+          const spaces = client.spaces.get();
+          const identity = client.halo.identity.get();
+          if (identity) {
+            // Group parts by space for efficient messaging.
+            const idsBySpace = reduceGroupBy(active, (id) => {
+              try {
+                const [spaceId] = parseFullyQualifiedId(id);
+                return spaceId;
+              } catch {
+                return null;
+              }
+            });
+
+            const removedBySpace = reduceGroupBy(inactive, (id) => {
+              try {
+                const [spaceId] = parseFullyQualifiedId(id);
+                return spaceId;
+              } catch {
+                return null;
+              }
+            });
+
+            // NOTE: Ensure all spaces are included so that we send the correct `removed` object arrays.
+            for (const space of spaces) {
+              if (!idsBySpace.has(space.id)) {
+                idsBySpace.set(space.id, []);
+              }
+            }
+
+            for (const [spaceId, added] of idsBySpace) {
+              const removed = removedBySpace.get(spaceId) ?? [];
+              const space = spaces.find((space) => space.id === spaceId);
+              if (!space) {
+                continue;
+              }
+
+              void space
+                .postMessage('viewing', {
+                  identityKey: identity.identityKey.toHex(),
+                  attended: current,
+                  added,
+                  removed,
+                })
+                // TODO(burdon): This seems defensive; why would this fail? Backoff interval.
+                .catch((err) => {
+                  log.warn('Failed to broadcast active node for presence.', { err: err.message });
+                });
+            }
+          }
+        };
+
+        send();
+        // Send at interval to allow peers to expire entries if they become disconnected.
+        const interval = setInterval(() => send(), ACTIVE_NODE_BROADCAST_INTERVAL);
+        return () => clearInterval(interval);
+      },
+    ),
+  );
+
+  // 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)
+            ) {
+              added.forEach((id) => {
+                if (typeof id === 'string') {
+                  if (!(id in state.viewersByObject)) {
+                    state.viewersByObject[id] = new ComplexMap(PublicKey.hash);
+                  }
+                  state.viewersByObject[id]!.set(identityKey, {
+                    lastSeen: Date.now(),
+                    currentlyAttended: new Set(attended).has(id),
+                  });
+                  if (!state.viewersByIdentity.has(identityKey)) {
+                    state.viewersByIdentity.set(identityKey, new Set());
+                  }
+                  state.viewersByIdentity.get(identityKey)!.add(id);
+                }
+              });
+
+              removed.forEach((id) => {
+                if (typeof id === 'string') {
+                  state.viewersByObject[id]?.delete(identityKey);
+                  state.viewersByIdentity.get(identityKey)?.delete(id);
+                  // It’s okay for these to be empty sets/maps, reduces churn.
+                }
+              });
+            }
+          }),
+        );
+      });
+    }).unsubscribe,
+  );
+
+  // Enable edge replication for all spaces.
+  try {
+    await Promise.all(
+      client.spaces.get().map((space) => space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED)),
+    );
+    state.enabledEdgeReplication = true;
+  } catch (err) {
+    log.catch(err);
+  }
+
+  return contributes(Capabilities.Null, null, () => {
+    spaceSubscriptions.clear();
+    subscriptions.clear();
+  });
+};

package/src/capabilities/state.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { effect } from '@preact/signals-core';
+
+import { Capabilities, contributes, type PluginsContext } from '@dxos/app-framework';
+import { PublicKey } from '@dxos/keys';
+import { LocalStorageStore } from '@dxos/local-storage';
+import { ComplexMap } from '@dxos/util';
+
+import { SpaceCapabilities } from './capabilities';
+import { SPACE_PLUGIN } from '../meta';
+import { type PluginState } from '../types';
+
+export default (context: PluginsContext) => {
+  const state = new LocalStorageStore<PluginState>(SPACE_PLUGIN, {
+    awaiting: undefined,
+    spaceNames: {},
+    viewersByObject: {},
+    // TODO(wittjosiah): Stop using (Complex)Map inside reactive object.
+    viewersByIdentity: new ComplexMap(PublicKey.hash),
+    sdkMigrationRunning: {},
+    navigableCollections: false,
+    enabledEdgeReplication: false,
+  });
+
+  state
+    .prop({ key: 'spaceNames', type: LocalStorageStore.json<Record<string, string>>() })
+    .prop({ key: 'enabledEdgeReplication', type: LocalStorageStore.bool() });
+
+  const manager = context.requestCapability(Capabilities.PluginManager);
+  const unsubscribe = effect(() => {
+    // TODO(wittjosiah): Find a way to make this capability-based.
+    const enabled = manager.enabled.includes('dxos.org/plugin/stack');
+    if (enabled !== state.values.navigableCollections) {
+      state.values.navigableCollections = enabled;
+    }
+  });
+
+  return contributes(SpaceCapabilities.State, state.values, () => {
+    unsubscribe();
+    state.close();
+  });
+};

package/src/components/AdvancedObjectSettings/AdvancedObjectSettings.tsx

@@ -0,0 +1,72 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { useCallback, useState } from 'react';
+
+import { type ForeignKey, ForeignKeySchema } from '@dxos/echo-schema';
+import { getMeta, type ReactiveEchoObject } from '@dxos/react-client/echo';
+import { IconButton, useTranslation, Separator } from '@dxos/react-ui';
+import { Form } from '@dxos/react-ui-form';
+
+import { ForeignKeys } from './ForeignKeys';
+import { SPACE_PLUGIN } from '../../meta';
+
+const initialValues = {
+  source: '',
+  id: '',
+};
+
+export type AdvancedObjectSettingsProps = {
+  object: ReactiveEchoObject<any>;
+};
+
+export const AdvancedObjectSettings = ({ object }: AdvancedObjectSettingsProps) => {
+  const { t } = useTranslation(SPACE_PLUGIN);
+  const [adding, setAdding] = useState(false);
+  const keys = getMeta(object).keys;
+
+  const handleNew = useCallback(() => setAdding(true), []);
+  const handleCancel = useCallback(() => setAdding(false), []);
+  const handleSave = useCallback(
+    (key: ForeignKey) => {
+      const index = keys.findIndex(({ source, id }) => source === key.source && id === key.id);
+      if (index === -1) {
+        keys.push(key);
+      }
+      setAdding(false);
+    },
+    [keys],
+  );
+  const handleDelete = useCallback(
+    (key: ForeignKey) => {
+      const index = keys.findIndex(({ source, id }) => source === key.source && id === key.id);
+      if (index !== -1) {
+        keys.splice(index, 1);
+      }
+    },
+    [keys],
+  );
+
+  // TODO(wittjosiah): This should be wrapped in an "Advanced" accordion.
+  return (
+    <>
+      <Separator />
+      <div className='p-2 flex flex-col gap-4'>
+        <h2>{t('advanced settings label')}</h2>
+        <div className='flex items-center'>
+          <h3 className='text-sm font-semibold'>{t('foreign keys')}</h3>
+          <div className='grow' />
+          <IconButton
+            classNames={adding && 'invisible'}
+            icon='ph--plus--regular'
+            label={t('add key')}
+            onClick={handleNew}
+          />
+        </div>
+        {!adding && <ForeignKeys keys={keys} onDelete={handleDelete} />}
+      </div>
+      {adding && <Form schema={ForeignKeySchema} values={initialValues} onSave={handleSave} onCancel={handleCancel} />}
+    </>
+  );
+};

package/src/components/AdvancedObjectSettings/ForeignKeys.tsx

@@ -0,0 +1,51 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React, { useCallback } from 'react';
+
+import { type ForeignKey } from '@dxos/echo-schema';
+import { IconButton, List, ListItem, useTranslation } from '@dxos/react-ui';
+
+import { SPACE_PLUGIN } from '../../meta';
+
+export type ForeignKeysProps = {
+  keys: ForeignKey[];
+  onDelete?: (key: ForeignKey) => void;
+};
+
+// TODO(wittjosiah): This is a clone of `TokenManager`. Consider a form variant for arrays of read-only objects.
+export const ForeignKeys = ({ keys, onDelete }: ForeignKeysProps) => {
+  return (
+    <List classNames='flex flex-col gap-2'>
+      {keys.map((key) => (
+        <KeyItem key={key.id} forignKey={key} onDelete={onDelete} />
+      ))}
+    </List>
+  );
+};
+
+type KeyItemProps = {
+  forignKey: ForeignKey;
+  onDelete?: (key: ForeignKey) => void;
+};
+
+const KeyItem = ({ forignKey, onDelete }: KeyItemProps) => {
+  const { t } = useTranslation(SPACE_PLUGIN);
+
+  const handleDelete = useCallback(() => {
+    onDelete?.(forignKey);
+  }, [forignKey, onDelete]);
+
+  return (
+    <ListItem.Root classNames='px-2'>
+      <ListItem.Heading classNames='flex flex-col grow truncate'>
+        <div>{forignKey.source}</div>
+        <div className='text-description text-sm truncate'>{forignKey.id}</div>
+      </ListItem.Heading>
+      <ListItem.Endcap>
+        <IconButton iconOnly icon='ph--x--regular' variant='ghost' label={t('delete key')} onClick={handleDelete} />
+      </ListItem.Endcap>
+    </ListItem.Root>
+  );
+};

package/src/components/AdvancedObjectSettings/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './AdvancedObjectSettings';