@dxos/plugin-space 0.8.4-main.7ace549 → 0.8.4-main.8360d9e660

package/src/cli/plugin.ts

@@ -0,0 +1,88 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { ActivationEvents, Capability, Plugin } from '@dxos/app-framework';
+import { AppPlugin } from '@dxos/app-toolkit';
+import { Tag } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
+import { ClientEvents } from '@dxos/plugin-client/types';
+import { DataTypes } from '@dxos/schema';
+import {
+  AnchoredTo,
+  Employer,
+  Event,
+  HasConnection,
+  HasRelationship,
+  HasSubject,
+  Organization,
+  Person,
+  Pipeline,
+  Task,
+} from '@dxos/types';
+
+import { IdentityCreated } from '../capabilities/identity-created';
+import { OperationResolver } from '../capabilities/operation-resolver';
+import { meta } from '../meta';
+import { SpaceEvents } from '../types';
+import { type CreateObject, type SpacePluginOptions } from '../types';
+
+import { database, queue, space } from './commands';
+
+export const SpacePlugin = Plugin.define<SpacePluginOptions>(meta).pipe(
+  // TODO(wittjosiah): Could some of these commands make use of operations?
+  AppPlugin.addCommandModule({
+    commands: [database, queue, space],
+  }),
+  AppPlugin.addMetadataModule({
+    metadata: {
+      id: Collection.Collection.typename,
+      metadata: {
+        createObject: ((props) => Effect.sync(() => Collection.make(props))) satisfies CreateObject,
+      },
+    },
+  }),
+  AppPlugin.addSchemaModule({
+    schema: [
+      ...DataTypes,
+      AnchoredTo.AnchoredTo,
+      Employer.Employer,
+      Event.Event,
+      HasConnection.HasConnection,
+      HasRelationship.HasRelationship,
+      HasSubject.HasSubject,
+      Organization.Organization,
+      Person.Person,
+      Pipeline.Pipeline,
+      Tag.Tag,
+      Task.Task,
+    ],
+  }),
+  Plugin.addModule(
+    ({
+      shareableLinkOrigin = 'http://localhost:5173',
+      invitationPath = '/',
+      invitationProp = 'spaceInvitationCode',
+    }) => {
+      const createInvitationUrl = (invitationCode: string) => {
+        const baseUrl = new URL(invitationPath || '/', shareableLinkOrigin);
+        baseUrl.searchParams.set(invitationProp, invitationCode);
+        return baseUrl.toString();
+      };
+
+      return {
+        id: Capability.getModuleTag(OperationResolver),
+        activatesOn: ActivationEvents.SetupOperationResolver,
+        activate: () => OperationResolver({ createInvitationUrl, observability: false }),
+      };
+    },
+  ),
+  Plugin.addModule({
+    activatesOn: ClientEvents.IdentityCreated,
+    activatesAfter: [SpaceEvents.DefaultSpaceReady],
+    activate: IdentityCreated,
+  }),
+  Plugin.make,
+);

package/src/components/{AwaitingObject.tsx → AwaitingObject/AwaitingObject.tsx}

@@ -4,22 +4,24 @@
 
 import React, { useCallback, useEffect, useState } from 'react';
 
-import { LayoutAction, createIntent } from '@dxos/app-framework';
-import { useIntentDispatcher, useLayout } from '@dxos/app-framework/react';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { useLayout } from '@dxos/app-toolkit/ui';
 import { Obj } from '@dxos/echo';
 import { useClient } from '@dxos/react-client';
 import { Filter, useQuery } from '@dxos/react-client/echo';
 import { Button, Icon, Toast, useTranslation } from '@dxos/react-ui';
+import { osTranslations } from '@dxos/ui-theme';
 
