@dxos/plugin-space 0.8.1 → 0.8.2-main.2f9c567

package/src/capabilities/react-surface.tsx

@@ -2,20 +2,27 @@
 // Copyright 2025 DXOS.org
 //
 
-import React from 'react';
+import { type Schema } from 'effect';
+import React, { useCallback } from 'react';
 
-import { Capabilities, contributes, createSurface, Surface, useCapability } from '@dxos/app-framework';
+import { Capabilities, contributes, createSurface, Surface, useCapability, useLayout } from '@dxos/app-framework';
 import { isInstanceOf } from '@dxos/echo-schema';
+import { findAnnotation } from '@dxos/effect';
 import { SettingsStore } from '@dxos/local-storage';
 import {
   getSpace,
   isEchoObject,
-  isReactiveObject,
+  isLiveObject,
   isSpace,
+  parseId,
   SpaceState,
-  type ReactiveEchoObject,
+  useSpace,
+  type AnyLiveObject,
   type Space,
 } from '@dxos/react-client/echo';
+import { Input } from '@dxos/react-ui';
+import { type InputProps } from '@dxos/react-ui-form';
+import { HuePicker, IconPicker } from '@dxos/react-ui-pickers';
 import { type JoinPanelProps } from '@dxos/shell/react';
 
 import { SpaceCapabilities } from './capabilities';
@@ -41,13 +48,13 @@ import {
   type CreateObjectDialogProps,
   POPOVER_ADD_SPACE,
   PopoverAddSpace,
-  SpaceSettingsContainer,
-  SpacePropertiesForm,
   MembersContainer,
   ObjectSettingsContainer,
+  SpaceSettingsContainer,
+  SchemaContainer,
 } from '../components';
 import { SPACE_PLUGIN } from '../meta';
