@dxos/plugin-space 0.8.4-main.72ec0f3 → 0.8.4-main.74a063c4e0

package/src/containers/SpaceSettingsContainer/SpaceSettingsContainer.tsx

@@ -0,0 +1,216 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import React, { type ChangeEvent, useCallback, useMemo, useState } from 'react';
+
+import { useCapabilities, useOperationInvoker } from '@dxos/app-framework/ui';
+import { getPersonalSpace, getSpacePath, isPersonalSpace, LayoutOperation } from '@dxos/app-toolkit';
+import { Obj } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
+import { useClient } from '@dxos/react-client';
+import { type Space, SpaceState } from '@dxos/react-client/echo';
+import { Button, Input, useFileDownload, useMulticastObservable, useTranslation } from '@dxos/react-ui';
+import { Form, type FormFieldMap, Settings } from '@dxos/react-ui-form';
+import { HuePicker, IconPicker } from '@dxos/react-ui-pickers';
+
+import { meta } from '#meta';
+import { SpaceOperation } from '#operations';
+import { SpaceCapabilities, SpaceForm } from '#types';
+
+const SpaceFormSchema = SpaceForm.pipe(
+  Schema.extend(
+    Schema.Struct({
+      archived: Schema.Boolean.annotations({ title: 'Archive Space' }),
+    }),
+  ),
+);
+
+export type SpaceSettingsContainerProps = {
+  space: Space;
+};
+
+// TODO(wittjosiah): Handle space migrations here?
+export const SpaceSettingsContainer = ({ space }: SpaceSettingsContainerProps) => {
+  const { t } = useTranslation(meta.id);
+  const { invokePromise } = useOperationInvoker();
+  const client = useClient();
+  const archived = useMulticastObservable(space.state) === SpaceState.SPACE_INACTIVE;
+  const [edgeReplication, setEdgeReplication] = useState(
+    space.internal.data.edgeReplication === EdgeReplicationSetting.ENABLED,
+  );
+  const toggleEdgeReplication = useCallback(
+    async (next: boolean) => {
+      setEdgeReplication(next);
+      await space?.internal
+        .setEdgeReplicationPreference(next ? EdgeReplicationSetting.ENABLED : EdgeReplicationSetting.DISABLED)
+        .catch((err: unknown) => {
+          log.catch(err);
+          setEdgeReplication(!next);
+        });
+    },
+    [space],
+  );
+
+  const handleValuesChanged = useCallback(
+    (newValues: Partial<Schema.Schema.Type<typeof SpaceFormSchema>>, meta: { changed?: Record<string, boolean> }) => {
+      const changed = meta.changed ?? {};
+      if (changed['edgeReplication']) {
+        void toggleEdgeReplication(newValues.edgeReplication ?? false);
+      }
+
+      if (changed['name'] || changed['icon'] || changed['hue']) {
+        Obj.change(space.properties, (obj) => {
+          if (changed['name'] && newValues.name !== undefined) {
+            obj.name = newValues.name;
+          }
+          if (changed['icon']) {
+            obj.icon = newValues.icon;
+          }
+          if (changed['hue']) {
+            obj.hue = newValues.hue;
+          }
+        });
+      }
+
+      if (changed['archived']) {
+        if (newValues.archived && !archived) {
+          void invokePromise(SpaceOperation.Close, { space });
+          const personalSpace = getPersonalSpace(client);
+          if (personalSpace) {
+            void invokePromise(LayoutOperation.SwitchWorkspace, {
+              subject: getSpacePath(personalSpace.id),
+            });
+          }
+        } else if (!newValues.archived && archived) {
+          void invokePromise(SpaceOperation.Open, { space });
+        }
+      }
+    },
+    [space, client, archived, invokePromise, toggleEdgeReplication],
+  );
+
+  const defaultValues = useMemo(
+    () => ({
+      name: space.properties.name,
+      icon: space.properties.icon,
+      hue: space.properties.hue,
+      edgeReplication,
+      archived,
+    }),
+    [space.properties.name, space.properties.icon, space.properties.hue, edgeReplication, archived],
+  );
+
+  const personal = isPersonalSpace(space);
+
+  const fieldMap = useMemo<FormFieldMap>(
+    () => ({
+      name: personal
+        ? () => null
+        : ({ type, label, getValue, onValueChange }) => {
+            const handleChange = useCallback(
+              ({ target: { value } }: ChangeEvent<HTMLInputElement>) => onValueChange(type, value),
+              [onValueChange, type],
+            );
+            return (
+              <Settings.Item title={label} description={t('display-name.description')}>
+                <Input.TextInput
+                  value={getValue()}
+                  onChange={handleChange}
+                  placeholder={t('display-name-input.placeholder')}
+                  classNames='min-w-64'
+                />
+              </Settings.Item>
+            );
+          },
+      icon: personal
+        ? () => null
+        : ({ type, label, getValue, onValueChange }) => {
+            const handleChange = useCallback((icon: string) => onValueChange(type, icon), [onValueChange, type]);
+            const handleReset = useCallback(() => onValueChange(type, undefined), [onValueChange, type]);
+            return (
+              <Settings.Item title={label} description={t('icon.description')}>
+                <IconPicker
+                  value={getValue()}
+                  onChange={handleChange}
+                  onReset={handleReset}
+                  classNames='justify-self-end'
+                />
+              </Settings.Item>
+            );
+          },
+      hue: ({ type, label, getValue, onValueChange }) => {
+        const handleChange = useCallback((nextHue: string) => onValueChange(type, nextHue), [onValueChange, type]);
+        const handleReset = useCallback(() => onValueChange(type, undefined), [onValueChange, type]);
+        return (
+          <Settings.Item title={label} description={t('hue.description')}>
+            <HuePicker value={getValue()} onChange={handleChange} onReset={handleReset} classNames='justify-self-end' />
+          </Settings.Item>
+        );
+      },
+      edgeReplication: ({ type, label, getValue, onValueChange }) => {
+        const handleChange = useCallback((checked: boolean) => onValueChange(type, checked), [onValueChange, type]);
+        return (
+          <Settings.Item title={label} description={t('edge-replication.description')}>
+            <Input.Switch checked={getValue()} onCheckedChange={handleChange} classNames='justify-self-end' />
+          </Settings.Item>
+        );
+      },
+      archived: personal
+        ? () => null
+        : ({ type, label, getValue, onValueChange }) => {
+            const handleChange = useCallback(() => onValueChange(type, !getValue()), [onValueChange, type, getValue]);
+            return (
+              <Settings.Item title={label} description={t('archive-space.description')}>
+                <Button variant={getValue() ? 'default' : 'destructive'} onClick={handleChange}>
+                  {getValue() ? t('unarchive-space.label') : t('archive-space.label')}
+                </Button>
+              </Settings.Item>
+            );
+          },
+    }),
+    [t, space, personal],
+  );
+
+  const download = useFileDownload();
+  const handleBackup = useCallback(async () => {
+    const archive = await space.internal.export();
+    download(new Blob([archive.contents as Uint8Array<ArrayBuffer>]), archive.filename);
+  }, [space, download]);
+
+  const repairs = useCapabilities(SpaceCapabilities.Repair);
+  const handleRepair = useCallback(async () => {
+    await Promise.all(repairs.map((repair) => repair({ space, isDefault: isPersonalSpace(space) })));
+  }, [space, repairs]);
+
+  return (
+    <Settings.Viewport>
+      <Settings.Section
+        title={t('space-properties-settings-verbose.label')}
+        description={t('space-properties-settings.description', { ns: meta.id })}
+      >
+        <Form.Root
+          key={space.id}
+          fieldMap={fieldMap}
+          schema={SpaceFormSchema}
+          defaultValues={defaultValues}
+          onValuesChanged={handleValuesChanged}
+        >
+          <Form.FieldSet />
+        </Form.Root>
+      </Settings.Section>
+      <Settings.Section title={t('space-controls.title')} description={t('space-controls.description')}>
+        <Settings.Item title={t('backup-space.title')} description={t('backup-space.description')}>
+          <Button onClick={handleBackup}>{t('download-backup.label')}</Button>
+        </Settings.Item>
+        <Settings.Item title={t('repair-space.title')} description={t('repair-space.description')}>
+          <Button onClick={handleRepair}>{t('repair-space.label')}</Button>
+        </Settings.Item>
+      </Settings.Section>
+    </Settings.Viewport>
+  );
+};
+
+SpaceSettingsContainer.displayName = 'SpaceSettingsContainer';

