@dxos/plugin-space 0.8.4-main.422d1c7879 → 0.8.4-main.43cb759274

package/src/capabilities/app-graph-builder/extensions/shared.ts

@@ -6,20 +6,19 @@ import { type Atom } from '@effect-atom/atom-react';
 import * as Option from 'effect/Option';
 
 import { type Space, SpaceState, isSpace } from '@dxos/client/echo';
-import { Filter, Obj, type Type } from '@dxos/echo';
+import { type Operation } from '@dxos/compute';
+import { Annotation, Filter, Obj, Type } from '@dxos/echo';
 import { AtomObj, AtomQuery } from '@dxos/echo-atom';
-import { Migrations } from '@dxos/migrations';
-import { type Operation } from '@dxos/operation';
+import { MigrationVersionAnnotation, Migrations } from '@dxos/migrations';
 import { type Node } from '@dxos/plugin-graph';
 import { type TreeData } from '@dxos/react-ui-list';
+import type { EchoViewRefPath } from '@dxos/schema';
 import { ViewAnnotation, getTypenameFromQuery } from '@dxos/schema';
-import { type Label } from '@dxos/ui-types';
+import { type Label } from '@dxos/ui-types/translations';
 
 import { meta } from '#meta';
-import { SPACE_TYPE } from '#types';
 
 export {
-  type MetadataResolver,
   ACCEPT_ECHO_CLASS,
   CACHEABLE_PROPS,
   CAN_DROP_OBJECT,
@@ -57,14 +56,6 @@ export const META_NS: { ns: string } = { ns: meta.id };
 export const BLOCK_REORDER_ABOVE = (_source: TreeData, instruction: any) => instruction.type === 'reorder-above';
 export const CAN_DROP_SPACE = (source: TreeData) => Obj.isObject(source.item.data) || isSpace(source.item.data);
 
-//
-// Matchers
-//
-
-/** Match space nodes and return the Space object. */
-export const whenSpace = (node: Node.Node): Option.Option<Space> =>
-  node.type === SPACE_TYPE && isSpace(node.data) ? Option.some(node.data) : Option.none();
-
 //
 // Caches (space-specific, not moved to app-toolkit)
 //
@@ -104,8 +95,9 @@ export const checkPendingMigration = (space: Space) => {
   return (
     space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION ||
     (space.state.get() === SpaceState.SPACE_READY &&
-      !!Migrations.versionProperty &&
-      space.properties[Migrations.versionProperty] !== Migrations.targetVersion)
+      !!Migrations.targetVersion &&
+      Annotation.get(space.properties, MigrationVersionAnnotation).pipe(Option.getOrUndefined) !==
+        Migrations.targetVersion)
   );
 };
 
