@dxos/plugin-space 0.8.4-main.f9ba587 → 0.8.4-main.fffef41

package/src/capabilities/app-graph-serializer.ts

@@ -4,15 +4,15 @@
 
 import { Capabilities, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
 import { isSpace } from '@dxos/client/echo';
-import { Obj, Type } from '@dxos/echo';
-import { DataType } from '@dxos/schema';
+import { Obj } from '@dxos/echo';
+import { Collection } from '@dxos/schema';
 
-import { SPACE_PLUGIN } from '../meta';
+import { meta } from '../meta';
 import { translations } from '../translations';
 import { SPACE_TYPE, SpaceAction } from '../types';
 import { SPACES } from '../util';
 
-const COLLECTION_TYPE = Type.getTypename(DataType.Collection);
+const COLLECTION_TYPE = Collection.Collection.typename;
 
 // https://stackoverflow.com/a/19016910
 const DIRECTORY_TYPE = 'text/directory';
@@ -23,8 +23,8 @@ export default (context: PluginContext) =>
       inputType: SPACES,
       outputType: DIRECTORY_TYPE,
       serialize: (node) => ({
-        name: translations[0]['en-US'][SPACE_PLUGIN]['spaces label'] ?? 'Spaces',
-        data: translations[0]['en-US'][SPACE_PLUGIN]['spaces label'] ?? 'Spaces',
+        name: translations[0]['en-US'][meta.id]['spaces label'] ?? 'Spaces',
+        data: translations[0]['en-US'][meta.id]['spaces label'] ?? 'Spaces',
         type: DIRECTORY_TYPE,
       }),
       deserialize: () => {
@@ -35,8 +35,8 @@ export default (context: PluginContext) =>
       inputType: SPACE_TYPE,
       outputType: DIRECTORY_TYPE,
       serialize: (node) => ({
-        name: node.data.properties.name ?? translations[0]['en-US'][SPACE_PLUGIN]['unnamed space label'],
-        data: node.data.properties.name ?? translations[0]['en-US'][SPACE_PLUGIN]['unnamed space label'],
+        name: node.data.properties.name ?? translations[0]['en-US'][meta.id]['unnamed space label'],
+        data: node.data.properties.name ?? translations[0]['en-US'][meta.id]['unnamed space label'],
         type: DIRECTORY_TYPE,
       }),
       deserialize: async (data) => {
@@ -49,14 +49,14 @@ export default (context: PluginContext) =>
       inputType: COLLECTION_TYPE,
       outputType: DIRECTORY_TYPE,
       serialize: (node) => ({
-        name: node.data.name ?? translations[0]['en-US'][SPACE_PLUGIN]['object name placeholder'],
-        data: node.data.name ?? translations[0]['en-US'][SPACE_PLUGIN]['object name placeholder'],
+        name: node.data.name ?? translations[0]['en-US'][meta.id]['object name placeholder'],
+        data: node.data.name ?? translations[0]['en-US'][meta.id]['object name placeholder'],
         type: DIRECTORY_TYPE,
       }),
       deserialize: async (data, ancestors) => {
         const space = ancestors.find(isSpace);
         const collection =
-          ancestors.findLast((ancestor) => Obj.instanceOf(DataType.Collection, ancestor)) ??
+          ancestors.findLast((ancestor) => Obj.instanceOf(Collection.Collection, ancestor)) ??
           space?.properties[COLLECTION_TYPE]?.target;
         if (!space || !collection) {
           return;
@@ -66,7 +66,7 @@ export default (context: PluginContext) =>
         const result = await dispatch(
           createIntent(SpaceAction.AddObject, {
             target: collection,
-            object: Obj.make(DataType.Collection, { name: data.name, objects: [] }),
+            object: Obj.make(Collection.Collection, { name: data.name, objects: [] }),
           }),
         );
 

package/src/capabilities/capabilities.ts

@@ -2,23 +2,34 @@
 // Copyright 2025 DXOS.org
 //
 
-import { defineCapability, type Label } from '@dxos/app-framework';
+import type * as Schema from 'effect/Schema';
+
+import { type AnyIntentChain, type Label, defineCapability } from '@dxos/app-framework';
 import { type Space } from '@dxos/react-client/echo';
-import { type DataType } from '@dxos/schema';
-import { type Position, type DeepReadonly, type MaybePromise } from '@dxos/util';
+import { type Collection } from '@dxos/schema';
+import { type DeepReadonly, type Position } from '@dxos/util';
 
-import { SPACE_PLUGIN } from '../meta';
+import { meta } from '../meta';
 import { type ObjectForm, type PluginState } from '../types';
 
 export namespace SpaceCapabilities {
-  export const State = defineCapability<DeepReadonly<PluginState>>(`${SPACE_PLUGIN}/capability/state`);
-  export const MutableState = defineCapability<PluginState>(`${SPACE_PLUGIN}/capability/state`);
+  export const State = defineCapability<DeepReadonly<PluginState>>(`${meta.id}/capability/state`);
+  export const MutableState = defineCapability<PluginState>(`${meta.id}/capability/state`);
 
   export type SettingsSection = { id: string; label: Label; position?: Position };
-  export const SettingsSection = defineCapability<SettingsSection>(`${SPACE_PLUGIN}/capability/settings-section`);
+  export const SettingsSection = defineCapability<SettingsSection>(`${meta.id}/capability/settings-section`);
+
+  export type onCreateSpace = (params: { space: Space; rootCollection: Collection.Collection }) => AnyIntentChain;
+  export const onCreateSpace = defineCapability<onCreateSpace>(`${meta.id}/capability/on-space-created`);
 
-  export type OnSpaceCreated = (params: { space: Space; rootCollection: DataType.Collection }) => MaybePromise<void>;
-  export const OnSpaceCreated = defineCapability<OnSpaceCreated>(`${SPACE_PLUGIN}/capability/on-space-created`);
+  export type OnSchemaAdded = (params: {
+    space: Space;
+    schema: Schema.Schema.AnyNoContext;
+    // TODO(wittjosiah): This is leaky.
+    show?: boolean;
+  }) => AnyIntentChain;
+  export const OnSchemaAdded = defineCapability<OnSchemaAdded>(`${meta.id}/capability/on-schema-added`);
 
-  export const ObjectForm = defineCapability<ObjectForm<any>>(`${SPACE_PLUGIN}/capability/object-form`);
+  // TODO(burdon): Should this be view? Forms are UI concepts? (associated with a View/schema).
+  export const ObjectForm = defineCapability<ObjectForm<any>>(`${meta.id}/capability/object-form`);
 }

package/src/capabilities/identity-created.ts

@@ -2,11 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { contributes, type PluginContext, Capabilities } from '@dxos/app-framework';
+import { Capabilities, type PluginContext, contributes } from '@dxos/app-framework';
 import { Obj, Ref } from '@dxos/echo';
 import { Migrations } from '@dxos/migrations';
 import { ClientCapabilities } from '@dxos/plugin-client';
-import { DataType } from '@dxos/schema';
+import { Collection } from '@dxos/schema';
 
 export default async (context: PluginContext) => {
   const client = context.getCapability(ClientCapabilities.Client);
@@ -16,7 +16,7 @@ export default async (context: PluginContext) => {
   await defaultSpace.waitUntilReady();
 
   // Create root collection structure.
-  defaultSpace.properties[DataType.Collection.typename] = Ref.make(Obj.make(DataType.Collection, { objects: [] }));
+  defaultSpace.properties[Collection.Collection.typename] = Ref.make(Obj.make(Collection.Collection, { objects: [] }));
   if (Migrations.versionProperty) {
     defaultSpace.properties[Migrations.versionProperty] = Migrations.targetVersion;
   }

package/src/capabilities/index.ts

@@ -11,7 +11,6 @@ export const IntentResolver = lazy(() => import('./intent-resolver'));
 export const ReactRoot = lazy(() => import('./react-root'));
 export const ReactSurface = lazy(() => import('./react-surface'));
 export const SchemaDefs = lazy(() => import('./schema-defs'));
-export const SchemaTools = lazy(() => import('./schema-tools'));
 export const SpaceSettings = lazy(() => import('./settings'));
 export const SpaceState = lazy(() => import('./state'));
 export const SpacesReady = lazy(() => import('./spaces-ready'));

package/src/capabilities/intent-resolver.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 
 import {
   Capabilities,
@@ -12,31 +12,36 @@ import {
   createIntent,
   createResolver,
 } from '@dxos/app-framework';
-import { Obj, Ref, Relation, type Type } from '@dxos/echo';
+import { Filter, Obj, Query, Ref, Relation, Type } from '@dxos/echo';
+import { Serializer } from '@dxos/echo-db';
+import { DatabaseService } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 import { Migrations } from '@dxos/migrations';
 import { ClientCapabilities } from '@dxos/plugin-client';
 import { ObservabilityAction } from '@dxos/plugin-observability/types';
 import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
-import { isSpace, getSpace, SpaceState, fullyQualifiedId } from '@dxos/react-client/echo';
+import { SpaceState, getSpace, isSpace } from '@dxos/react-client/echo';
 import { Invitation, InvitationEncoder } from '@dxos/react-client/invitations';
 import { ATTENDABLE_PATH_SEPARATOR } from '@dxos/react-ui-attention';
-import { DataType } from '@dxos/schema';
+import { iconValues } from '@dxos/react-ui-pickers';
+import { hues } from '@dxos/react-ui-theme';
+import { Collection, ProjectionModel, StoredSchema, getTypenameFromQuery } from '@dxos/schema';
 
-import { SpaceCapabilities } from './capabilities';
 import {
   CREATE_OBJECT_DIALOG,
   CREATE_SPACE_DIALOG,
-  JOIN_DIALOG,
-  POPOVER_RENAME_OBJECT,
-  POPOVER_RENAME_SPACE,
   type CreateObjectDialogProps,
+  JOIN_DIALOG,
   type JoinDialogProps,
+  OBJECT_RENAME_POPOVER,
+  SPACE_RENAME_POPOVER,
 } from '../components';
 import { SpaceEvents } from '../events';
-import { SPACE_PLUGIN } from '../meta';
+import { meta } from '../meta';
 import { CollectionAction, SpaceAction } from '../types';
-import { cloneObject, COMPOSER_SPACE_LOCK, getNestedObjects } from '../util';
+import { COMPOSER_SPACE_LOCK, cloneObject, getNestedObjects } from '../util';
+
+import { SpaceCapabilities } from './capabilities';
 
 // TODO(wittjosiah): Remove.
 const SPACE_MAX_OBJECTS = 500;
@@ -68,24 +73,40 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
     }),
     createResolver({
       intent: SpaceAction.Create,
-      resolve: async ({ name, hue, icon, edgeReplication }) => {
+      resolve: async ({ name, hue: hue_, icon: icon_, edgeReplication }) => {
         const client = context.getCapability(ClientCapabilities.Client);
+        const hue = hue_ ?? hues[Math.floor(Math.random() * hues.length)];
+        const icon = icon_ ?? iconValues[Math.floor(Math.random() * iconValues.length)];
         const space = await client.spaces.create({ name, hue, icon });
         if (edgeReplication) {
           await space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED);
         }
         await space.waitUntilReady();
-        const collection = Obj.make(DataType.Collection, { objects: [] });
-        space.properties[DataType.Collection.typename] = Ref.make(collection);
 
+        // Create root collection.
+        const collection = Obj.make(Collection.Collection, { objects: [] });
+        space.properties[Collection.Collection.typename] = Ref.make(collection);
+
+        // Set current migration version.
         if (Migrations.versionProperty) {
           space.properties[Migrations.versionProperty] = Migrations.targetVersion;
         }
 
+        // Create records smart collection.
+        collection.objects.push(
+          Ref.make(
+            Obj.make(Collection.QueryCollection, {
+              // NOTE: This is specifically Filter.typename due to current limitations in query collection parsing.
+              query: Query.select(Filter.typename(StoredSchema.typename)).ast,
+            }),
+          ),
+        );
+
+        // Allow other plugins to add default content.
         await context.activatePromise(SpaceEvents.SpaceCreated);
-        const onSpaceCreatedCallbacks = context.getCapabilities(SpaceCapabilities.OnSpaceCreated);
-        await Promise.all(
-          onSpaceCreatedCallbacks.map((onSpaceCreated) => onSpaceCreated({ space, rootCollection: collection })),
+        const onCreateSpaceCallbacks = context.getCapabilities(SpaceCapabilities.onCreateSpace);
+        const spaceCreatedIntents = onCreateSpaceCallbacks.map((onCreateSpace) =>
+          onCreateSpace({ space, rootCollection: collection }),
         );
 
         return {
@@ -95,6 +116,7 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
             space,
           },
           intents: [
+            ...spaceCreatedIntents,
             ...(observability
               ? [
                   createIntent(ObservabilityAction.SendEvent, {
@@ -242,7 +264,7 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
           intents: [
             createIntent(LayoutAction.UpdatePopover, {
               part: 'popover',
-              subject: POPOVER_RENAME_SPACE,
+              subject: SPACE_RENAME_POPOVER,
               options: {
                 anchorId: `dxos.org/ui/${caller}/${space.id}`,
                 props: space,
@@ -309,9 +331,124 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
         };
       },
     }),
+    createResolver({
+      intent: SpaceAction.Snapshot,
+      resolve: async ({ space, query }) => {
+        const backup = await new Serializer().export(space.db, query && Query.fromAst(query));
+        return {
+          data: {
+            snapshot: new Blob([JSON.stringify(backup, null, 2)], { type: 'application/json' }),
+          },
+        };
+      },
+    }),
+    createResolver({
+      intent: SpaceAction.UseStaticSchema,
+      resolve: async ({ space, typename, show }) => {
+        const client = context.getCapability(ClientCapabilities.Client);
+        const schema = client.graph.schemaRegistry.schemas.find((schema) => Type.getTypename(schema) === typename);
+        invariant(schema, `Schema not found: ${typename}`);
+
+        if (!space.properties.staticRecords) {
+          space.properties.staticRecords = [];
+        }
+
+        if (!space.properties.staticRecords.includes(typename)) {
+          space.properties.staticRecords.push(typename);
+        }
+
+        await context.activatePromise(SpaceEvents.SchemaAdded);
+        const onSchemaAdded = context.getCapabilities(SpaceCapabilities.OnSchemaAdded);
+        const schemaAddedIntents = onSchemaAdded.map((onSchemaAdded) => onSchemaAdded({ space, schema, show }));
+
+        return {
+          data: {},
+          intents: [
+            ...schemaAddedIntents,
+            ...(observability
+              ? [
+                  createIntent(ObservabilityAction.SendEvent, {
+                    name: 'space.schema.use',
+                    properties: {
+                      spaceId: space.id,
+                      typename: Type.getTypename(schema),
+                    },
+                  }),
+                ]
+              : []),
+          ],
+        };
+      },
+    }),
+    createResolver({
+      intent: SpaceAction.AddSchema,
+      resolve: async ({ space, name, typename, version, schema: schemaInput, show }) => {
+        const [schema] = await space.db.schemaRegistry.register([schemaInput]);
+        if (name) {
+          schema.storedSchema.name = name;
+        }
+        if (typename) {
+          schema.storedSchema.typename = typename;
+        }
+        if (version) {
+          schema.storedSchema.version = version;
+        }
+
+        await context.activatePromise(SpaceEvents.SchemaAdded);
+        const onSchemaAdded = context.getCapabilities(SpaceCapabilities.OnSchemaAdded);
+        const schemaAddedIntents = onSchemaAdded.map((onSchemaAdded) => onSchemaAdded({ space, schema, show }));
+
+        return {
+          data: {
+            id: schema.id,
+            object: schema.storedSchema,
+            schema,
+          },
+          intents: [
+            ...schemaAddedIntents,
+            ...(observability
+              ? [
+                  createIntent(ObservabilityAction.SendEvent, {
+                    name: 'space.schema.add',
+                    properties: {
+                      spaceId: space.id,
+                      objectId: schema.id,
+                      typename: schema.typename,
+                    },
+                  }),
+                ]
+              : []),
+          ],
+        };
+      },
+    }),
+    createResolver({
+      intent: SpaceAction.DeleteField,
+      resolve: async ({ view, fieldId, deletionData }, undo) => {
+        const space = getSpace(view);
+        invariant(space);
+        const typename = getTypenameFromQuery(view.query.ast);
+        invariant(typename);
+        const schema = await space.db.schemaRegistry.query({ typename }).firstOrUndefined();
+        invariant(schema);
+        const projection = new ProjectionModel(schema.jsonSchema, view.projection);
+        if (!undo) {
+          const { deleted, index } = projection.deleteFieldProjection(fieldId);
+          return {
+            undoable: {
+              message: ['field deleted label', { ns: meta.id }],
+              data: { deletionData: { ...deleted, index } },
+            },
+          };
+        } else if (undo && deletionData) {
+          const { field, props, index } = deletionData;
+          projection.setFieldProjection({ field, props }, index);
+        }
+      },
+    }),
     createResolver({
       intent: SpaceAction.OpenCreateObject,
-      resolve: ({ target, typename, navigable = true }) => {
+      resolve: ({ target, views, typename, initialFormValues, navigable = true, onCreateObject }) => {
         const state = context.getCapability(SpaceCapabilities.State);
 
         return {
@@ -323,11 +460,14 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
                 blockAlign: 'start',
                 props: {
                   target,
+                  views,
                   typename,
+                  initialFormValues,
+                  onCreateObject,
                   shouldNavigate: navigable
                     ? (object: Obj.Any) => {
-                        const isCollection = Obj.instanceOf(DataType.Collection, object);
-                        const isQueryCollection = Obj.instanceOf(DataType.QueryCollection, object);
+                        const isCollection = Obj.instanceOf(Collection.Collection, object);
+                        const isQueryCollection = Obj.instanceOf(Collection.QueryCollection, object);
                         return (!isCollection && !isQueryCollection) || state.navigableCollections;
                       }
                     : () => false,
@@ -351,13 +491,13 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
               createIntent(LayoutAction.AddToast, {
                 part: 'toast',
                 subject: {
-                  id: `${SPACE_PLUGIN}/space-limit`,
-                  title: ['space limit label', { ns: SPACE_PLUGIN }],
-                  description: ['space limit description', { ns: SPACE_PLUGIN }],
+                  id: `${meta.id}/space-limit`,
+                  title: ['space limit label', { ns: meta.id }],
+                  description: ['space limit description', { ns: meta.id }],
                   duration: 5_000,
                   icon: 'ph--warning--regular',
-                  actionLabel: ['remove deleted objects label', { ns: SPACE_PLUGIN }],
-                  actionAlt: ['remove deleted objects alt', { ns: SPACE_PLUGIN }],
+                  actionLabel: ['remove deleted objects label', { ns: meta.id }],
+                  actionAlt: ['remove deleted objects alt', { ns: meta.id }],
                   closeLabel: ['close label', { ns: 'os' }],
                   onAction: () => space.db.coreDatabase.unlinkDeletedObjects(),
                 },
@@ -376,25 +516,18 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
           };
         }
 
-        if (Obj.instanceOf(DataType.Collection, target)) {
-          target.objects.push(Ref.make(object));
-        } else if (isSpace(target) && hidden) {
-          space.db.add(object);
-        } else if (isSpace(target)) {
-          const collection = space.properties[DataType.Collection.typename]?.target;
-          if (Obj.instanceOf(DataType.Collection, collection)) {
-            collection.objects.push(Ref.make(object));
-          } else {
-            // TODO(wittjosiah): Can't add non-echo objects by including in a collection because of types.
-            const collection = Obj.make(DataType.Collection, { objects: [Ref.make(object)] });
-            space.properties[DataType.Collection.typename] = Ref.make(collection);
-          }
-        }
+        await Effect.gen(function* () {
+          yield* Collection.add({
+            object,
+            target: isSpace(target) ? undefined : target,
+            hidden,
+          });
+        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.runPromise);
 
         return {
           data: {
-            id: fullyQualifiedId(object),
-            subject: [fullyQualifiedId(object)],
+            id: Obj.getDXN(object).toString(),
+            subject: [Obj.getDXN(object).toString()],
             object,
           },
           intents: [
@@ -443,26 +576,26 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
         const openObjectIds = new Set<string>(layout.active);
 
         if (!undo) {
-          const parentCollection: DataType.Collection =
-            target ?? space.properties[DataType.Collection.typename]?.target;
+          const parentCollection: Collection.Collection =
+            target ?? space.properties[Collection.Collection.typename]?.target;
           const nestedObjectsList = await Promise.all(objects.map((obj) => getNestedObjects(obj, resolve)));
 
           const deletionData = {
             objects,
             parentCollection,
             indices: objects.map((obj) =>
-              Obj.instanceOf(DataType.Collection, parentCollection)
+              Obj.instanceOf(Collection.Collection, parentCollection)
                 ? parentCollection.objects.findIndex((object) => object.target === obj)
                 : -1,
             ),
             nestedObjectsList,
             wasActive: objects
               .flatMap((obj, i) => [obj, ...nestedObjectsList[i]])
-              .map((obj) => fullyQualifiedId(obj))
+              .map((obj) => Obj.getDXN(obj).toString())
               .filter((id) => openObjectIds.has(id)),
           } satisfies SpaceAction.DeletionData;
 
-          if (Obj.instanceOf(DataType.Collection, deletionData.parentCollection)) {
+          if (Obj.instanceOf(Collection.Collection, deletionData.parentCollection)) {
             [...deletionData.indices]
               .sort((a, b) => b - a)
               .forEach((index: number) => {
@@ -477,7 +610,7 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
           });
           objects.forEach((obj) => space.db.remove(obj));
 
-          const undoMessageKey = objects.some((obj) => Obj.instanceOf(DataType.Collection, obj))
+          const undoMessageKey = objects.some((obj) => Obj.instanceOf(Collection.Collection, obj))
             ? 'collection deleted label'
             : objects.length > 1
               ? 'objects deleted label'
@@ -486,7 +619,7 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
           return {
             undoable: {
               // TODO(ZaymonFC): Pluralize if more than one object.
-              message: [undoMessageKey, { ns: SPACE_PLUGIN }],
+              message: [undoMessageKey, { ns: meta.id }],
               data: { deletionData },
             },
             intents:
@@ -504,7 +637,7 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
           if (
             deletionData?.objects?.length &&
             deletionData.objects.every(Obj.isObject) &&
-            Obj.instanceOf(DataType.Collection, deletionData.parentCollection)
+            Obj.instanceOf(Collection.Collection, deletionData.parentCollection)
           ) {
             // Restore the object to the space.
             const restoredObjects = deletionData.objects.map((obj: Type.Expando) => space.db.add(obj));
@@ -541,9 +674,9 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
         intents: [
           createIntent(LayoutAction.UpdatePopover, {
             part: 'popover',
-            subject: POPOVER_RENAME_OBJECT,
+            subject: OBJECT_RENAME_POPOVER,
             options: {
-              anchorId: `dxos.org/ui/${caller}/${fullyQualifiedId(object)}`,
+              anchorId: `dxos.org/ui/${caller}/${Obj.getDXN(object).toString()}`,
               props: object,
             },
           }),
@@ -555,7 +688,6 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
       resolve: async ({ object, target }) => {
         const space = isSpace(target) ? target : getSpace(target);
         invariant(space, 'Space not found.');
-
         const newObject = await cloneObject(object, resolve, space);
         return {
           intents: [createIntent(SpaceAction.AddObject, { object: newObject, target })],
@@ -572,13 +704,18 @@ export default ({ context, observability, createInvitationUrl }: IntentResolverO
     createResolver({
       intent: CollectionAction.Create,
       resolve: async ({ name }) => ({
-        data: { object: Obj.make(DataType.Collection, { name, objects: [] }) },
+        data: { object: Obj.make(Collection.Collection, { name, objects: [] }) },
       }),
     }),
     createResolver({
       intent: CollectionAction.CreateQueryCollection,
       resolve: async ({ name, typename }) => ({
-        data: { object: Obj.make(DataType.QueryCollection, { name, query: { typename } }) },
+        data: {
+          object: Obj.make(Collection.QueryCollection, {
+            name,
+            query: Query.select(Filter.typename(typename)).ast,
+          }),
+        },
       }),
     }),
   ]);

package/src/capabilities/react-root.tsx

@@ -4,15 +4,17 @@
 
 import React from 'react';
 
-import { Capabilities, contributes, useCapability } from '@dxos/app-framework';
+import { Capabilities, contributes } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/react';
 
-import { SpaceCapabilities } from './capabilities';
 import { AwaitingObject } from '../components';
-import { SPACE_PLUGIN } from '../meta';
+import { meta } from '../meta';
+
+import { SpaceCapabilities } from './capabilities';
 
 export default () =>
   contributes(Capabilities.ReactRoot, {
-    id: SPACE_PLUGIN,
+    id: meta.id,
     root: () => {
       const state = useCapability(SpaceCapabilities.State);
       return state.awaiting ? <AwaitingObject id={state.awaiting} /> : null;