@dxos/plugin-space 0.9.0 → 0.9.1-staging.ee54ba693a

package/src/containers/TypeCollectionArticle/TypeCollectionArticle.stories.tsx

@@ -0,0 +1,116 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import React from 'react';
+
+import { Capability } from '@dxos/app-framework';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { AppAnnotation, AppCapabilities } from '@dxos/app-toolkit';
+import { Annotation, DXN, Obj, Type } from '@dxos/echo';
+import { LabelAnnotation } from '@dxos/echo/Annotation';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
+import { PreviewPlugin } from '@dxos/plugin-preview/testing';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { useSpaces } from '@dxos/react-client/echo';
+import { Loading, withLayout } from '@dxos/react-ui/testing';
+
+import { translations } from '#translations';
+
+import { TypeCollectionArticle } from './TypeCollectionArticle';
+
+/**
+ * Type that opts in to a content preview card via `CardAnnotation`.
+ */
+class CardType extends Type.makeObject<CardType>(DXN.make('org.dxos.type.test.cardType', '0.1.0'))(
+  Schema.Struct({
+    name: Schema.optional(Schema.String),
+    description: Schema.optional(Schema.String),
+  }).pipe(
+    LabelAnnotation.set(['name']),
+    Annotation.IconAnnotation.set({ icon: 'ph--cards--regular', hue: 'emerald' }),
+    AppAnnotation.CardAnnotation.set(true),
+  ),
+) {}
+
+/**
+ * Type without the annotation; renders as a header-only tile.
+ */
+class PlainType extends Type.makeObject<PlainType>(DXN.make('org.dxos.type.test.plainType', '0.1.0'))(
+  Schema.Struct({
+    name: Schema.optional(Schema.String),
+    description: Schema.optional(Schema.String),
+  }).pipe(LabelAnnotation.set(['name']), Annotation.IconAnnotation.set({ icon: 'ph--circle--regular', hue: 'indigo' })),
+) {}
+
+const OBJECT_COUNT = 6;
+
+type StoryArgs = {
+  type: Type.AnyObj;
+};
+
+const DefaultStory = ({ type }: StoryArgs) => {
+  const spaces = useSpaces();
+  const space = spaces[spaces.length - 1];
+  if (!space) {
+    return <Loading />;
+  }
+
+  return <TypeCollectionArticle role='article' space={space} typeUri={Type.getURI(type)} attendableId='story' />;
+};
+
+const meta = {
+  title: 'plugins/plugin-space/containers/TypeCollectionArticle',
+  render: DefaultStory,
+  decorators: [
+    withLayout({ layout: 'fullscreen' }),
+    withPluginManager({
+      capabilities: [Capability.contributes(AppCapabilities.Translations, translations)],
+      plugins: [
+        ...corePlugins(),
+        StorybookPlugin({}),
+        PreviewPlugin(),
+        ClientPlugin({
+          types: [CardType, PlainType],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* Effect.promise(() => client.halo.createIdentity());
+              const space = yield* Effect.promise(() => client.spaces.create());
+              yield* Effect.promise(() => space.waitUntilReady());
+
+              for (let i = 0; i < OBJECT_COUNT; i++) {
+                space.db.add(
+                  Obj.make(CardType, { name: `Card ${i + 1}`, description: `Preview body for card ${i + 1}.` }),
+                );
+                space.db.add(Obj.make(PlainType, { name: `Plain ${i + 1}`, description: `Plain object ${i + 1}.` }));
+              }
+            }),
+        }),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+  },
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+/** Collection of objects without the annotation — header-only tiles. */
+export const Default: Story = {
+  args: {
+    type: PlainType,
+  },
+};
+
+/** Collection of objects whose type carries `CardAnnotation` — tiles render a preview body. */
+export const WithCardContent: Story = {
+  args: {
+    type: CardType,
+  },
+};

package/src/containers/TypeCollectionArticle/TypeCollectionArticle.tsx

@@ -0,0 +1,162 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Option from 'effect/Option';
+import React, { useCallback, useMemo } from 'react';
+
+import { Surface, useOperationInvoker } from '@dxos/app-framework/ui';
+import { AppAnnotation, LayoutOperation, Paths } from '@dxos/app-toolkit';
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { Filter, Obj, Type } from '@dxos/echo';
+import { type URI } from '@dxos/keys';
+import { type Space, useObject, useQuery } from '@dxos/react-client/echo';
+import { Card, Focus, Icon, Panel, useTranslation } from '@dxos/react-ui';
+import { useSelection } from '@dxos/react-ui-attention';
+import { Empty } from '@dxos/react-ui-list';
+import { Masonry } from '@dxos/react-ui-masonry';
+import { getStyles } from '@dxos/ui-theme';
+
+import { meta } from '#meta';
+
+export type TypeCollectionArticleProps = {
+  role?: string;
+  space: Space;
+  typeUri: URI.URI;
+  attendableId: string;
+};
+
+/**
+ * List view rendered when a type node is selected: a masonry grid of header-only cards, one per object
+ * of the type. Selecting a card navigates to that object, opening it as a sibling plank. Objects are not
+ * enumerated in the nav tree; each navigated object becomes a hidden child of the type node resolved on demand.
+ */
+export const TypeCollectionArticle = ({ role, space, typeUri, attendableId }: TypeCollectionArticleProps) => {
+  const { t } = useTranslation(meta.profile.key);
+  const { invokePromise } = useOperationInvoker();
+  const currentId = useSelection(attendableId, 'single');
+
+  const objects = useQuery(space.db, Filter.type(typeUri));
+
+  const handleOpen = useCallback(
+    (object: Obj.Unknown) => {
+      const id = Obj.getURI(object);
+      void invokePromise(LayoutOperation.Select, { contextId: attendableId, subject: { mode: 'single', id } });
+      void invokePromise(LayoutOperation.Open, {
+        subject: [Paths.getObjectPathFromObject(object)],
+        pivotId: attendableId,
+        navigation: 'immediate',
+      });
+    },
+    [attendableId, invokePromise],
+  );
+
+  const handleDelete = useCallback((object: Obj.Unknown) => {
+    Obj.getDatabase(object)?.remove(object);
+  }, []);
+
+  const tileItems = useMemo<TileData[]>(
+    () =>
+      objects.map((object) => ({
+        object,
+        current: Obj.getURI(object) === currentId,
+        onOpen: handleOpen,
+        onDelete: Obj.getParent(object) ? undefined : handleDelete,
+      })),
+    [objects, currentId, handleOpen, handleDelete],
+  );
+
+  return (
+    <Panel.Root role={role}>
+      <Panel.Toolbar />
+      <Panel.Content>
+        {objects.length === 0 ? (
+          <Empty classNames='bs-full' label={t('type-collection-empty.message')} />
+        ) : (
+          <Masonry.Root Tile={TileAdapter}>
+            <Masonry.Content classNames='p-trim-md'>
+              <Masonry.Viewport getId={(data) => Obj.getURI(data.object)} items={tileItems} />
+            </Masonry.Content>
+          </Masonry.Root>
+        )}
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+type TileData = {
+  object: Obj.Unknown;
+  current: boolean;
+  onOpen: (object: Obj.Unknown) => void;
+  onDelete?: (object: Obj.Unknown) => void;
+};
+
+const TileAdapter = ({ data }: { data: TileData | undefined; index: number }) => {
+  if (!data?.object) {
+    return null;
+  }
+
+  return (
+    <TypeCollectionTile object={data.object} current={data.current} onOpen={data.onOpen} onDelete={data.onDelete} />
+  );
+};
+
+type TypeCollectionTileProps = TileData;
+
+/** Selectable header-only card for a single object. */
+const TypeCollectionTile = ({ object, current, onOpen, onDelete }: TypeCollectionTileProps) => {
+  const { t } = useTranslation(meta.profile.key);
+  // Subscribe so the label re-renders when the object changes.
+  const [live] = useObject(object);
+  // Mirror the app-graph label: the object's own label, else the type-scoped placeholder
+  // (e.g. "New video" lives in the type's namespace, not the space plugin's).
+  const typename = Obj.getTypename(live);
+  const label =
+    Obj.getLabel(live) ||
+    t('object-name.placeholder', { ns: typename ?? meta.profile.key, defaultValue: t('object-name.placeholder') });
+
+  const iconAnnotation = Obj.getIcon(live);
+  const icon = iconAnnotation?.icon ?? 'ph--circle-dashed--regular';
+  const iconStyles = iconAnnotation?.hue ? getStyles(iconAnnotation.hue) : undefined;
+
+  // Render a content preview body only for types that opt in via `CardAnnotation`.
+  const type = Obj.getType(object);
+  const showCardContent =
+    !!type && Option.getOrElse(AppAnnotation.CardAnnotation.get(Type.getSchema(type)), () => false);
+  const cardData = useMemo<AppSurface.ObjectCardData>(() => ({ subject: object }), [object]);
+
+  // `Focus.Item` calls `onCurrentChange` on click and on Enter.
+  const handleCurrentChange = useCallback(() => onOpen(object), [onOpen, object]);
+
+  const menuItems = useMemo(
+    () => [
+      ...(onDelete
+        ? [
+            {
+              label: t('delete-object.label', {
+                ns: typename ?? meta.profile.key,
+                defaultValue: t('delete-object.label'),
+              }),
+              onClick: () => onDelete?.(object),
+            },
+          ]
+        : []),
+    ],
+    [t, typename, onDelete, object],
+  );
+
+  return (
+    <Focus.Item asChild current={current} onCurrentChange={handleCurrentChange}>
+      <Card.Root fullWidth classNames={['dx-hover cursor-pointer', current && 'dx-current']}>
+        <Card.Header>
+          <Card.Block>
+            <Icon icon={icon} classNames={iconStyles?.text} />
+          </Card.Block>
+          <Card.Title>{label}</Card.Title>
+          {menuItems.length > 0 && <Card.Menu items={menuItems} />}
+        </Card.Header>
+        {showCardContent && <Surface.Surface type={AppSurface.CardContent} data={cardData} limit={1} />}
+      </Card.Root>
+    </Focus.Item>
+  );
+};

package/src/containers/TypeCollectionArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { TypeCollectionArticle as default } from './TypeCollectionArticle';

package/src/containers/index.ts

@@ -5,25 +5,29 @@
 import { type ComponentType, lazy } from 'react';
 
 export type { CreateObjectDialogProps } from './CreateObjectDialog';
+export type { RenameSubject } from './RenamePopover';
 
 export const CollectionArticle: ComponentType<any> = lazy(() => import('./CollectionArticle'));
 export const CollectionSection: ComponentType<any> = lazy(() => import('./CollectionSection'));
 export const CreateObjectDialog: ComponentType<any> = lazy(() => import('./CreateObjectDialog'));
 export const CreateSpaceDialog: ComponentType<any> = lazy(() => import('./CreateSpaceDialog'));
+export const DefaultProperties: ComponentType<any> = lazy(() => import('./DefaultProperties'));
 export const ImportSpaceDialog: ComponentType<any> = lazy(() => import('./ImportSpaceDialog'));
 export const InlineSyncStatus: ComponentType<any> = lazy(() => import('./InlineSyncStatus'));
 export const JoinDialog: ComponentType<any> = lazy(() => import('./JoinDialog'));
 export const MembersContainer: ComponentType<any> = lazy(() => import('./MembersContainer'));
 export const MenuFooter: ComponentType<any> = lazy(() => import('./MenuFooter'));
 export const ObjectCardStack: ComponentType<any> = lazy(() => import('./ObjectCardStack'));
-export const ObjectProperties: ComponentType<any> = lazy(() => import('./ObjectProperties'));
-export const EntityRenamePopover: ComponentType<any> = lazy(() => import('./EntityRenamePopover'));
 export const RecordArticle: ComponentType<any> = lazy(() => import('./RecordArticle'));
 export const RelatedArticle: ComponentType<any> = lazy(() => import('./RelatedArticle'));
+export const RenamePopover: ComponentType<any> = lazy(() => import('./RenamePopover'));
 export const SchemaContainer: ComponentType<any> = lazy(() => import('./SchemaContainer'));
 export const SmallPresenceLive: ComponentType<any> = lazy(() => import('./SmallPresenceLive'));
 export const SpacePresence: ComponentType<any> = lazy(() => import('./SpacePresence'));
-export const SpaceRenamePopover: ComponentType<any> = lazy(() => import('./SpaceRenamePopover'));
+export const SpaceHomeArticle: ComponentType<any> = lazy(() => import('./SpaceHomeArticle'));
+export const SpaceHomeRecent: ComponentType<any> = lazy(() => import('./SpaceHomeRecent'));
+export const SpaceSettings: ComponentType<any> = lazy(() => import('./SpaceSettings'));
 export const SpaceSettingsContainer: ComponentType<any> = lazy(() => import('./SpaceSettingsContainer'));
 export const SyncStatus: ComponentType<any> = lazy(() => import('./SyncStatus'));
+export const TypeCollectionArticle: ComponentType<any> = lazy(() => import('./TypeCollectionArticle'));
 export const ViewEditor: ComponentType<any> = lazy(() => import('./ViewEditor'));

package/src/errors.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { BaseError } from '@dxos/errors';
+
+/** Space invitations authenticate against a local HALO identity; there is nothing to redeem without one. */
+export class NoIdentityError extends BaseError.extend(
+  'NoIdentityError',
+  'A local identity is required to accept a space invitation.',
+) {}

package/src/hooks/useInputSurfaceLookup.tsx

@@ -5,6 +5,7 @@
 import React, { useCallback } from 'react';
 
 import { Surface, usePluginManager } from '@dxos/app-framework/ui';
+import { AppSurface } from '@dxos/app-toolkit/ui';
 import { type FormFieldProvider } from '@dxos/react-ui-form';
 
 /**
@@ -25,8 +26,8 @@ export const useInputSurfaceLookup = (baseData?: Record<string, any>): FormField
         ...baseData,
       };
       const { type: _fieldPropertyAstExcluded, ...surfaceFieldProps } = fieldProps as Record<string, any>;
-      if (Surface.isAvailable(pluginManager.capabilities, { role: 'form-input', data })) {
-        return <Surface.Surface role='form-input' data={data} {...surfaceFieldProps} />;
+      if (Surface.isAvailable(pluginManager.capabilities, { type: AppSurface.FormInput, data })) {
+        return <Surface.Surface type={AppSurface.FormInput} data={data} {...surfaceFieldProps} />;
       }
     },
     [pluginManager, baseData],

package/src/hooks/useRelatedObjects.ts

@@ -2,9 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
+import * as Option from 'effect/Option';
 import { useMemo } from 'react';
 
-import { type Database, Entity, Filter, Obj, Ref, Relation } from '@dxos/echo';
+import { type Database, Entity, Filter, Obj, Ref, Relation, Type } from '@dxos/echo';
+import { HiddenAnnotation } from '@dxos/echo/Annotation';
 import { useQuery } from '@dxos/react-client/echo';
 import { isNonNullable } from '@dxos/util';
 
@@ -74,6 +76,16 @@ export const useRelatedObjects = (
         // TODO(burdon): Configure.
         .filter((obj) => Entity.getTypename(obj) !== 'org.dxos.type.text')
         .filter((obj) => Entity.getTypename(obj) !== 'org.dxos.type.assistant.chat')
+        .filter((obj) => {
+          if (!Obj.isObject(obj)) {
+            return true;
+          }
+          const typeEntity = Obj.getType(obj);
+          if (!typeEntity) {
+            return true;
+          }
+          return !HiddenAnnotation.get(Type.getSchema(typeEntity)).pipe(Option.getOrElse(() => false));
+        })
     );
   }, [subject, objects, options.references, options.relations]);
 };

package/src/index.ts

@@ -2,6 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
+export * from './errors';
 export * from './meta';
 export * from './types';
 export * from './util';

package/src/meta.ts

@@ -3,32 +3,7 @@
 //
 
 import { Plugin } from '@dxos/app-framework';
-import { DXN } from '@dxos/keys';
-import { trim } from '@dxos/util';
 
-export const meta = Plugin.makeMeta({
-  key: DXN.make('org.dxos.plugin.space'),
-  name: 'Spaces',
-  author: 'DXOS',
-  spec: 'PLUGIN.mdl',
-  description: trim`
-    SpacePlugin is the core workspace container for DXOS Composer. It owns the full lifecycle of
-    collaborative spaces — creating, joining, opening, closing, and resetting them — and manages
-    the membership and invitation system that controls who can access each space.
+import config from '../dx.config';
 
-    The plugin maintains an ordered app-graph of every space and its collections, wires navigation
-    so that opening a space or object updates the layout, and tracks real-time peer presence so
-    that the UI can show which collaborators are viewing each object.
-
-    Object and schema management sit at the heart of SpacePlugin: it registers the canonical DXOS
-    schema types (Person, Task, Project, Event, …), provides the create-object dialog that all
-    other plugins populate with their own types, and exposes operations for adding, removing,
-    restoring, duplicating, and serialising objects. Import/export of space archives and schema
-    migrations are also handled here.
-
-    A full set of undo-aware operations (RemoveObjects/RestoreObjects, DeleteField/RestoreField)
-    integrates with the process manager so that destructive edits can be reversed in one step.
-  `,
-  icon: 'ph--planet--regular',
-  tags: ['system'],
-});
+export const meta = Plugin.getMetaFromConfig(config);

package/src/operations/add-object.ts

@@ -3,16 +3,9 @@
 import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 
-import {
-  CollectionModel,
-  getCollectionsPath,
-  getObjectPath,
-  getTypePath,
-  getTypeSlug,
-  getTypeSlugFromUri,
-} from '@dxos/app-toolkit';
+import { AppNode, CollectionModel, Paths } from '@dxos/app-toolkit';
 import { Operation } from '@dxos/compute';
-import { Collection, Database, Filter, Obj, Query, Scope, Type } from '@dxos/echo';
+import { Database, Filter, Obj, Query, Scope, Type } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 import { ObservabilityOperation } from '@dxos/plugin-observability';
 import { ViewAnnotation, getTypeURIFromQuery } from '@dxos/schema';
@@ -30,7 +23,6 @@ const handler: Operation.WithHandler<typeof SpaceOperation.AddObject> = SpaceOpe
       yield* CollectionModel.add({
         object,
         target: Database.isDatabase(target) ? undefined : target,
-        hidden: input.hidden,
       }).pipe(Effect.provide(Database.layer(db)));
 
       const typename = Obj.getTypename(object)!;
@@ -62,14 +54,15 @@ const handler: Operation.WithHandler<typeof SpaceOperation.AddObject> = SpaceOpe
       // Graph type nodes are keyed by a slash-free slug (entity id for stored types, typename for
       // static); resolve the object's own type slug rather than filing it under its (human) typename.
       const objectType = Obj.getType(object);
-      const typeSlug = objectType ? getTypeSlug(objectType) : typename;
+      const typeSlug = objectType ? Paths.getTypeSlug(objectType) : typename;
       const subject = getSubjectPathForNewObject({
         spaceId: db.spaceId,
         objectId: object.id,
         nodeId: input.targetNodeId,
+        object,
         typename,
         typeSlug,
-        viewTargetSlug: viewTargetUri ? getTypeSlugFromUri(viewTargetUri) : undefined,
+        viewTargetSlug: viewTargetUri ? Paths.getTypeSlugFromUri(viewTargetUri) : undefined,
       });
 
       return {
@@ -86,21 +79,22 @@ const getSubjectPathForNewObject = (props: {
   spaceId: string;
   objectId: string;
   nodeId?: string;
+  object: Obj.Unknown;
   typename: string;
   /** Slug of the object's own type ({@link getTypeSlug}) — keys the `types/<slug>` node it files under. */
   typeSlug: string;
   /** Slug of the view holder's target type, when the object is a view holder. */
   viewTargetSlug?: string;
 }): string => {
-  const { nodeId, typename, typeSlug, viewTargetSlug, spaceId, objectId } = props;
+  const { nodeId, object, typeSlug, viewTargetSlug, spaceId, objectId } = props;
   if (typeof nodeId === 'string') {
-    return `${nodeId}/${objectId}`;
+    return Paths.getCollectionObjectPath(nodeId, objectId);
   }
-  if (typename === Type.getTypename(Collection.Collection)) {
-    return getCollectionsPath(spaceId, objectId);
+  if (AppNode.isCollectionItem(object)) {
+    return Paths.getCollectionsPath(spaceId, objectId);
   }
   if (viewTargetSlug) {
-    return getTypePath(spaceId, viewTargetSlug, objectId);
+    return Paths.getTypePath(spaceId, viewTargetSlug, objectId);
   }
-  return getObjectPath(spaceId, typeSlug, objectId);
+  return Paths.getObjectPath(spaceId, typeSlug, objectId);
 };

package/src/operations/add-type.ts

@@ -7,7 +7,7 @@ import { Operation } from '@dxos/compute';
 import { Type } from '@dxos/echo';
 import { ObservabilityOperation } from '@dxos/plugin-observability';
 
-import { SpaceEvents, SpaceCapabilities } from '../types';
+import { SpaceCapabilities, SpaceEvents } from '../types';
 import { SpaceOperation } from './definitions';
 
 const handler: Operation.WithHandler<typeof SpaceOperation.AddType> = SpaceOperation.AddType.pipe(

package/src/operations/create.ts

@@ -3,17 +3,17 @@
 import * as Effect from 'effect/Effect';
 
 import { Capability, Plugin } from '@dxos/app-framework';
-import { RootCollectionAnnotation } from '@dxos/app-toolkit';
+import { AppAnnotation } from '@dxos/app-toolkit';
 import { Operation } from '@dxos/compute';
 import { Annotation, Collection, Obj, Ref } from '@dxos/echo';
-import { MigrationVersionAnnotation, Migrations } from '@dxos/migrations';
+import { Migrations, MigrationVersionAnnotation } from '@dxos/migrations';
 import { ClientCapabilities } from '@dxos/plugin-client';
 import { ObservabilityOperation } from '@dxos/plugin-observability';
 import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
 import { iconValues } from '@dxos/react-ui-pickers/icons';
 import { hues } from '@dxos/ui-theme';
 
-import { SpaceEvents, SpaceCapabilities } from '../types';
+import { SpaceCapabilities, SpaceEvents } from '../types';
 import { SpaceOperation } from './definitions';
 import { SpaceOperationConfig } from './helpers';
 
@@ -37,7 +37,7 @@ const handler: Operation.WithHandler<typeof SpaceOperation.Create> = SpaceOperat
 
       const collection = Obj.make(Collection.Collection, { objects: [] });
       Obj.update(space.properties, (properties) => {
-        Annotation.set(properties, RootCollectionAnnotation, Ref.make(collection));
+        Annotation.set(properties, AppAnnotation.RootCollectionAnnotation, Ref.make(collection));
         if (Migrations.targetVersion) {
           Annotation.set(properties, MigrationVersionAnnotation, Migrations.targetVersion);
         }

package/src/operations/definitions.ts

@@ -8,7 +8,7 @@ import { Capability, Plugin } from '@dxos/app-framework';
 import { SpaceSchema } from '@dxos/client/echo';
 import { CancellableInvitationObservable, Invitation } from '@dxos/client/invitations';
 import { Operation } from '@dxos/compute';
-import { Collection, Database, Entity, Obj, QueryAST, Type, View, DXN } from '@dxos/echo';
+import { Collection, Database, DXN, Entity, Obj, QueryAST, Type, View } from '@dxos/echo';
 import { SpaceArchive } from '@dxos/protocols/proto/dxos/client/services';
 
 import { meta } from '#meta';
@@ -30,7 +30,7 @@ export namespace CollectionOperation {
   });
 }
 
-const makeKey = (name: string) => DXN.make(`${meta.id}.operation.${name}`);
+const makeKey = (name: string) => DXN.make(`${meta.profile.key}.operation.${name}`);
 
 /**
  * Operations for the Space plugin.
@@ -168,7 +168,6 @@ export namespace SpaceOperation {
       target: Schema.Union(Database.Database, Type.getSchema(Collection.Collection)).annotations({
         description: 'The database or collection to add to.',
       }),
-      hidden: Schema.optional(Schema.Boolean),
       targetNodeId: Schema.optional(
         Schema.String.annotations({ description: 'Qualified graph node ID of the target collection.' }),
       ),

package/src/operations/helpers.ts

@@ -7,4 +7,4 @@ export type SpaceOperationConfig = {
   observability: boolean;
 };
 
-export const SpaceOperationConfig = Capability.make<SpaceOperationConfig>('org.dxos.plugin.space.operation-config');
+export const SpaceOperationConfig = Capability.make<SpaceOperationConfig>('org.dxos.plugin.space.operationConfig');

package/src/operations/join.ts

@@ -2,16 +2,35 @@
 
 import * as Effect from 'effect/Effect';
 
+import { Capability } from '@dxos/app-framework';
 import { LayoutOperation } from '@dxos/app-toolkit';
 import { Operation } from '@dxos/compute';
+import { ClientCapabilities } from '@dxos/plugin-client';
+
+import { meta } from '#meta';
 
 import { JOIN_DIALOG } from '../constants';
 import { type JoinDialogProps } from '../containers/JoinDialog';
+import { NoIdentityError } from '../errors';
 import { SpaceOperation } from './definitions';
 
 const handler: Operation.WithHandler<typeof SpaceOperation.Join> = SpaceOperation.Join.pipe(
   Operation.withHandler(
     Effect.fnUntraced(function* (input) {
+      const client = yield* Capability.get(ClientCapabilities.Client);
+      if (!client.halo.identity.get()) {
+        // Space invitations authenticate against a local identity; there is nothing to redeem without one.
+        yield* Effect.ignore(
+          Operation.invoke(LayoutOperation.AddToast, {
+            id: `${meta.profile.key}.join-no-identity`,
+            icon: 'ph--warning--regular',
+            title: ['join-no-identity-toast.title', { ns: meta.profile.key }],
+            closeLabel: ['dismiss.label', { ns: meta.profile.key }],
+          }),
+        );
+        return yield* Effect.fail(new NoIdentityError());
+      }
+
       yield* Operation.invoke(LayoutOperation.UpdateDialog, {
         subject: JOIN_DIALOG,
         blockAlign: 'start',

package/src/operations/migrate.ts

@@ -7,7 +7,7 @@ import { Capabilities } from '@dxos/app-framework';
 import { SpaceState } from '@dxos/client/echo';
 import { Operation } from '@dxos/compute';
 import { Annotation } from '@dxos/echo';
-import { MigrationVersionAnnotation, Migrations } from '@dxos/migrations';
+import { Migrations, MigrationVersionAnnotation } from '@dxos/migrations';
 import { ObservabilityOperation } from '@dxos/plugin-observability';
 
 import { SpaceCapabilities } from '../types';

package/src/operations/open-members.ts

@@ -2,7 +2,7 @@
 
 import * as Effect from 'effect/Effect';
 
-import { LayoutOperation, getSpacePath } from '@dxos/app-toolkit';
+import { LayoutOperation, Paths } from '@dxos/app-toolkit';
 import { Operation } from '@dxos/compute';
 
 import { SpaceOperation } from './definitions';
@@ -11,8 +11,8 @@ const handler: Operation.WithHandler<typeof SpaceOperation.OpenMembers> = SpaceO
   Operation.withHandler(
     Effect.fnUntraced(function* (input) {
       yield* Operation.invoke(LayoutOperation.Open, {
-        subject: [`${getSpacePath(input.space.id)}/settings`],
-        workspace: getSpacePath(input.space.id),
+        subject: [Paths.getSpacePath(input.space.id, 'settings')],
+        workspace: Paths.getSpacePath(input.space.id),
       });
     }),
   ),

package/src/operations/open-settings.ts

@@ -2,7 +2,7 @@
 
 import * as Effect from 'effect/Effect';
 
-import { LayoutOperation, getSpacePath } from '@dxos/app-toolkit';
+import { LayoutOperation, Paths } from '@dxos/app-toolkit';
 import { Operation } from '@dxos/compute';
 
 import { SpaceOperation } from './definitions';
@@ -11,8 +11,8 @@ const handler: Operation.WithHandler<typeof SpaceOperation.OpenSettings> = Space
   Operation.withHandler(
     Effect.fnUntraced(function* (input) {
       yield* Operation.invoke(LayoutOperation.Open, {
-        subject: [`${getSpacePath(input.space.id)}/settings/general`],
-        workspace: getSpacePath(input.space.id),
+        subject: [Paths.getSpacePath(input.space.id, 'settings', 'general')],
+        workspace: Paths.getSpacePath(input.space.id),
       });
     }),
   ),