@@ -134,6 +126,8 @@ export type ViewIndex = {
   typenamesWithViews: Set<string>;
   /** View objects targeting a specific typename. */
   getViewsForTypename: (typename: string) => Obj.Any[];
+  /** True when the schema has `ViewAnnotation` and that path resolves non-null on `object`; false otherwise (no annotation, or null/undefined path — e.g. Kanban with unset `view`). */
+  isView: (object: Obj.Any) => boolean;
 };
 
 /**
@@ -143,18 +137,45 @@ export type ViewIndex = {
  */
 // TODO(wittjosiah): Make reactive to schema registry changes (currently only object/view mutations trigger updates).
 export const buildViewIndex = (get: Atom.Context, space: Space, schemas: Type.AnyEntity[]): ViewIndex => {
-  const viewSchemas = schemas.filter((schema) => ViewAnnotation.get(schema).pipe(Option.getOrElse(() => false)));
+  const viewSchemas = schemas.filter((schema) => ViewAnnotation.has(schema));
 
   const viewsByTypename = new Map<string, Obj.Any[]>();
+  // Object IDs whose `ViewAnnotation` path resolves to a non-null value.
+  // Used by `isView` to distinguish view instances from regular instances of
+  // the same schema (e.g. items-variant Kanban vs view-variant Kanban).
+  const viewObjectIds = new Set<string>();
 
   if (viewSchemas.length > 0) {
     const filter = Filter.or(...viewSchemas.map((schema) => Filter.type(schema)));
     const viewObjects = get(AtomQuery.make(space.db, filter));
 
     for (const viewObject of viewObjects) {
+      if (!Obj.isObject(viewObject)) {
+        continue;
+      }
+      const holderType = Obj.getType(viewObject);
+      const path = holderType
+        ? ViewAnnotation.get(Type.getSchema(holderType)).pipe(Option.getOrElse(() => [] as EchoViewRefPath))
+        : ([] as EchoViewRefPath);
+
+      if (path.length === 0) {
+        continue;
+      }
+
       const viewSnapshot = get(AtomObj.make(viewObject));
-      const viewRef = viewSnapshot.view;
-      const viewTarget = viewRef ? get(AtomObj.make(viewRef)) : undefined;
+      let holder: unknown = viewSnapshot;
+      for (const segment of path) {
+        holder =
+          holder == null || typeof holder !== 'object' ? undefined : (holder as Record<string, unknown>)[segment];
+      }
+      // Path resolved to a non-null value → this instance is a "view". Path
+      // resolved to null/undefined → it's a regular object that happens to
+      // be of a view-annotated schema.
+      if (holder != null) {
+        viewObjectIds.add(viewObject.id);
+      }
+
+      const viewTarget = holder !== undefined ? get(AtomObj.make(holder as Obj.Any)) : undefined;
       const typename = getTypenameFromQuery(viewTarget?.query?.ast);
       if (typename) {
         const existing = viewsByTypename.get(typename) ?? [];
@@ -167,5 +188,6 @@ export const buildViewIndex = (get: Atom.Context, space: Space, schemas: Type.An
   return {
     typenamesWithViews: new Set(viewsByTypename.keys()),
     getViewsForTypename: (typename) => viewsByTypename.get(typename) ?? [],
+    isView: (object) => viewObjectIds.has(object.id),
   };
 };

package/src/capabilities/app-graph-builder/extensions/spaces.ts

@@ -5,14 +5,22 @@
 import * as Effect from 'effect/Effect';
 
 import { Capability } from '@dxos/app-framework';
-import { AppCapabilities, getActiveSpace, getPersonalSpace, isPersonalSpace } from '@dxos/app-toolkit';
+import {
+  AppCapabilities,
+  AppNodeMatcher,
+  getActiveSpace,
+  getPersonalSpace,
+  isExemplarSpace,
+  isPersonalSpace,
+} from '@dxos/app-toolkit';
 import { type Space, SpaceState } from '@dxos/client/echo';
+import { Operation } from '@dxos/compute';
 import { Filter, Obj } from '@dxos/echo';
 import { AtomObj, AtomQuery } from '@dxos/echo-atom';
 import { Migrations } from '@dxos/migrations';
-import { Operation } from '@dxos/operation';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { ClientCapabilities } from '@dxos/plugin-client';
 import { CreateAtom, Graph, GraphBuilder, Node, NodeMatcher } from '@dxos/plugin-graph';
+import { SpaceArchive } from '@dxos/protocols/proto/dxos/client/services';
 import { Expando } from '@dxos/schema';
 
 import { meta } from '#meta';
@@ -26,11 +34,9 @@ import {
   CREATE_OBJECT_IN_SPACE_LABEL,
   MIGRATE_SPACE_LABEL,
   RENAME_SPACE_LABEL,
-  SETTINGS_PANEL_LABEL,
   checkPendingMigration,
   spaceActionsCache,
   spaceRearrangeCache,
-  whenSpace,
 } from './shared';
 
 //
@@ -43,8 +49,8 @@ export const createSpaceExtensions = Effect.fnUntraced(function* () {
 
   return yield* Effect.all([
     GraphBuilder.createExtension({
-      id: 'primary-actions',
-      position: 'hoist',
+      id: 'primaryActions',
+      position: 'first',
       match: NodeMatcher.whenRoot,
       actions: () =>
         Effect.succeed([
@@ -68,6 +74,45 @@ export const createSpaceExtensions = Effect.fnUntraced(function* () {
               disposition: 'menu',
             },
           }),
+          Node.makeAction({
+            id: SpaceOperation.OpenImportSpace.meta.key,
+            data: () => Operation.invoke(SpaceOperation.OpenImportSpace),
+            properties: {
+              label: ['import-space.label', { ns: meta.id }],
+              icon: 'ph--upload--regular',
+              testId: 'spacePlugin.importSpace',
+            },
+          }),
+          Node.makeAction({
+            id: `${SpaceOperation.ExportSpace.meta.key}.binary`,
+            data: Effect.fnUntraced(function* () {
+              const client = yield* Capability.get(ClientCapabilities.Client);
+              const space = getActiveSpace(client, capabilities) ?? getPersonalSpace(client);
+              if (space) {
+                yield* Operation.invoke(SpaceOperation.ExportSpace, { space, format: SpaceArchive.Format.BINARY });
+              }
+            }),
+            properties: {
+              label: ['export-space-binary.label', { ns: meta.id }],
+              icon: 'ph--download--regular',
+              testId: 'spacePlugin.exportSpaceBinary',
+            },
+          }),
+          Node.makeAction({
+            id: `${SpaceOperation.ExportSpace.meta.key}.json`,
+            data: Effect.fnUntraced(function* () {
+              const client = yield* Capability.get(ClientCapabilities.Client);
+              const space = getActiveSpace(client, capabilities) ?? getPersonalSpace(client);
+              if (space) {
+                yield* Operation.invoke(SpaceOperation.ExportSpace, { space, format: SpaceArchive.Format.JSON });
+              }
+            }),
+            properties: {
+              label: ['export-space-json.label', { ns: meta.id }],
+              icon: 'ph--download--regular',
+              testId: 'spacePlugin.exportSpaceJson',
+            },
+          }),
           Node.makeAction({
             id: SpaceOperation.OpenMembers.meta.key,
             data: Effect.fnUntraced(function* () {
@@ -153,7 +198,7 @@ export const createSpaceExtensions = Effect.fnUntraced(function* () {
               ...spaces.filter((space) => !orderMap.has(space.id)),
             ]
               .filter((space, idx) => (settings?.showHidden ? true : spaceStates[idx] !== SpaceState.SPACE_INACTIVE))
-              .filter((space) => space.tags.length === 0 || isPersonalSpace(space))
+              .filter((space) => space.tags.length === 0 || isPersonalSpace(space) || isExemplarSpace(space))
               .map((space) =>
                 constructSpaceNode({
                   space,
@@ -175,7 +220,7 @@ export const createSpaceExtensions = Effect.fnUntraced(function* () {
 
     GraphBuilder.createExtension({
       id: 'actions',
-      match: whenSpace,
+      match: AppNodeMatcher.whenSpace,
       actions: (space, get) => {
         const [client] = get(capabilities.atom(ClientCapabilities.Client));
         const ephemeralAtom = capabilities.get(SpaceCapabilities.EphemeralState);
@@ -185,6 +230,12 @@ export const createSpaceExtensions = Effect.fnUntraced(function* () {
           return Effect.succeed([]);
         }
 
+        // Recompute actions when a migration completes (state transition or versionProperty stamp).
+        get(CreateAtom.fromObservable(space.state));
+        if (space.state.get() === SpaceState.SPACE_READY) {
+          get(AtomObj.make(space.properties));
+        }
+
         return Effect.succeed(
           constructSpaceActions({
             space,
@@ -230,7 +281,7 @@ const constructSpaceNode = ({
           nextOrder.map(({ id }) => id),
         );
 
-        Obj.change(spacesOrder, (spacesOrder: any) => {
+        Obj.update(spacesOrder, (spacesOrder: any) => {
           spacesOrder.order = nextOrder.map(({ id }) => id);
         });
       };
@@ -258,19 +309,6 @@ const constructSpaceNode = ({
       onRearrange,
       canDrop: CAN_DROP_SPACE,
     },
-    nodes: [
-      Node.make({
-        id: 'settings',
-        type: `${meta.id}.settings`,
-        data: null,
-        properties: {
-          label: SETTINGS_PANEL_LABEL,
-          icon: 'ph--faders--regular',
-          disposition: 'alternate-tree',
-          space,
-        },
-      }),
-    ],
   });
 };
 

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

@@ -3,21 +3,21 @@
 //
 
 import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
-import { AppCapabilities } from '@dxos/app-toolkit';
+import { AppCapabilities, RootCollectionAnnotation } from '@dxos/app-toolkit';
 import { isSpace } from '@dxos/client/echo';
-import { Obj } from '@dxos/echo';
-import { Collection } from '@dxos/echo';
+import { Annotation, Collection, Obj, Type } from '@dxos/echo';
 
 import { meta } from '#meta';
 import { SpaceOperation } from '#operations';
+import { translations } from '#translations';
 import { SPACE_TYPE } from '#types';
 
-import { translations } from '../translations';
 import { SPACES } from '../util';
 
-const COLLECTION_TYPE = Collection.Collection.typename;
+const COLLECTION_TYPE = Type.getTypename(Collection.Collection);
 
 // https://stackoverflow.com/a/19016910
 const DIRECTORY_TYPE = 'text/directory';
@@ -66,7 +66,7 @@ export default Capability.makeModule(
           const space = ancestors.find(isSpace);
           const collection =
             ancestors.findLast((ancestor) => Obj.instanceOf(Collection.Collection, ancestor)) ??
-            space?.properties[COLLECTION_TYPE]?.target;
+            (space && Annotation.get(space.properties, RootCollectionAnnotation).pipe(Option.getOrUndefined)?.target);
           if (!space || !collection) {
             return;
           }

package/src/capabilities/create-object.ts

@@ -0,0 +1,107 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Collection, Type } from '@dxos/echo';
+import { createDefaultSchema } from '@dxos/schema';
+import { Organization, Person, Project, Task } from '@dxos/types';
+
+import { SpaceOperation } from '#operations';
+import { SpaceCapabilities } from '#types';
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    return [
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Collection.Collection),
+        inputSchema: Schema.Struct({ name: Schema.optional(Schema.String) }),
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Collection.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: false,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Type.Type),
+        inputSchema: SpaceOperation.StoredSchemaForm,
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const result = yield* Operation.invoke(SpaceOperation.AddType, {
+              db: options.db,
+              name: props.name,
+              type: createDefaultSchema(),
+            });
+            return {
+              id: result.id,
+              subject: [],
+              object: result.object,
+            };
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Organization.Organization),
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Organization.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Person.Person),
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Person.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Project.Project),
+        inputSchema: Type.getSchema(Project.Project),
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Project.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+      Capability.contributes(SpaceCapabilities.CreateObjectEntry, {
+        id: Type.getTypename(Task.Task),
+        inputSchema: Type.getSchema(Task.Task),
+        createObject: (props, options) =>
+          Effect.gen(function* () {
+            const object = Task.make(props);
+            return yield* Operation.invoke(SpaceOperation.AddObject, {
+              object,
+              target: options.target,
+              hidden: true,
+              targetNodeId: options.targetNodeId,
+            });
+          }),
+      }),
+    ];
+  }),
+);

package/src/capabilities/identity-created.ts

@@ -5,11 +5,10 @@
 import * as Effect from 'effect/Effect';
 
 import { Capability } from '@dxos/app-framework';
-import { PERSONAL_SPACE_TAG } from '@dxos/app-toolkit';
-import { Obj, Ref } from '@dxos/echo';
-import { Collection } from '@dxos/echo';
-import { Migrations } from '@dxos/migrations';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
+import { PERSONAL_SPACE_TAG, RootCollectionAnnotation } from '@dxos/app-toolkit';
+import { Annotation, Collection, Obj, Ref } from '@dxos/echo';
+import { MigrationVersionAnnotation, Migrations } from '@dxos/migrations';
+import { ClientCapabilities } from '@dxos/plugin-client';
 import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
 import { MembershipPolicy } from '@dxos/protocols/proto/dxos/halo/credentials';
 
@@ -24,10 +23,10 @@ export default Capability.makeModule(
 
     // Create root collection structure.
     yield* Effect.tryPromise(() => personalSpace.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED));
-    Obj.change(personalSpace.properties, (properties) => {
-      properties[Collection.Collection.typename] = Ref.make(Collection.make());
-      if (Migrations.versionProperty) {
-        properties[Migrations.versionProperty] = Migrations.targetVersion;
+    Obj.update(personalSpace.properties, (properties) => {
+      Annotation.set(properties, RootCollectionAnnotation, Ref.make(Collection.make()));
+      if (Migrations.targetVersion) {
+        Annotation.set(properties, MigrationVersionAnnotation, Migrations.targetVersion);
       }
     });
   }),

package/src/capabilities/index.ts

@@ -3,13 +3,13 @@
 //
 
 import { Capability } from '@dxos/app-framework';
-import { OperationHandlerSet } from '@dxos/operation';
+import { OperationHandlerSet } from '@dxos/compute';
 
 export * from './app-graph-builder';
 
 export const AppGraphSerializer = Capability.lazy('AppGraphSerializer', () => import('./app-graph-serializer'));
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
 export const IdentityCreated = Capability.lazy('IdentityCreated', () => import('./identity-created'));
-export const Migrations = Capability.lazy('SpaceMigrations', () => import('./migrations'));
 export { NavigationHandler } from './navigation-handler';
 export type { NavigationHandlerOptions } from './navigation-handler';
 export const NavigationResolver = Capability.lazy('NavigationResolver', () => import('./navigation-resolver'));

package/src/capabilities/navigation-handler/navigation-handler.ts

@@ -6,8 +6,8 @@ import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { AppCapabilities } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/compute';
 import { log } from '@dxos/log';
-import { Operation } from '@dxos/operation';
 
 import { SpaceOperation } from '../../operations';
 

package/src/capabilities/navigation-resolver.ts

@@ -14,9 +14,8 @@ import {
   type AppCapabilities as AppCaps,
 } from '@dxos/app-toolkit';
 import { Database, Entity, Key } from '@dxos/echo';
-import { DXN } from '@dxos/keys';
-import { ClientCapabilities } from '@dxos/plugin-client/types';
-import { SETTINGS_ID, SETTINGS_KEY } from '@dxos/plugin-settings/types';
+import { EID } from '@dxos/keys';
+import { SETTINGS_ID, SETTINGS_KEY } from '@dxos/plugin-settings';
 
 import { meta } from '#meta';
 
@@ -35,7 +34,7 @@ export default Capability.makeModule(
           ];
         }
 
-        const dxn = DXN.tryParse(query.dxn.startsWith('@dxn:') ? query.dxn.slice(1) : query.dxn);
+        const dxn = EID.tryParse(query.dxn.startsWith('@dxn:') ? query.dxn.slice(1) : query.dxn);
         if (!dxn) {
           return [];
         }
@@ -61,29 +60,18 @@ export default Capability.makeModule(
         ];
       })) as AppCaps.NavigationTargetResolver;
 
-    // Resolve object paths to DXNs.
+    // Parse object paths into EIDs (structure only; existence is checked by the caller).
     // Handles canonical type paths (root/<spaceId>/types/<typename>/all/<objectId>)
-    // and collection paths (root/<spaceId>/collections/<collectionId>/<objectId>).
-    // Validates that the object actually exists in the space before returning a DXN.
-    const client = yield* Capability.get(ClientCapabilities.Client);
+    // and collection paths (root/<spaceId>/collections/<collectionId>/<objectId>): the space id
+    // is the first segment and the object id the last.
     const pathResolver: AppCaps.NavigationPathResolver = (qualifiedPath) => {
       const segments = qualifiedPath.split('/');
       const spaceId = getSpaceIdFromPath(qualifiedPath);
       const objectId = segments[segments.length - 1];
-      if (!spaceId || !objectId || !Key.ObjectId.isValid(objectId)) {
+      if (!spaceId || !objectId || !Key.EntityId.isValid(objectId)) {
         return Effect.succeed(Option.none());
       }
-
-      const space = client.spaces.get(spaceId);
-      if (!space) {
-        return Effect.succeed(Option.none());
-      }
-
-      const dxn = DXN.fromSpaceAndObjectId(spaceId, objectId as Key.ObjectId);
-      const ref = space.db.makeRef(dxn);
-      return Database.loadOption(ref).pipe(
-        Effect.map((option) => (Option.isSome(option) ? Option.some(dxn) : Option.none<DXN>())),
-      );
+      return Effect.succeed(Option.some(EID.make({ spaceId, entityId: objectId as Key.EntityId })));
     };
 
     return [

package/src/capabilities/node.ts

@@ -3,8 +3,9 @@
 //
 
 import { Capability } from '@dxos/app-framework';
-import { OperationHandlerSet } from '@dxos/operation';
+import { OperationHandlerSet } from '@dxos/compute';
 
+export const CreateObject = Capability.lazy('CreateObject', () => import('./create-object'));
 export const IdentityCreated = Capability.lazy('IdentityCreated', () => import('./identity-created'));
 export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
   'OperationHandler',

package/src/capabilities/operation-handler.ts

@@ -3,7 +3,7 @@
 import * as Effect from 'effect/Effect';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
-import type { OperationHandlerSet } from '@dxos/operation';
+import type { OperationHandlerSet } from '@dxos/compute';
 
 import { SpaceOperationHandlerSet } from '#operations';