-import { meta } from '../meta';
-import { SpaceAction } from '../types';
+import { meta } from '../../meta';
+import { SpaceOperation } from '../../types';
 
 const WAIT_FOR_OBJECT_TIMEOUT = 3 * 60 * 1_000;
 const TOAST_TIMEOUT = 4 * 60 * 1_000;
 
 export const AwaitingObject = ({ id }: { id: string }) => {
   const { t } = useTranslation(meta.id);
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const { invokePromise } = useOperationInvoker();
   const [open, setOpen] = useState(true);
   const [waiting, setWaiting] = useState(true);
   const [found, setFound] = useState(false);
@@ -47,14 +49,14 @@ export const AwaitingObject = ({ id }: { id: string }) => {
   }, [id, objects, layout]);
 
   const handleClose = useCallback(
-    async () => dispatch(createIntent(SpaceAction.WaitForObject, { id: undefined })),
-    [dispatch],
+    async () => invokePromise(SpaceOperation.WaitForObject, { id: undefined }),
+    [invokePromise],
   );
 
   const handleNavigate = useCallback(() => {
-    void dispatch(createIntent(LayoutAction.Open, { part: 'main', subject: [id] }));
+    void invokePromise(LayoutOperation.Open, { subject: [id] });
     void handleClose();
-  }, [id, handleClose, dispatch]);
+  }, [id, handleClose, invokePromise]);
 
   return (
     <Toast.Root open={open} duration={TOAST_TIMEOUT} onOpenChange={setOpen}>
@@ -96,12 +98,14 @@ export const AwaitingObject = ({ id }: { id: string }) => {
               </Button>
             </Toast.Action>
             <Toast.Close asChild>
-              <Button onClick={handleClose}>{t('close label', { ns: 'appkit' })}</Button>
+              <Button onClick={handleClose}>{t('close label', { ns: osTranslations })}</Button>
             </Toast.Close>
           </>
         ) : (
           <Toast.Close asChild>
-            <Button onClick={handleClose}>{t(waiting ? 'close label' : 'confirm label', { ns: 'appkit' })}</Button>
+            <Button onClick={handleClose}>
+              {t(waiting ? 'close label' : 'confirm label', { ns: osTranslations })}
+            </Button>
           </Toast.Close>
         )}
       </Toast.Actions>

package/src/components/AwaitingObject/index.ts

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

package/src/components/CreateDialog/CreateObjectPanel.tsx

@@ -2,76 +2,65 @@
 // Copyright 2024 DXOS.org
 //
 
-import * as Option from 'effect/Option';
 import type * as Schema from 'effect/Schema';
-import React, { useCallback } from 'react';
+import React, { useCallback, useMemo } from 'react';
 
-import { type AnyProperties, type TypeAnnotation, getTypeAnnotation } from '@dxos/echo/internal';
+import { type Database, Obj } from '@dxos/echo';
+import { type Collection } from '@dxos/echo';
+import { type AnyProperties } from '@dxos/echo/internal';
 import { type Space, type SpaceId } from '@dxos/react-client/echo';
-import { Icon, toLocalizedString, useDefaultValue, 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 Collection, ViewAnnotation } from '@dxos/schema';
-import { type MaybePromise, isNonNullable } from '@dxos/util';
+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 MaybePromise } from '@dxos/util';
 
 import { useInputSurfaceLookup } from '../../hooks';
 import { meta } from '../../meta';
-import { type CreateObjectIntent } from '../../types';
+import { type CreateObject } from '../../types';
 import { getSpaceDisplayName } from '../../util';
 