package/src/containers/SpaceSettingsContainer/index.ts

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

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

@@ -8,13 +8,12 @@ import { withClientProvider } from '@dxos/react-client/testing';
 import { withTheme } from '@dxos/react-ui/testing';
 
 import { translations } from '../../translations';
-
 import { SyncStatusIndicator } from './SyncStatus';
 
 const meta = {
-  title: 'plugins/plugin-space/SyncStatusIndicator',
+  title: 'plugins/plugin-space/containers/SyncStatusIndicator',
   component: SyncStatusIndicator,
-  decorators: [withTheme, withClientProvider({ createIdentity: true })],
+  decorators: [withTheme(), withClientProvider({ createIdentity: true })],
   parameters: {
     layout: 'centered',
     translations,

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

@@ -4,20 +4,19 @@
 
 import React, { useEffect, useState } from 'react';
 
+import { log } from '@dxos/log';
 import { StatusBar } from '@dxos/plugin-status-bar';
 import { EdgeStatus } from '@dxos/protocols/proto/dxos/client/services';
 import { type QueryEdgeStatusResponse } from '@dxos/protocols/proto/dxos/client/services';
 import { useClient } from '@dxos/react-client';
 import { useStream } from '@dxos/react-client/devtools';
 import { type SpaceSyncStateMap, getSyncSummary, useSyncState } from '@dxos/react-client/echo';
-import { Icon, Popover, useTranslation } from '@dxos/react-ui';
-import { mx } from '@dxos/react-ui-theme';
+import { Icon, IconButton, Popover, useTranslation } from '@dxos/react-ui';
+import { iconSize, mx } from '@dxos/ui-theme';
 import { Unit, type UnitFormat } from '@dxos/util';
 
-import { meta } from '../../meta';
-
-import { createClientSaveTracker } from './save-tracker';
-import { getIcon, getStatus } from './status';
+import { createClientSaveTracker, getIcon, getStatus } from '#components';
+import { meta } from '#meta';
 
 const SYNC_STALLED_TIMEOUT = 5_000;
 
@@ -46,22 +45,25 @@ export const SyncStatusIndicator = ({ state, saved }: { state: SpaceSyncStateMap
     }
 
     const t = setTimeout(() => {
-      // TODO(wittjosiah): Use semantic color tokens.
-      setClassNames('text-orange-500');
+      log.warn('sync stalled', { state });
+      setClassNames('text-error-text');
     }, SYNC_STALLED_TIMEOUT);
-    return () => clearTimeout(t);
-  }, [offline, needsToUpload, needsToDownload]);
 
-  const title = t(`${status} label`);
-  const icon = <Icon icon={getIcon(status)} classNames={classNames} />;
+    return () => {
+      clearTimeout(t);
+      setClassNames(undefined);
+    };
+  }, [offline, needsToUpload, needsToDownload]);
 
   return (
     <Popover.Root>
       <Popover.Trigger asChild>
-        <StatusBar.Item title={title}>{icon}</StatusBar.Item>
+        <StatusBar.Item>
+          <IconButton icon={getIcon(status)} iconOnly label={t(`${status}.label`)} classNames={classNames} />
+        </StatusBar.Item>
       </Popover.Trigger>
       <Popover.Portal>
-        <Popover.Content>
+        <Popover.Content side='left' classNames=''>
           <EdgeConnectionPopover />
           <Popover.Arrow />
         </Popover.Content>
@@ -70,68 +72,60 @@ export const SyncStatusIndicator = ({ state, saved }: { state: SpaceSyncStateMap
   );
 };
 
-const useEdgeStatus = (): EdgeStatus | undefined => {
+const EdgeConnectionPopover = () => {
+  const { t } = useTranslation(meta.id);
   const client = useClient();
   const { status } = useStream(
     () => client.services.services.EdgeAgentService!.queryEdgeStatus(),
     {} as QueryEdgeStatusResponse,
   );
-  return status;
-};
-
-const EdgeConnectionPopover = () => {
-  const status = useEdgeStatus();
-  const { t } = useTranslation(meta.id);
 
   const isConnected = status?.state === EdgeStatus.ConnectionState.CONNECTED;
 
   return (
-    <div className='min-is-[240px] p-2'>
+    <div className='flex flex-col gap-2 w-[240px] p-2' style={iconSize(4)}>
       {/* Connection Status Header */}
-      <div className='flex items-center gap-2 mbe-2'>
+      <div className='flex items-center gap-2 mb-2'>
         <Icon
           icon={isConnected ? 'ph--check-circle--regular' : 'ph--warning-circle--regular'}
-          classNames={mx(isConnected ? 'text-successText' : 'text-errorText animate-pulse')}
+          classNames={mx(isConnected ? 'text-success-text' : 'text-error-text animate-pulse')}
         />
         <span className='font-medium text-sm'>
-          {isConnected ? t('sync edge connected label') : t('sync edge disconnected label')}
+          {isConnected ? t('sync-edge-connected.label') : t('sync-edge-disconnected.label')}
         </span>
       </div>
 
       {/* Connection Details */}
       {status?.state === EdgeStatus.ConnectionState.NOT_CONNECTED && (
-        <div className='flex items-center gap-2 text-sm text-description'>
+        <div className='grid grid-cols-[min-content_1fr_min-content_min-content] gap-2'>
           <Icon icon='ph--cloud-x--regular' />
-          <span>{t('sync no connection label')}</span>
+          <span className='text-description'>{t('sync-no-connection.label')}</span>
         </div>
       )}
 
       {status?.state === EdgeStatus.ConnectionState.CONNECTED && (
-        <div className='space-y-2'>
+        <div className='grid grid-cols-[min-content_1fr_min-content_min-content] gap-2 gap-y-1'>
           {/* Latency */}
-          <div className='flex items-center justify-between text-sm'>
-            <div className='flex items-center gap-2 text-description'>
-              <Icon icon='ph--timer--regular' />
-              <span>{t('sync latency label')}</span>
-            </div>
+          <div className='col-span-full grid grid-cols-subgrid gap-2 items-center text-sm'>
+            <Icon icon='ph--timer--regular' />
+            <span className='text-description'>{t('sync-latency.label')}</span>
+            <div />
             <UnitValue value={status.rtt} format={Unit.Millisecond} />
           </div>
 
           {/* Upload Speed */}
-          <div className='flex items-center justify-between text-sm'>
-            <div className='flex items-center gap-2 text-description'>
-              <Icon icon='ph--arrow-up--regular' />
-              <span>{t('sync upload label')}</span>
-            </div>
+          <div className='col-span-full grid grid-cols-subgrid gap-2 items-center text-sm'>
+            <Icon icon='ph--arrow-up--regular' classNames='text-green-500' />
+            <span className='text-description'>{t('sync-upload.label')}</span>
+            <UnitValue value={status.messagesSent} format={Unit.Thousand} />
             <UnitValue value={status.rateBytesUp} format={Unit.Kilobyte} suffix='/s' />
           </div>
 
           {/* Download Speed */}
-          <div className='flex items-center justify-between text-sm'>
-            <div className='flex items-center gap-2 text-sm text-description'>
-              <Icon icon='ph--arrow-down--regular' />
-              <span>{t('sync download label')}</span>
-            </div>
+          <div className='col-span-full grid grid-cols-subgrid gap-2 items-center text-sm'>
+            <Icon icon='ph--arrow-down--regular' classNames='text-orange-500' />
+            <span className='text-description'>{t('sync-download.label')}</span>
+            <UnitValue value={status.messagesReceived} format={Unit.Thousand} />
             <UnitValue value={status.rateBytesDown} format={Unit.Kilobyte} suffix='/s' />
           </div>
         </div>
@@ -146,7 +140,7 @@ const UnitValue = ({ value: input, format, suffix }: { value: number; format: Un
   return (
     <span className='font-mono'>
       {formattedValue}
-      <span className='mis-1 text-subdued'>
+      <span className='ms-1 text-subdued'>
         {unit.symbol}
         {suffix}
       </span>

package/src/containers/SyncStatus/index.ts

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

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

@@ -5,35 +5,42 @@
 import * as Schema from 'effect/Schema';
 import React, { useCallback, useState } from 'react';
 
-import { createIntent } from '@dxos/app-framework';
-import { useIntentDispatcher } from '@dxos/app-framework/react';
-import { DXN, Filter, Obj, Query, type QueryAST, Tag, Type } from '@dxos/echo';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { resolveSchemaWithRegistry } from '@dxos/app-toolkit/query';
+import { useTypeOptions } from '@dxos/app-toolkit/ui';
+import { DXN, Filter, JsonSchema, Obj, Query, type QueryAST, Tag, Type } from '@dxos/echo';
+import { type View } from '@dxos/echo';
+import { type Mutable } from '@dxos/echo/internal';
 import { useClient } from '@dxos/react-client';
 import { getSpace, useQuery } from '@dxos/react-client/echo';
 import { useAsyncEffect } from '@dxos/react-ui';
 import { ViewEditor as NaturalViewEditor } from '@dxos/react-ui-form';
-import { View } from '@dxos/schema';
+import { ViewModel } from '@dxos/schema';
 
-import { resolveSchemaWithClientAndSpace } from '../helpers';
-import { useTypeOptions } from '../hooks';
-import { SpaceAction } from '../types';
+import { SpaceOperation } from '#operations';
 
 export type ViewEditorProps = { view: View.View };
 
 export const ViewEditor = ({ view }: ViewEditorProps) => {
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const { invokePromise } = useOperationInvoker();
   const client = useClient();
   const space = getSpace(view);
   const [schema, setSchema] = useState<Schema.Schema.AnyNoContext>(() => Schema.Struct({}));
-  const tags = useQuery(space, Filter.type(Tag.Tag));
-  const types = useTypeOptions({ space, annotation: ['dynamic', 'limited-static', 'object-form'] });
+  const tags = useQuery(space?.db, Filter.type(Tag.Tag));
+  const types = useTypeOptions({
+    space,
+    annotation: {
+      location: ['database', 'runtime'],
+      kind: ['user'],
+    },
+  });
 
   useAsyncEffect(async () => {
     if (!view?.query || !space) {
       return;
     }
 
-    const foundSchema = await resolveSchemaWithClientAndSpace(client, space, view.query.ast);
+    const foundSchema = await resolveSchemaWithRegistry(space.db.schemaRegistry, view.query.ast);
     if (foundSchema && foundSchema !== schema) {
       setSchema(() => foundSchema);
     }
@@ -46,19 +53,22 @@ export const ViewEditor = ({ view }: ViewEditorProps) => {
       }
 
       const queue = target && DXN.tryParse(target) ? target : undefined;
-      const query = queue ? Query.fromAst(newQuery).options({ queues: [queue] }) : Query.fromAst(newQuery);
-      view.query.ast = query.ast;
-      const newSchema = await resolveSchemaWithClientAndSpace(client, space, query.ast);
+      const query = queue ? Query.fromAst(newQuery).from({ queues: [queue] }) : Query.fromAst(newQuery);
+      Obj.change(view, (obj) => {
+        obj.query.ast = query.ast as Mutable<typeof query.ast>;
+      });
+      const newSchema = await resolveSchemaWithRegistry(space.db.schemaRegistry, query.ast);
       if (!newSchema) {
         return;
       }
 
-      const newView = View.make({
+      const newView = ViewModel.make({
         query,
-        jsonSchema: Type.toJsonSchema(newSchema),
-        presentation: Obj.make(Type.Expando, {}),
+        jsonSchema: JsonSchema.toJsonSchema(newSchema),
+      });
+      Obj.change(view, (obj) => {
+        obj.projection = Obj.getSnapshot(newView).projection as Mutable<typeof obj.projection>;
       });
-      view.projection = Obj.getSnapshot(newView).projection;
 
       setSchema(() => newSchema);
     },
@@ -67,9 +77,9 @@ export const ViewEditor = ({ view }: ViewEditorProps) => {
 
   const handleDelete = useCallback(
     (fieldId: string) => {
-      void dispatch(createIntent(SpaceAction.DeleteField, { view, fieldId }));
+      void invokePromise(SpaceOperation.DeleteField, { view, fieldId });
     },
-    [dispatch, view],
+    [invokePromise, view],
   );
 
   if (!space || !schema) {
@@ -81,8 +91,8 @@ export const ViewEditor = ({ view }: ViewEditorProps) => {
       registry={space.db.schemaRegistry}
       schema={schema}
       view={view}
-      mode='query'
-      outerSpacing={false}
+      mode='tag'
+      db={space.db}
       tags={tags}
       types={types}
       onQueryChanged={handleQueryChanged}

package/src/containers/ViewEditor/index.ts

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

package/src/containers/index.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ComponentType, lazy } from 'react';
+
+export type { CreateObjectDialogProps } from './CreateObjectDialog';
+
+export const CollectionArticle: ComponentType<any> = lazy(() => import('./CollectionArticle'));
+export const CollectionSection: ComponentType<any> = lazy(() => import('./CollectionSection'));
+export const CreateObjectDialog: ComponentType<any> = lazy(() => import('./CreateObjectDialog'));
+export const CreateSpaceDialog: ComponentType<any> = lazy(() => import('./CreateSpaceDialog'));
+export const InlineSyncStatus: ComponentType<any> = lazy(() => import('./InlineSyncStatus'));
+export const JoinDialog: ComponentType<any> = lazy(() => import('./JoinDialog'));
+export const MembersContainer: ComponentType<any> = lazy(() => import('./MembersContainer'));
+export const MenuFooter: ComponentType<any> = lazy(() => import('./MenuFooter'));
+export const ObjectCardStack: ComponentType<any> = lazy(() => import('./ObjectCardStack'));
+export const ObjectDetails: ComponentType<any> = lazy(() => import('./ObjectDetails'));
+export const ObjectRenamePopover: ComponentType<any> = lazy(() => import('./ObjectRenamePopover'));
+export const RecordArticle: ComponentType<any> = lazy(() => import('./RecordArticle'));
+export const RelatedArticle: ComponentType<any> = lazy(() => import('./RelatedArticle'));
+export const SchemaContainer: ComponentType<any> = lazy(() => import('./SchemaContainer'));
+export const SmallPresenceLive: ComponentType<any> = lazy(() => import('./SmallPresenceLive'));
+export const SpacePresence: ComponentType<any> = lazy(() => import('./SpacePresence'));
+export const SpaceRenamePopover: ComponentType<any> = lazy(() => import('./SpaceRenamePopover'));
+export const SpaceSettingsContainer: ComponentType<any> = lazy(() => import('./SpaceSettingsContainer'));
+export const SyncStatus: ComponentType<any> = lazy(() => import('./SyncStatus'));
+export const ViewEditor: ComponentType<any> = lazy(() => import('./ViewEditor'));

package/src/hooks/index.ts

@@ -2,7 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './useActiveSpace';
 export * from './useInputSurfaceLookup';
 export * from './usePath';
-export * from './useTypeOptions';
+export * from './useRelatedObjects';

package/src/hooks/useInputSurfaceLookup.tsx

@@ -2,34 +2,25 @@
 // Copyright 2025 DXOS.org
 //
 
-import type * as Schema from 'effect/Schema';
 import React, { useCallback } from 'react';
 
-import { Surface, isSurfaceAvailable, usePluginManager } from '@dxos/app-framework/react';
-import { type InputProps } from '@dxos/react-ui-form';
+import { Surface, usePluginManager } from '@dxos/app-framework/ui';
+import { type FormFieldProvider } from '@dxos/react-ui-form';
 
-// TODO(ZaymonFC): Move this if you find yourself needing it elsewhere.
 /**
  * Creates a surface input component based on plugin context.
  * @param baseData Additional data that will be merged with form data and passed to the surface.
  * This allows providing more context to the surface than what's available from the form itself.
  */
-export const useInputSurfaceLookup = (baseData?: Record<string, any>) => {
+// TODO(burdon): Factor out?
+export const useInputSurfaceLookup = (baseData?: Record<string, any>): FormFieldProvider => {
   const pluginManager = usePluginManager();
-
-  return useCallback(
-    ({ prop, schema, inputProps }: { prop: string; schema: Schema.Schema<any>; inputProps: InputProps }) => {
-      const composedData = { prop, schema, ...baseData };
-      if (
-        !isSurfaceAvailable(pluginManager.context, {
-          role: 'form-input',
-          data: composedData,
-        })
-      ) {
-        return undefined;
+  return useCallback<FormFieldProvider>(
+    ({ schema, prop, fieldProps }) => {
+      const data = { prop, schema, ...baseData };
+      if (Surface.isAvailable(pluginManager.capabilities, { role: 'form-input', data })) {
+        return <Surface.Surface role='form-input' data={data} {...fieldProps} />;
       }
-
-      return <Surface role='form-input' data={composedData} {...inputProps} />;
     },
     [pluginManager, baseData],
   );

package/src/hooks/usePath.ts

@@ -5,7 +5,7 @@
 import * as Option from 'effect/Option';
 import { useEffect, useState } from 'react';
 
-import { type ReadableGraph } from '@dxos/plugin-graph';
+import { Graph } from '@dxos/plugin-graph';
 
 /**
  * React hook to get a path from the graph.
@@ -16,9 +16,9 @@ import { type ReadableGraph } from '@dxos/plugin-graph';
  * @returns Path if found, undefined otherwise.
  */
 // TODO(wittjosiah): Factor out.
-export const usePath = (graph: ReadableGraph, id?: string, timeout?: number): Option.Option<string[]> => {
+export const usePath = (graph: Graph.ReadableGraph, id?: string, timeout?: number): Option.Option<string[]> => {
   const [pathState, setPathState] = useState<Option.Option<string[]>>(
-    id ? graph.getPath({ target: id }) : Option.none(),
+    id ? Graph.getPath(graph, { target: id }) : Option.none(),
   );
 
   useEffect(() => {
@@ -33,7 +33,7 @@ export const usePath = (graph: ReadableGraph, id?: string, timeout?: number): Op
     // Set timeout did not seem to effectively not block the UI thread.
     const frame = requestAnimationFrame(async () => {
       try {
-        const path = await graph.waitForPath({ target: id }, { timeout });
+        const path = await Graph.waitForPath(graph, { target: id }, { timeout });
         if (path) {
           setPathState(Option.some(path));
         }