@dxos/plugin-space 0.8.3 → 0.8.4-main.1068cf700f

package/src/components/CreateDialog/CreateObjectDialog.tsx

@@ -2,119 +2,146 @@
 // Copyright 2024 DXOS.org
 //
 
-import { pipe } from 'effect';
-import React, { useCallback, useRef, useState } from 'react';
+import * as Effect from 'effect/Effect';
+import React, { useCallback, useMemo, useRef, useState } from 'react';
 
-import {
-  Capabilities,
-  LayoutAction,
-  chain,
-  createIntent,
-  useCapabilities,
-  useIntentDispatcher,
-  usePluginManager,
-} from '@dxos/app-framework';
-import { Query, Type, type Obj } from '@dxos/echo';
+import { Capability } from '@dxos/app-framework';
+import { useOperationInvoker, usePluginManager } from '@dxos/app-framework/ui';
+import { AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';
+import { Database, Obj, Type } from '@dxos/echo';
+import { EntityKind, getTypeAnnotation } from '@dxos/echo/internal';
+import { runAndForwardErrors } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
 import { useClient } from '@dxos/react-client';
-import { getSpace, isLiveObject, isSpace, type Space, useQuery, useSpaces } from '@dxos/react-client/echo';
-import { Button, Dialog, Icon, useTranslation } from '@dxos/react-ui';
-import { cardDialogContent, cardDialogHeader } from '@dxos/react-ui-stack';
-import { DataType } from '@dxos/schema';
-import { isNonNullable } from '@dxos/util';
+import { useSpaces } from '@dxos/react-client/echo';
+import { Dialog, useTranslation } from '@dxos/react-ui';
+import { type Collection } from '@dxos/schema';
 
-import { CreateObjectPanel, type CreateObjectPanelProps } from './CreateObjectPanel';
-import { SpaceCapabilities } from '../../capabilities';
-import { SPACE_PLUGIN } from '../../meta';
-import { SpaceAction } from '../../types';
+import { meta } from '../../meta';
+import { SpaceOperation } from '../../types';
 
-export const CREATE_OBJECT_DIALOG = `${SPACE_PLUGIN}/CreateObjectDialog`;
+import { CreateObjectPanel, type CreateObjectPanelProps, type Metadata } from './CreateObjectPanel';
 
-export type CreateObjectDialogProps = Pick<CreateObjectPanelProps, 'target' | 'typename' | 'name'> & {
-  shouldNavigate?: (object: Obj.Any) => boolean;
+export const CREATE_OBJECT_DIALOG = `${meta.id}/CreateObjectDialog`;
+
+export type CreateObjectDialogProps = Pick<
+  CreateObjectPanelProps,
+  'target' | 'views' | 'typename' | 'initialFormValues'
+> & {
+  onCreateObject?: (object: Obj.Unknown) => void;
+  shouldNavigate?: (object: Obj.Unknown) => boolean;
 };
 
 export const CreateObjectDialog = ({
   target: initialTarget,
   typename: initialTypename,
-  name,
+  views,
+  initialFormValues,
+  onCreateObject,
   shouldNavigate: _shouldNavigate,
 }: CreateObjectDialogProps) => {
-  const closeRef = useRef<HTMLButtonElement | null>(null);
   const manager = usePluginManager();
-  const { t } = useTranslation(SPACE_PLUGIN);
+  const { t } = useTranslation(meta.id);
+  const operationInvoker = useOperationInvoker();
+  const [target, setTarget] = useState<Database.Database | Collection.Collection | undefined>(initialTarget);
+  const [typename, setTypename] = useState<string | undefined>(initialTypename);
   const client = useClient();
   const spaces = useSpaces();
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-  const forms = useCapabilities(SpaceCapabilities.ObjectForm);
-  const [target, setTarget] = useState<Space | DataType.Collection | undefined>(initialTarget);
-  const [typename, setTypename] = useState<string | undefined>(initialTypename);
-  const space = isSpace(target) ? target : getSpace(target);
-  const queryCollections = useQuery(space, Query.type(DataType.QueryCollection));
-  const hiddenTypenames = queryCollections.map((collection) => collection.query.typename).filter(isNonNullable);
+  const closeRef = useRef<HTMLButtonElement | null>(null);
 
   const resolve = useCallback<NonNullable<CreateObjectPanelProps['resolve']>>(
-    (typename) =>
-      manager.context.getCapabilities(Capabilities.Metadata).find(({ id }) => id === typename)?.metadata ?? {},
+    (typename) => {
+      const metadata = manager.capabilities
+        .getAll(AppCapabilities.Metadata)
+        .find(({ id }) => id === typename)?.metadata;
+      return metadata?.createObject ? (metadata as Metadata) : undefined;
+    },
     [manager],
   );
 
+  const db = Database.isDatabase(target) ? target : target && Obj.getDatabase(target);
+  // TODO(wittjosiah): Support database schemas.
+  const schemas = db?.schemaRegistry.query({ location: ['runtime'], includeSystem: false }).runSync();
+  const userSchemas = useMemo(
+    () =>
+      schemas
+        ?.filter((schema) => getTypeAnnotation(schema)?.kind !== EntityKind.Relation)
+        .filter((schema) => !!resolve(Type.getTypename(schema))) ?? [],
+    [schemas],
+  );
+
   const handleCreateObject = useCallback<NonNullable<CreateObjectPanelProps['onCreateObject']>>(
-    async ({ form, data = {} }) => {
-      if (!target) {
-        // TODO(wittjosiah): UI feedback.
-        return;
-      }
+    ({ metadata, data = {} }) =>
+      Effect.gen(function* () {
+        if (!target) {
+          // TODO(wittjosiah): UI feedback.
+          return;
+        }
 
-      // NOTE: Must close before navigating or attention won't follow object.
-      closeRef.current?.click();
+        // NOTE: Must close before navigating or attention won't follow object.
+        closeRef.current?.click();
 
-      const space = isSpace(target) ? target : getSpace(target);
-      invariant(space, 'Missing space');
-      const result = await dispatch(form.getIntent(data, { space }));
-      const object = result.data?.object;
-      if (isLiveObject(object)) {
-        // TODO(wittjosiah): Selection in navtree isn't working as expected when hidden typenames evals to true.
-        const hidden = form.hidden || hiddenTypenames.includes(Type.getTypename(form.objectSchema));
-        const addObjectIntent = createIntent(SpaceAction.AddObject, { target, object, hidden });
-        const shouldNavigate = _shouldNavigate ?? (() => true);
-        if (shouldNavigate(object)) {
-          await dispatch(pipe(addObjectIntent, chain(LayoutAction.Open, { part: 'main' })));
-        } else {
-          await dispatch(addObjectIntent);
+        const db = Database.isDatabase(target) ? target : target && Obj.getDatabase(target);
+        invariant(db, 'Missing database');
+        const object = yield* metadata.createObject(data, { db });
+        if (Obj.isObject(object) && !Obj.instanceOf(Type.PersistentType, object)) {
+          // TODO(wittjosiah): Selection in navtree isn't working as expected when hidden typenames evals to true.
+          const hidden = !metadata.addToCollectionOnCreate;
+          yield* operationInvoker.invoke(SpaceOperation.AddObject, {
+            target,
+            object,
+            hidden,
+          });
+          const shouldNavigate = _shouldNavigate ?? (() => true);
+          if (shouldNavigate(object)) {
+            yield* Effect.promise(() =>
+              operationInvoker.invokePromise(LayoutOperation.Open, {
+                subject: [Obj.getDXN(object).toString()],
+              }),
+            );
+          }
+
+          onCreateObject?.(object);
         }
-      }
-    },
-    [dispatch, target, resolve, hiddenTypenames, _shouldNavigate],
+      }).pipe(
+        Effect.provideService(Capability.Service, manager.capabilities),
+        Effect.provideService(Operation.Service, operationInvoker),
+        runAndForwardErrors,
+      ),
+    [target, _shouldNavigate, onCreateObject, manager.capabilities, operationInvoker],
   );
 
   return (
-    // TODO(wittjosiah): The tablist dialog pattern is copied from @dxos/plugin-manager.
-    //  Consider factoring it out to the tabs package.
-    <Dialog.Content classNames={cardDialogContent}>
-      <div role='none' className={cardDialogHeader}>
+    <Dialog.Content>
+      <Dialog.Header>
         <Dialog.Title>
-          {t('create object dialog title', { object: t('typename label', { ns: typename, defaultValue: 'Item' }) })}
+          {t('create object dialog title', {
+            object: t('typename label', {
+              ns: typename,
+              defaultValue: views ? 'View' : 'Object',
+            }),
+          })}
         </Dialog.Title>
         <Dialog.Close asChild>
-          <Button ref={closeRef} density='fine' variant='ghost' autoFocus>
-            <Icon icon='ph--x--regular' size={4} />
-          </Button>
+          <Dialog.CloseIconButton ref={closeRef} />
         </Dialog.Close>
-      </div>
-
-      <CreateObjectPanel
-        forms={forms}
-        spaces={spaces}
-        target={target}
-        typename={typename}
-        name={name}
-        defaultSpaceId={client.spaces.default.id}
-        resolve={resolve}
-        onTargetChange={setTarget}
-        onTypenameChange={setTypename}
-        onCreateObject={handleCreateObject}
-      />
+      </Dialog.Header>
+      <Dialog.Body>
+        <CreateObjectPanel
+          schemas={userSchemas}
+          spaces={spaces}
+          target={target}
+          views={views}
+          typename={typename}
+          initialFormValues={initialFormValues}
+          defaultSpaceId={client.spaces.default.id}
+          resolve={resolve}
+          onTargetChange={setTarget}
+          onTypenameChange={setTypename}
+          onCreateObject={handleCreateObject}
+        />
+      </Dialog.Body>
     </Dialog.Content>
   );
 };

package/src/components/CreateDialog/CreateObjectPanel.tsx

@@ -2,136 +2,197 @@
 // Copyright 2024 DXOS.org
 //
 
-import React, { useCallback } from 'react';
-
-import { Type } from '@dxos/echo';
-import { getTypeAnnotation, type TypeAnnotation } from '@dxos/echo-schema';
-import { type SpaceId, type Space } from '@dxos/react-client/echo';
-import { Icon, toLocalizedString, useTranslation } from '@dxos/react-ui';
-import { Form } from '@dxos/react-ui-form';
-import { SearchList } from '@dxos/react-ui-searchlist';
-import { cardDialogOverflow, cardDialogPaddedOverflow, cardDialogSearchListRoot } from '@dxos/react-ui-stack';
-import { type DataType } from '@dxos/schema';
-import { isNonNullable, type MaybePromise } from '@dxos/util';
+import * as Option from 'effect/Option';
+import type * as Schema from 'effect/Schema';
+import React, { useCallback, useMemo } from 'react';
+
+import { type Database, Obj } from '@dxos/echo';
+import { type AnyProperties, type TypeAnnotation, getTypeAnnotation } from '@dxos/echo/internal';
+import { type Space, type SpaceId } from '@dxos/react-client/echo';
+import { toLocalizedString, useDefaultValue, useTranslation } from '@dxos/react-ui';
+import { Form, omitId } from '@dxos/react-ui-form';
+import { SearchList, useSearchListResults } from '@dxos/react-ui-searchlist';
+import { type Collection, ViewAnnotation } from '@dxos/schema';
+import { type MaybePromise, isNonNullable } from '@dxos/util';
 
 import { useInputSurfaceLookup } from '../../hooks';
-import { SPACE_PLUGIN } from '../../meta';
-import { type ObjectForm } from '../../types';
+import { meta } from '../../meta';
+import { type CreateObject } from '../../types';
 import { getSpaceDisplayName } from '../../util';
 
+export type Metadata = {
+  createObject: CreateObject;
+  inputSchema?: Schema.Schema.AnyNoContext;
+  addToCollectionOnCreate?: boolean;
+  icon?: string;
+};
+
 export type CreateObjectPanelProps = {
-  forms: ObjectForm[];
+  schemas: Schema.Schema.AnyNoContext[];
   spaces: Space[];
   typename?: string;
-  target?: Space | DataType.Collection;
-  name?: string;
+  target?: Database.Database | Collection.Collection;
+  views?: boolean;
+  initialFormValues?: Partial<AnyProperties>;
   defaultSpaceId?: SpaceId;
-  resolve?: (typename: string) => Record<string, any>;
-  onTargetChange?: (target: Space) => void;
+  resolve?: (typename: string) => Metadata | undefined;
+  onTargetChange?: (target: Database.Database) => void;
   onTypenameChange?: (typename: string) => void;
-  onCreateObject?: (params: { form: ObjectForm; data?: Record<string, any> }) => MaybePromise<void>;
+  onCreateObject?: (params: { metadata: Metadata; data?: Record<string, any> }) => MaybePromise<void>;
 };
 
 export const CreateObjectPanel = ({
-  forms,
+  schemas,
   spaces,
   typename,
   target,
-  name: initialName,
+  views,
+  initialFormValues: _initialFormValues,
   defaultSpaceId,
   resolve,
   onTargetChange,
   onTypenameChange,
   onCreateObject,
 }: CreateObjectPanelProps) => {
-  const { t } = useTranslation(SPACE_PLUGIN);
-  const form = forms.find((form) => Type.getTypename(form.objectSchema) === typename);
-  const options: TypeAnnotation[] = forms
-    .map((form) => getTypeAnnotation(form.objectSchema))
+  const { t } = useTranslation(meta.id);
+  const initialFormValues = useDefaultValue(_initialFormValues, () => ({}));
+  const metadata = typename && resolve?.(typename);
+  const options: TypeAnnotation[] = schemas
+    .filter((schema) => {
+      if (views == null) {
+        return true;
+      } else {
+        return views === ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false));
+      }
+    })
+    .map((schema) => getTypeAnnotation(schema))
     .filter(isNonNullable)
     .sort((a, b) => {
-      const nameA = t('typename label', { ns: a.typename, defaultValue: a.typename });
-      const nameB = t('typename label', { ns: b.typename, defaultValue: b.typename });
+      const nameA = t('typename label', {
+        ns: a.typename,
+        defaultValue: a.typename,
+      });
+      const nameB = t('typename label', {
+        ns: b.typename,
+        defaultValue: b.typename,
+      });
       return nameA.localeCompare(nameB);
     });
 
   const handleCreateObject = useCallback(
     async (props: Record<string, any>) => {
-      if (!form) {
+      if (!metadata) {
         return;
       }
-      await onCreateObject?.({ form, data: props });
+      await onCreateObject?.({ metadata, data: props });
     },
-    [onCreateObject, form],
+    [onCreateObject, metadata],
   );
 
   const handleSetTypename = useCallback(
     async (typename: string) => {
-      const form = forms.find((form) => getTypeAnnotation(form.objectSchema)?.typename === typename);
-      if (form && !form.formSchema) {
-        await onCreateObject?.({ form });
+      const metadata = resolve?.(typename);
+      if (metadata && !metadata.inputSchema) {
+        await onCreateObject?.({ metadata });
       } else {
         onTypenameChange?.(typename);
       }
     },
-    [forms, onCreateObject],
+    [resolve, onCreateObject],
   );
 
   const inputSurfaceLookup = useInputSurfaceLookup({ target });
 
   // TODO(wittjosiah): These inputs should be rolled into a `Form` once it supports the necessary variants.
-  return !form ? (
+  return !metadata ? (
     <SelectSchema options={options} resolve={resolve} onChange={handleSetTypename} />
   ) : !target ? (
     <SelectSpace spaces={spaces} defaultSpaceId={defaultSpaceId} onChange={onTargetChange} />
-  ) : form.formSchema ? (
-    <div role='none' className={cardDialogOverflow}>
-      <Form
-        autoFocus
-        values={{ name: initialName }}
-        schema={form.formSchema}
-        testId='create-object-form'
-        onSave={handleCreateObject}
-        lookupComponent={inputSurfaceLookup}
-        outerSpacing='blockStart-0'
-      />
-    </div>
+  ) : metadata.inputSchema ? (
+    <Form.Root
+      testId='create-object-form'
+      autoFocus
+      schema={omitId(metadata.inputSchema)}
+      values={initialFormValues}
+      db={Obj.isObject(target) ? Obj.getDatabase(target) : target}
+      fieldProvider={inputSurfaceLookup}
+      onSave={handleCreateObject}
+    >
+      <Form.Viewport>
+        <Form.Content>
+          <Form.FieldSet />
+          <Form.Submit />
+        </Form.Content>
+      </Form.Viewport>
+    </Form.Root>
   ) : null;
 };
 
+CreateObjectPanel.displayName = 'CreateObjectPanel';
+
 const SelectSpace = ({
   spaces,
   defaultSpaceId,
   onChange,
-}: { onChange?: (space: Space) => void } & Pick<CreateObjectPanelProps, 'spaces' | 'defaultSpaceId'>) => {
-  const { t } = useTranslation(SPACE_PLUGIN);
+}: { onChange?: (db: Database.Database) => void } & Pick<CreateObjectPanelProps, 'spaces' | 'defaultSpaceId'>) => {
+  const { t } = useTranslation(meta.id);
 
+  const sortedSpaces = useMemo(
+    () =>
+      [...spaces].sort((a, b) => {
+        const labelA = toLocalizedString(
+          getSpaceDisplayName(a, {
+            personal: a.id === defaultSpaceId,
+          }),
+          t,
+        );
+        const labelB = toLocalizedString(
+          getSpaceDisplayName(b, {
+            personal: b.id === defaultSpaceId,
+          }),
+          t,
+        );
+        return labelA.localeCompare(labelB);
+      }),
+    [spaces, defaultSpaceId, t],
+  );
+
+  const { results, handleSearch } = useSearchListResults({
+    items: sortedSpaces,
+    extract: (space) =>
+      toLocalizedString(
+        getSpaceDisplayName(space, {
+          personal: space.id === defaultSpaceId,
+        }),
+        t,
+      ),
+  });
+
+  // TODO(burdon): Replace with Combobox.
   return (
-    <SearchList.Root label={t('space input label')} classNames={cardDialogSearchListRoot}>
-      <SearchList.Input
-        autoFocus
-        data-testid='create-object-form.space-input'
-        placeholder={t('space input placeholder')}
-      />
-      <SearchList.Content classNames={[cardDialogOverflow, 'plb-cardSpacingBlock']}>
-        {spaces
-          .sort((a, b) => {
-            const aName = toLocalizedString(getSpaceDisplayName(a, { personal: a.id === defaultSpaceId }), t);
-            const bName = toLocalizedString(getSpaceDisplayName(b, { personal: b.id === defaultSpaceId }), t);
-            return aName.localeCompare(bName);
-          })
-          .map((space) => (
+    <SearchList.Root onSearch={handleSearch}>
+      <SearchList.Content>
+        <SearchList.Input
+          autoFocus
+          data-testid='create-object-form.space-input'
+          placeholder={t('space input placeholder')}
+        />
+        <SearchList.Viewport>
+          {results.map((space) => (
             <SearchList.Item
               key={space.id}
-              value={toLocalizedString(getSpaceDisplayName(space, { personal: space.id === defaultSpaceId }), t)}
-              onSelect={() => onChange?.(space)}
+              value={space.id}
+              label={toLocalizedString(
+                getSpaceDisplayName(space, {
+                  personal: space.id === defaultSpaceId,
+                }),
+                t,
+              )}
+              onSelect={() => onChange?.(space.db)}
               classNames='flex items-center gap-2'
-            >
-              <span className='grow truncate'>
-                {toLocalizedString(getSpaceDisplayName(space, { personal: space.id === defaultSpaceId }), t)}
-              </span>
-            </SearchList.Item>
+            />
           ))}
+        </SearchList.Viewport>
       </SearchList.Content>
     </SearchList.Root>
   );
@@ -145,29 +206,40 @@ const SelectSchema = ({
   options: TypeAnnotation[];
   onChange: (type: string) => void;
 } & Pick<CreateObjectPanelProps, 'resolve'>) => {
-  const { t } = useTranslation(SPACE_PLUGIN);
+  const { t } = useTranslation(meta.id);
+
+  const { results, handleSearch } = useSearchListResults({
+    items: options,
+    extract: (option) =>
+      t('typename label', {
+        ns: option.typename,
+        defaultValue: option.typename,
+      }),
+  });
 
   return (
-    <SearchList.Root label={t('schema input label')} classNames={cardDialogSearchListRoot}>
-      <SearchList.Input
-        autoFocus
-        data-testid='create-object-form.schema-input'
-        placeholder={t('schema input placeholder')}
-      />
-      <SearchList.Content classNames={cardDialogPaddedOverflow}>
-        {options.map((option) => (
-          <SearchList.Item
-            key={option.typename}
-            value={t('typename label', { ns: option.typename, defaultValue: option.typename })}
-            onSelect={() => onChange(option.typename)}
-            classNames='flex items-center gap-2'
-          >
-            <span className='flex gap-2 items-center grow truncate'>
-              <Icon icon={resolve?.(option.typename).icon ?? 'ph--placeholder--regular'} size={5} />
-              {t('typename label', { ns: option.typename, defaultValue: option.typename })}
-            </span>
-          </SearchList.Item>
-        ))}
+    <SearchList.Root onSearch={handleSearch}>
+      <SearchList.Content>
+        <SearchList.Input
+          autoFocus
+          data-testid='create-object-form.schema-input'
+          placeholder={t('schema input placeholder')}
+        />
+        <SearchList.Viewport>
+          {results.map((option) => (
+            <SearchList.Item
+              key={option.typename}
+              value={option.typename}
+              label={t('typename label', {
+                ns: option.typename,
+                defaultValue: option.typename,
+              })}
+              icon={resolve?.(option.typename)?.icon ?? 'ph--placeholder--regular'}
+              onSelect={() => onChange(option.typename)}
+              classNames='flex items-center gap-2'
+            />
+          ))}
+        </SearchList.Viewport>
       </SearchList.Content>
     </SearchList.Root>
   );

package/src/components/CreateDialog/CreateSpaceDialog.tsx

@@ -2,65 +2,71 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Effect, type Schema } from 'effect';
+import * as Effect from 'effect/Effect';
+import type * as Schema from 'effect/Schema';
 import React, { useCallback, useRef } from 'react';
 
-import { createIntent, LayoutAction, useIntentDispatcher } from '@dxos/app-framework';
-import { Button, Dialog, Icon, useTranslation } from '@dxos/react-ui';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { runAndForwardErrors } from '@dxos/effect';
+import { Dialog, useTranslation } from '@dxos/react-ui';
 import { Form } from '@dxos/react-ui-form';
-import { cardDialogContent, cardDialogHeader } from '@dxos/react-ui-stack';
 
 import { useInputSurfaceLookup } from '../../hooks';
-import { SPACE_PLUGIN } from '../../meta';
-import { SpaceAction, SpaceForm } from '../../types';
+import { meta } from '../../meta';
+import { SpaceForm, SpaceOperation } from '../../types';
 
-export const CREATE_SPACE_DIALOG = `${SPACE_PLUGIN}/CreateSpaceDialog`;
+export const CREATE_SPACE_DIALOG = `${meta.id}/CreateSpaceDialog`;
 
 type FormValues = Schema.Schema.Type<typeof SpaceForm>;
 const initialValues: FormValues = { edgeReplication: true };
 
 export const CreateSpaceDialog = () => {
   const closeRef = useRef<HTMLButtonElement | null>(null);
-  const { t } = useTranslation(SPACE_PLUGIN);
-  const { dispatch } = useIntentDispatcher();
+  const { t } = useTranslation(meta.id);
+  const { invokePromise } = useOperationInvoker();
 
   const inputSurfaceLookup = useInputSurfaceLookup();
 
   const handleCreateSpace = useCallback(
     async (data: FormValues) => {
       const program = Effect.gen(function* () {
-        const { space } = yield* dispatch(createIntent(SpaceAction.Create, data));
-        yield* dispatch(createIntent(LayoutAction.SwitchWorkspace, { part: 'workspace', subject: space.id }));
-        yield* dispatch(createIntent(LayoutAction.UpdateDialog, { part: 'dialog', options: { state: false } }));
+        const { data: result } = yield* Effect.promise(() => invokePromise(SpaceOperation.Create, data));
+        if (result?.space) {
+          yield* Effect.promise(() => invokePromise(LayoutOperation.SwitchWorkspace, { subject: result.space.id }));
+          yield* Effect.promise(() => invokePromise(LayoutOperation.UpdateDialog, { state: false }));
+        }
       });
-      await Effect.runPromise(program);
+      await runAndForwardErrors(program);
     },
-    [dispatch],
+    [invokePromise],
   );
 
   return (
-    // TODO(wittjosiah): The tablist dialog pattern is copied from @dxos/plugin-manager.
-    //  Consider factoring it out to the tabs package.
-    <Dialog.Content classNames={cardDialogContent}>
-      <div role='none' className={cardDialogHeader}>
+    <Dialog.Content>
+      <Dialog.Header>
         <Dialog.Title>{t('create space dialog title')}</Dialog.Title>
         <Dialog.Close asChild>
-          <Button ref={closeRef} density='fine' variant='ghost' autoFocus>
-            <Icon icon='ph--x--regular' size={4} />
-          </Button>
+          <Dialog.CloseIconButton ref={closeRef} />
         </Dialog.Close>
-      </div>
-      <div role='none' className='contents'>
-        <Form
+      </Dialog.Header>
+      <Dialog.Body>
+        <Form.Root
           testId='create-space-form'
           autoFocus
-          values={initialValues}
           schema={SpaceForm}
-          lookupComponent={inputSurfaceLookup}
+          values={initialValues}
+          fieldProvider={inputSurfaceLookup}
           onSave={handleCreateSpace}
-          outerSpacing='scroll-fields'
-        />
-      </div>
+        >
+          <Form.Viewport>
+            <Form.Content>
+              <Form.FieldSet />
+              <Form.Submit />
+            </Form.Content>
+          </Form.Viewport>
+        </Form.Root>
+      </Dialog.Body>
     </Dialog.Content>
   );
 };