+/** Display-ready option for the create object search list. */
+export type CreateObjectOption = {
+  id: string;
+  label: string;
+  icon?: string;
+};
+
 export type Metadata = {
-  createObjectIntent: CreateObjectIntent;
+  createObject: CreateObject;
   inputSchema?: Schema.Schema.AnyNoContext;
-  addToCollectionOnCreate?: boolean;
   icon?: string;
 };
 
 export type CreateObjectPanelProps = {
-  schemas: Schema.Schema.AnyNoContext[];
+  options: CreateObjectOption[];
   spaces: Space[];
   typename?: string;
-  target?: Space | Collection.Collection;
-  views?: boolean;
+  target?: Database.Database | Collection.Collection;
   initialFormValues?: Partial<AnyProperties>;
   defaultSpaceId?: SpaceId;
   resolve?: (typename: string) => Metadata | undefined;
-  onTargetChange?: (target: Space) => void;
+  onTargetChange?: (target: Database.Database) => void;
   onTypenameChange?: (typename: string) => void;
   onCreateObject?: (params: { metadata: Metadata; data?: Record<string, any> }) => MaybePromise<void>;
 };
 
 export const CreateObjectPanel = ({
-  schemas,
+  options,
   spaces,
   typename,
   target,
-  views,
-  initialFormValues: _initialFormValues,
+  initialFormValues: initialFormValuesProp,
   defaultSpaceId,
   resolve,
   onTargetChange,
   onTypenameChange,
   onCreateObject,
 }: CreateObjectPanelProps) => {
-  const { t } = useTranslation(meta.id);
-  const initialFormValues = useDefaultValue(_initialFormValues, () => ({}));
+  const initialFormValues = useDefaultValue(initialFormValuesProp, () => ({}));
   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 });
-      return nameA.localeCompare(nameB);
-    });
+
+  const sortedOptions = useMemo(() => [...options].sort((a, b) => a.label.localeCompare(b.label)), [options]);
 
   const handleCreateObject = useCallback(
     async (props: Record<string, any>) => {
@@ -83,109 +72,154 @@ export const CreateObjectPanel = ({
     [onCreateObject, metadata],
   );
 
-  const handleSetTypename = useCallback(
-    async (typename: string) => {
-      const metadata = resolve?.(typename);
+  const handleSelectOption = useCallback(
+    async (id: string) => {
+      const metadata = resolve?.(id);
       if (metadata && !metadata.inputSchema) {
         await onCreateObject?.({ metadata });
       } else {
-        onTypenameChange?.(typename);
+        onTypenameChange?.(id);
       }
     },
     [resolve, onCreateObject],
   );
 
+  const inputSchema = useMemo(
+    () => (metadata && typeof metadata === 'object' && metadata.inputSchema ? omitId(metadata.inputSchema) : undefined),
+    [metadata],
+  );
   const inputSurfaceLookup = useInputSurfaceLookup({ target });
 
   // TODO(wittjosiah): These inputs should be rolled into a `Form` once it supports the necessary variants.
-  return !metadata ? (
-    <SelectSchema options={options} resolve={resolve} onChange={handleSetTypename} />
-  ) : !target ? (
-    <SelectSpace spaces={spaces} defaultSpaceId={defaultSpaceId} onChange={onTargetChange} />
-  ) : metadata.inputSchema ? (
-    <div role='none' className={cardDialogOverflow}>
-      <Form
-        autoFocus
-        values={initialFormValues}
-        schema={metadata.inputSchema}
+  if (!metadata) {
+    return <SelectType options={sortedOptions} onChange={handleSelectOption} />;
+  }
+
+  if (!target) {
+    return <SelectSpace spaces={spaces} defaultSpaceId={defaultSpaceId} onChange={onTargetChange} />;
+  }
+
+  if (metadata.inputSchema) {
+    return (
+      <Form.Root
         testId='create-object-form'
+        autoFocus
+        schema={inputSchema}
+        defaultValues={initialFormValues}
+        db={Obj.isObject(target) ? Obj.getDatabase(target) : target}
+        fieldProvider={inputSurfaceLookup}
         onSave={handleCreateObject}
-        lookupComponent={inputSurfaceLookup}
-        outerSpacing='blockStart-0'
-      />
-    </div>
-  ) : null;
+      >
+        <Form.Viewport>
+          <Form.Content>
+            <Form.FieldSet />
+            <Form.Submit />
+          </Form.Content>
+        </Form.Viewport>
+      </Form.Root>
+    );
+  }
+
+  return null;
 };
 
+CreateObjectPanel.displayName = 'CreateObjectPanel';
+
 const SelectSpace = ({
   spaces,
   defaultSpaceId,
   onChange,
-}: { onChange?: (space: Space) => void } & Pick<CreateObjectPanelProps, 'spaces' | 'defaultSpaceId'>) => {
+}: { 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,
+      ),
+  });
+
   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>
   );
 };
 