-import { CollectionType, type SpaceSettingsProps } from '../types';
+import { CollectionType, HueAnnotationId, IconAnnotationId, type SpaceSettingsProps } from '../types';
 
 type ReactSurfaceOptions = {
   createInvitationUrl: (invitationCode: string) => string;
@@ -77,33 +84,64 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
       component: ({ data }) => <CollectionMain collection={data.subject} />,
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/members`,
-      role: 'article',
-      position: 'hoist',
-      filter: (data): data is { subject: Space; variant: 'members' } =>
-        isSpace(data.subject) && data.variant === 'members',
-      component: ({ data }) => <MembersContainer space={data.subject} createInvitationUrl={createInvitationUrl} />,
-    }),
-    createSurface({
-      id: `${SPACE_PLUGIN}/settings`,
+      id: `${SPACE_PLUGIN}/plugin-settings`,
       role: 'article',
-      position: 'hoist',
-      filter: (data): data is { subject: Space; variant: 'settings' } =>
-        isSpace(data.subject) && data.variant === 'settings',
-      component: ({ data }) => <SpaceSettingsContainer space={data.subject} />,
+      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}/companion/object-settings`,
       role: 'article',
-      filter: (data): data is { companionTo: ReactiveEchoObject<any> } =>
+      filter: (data): data is { companionTo: AnyLiveObject<any> } =>
         isEchoObject(data.companionTo) && data.subject === 'settings',
       component: ({ data, role }) => <ObjectSettingsContainer object={data.companionTo} role={role} />,
     }),
     createSurface({
-      id: `${SPACE_PLUGIN}/space-settings--properties`,
-      role: 'space-settings--properties',
-      filter: (data): data is { subject: Space } => isSpace(data.subject),
-      component: ({ data }) => <SpacePropertiesForm space={data.subject} />,
+      id: `${SPACE_PLUGIN}/space-settings-properties`,
+      role: 'article',
+      filter: (data): data is { subject: string } => data.subject === `${SPACE_PLUGIN}/properties`,
+      component: () => {
+        const layout = useLayout();
+        const { spaceId } = parseId(layout.workspace);
+        const space = useSpace(spaceId);
+        if (!space || !spaceId) {
+          return null;
+        }
+
+        return <SpaceSettingsContainer space={space} />;
+      },
+    }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/space-settings-members`,
+      role: 'article',
+      position: 'hoist',
+      filter: (data): data is { subject: string } => data.subject === `${SPACE_PLUGIN}/members`,
+      component: () => {
+        const layout = useLayout();
+        const { spaceId } = parseId(layout.workspace);
+        const space = useSpace(spaceId);
+        if (!space || !spaceId) {
+          return null;
+        }
+
+        return <MembersContainer space={space} createInvitationUrl={createInvitationUrl} />;
+      },
+    }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/space-settings-schema`,
+      role: 'article',
+      filter: (data): data is { subject: string } => data.subject === `${SPACE_PLUGIN}/schema`,
+      component: () => {
+        const layout = useLayout();
+        const { spaceId } = parseId(layout.workspace);
+        const space = useSpace(spaceId);
+        if (!space || !spaceId) {
+          return null;
+        }
+
+        return <SchemaContainer space={space} />;
+      },
     }),
     createSurface({
       id: JOIN_DIALOG,
@@ -123,6 +161,44 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
       filter: (data): data is { props: CreateObjectDialogProps } => data.component === CREATE_OBJECT_DIALOG,
       component: ({ data }) => <CreateObjectDialog {...data.props} />,
     }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/create-initial-space-form-[hue]`,
+      role: 'form-input',
+      filter: (data): data is { prop: string; schema: Schema.Schema<any> } => {
+        const annotation = findAnnotation<boolean>((data.schema as Schema.Schema.All).ast, HueAnnotationId);
+        return !!annotation;
+      },
+      component: ({ data: _, ...inputProps }) => {
+        const { label, disabled, type, getValue, onValueChange } = inputProps as any as InputProps;
+        const handleChange = useCallback((nextHue: string) => onValueChange(type, nextHue), [onValueChange]);
+        const handleReset = useCallback(() => onValueChange(type, undefined), [onValueChange]);
+        return (
+          <Input.Root>
+            <Input.Label>{label}</Input.Label>
+            <HuePicker disabled={disabled} value={getValue() ?? ''} onChange={handleChange} onReset={handleReset} />
+          </Input.Root>
+        );
+      },
+    }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/create-initial-space-form-[icon]`,
+      role: 'form-input',
+      filter: (data): data is { prop: string; schema: Schema.Schema<any> } => {
+        const annotation = findAnnotation<boolean>((data.schema as Schema.Schema.All).ast, IconAnnotationId);
+        return !!annotation;
+      },
+      component: ({ data: _, ...inputProps }) => {
+        const { label, disabled, type, getValue, onValueChange } = inputProps as any as InputProps;
+        const handleChange = useCallback((nextIcon: string) => onValueChange(type, nextIcon), [onValueChange]);
+        const handleReset = useCallback(() => onValueChange(type, undefined), [onValueChange]);
+        return (
+          <Input.Root>
+            <Input.Label>{label}</Input.Label>
+            <IconPicker disabled={disabled} value={getValue() ?? ''} onChange={handleChange} onReset={handleReset} />
+          </Input.Root>
+        );
+      },
+    }),
     createSurface({
       id: POPOVER_RENAME_SPACE,
       role: 'popover',
@@ -132,8 +208,8 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
     createSurface({
       id: POPOVER_RENAME_OBJECT,
       role: 'popover',
-      filter: (data): data is { props: ReactiveEchoObject<any> } =>
-        data.component === POPOVER_RENAME_OBJECT && isReactiveObject(data.props),
+      filter: (data): data is { props: AnyLiveObject<any> } =>
+        data.component === POPOVER_RENAME_OBJECT && isLiveObject(data.props),
       component: ({ data }) => <PopoverRenameObject object={data.props} />,
     }),
     createSurface({
@@ -142,10 +218,16 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
       filter: (data): data is any => data.component === POPOVER_ADD_SPACE,
       component: () => <PopoverAddSpace />,
     }),
+    createSurface({
+      id: `${SPACE_PLUGIN}/menu-footer`,
+      role: 'menu-footer',
+      filter: (data): data is { subject: AnyLiveObject<any> } => isEchoObject(data.subject),
+      component: ({ data }) => <MenuFooter object={data.subject} />,
+    }),
     createSurface({
       id: `${SPACE_PLUGIN}/navtree-presence`,
       role: 'navtree-item-end',
-      filter: (data): data is { id: string; subject: ReactiveEchoObject<any>; open?: boolean } =>
+      filter: (data): data is { id: string; subject: AnyLiveObject<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.
@@ -172,7 +254,7 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
       id: `${SPACE_PLUGIN}/navbar-presence`,
       role: 'navbar-end',
       position: 'hoist',
-      filter: (data): data is { subject: Space | ReactiveEchoObject<any> } =>
+      filter: (data): data is { subject: Space | AnyLiveObject<any> } =>
         isSpace(data.subject) || isEchoObject(data.subject),
       component: ({ data }) => {
         const space = isSpace(data.subject) ? data.subject : getSpace(data.subject);
@@ -191,19 +273,6 @@ export default ({ createInvitationUrl }: ReactSurfaceOptions) =>
       filter: (data): data is { subject: CollectionType } => isInstanceOf(CollectionType, data.subject),
       component: ({ data }) => <CollectionSection collection={data.subject} />,
     }),
-    createSurface({
-      id: `${SPACE_PLUGIN}/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',

package/src/capabilities/schema-tool.test.ts

@@ -2,10 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Schema } from 'effect';
 import { describe, it, expect } from 'vitest';
 
-import { S } from '@dxos/echo-schema';
-
 import { TypeNameSchema } from './schema-tools';
 
 describe('TypeNameSchema format', () => {
@@ -29,7 +28,7 @@ describe('TypeNameSchema format', () => {
     '.org/Type', // Must have domain
   ];
 
-  const validate = S.validateSync(TypeNameSchema);
+  const validate = Schema.validateSync(TypeNameSchema);
 
   valid.forEach((typename) => {
     it(`should accept valid typename: ${typename}`, () => {

package/src/capabilities/schema-tools.ts

@@ -2,12 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
-import { DescriptionAnnotationId, ExamplesAnnotationId, TitleAnnotationId } from 'effect/SchemaAST';
+import { Schema, SchemaAST } from 'effect';
 
 import { Capabilities, contributes, type PromiseIntentDispatcher } from '@dxos/app-framework';
 import { defineTool, ToolResult } from '@dxos/artifact';
 import { type Space } from '@dxos/client/echo';
-import { FormatEnum, FormatEnums, S, SelectOptionSchema, GeoPoint, toJsonSchema } from '@dxos/echo-schema';
+import { FormatEnum, FormatEnums, SelectOptionSchema, GeoPoint, toJsonSchema } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { hues } from '@dxos/react-ui-theme';
 import { getSchemaFromPropertyDefinitions } from '@dxos/schema';
@@ -21,13 +21,13 @@ declare global {
 }
 
 // TODO(ZaymonFC): Move this somewhere common.
-export const TypeNameSchema = S.String.pipe(
-  S.pattern(/^\w+\.\w{2,}\/[\w/]+$/i),
-  S.annotations({
-    [TitleAnnotationId]: 'TypeName',
-    [DescriptionAnnotationId]:
+export const TypeNameSchema = Schema.String.pipe(
+  Schema.pattern(/^\w+\.\w{2,}\/[\w/]+$/i),
+  Schema.annotations({
+    [SchemaAST.TitleAnnotationId]: 'TypeName',
+    [SchemaAST.DescriptionAnnotationId]:
       'Domain-style type name path. Dashes are not allowed. Use camel case for the final component of the type name.',
-    [ExamplesAnnotationId]: ['example.com/type/Document', 'example.com/type/FlightList'],
+    [SchemaAST.ExamplesAnnotationId]: ['example.com/type/Document', 'example.com/type/FlightList'],
   }),
 );
 
@@ -36,23 +36,23 @@ const formatDescription = `The format of the property. Additional information:
   This tuple is GeoJSON. You must specify \`${FormatEnum.GeoPoint}\` as [Longitude, Latitude]`;
 
 // TODO(ZaymonFC): All properties are default optional, but maybe we should allow for required properties.
-const PropertyDefinitionSchema = S.Struct({
-  name: S.String.annotations({ [DescriptionAnnotationId]: 'The name of the property.' }),
-  format: S.Union(...FormatEnums.map((format) => S.Literal(format))).annotations({
-    [DescriptionAnnotationId]: formatDescription,
+const PropertyDefinitionSchema = Schema.Struct({
+  name: Schema.String.annotations({ [SchemaAST.DescriptionAnnotationId]: 'The name of the property.' }),
+  format: Schema.Union(...FormatEnums.map((format) => Schema.Literal(format))).annotations({
+    [SchemaAST.DescriptionAnnotationId]: formatDescription,
   }),
-  config: S.optional(
-    S.Struct({
-      options: S.optional(
-        S.Array(SelectOptionSchema)
+  config: Schema.optional(
+    Schema.Struct({
+      options: Schema.optional(
+        Schema.Array(SelectOptionSchema)
           .annotations({
             description: `Options for SingleSelect/MultiSelect formats. Available colors: ${hues.join(', ')}`,
           })
-          .pipe(S.mutable),
+          .pipe(Schema.mutable),
       ),
     }),
   ),
-}).pipe(S.mutable);
+}).pipe(Schema.mutable);
 
 const SYSTEM_NAMESPACE = 'dxos.org/echo/schema';
 
@@ -62,7 +62,7 @@ export default () =>
       name: 'list',
       description: 'List registered schemas in the space.',
       caption: 'Listing registered schemas...',
-      schema: S.Struct({}),
+      schema: Schema.Struct({}),
       execute: async (_input, { extensions }) => {
         invariant(extensions?.space, 'No space.');
         const space = extensions.space;
@@ -80,8 +80,8 @@ export default () =>
       name: 'get',
       description: 'Get a specific schema by its typename.',
       caption: 'Getting schema...',
-      schema: S.Struct({
-        typename: S.String.annotations({
+      schema: Schema.Struct({
+        typename: Schema.String.annotations({
           description: 'The fully qualified typename of the schema.',
         }),
       }),
@@ -101,14 +101,14 @@ export default () =>
       name: 'create',
       description: 'Create a new schema with the provided definition.',
       caption: 'Creating schema...',
-      schema: S.Struct({
+      schema: Schema.Struct({
         typename: TypeNameSchema.annotations({
           description:
             'The fully qualified schema typename. Must start with a domain, and then one or more path components (e.g., "example.com/type/TypeName").',
         }),
-        properties: S.Array(PropertyDefinitionSchema).pipe(
-          S.annotations({ description: 'Array of property definitions for the schema.' }),
-          S.mutable,
+        properties: Schema.Array(PropertyDefinitionSchema).pipe(
+          Schema.annotations({ description: 'Array of property definitions for the schema.' }),
+          Schema.mutable,
         ),
       }),
       execute: async ({ typename, properties }, { extensions }) => {

package/src/capabilities/settings.ts

@@ -3,13 +3,13 @@
 //
 
 import { Capabilities, contributes } from '@dxos/app-framework';
-import { create } from '@dxos/live-object';
+import { live } from '@dxos/live-object';
 
 import { SPACE_PLUGIN } from '../meta';
 import { type SpaceSettingsProps, SpaceSettingsSchema } from '../types';
 
 export default () => {
-  const settings = create<SpaceSettingsProps>({
+  const settings = live<SpaceSettingsProps>({
     showHidden: false,
   });
 

package/src/capabilities/spaces-ready.ts

@@ -6,7 +6,7 @@ import { contributes, createIntent, type PluginsContext, Capabilities, LayoutAct
 import { SubscriptionList } from '@dxos/async';
 import { Expando } from '@dxos/echo-schema';
 import { scheduledEffect } from '@dxos/echo-signals/core';
-import { create } from '@dxos/live-object';
+import { live } from '@dxos/live-object';
 import { log } from '@dxos/log';
 import { AttentionCapabilities } from '@dxos/plugin-attention';
 import { ClientCapabilities } from '@dxos/plugin-client';
@@ -53,7 +53,7 @@ export default async (context: PluginsContext) => {
   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: [] }));
+    defaultSpace.db.add(live({ key: SHARED, order: [] }));
   }
 
   // Await missing objects.

package/src/capabilities/state.ts

@@ -14,11 +14,9 @@ import { SPACE_PLUGIN } from '../meta';
 import { type PluginState } from '../types';
 
 export default (context: PluginsContext) => {
-  const sections = context.requestCapabilities(SpaceCapabilities.SettingsSection);
   const state = new LocalStorageStore<PluginState>(SPACE_PLUGIN, {
     awaiting: undefined,
     spaceNames: {},
-    spaceSettingsOpenSections: sections.map((section) => section.id),
     viewersByObject: {},
     // TODO(wittjosiah): Stop using (Complex)Map inside reactive object.
     viewersByIdentity: new ComplexMap(PublicKey.hash),

package/src/components/CollectionMain.tsx

@@ -5,7 +5,7 @@
 import React from 'react';
 
 import { useTranslation } from '@dxos/react-ui';
-import { baseSurface, descriptionText, mx } from '@dxos/react-ui-theme';
+import { baseSurface, descriptionMessage, mx } from '@dxos/react-ui-theme';
 
 import { SPACE_PLUGIN } from '../meta';
 import type { CollectionType } from '../types';
@@ -21,10 +21,7 @@ export const CollectionMain = ({ collection }: { collection: CollectionType }) =
     >
       <p
         role='alert'
-        className={mx(
-          descriptionText,
-          'border border-dashed border-neutral-400/50 rounded-lg p-8 font-normal text-lg max-is-[24rem] break-words',
-        )}
+        className={mx(descriptionMessage, 'rounded-lg p-8 font-normal text-lg max-is-[24rem] break-words')}
       >
         {collection.name ?? t('unnamed collection label')}
       </p>

package/src/components/CreateDialog/CreateObjectDialog.stories.tsx

@@ -7,7 +7,7 @@ import '@dxos-theme';
 import { type Meta, type StoryObj } from '@storybook/react';
 import React, { useEffect } from 'react';
 
-import { create, Filter, useQuery, useSpace } from '@dxos/react-client/echo';
+import { live, Filter, useQuery, useSpace } from '@dxos/react-client/echo';
 import { withClientProvider } from '@dxos/react-client/testing';
 import { Dialog } from '@dxos/react-ui';
 import { osTranslations } from '@dxos/shell/react';
@@ -70,7 +70,7 @@ export const TargetCollection: StoryObj<typeof CreateObjectDialog> = {
 
     useEffect(() => {
       if (space) {
-        space.db.add(create(CollectionType, { name: 'My Collection', objects: [], views: {} }));
+        space.db.add(live(CollectionType, { name: 'My Collection', objects: [], views: {} }));
       }
     }, [space]);
 

package/src/components/CreateDialog/CreateObjectDialog.tsx

@@ -16,7 +16,7 @@ import {
 } from '@dxos/app-framework';
 import { invariant } from '@dxos/invariant';
 import { useClient } from '@dxos/react-client';
-import { getSpace, isReactiveObject, isSpace, type ReactiveObject, useSpaces } from '@dxos/react-client/echo';
+import { getSpace, isLiveObject, isSpace, type Live, useSpaces } from '@dxos/react-client/echo';
 import { Button, Dialog, Icon, useTranslation } from '@dxos/react-ui';
 
 import { CreateObjectPanel, type CreateObjectPanelProps } from './CreateObjectPanel';
@@ -27,7 +27,7 @@ import { type ObjectForm, SpaceAction } from '../../types';
 export const CREATE_OBJECT_DIALOG = `${SPACE_PLUGIN}/CreateObjectDialog`;
 
 export type CreateObjectDialogProps = Pick<CreateObjectPanelProps, 'target' | 'typename' | 'name'> & {
-  shouldNavigate?: (object: ReactiveObject<any>) => boolean;
+  shouldNavigate?: (object: Live<any>) => boolean;
 };
 
 export const CreateObjectDialog = ({
@@ -72,7 +72,7 @@ export const CreateObjectDialog = ({
       invariant(space, 'Missing space');
       const result = await dispatch(form.getIntent(data, { space }));
       const object = result.data?.object;
-      if (isReactiveObject(object)) {
+      if (isLiveObject(object)) {
         const addObjectIntent = createIntent(SpaceAction.AddObject, { target, object, hidden: form.hidden });
         const shouldNavigate = _shouldNavigate ?? (() => true);
         if (shouldNavigate(object)) {

package/src/components/CreateDialog/CreateObjectPanel.tsx

@@ -4,42 +4,20 @@
 
 import React, { useCallback, useState } from 'react';
 
-import { Surface, isSurfaceAvailable, usePluginManager } from '@dxos/app-framework';
-import { getTypeAnnotation, type TypeAnnotation, type S } from '@dxos/echo-schema';
+import { getTypeAnnotation, type TypeAnnotation } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { type SpaceId, type Space } from '@dxos/react-client/echo';
 import { Icon, type ThemedClassName, toLocalizedString, useTranslation } from '@dxos/react-ui';
-import { Form, type InputProps } from '@dxos/react-ui-form';
+import { Form } from '@dxos/react-ui-form';
 import { SearchList } from '@dxos/react-ui-searchlist';
 import { mx } from '@dxos/react-ui-theme';
 import { isNonNullable, type MaybePromise } from '@dxos/util';
 
+import { useInputSurfaceLookup } from '../../hooks';
 import { SPACE_PLUGIN } from '../../meta';
 import { type ObjectForm, type CollectionType } from '../../types';
 import { getSpaceDisplayName } from '../../util';
 
-// 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.
- */
-const useInputSurfaceLookup = (baseData?: Record<string, any>) => {
-  const pluginManager = usePluginManager();
-
-  return useCallback(
-    ({ prop, schema, inputProps }: { prop: string; schema: S.Schema<any>; inputProps: InputProps }) => {
-      const composedData = { prop, schema, ...baseData };
-      if (!isSurfaceAvailable(pluginManager.context, { role: 'form-input', data: composedData })) {
-        return undefined;
-      }
-
-      return <Surface role='form-input' data={composedData} {...inputProps} />;
-    },
-    [pluginManager, baseData],
-  );
-};
-
 export type CreateObjectPanelProps = ThemedClassName<{
   forms: ObjectForm[];
   spaces: Space[];

package/src/components/CreateDialog/CreateSpaceDialog.tsx

@@ -2,20 +2,20 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Effect } from 'effect';
+import { Effect, type Schema } from 'effect';
 import React, { useCallback, useRef } from 'react';
 
 import { createIntent, LayoutAction, useIntentDispatcher } from '@dxos/app-framework';
-import { type S } from '@dxos/echo-schema';
 import { Button, Dialog, Icon, useTranslation } from '@dxos/react-ui';
 import { Form } from '@dxos/react-ui-form';
 
+import { useInputSurfaceLookup } from '../../hooks';
 import { SPACE_PLUGIN } from '../../meta';
 import { SpaceAction, SpaceForm } from '../../types';
 
 export const CREATE_SPACE_DIALOG = `${SPACE_PLUGIN}/CreateSpaceDialog`;
 
-type FormValues = S.Schema.Type<typeof SpaceForm>;
+type FormValues = Schema.Schema.Type<typeof SpaceForm>;
 const initialValues: FormValues = { edgeReplication: true };
 
 export const CreateSpaceDialog = () => {
@@ -23,6 +23,8 @@ export const CreateSpaceDialog = () => {
   const { t } = useTranslation(SPACE_PLUGIN);
   const { dispatch } = useIntentDispatcher();
 
+  const inputSurfaceLookup = useInputSurfaceLookup();
+
   const handleCreateSpace = useCallback(
     async (data: FormValues) => {
       const program = Effect.gen(function* () {
@@ -54,6 +56,7 @@ export const CreateSpaceDialog = () => {
           autoFocus
           values={initialValues}
           schema={SpaceForm}
+          lookupComponent={inputSurfaceLookup}
           onSave={handleCreateSpace}
         />
       </div>