-const SelectSchema = ({
-  options,
-  resolve,
-  onChange,
-}: {
-  options: TypeAnnotation[];
-  onChange: (type: string) => void;
-} & Pick<CreateObjectPanelProps, 'resolve'>) => {
+const SelectType = ({ options, onChange }: { options: CreateObjectOption[]; onChange: (id: string) => void }) => {
   const { t } = useTranslation(meta.id);
 
+  const { results, handleSearch } = useSearchListResults({
+    items: options,
+    extract: (option) => option.label,
+  });
+
   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.id}
+              value={option.id}
+              label={option.label}
+              icon={option.icon ?? 'ph--placeholder--regular'}
+              classNames='flex items-center gap-2'
+              onSelect={() => onChange(option.id)}
+            />
+          ))}
+        </SearchList.Viewport>
       </SearchList.Content>
     </SearchList.Root>
   );

package/src/components/CreateDialog/index.ts

@@ -2,5 +2,4 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './CreateObjectDialog';
-export * from './CreateSpaceDialog';
+export * from './CreateObjectPanel';

package/src/components/{ObjectSettings → ObjectDetails}/BaseObjectSettings.stories.tsx

@@ -6,43 +6,43 @@ import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useEffect, useState } from 'react';
 
 import { type Obj, Tag } from '@dxos/echo';
-import { useClientProvider, withClientProvider } from '@dxos/react-client/testing';
-import { withTheme } from '@dxos/react-ui/testing';
-import { render } from '@dxos/storybook-utils';
-import { Project } from '@dxos/types';
+import { useClientStory, withClientProvider } from '@dxos/react-client/testing';
+import { Loading, withTheme } from '@dxos/react-ui/testing';
+
+import { Pipeline } from '@dxos/types';
 
 import { translations } from '../../translations';
 
 import { BaseObjectSettings } from './BaseObjectSettings';
 
 const DefaultStory = () => {
-  const { space } = useClientProvider();
-  const [object, setObject] = useState<Obj.Any>();
+  const { space } = useClientStory();
+  const [object, setObject] = useState<Obj.Unknown>();
 
   useEffect(() => {
     if (space && !object) {
-      const object = space.db.add(Project.make());
-      setObject(object as Obj.Any);
+      const object = space.db.add(Pipeline.make());
+      setObject(object);
     }
   }, [space, object]);
 
   if (!object) {
-    return null;
+    return <Loading data={{ space: !!space, object: !!object }} />;
   }
 
-  return <BaseObjectSettings object={object} classNames='is-[20rem]' />;
+  return <BaseObjectSettings object={object} classNames='w-[20rem]' />;
 };
 
 const meta = {
-  title: 'plugins/plugin-space/BaseObjectSettings',
+  title: 'plugins/plugin-space/components/BaseObjectSettings',
   component: BaseObjectSettings as any,
-  render: render(DefaultStory),
+  render: DefaultStory,
   decorators: [
-    withTheme,
+    withTheme(),
     withClientProvider({
       createIdentity: true,
       createSpace: true,
-      types: [Project.Project, Tag.Tag],
+      types: [Pipeline.Pipeline, Tag.Tag],
       onCreateSpace: async ({ space }) => {
         space.db.add(Tag.make({ label: 'Tag 1' }));
         space.db.add(Tag.make({ label: 'Tag 2' }));

package/src/components/ObjectDetails/BaseObjectSettings.tsx

@@ -0,0 +1,122 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+import React, { type PropsWithChildren, useCallback, useMemo } from 'react';
+
+import { DXN, Obj, Ref, Tag, Type } from '@dxos/echo';
+import { type JsonPath, splitJsonPath } from '@dxos/echo/internal';
+import { invariant } from '@dxos/invariant';
+import { type ThemedClassName } from '@dxos/react-ui';
+import { Form, omitId } from '@dxos/react-ui-form';
+import { isNonNullable } from '@dxos/util';
+
+import { meta as pluginMeta } from '../../meta';
+
+// TODO(wittjosiah): Would be nice to control order when extending so this isn't always first/last.
+const BaseSchema = Schema.Struct({
+  tags: Schema.Array(Ref.Ref(Tag.Tag)).pipe(Schema.optional),
+});
+
+export type BaseObjectSettingsProps = ThemedClassName<
+  PropsWithChildren<{
+    object: Obj.Unknown;
+  }>
+>;
+
+// TODO(wittjosiah): Reconcile w/ ObjectForm.
+export const BaseObjectSettings = ({ classNames, children, object }: BaseObjectSettingsProps) => {
+  const db = Obj.getDatabase(object);
+
+  const formSchema = useMemo(() => {
+    return Function.pipe(
+      Obj.getSchema(object),
+      Option.fromNullable,
+      Option.map((schema) => omitId(BaseSchema.pipe(Schema.extend(schema)))),
+      Option.getOrUndefined,
+    );
+  }, [object]);
+
+  const meta = Obj.getMeta(object);
+  const tags = (meta.tags ?? []).map((tag) => db?.makeRef(DXN.parse(tag))).filter(isNonNullable);
+  const values = useMemo(
+    () => ({
+      tags,
+      ...object,
+    }),
+    [object, tags],
+  );
+
+  const handleCreate = useCallback((schema: Type.AnyEntity, values: any) => {
+    invariant(db);
+    invariant(Type.isObjectSchema(schema));
+    const newObject = db.add(Obj.make(schema, values));
+    if (Obj.instanceOf(Tag.Tag, newObject)) {
+      Obj.change(object, (obj) => {
+        Obj.getMeta(obj).tags = [...(Obj.getMeta(obj).tags ?? []), Obj.getDXN(newObject).toString()];
+      });
+    }
+  }, []);
+
+  // TODO(wittjosiah): Use FormRootProps type.
+  const handleChange = useCallback(
+    (
+      { tags, ...values }: Schema.Schema.Type<typeof formSchema>,
+      { isValid, changed }: { isValid: boolean; changed: Record<JsonPath, boolean> },
+    ) => {
+      if (!isValid) {
+        return;
+      }
+
+      const changedPaths = Object.keys(changed).filter((path) => changed[path as JsonPath]) as JsonPath[];
+
+      // Handle tags separately using Obj.change.
+      const hasTagsChange = changedPaths.some((path) => splitJsonPath(path)[0] === 'tags');
+      if (hasTagsChange) {
+        Obj.change(object, (obj) => {
+          Obj.getMeta(obj).tags = tags?.map((tag: Ref.Ref<Tag.Tag>) => tag.dxn.toString()) ?? [];
+        });
+      }
+
+      // Handle other property changes.
+      const nonTagPaths = changedPaths.filter((path) => splitJsonPath(path)[0] !== 'tags');
+      if (nonTagPaths.length > 0) {
+        Obj.change(object, () => {
+          for (const path of nonTagPaths) {
+            const parts = splitJsonPath(path);
+            const value = Obj.getValue(values as any, parts);
+            Obj.setValue(object, parts, value);
+          }
+        });
+      }
+    },
+    [object],
+  );
+
+  if (!formSchema) {
+    return null;
+  }
+
+  return (
+    <Form.Root
+      schema={formSchema}
+      defaultValues={values as any}
+      createOptionIcon='ph--plus--regular'
+      createOptionLabel={['add tag label', { ns: pluginMeta.id }]}
+      createInitialValuePath='label'
+      db={db}
+      onValuesChanged={handleChange}
+      onCreate={handleCreate}
+    >
+      <Form.Viewport>
+        <Form.Content classNames={classNames}>
+          <Form.FieldSet />
+          {children}
+        </Form.Content>
+      </Form.Viewport>
+    </Form.Root>
+  );
+};