@dxos/plugin-space 0.10.0 → 0.11.1

package/src/operations/helpers.ts

@@ -1,6 +1,11 @@
 // Copyright 2025 DXOS.org
 
+import * as Effect from 'effect/Effect';
+
 import { Capability } from '@dxos/app-framework';
+import { Type } from '@dxos/echo';
+
+import { SpaceCapabilities } from '../types';
 
 export type SpaceOperationConfig = {
   createInvitationUrl: (invitationCode: string) => string;
@@ -8,3 +13,9 @@ export type SpaceOperationConfig = {
 };
 
 export const SpaceOperationConfig = Capability.make<SpaceOperationConfig>('org.dxos.plugin.space.operationConfig');
+
+/** The contributed identity rule for a typename, or `undefined` when no plugin owns one. */
+export const resolveIdentitySpec = Effect.fnUntraced(function* (typename: string) {
+  const specs = yield* Capability.getAll(SpaceCapabilities.IdentitySpec);
+  return specs.find((spec) => Type.getTypename(spec.type) === typename);
+});

package/src/operations/index.ts

@@ -14,9 +14,11 @@ export const SpaceOperationHandlerSet = OperationHandlerSet.lazy(
   () => import('./delete-field'),
   () => import('./duplicate-object'),
   () => import('./export-space'),
+  () => import('./find-duplicates'),
   () => import('./get-share-link'),
   () => import('./import-space'),
   () => import('./join'),
+  () => import('./merge-duplicates'),
   () => import('./migrate'),
   () => import('./open'),
   () => import('./open-create-object'),

package/src/operations/join.ts

@@ -1,24 +1,25 @@
 // Copyright 2025 DXOS.org
 
 import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
 
-import { Capability } from '@dxos/app-framework';
 import { LayoutOperation } from '@dxos/app-toolkit';
 import { Operation } from '@dxos/compute';
-import { ClientCapabilities } from '@dxos/plugin-client';
+import { Identity } from '@dxos/halo';
+import { HaloServicesLayer } from '@dxos/plugin-client';
 
 import { meta } from '#meta';
 
 import { JOIN_DIALOG } from '../constants';
-import { type JoinDialogProps } from '../containers/JoinDialog';
+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()) {
+      const identity = yield* Identity.getSnapshot.pipe(Effect.provide(HaloServicesLayer));
+      if (Option.isNone(identity)) {
         // Space invitations authenticate against a local identity; there is nothing to redeem without one.
         yield* Effect.ignore(
           Operation.invoke(LayoutOperation.AddToast, {

package/src/operations/merge-duplicates.ts

@@ -0,0 +1,51 @@
+// Copyright 2026 DXOS.org
+
+import * as Effect from 'effect/Effect';
+
+import { Operation } from '@dxos/compute';
+import { Database, Filter, Obj, Query } from '@dxos/echo';
+import { applyMerge, findDuplicates, planMerge } from '@dxos/extractor';
+import { invariant } from '@dxos/invariant';
+
+import { SpaceOperation } from './definitions';
+import { resolveIdentitySpec } from './helpers';
+
+const handler: Operation.WithHandler<typeof SpaceOperation.MergeDuplicates> = SpaceOperation.MergeDuplicates.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ typename, objectIds, overrides }) {
+      const spec = yield* resolveIdentitySpec(typename);
+      invariant(spec, `No identity spec registered for ${typename}.`);
+
+      const { db } = yield* Database.Service;
+      // Re-resolve live proxies by id: the caller's objects crossed the operation boundary as
+      // snapshots, and a merge must mutate the reactive object the space actually holds.
+      const objects = yield* Database.query(Query.select(Filter.id(...objectIds))).run;
+      // The input arrives from a client that may be acting on a stale scan. Refuse a partial or
+      // mistyped set rather than merging whatever happened to resolve.
+      const requested = new Set(objectIds);
+      invariant(requested.size > 1, 'A merge needs at least two distinct members.');
+      invariant(objects.length === requested.size, 'Every member of a merge must still exist.');
+      invariant(
+        objects.every((object) => Obj.instanceOf(spec.type, object)),
+        `Every member of a merge must be a ${typename}.`,
+      );
+
+      // The merge deletes the losers, so being asked to merge is not enough — the members must
+      // actually share identity. Re-deriving the group over just these objects (not the whole space)
+      // rejects a set that is unrelated or only partly connected, and yields the real shared keys.
+      const [group, ...rest] = findDuplicates(spec, objects);
+      invariant(
+        group && rest.length === 0 && group.objects.length === objects.length,
+        'A merge must be applied to a single duplicate group.',
+      );
+
+      const plan = planMerge(spec, group);
+      const survivor = yield* applyMerge(db, spec, plan, overrides);
+      yield* Database.flush({ indexes: true });
+
+      return { survivorId: survivor.id, removedIds: plan.losers.map((loser) => loser.id) };
+    }),
+  ),
+);
+
+export default handler;

package/src/operations/open-members.ts

@@ -2,7 +2,7 @@
 
 import * as Effect from 'effect/Effect';
 
-import { LayoutOperation, Paths } from '@dxos/app-toolkit';
+import { GraphPath, LayoutOperation } 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: [Paths.getSpacePath(input.space.id, 'settings')],
-        workspace: Paths.getSpacePath(input.space.id),
+        subject: [GraphPath.getSpacePath(input.space.id, 'settings')],
+        workspace: GraphPath.getSpacePath(input.space.id),
       });
     }),
   ),

package/src/operations/open-settings.ts

@@ -2,7 +2,7 @@
 
 import * as Effect from 'effect/Effect';
 
-import { LayoutOperation, Paths } from '@dxos/app-toolkit';
+import { GraphPath, LayoutOperation } from '@dxos/app-toolkit';
 import { Operation } from '@dxos/compute';
 
 import { SpaceOperation } from './definitions';
@@ -11,8 +11,10 @@ const handler: Operation.WithHandler<typeof SpaceOperation.OpenSettings> = Space
   Operation.withHandler(
     Effect.fnUntraced(function* (input) {
       yield* Operation.invoke(LayoutOperation.Open, {
-        subject: [Paths.getSpacePath(input.space.id, 'settings', 'general')],
-        workspace: Paths.getSpacePath(input.space.id),
+        // The general settings panel node segment is `settings` (id-less `settings` url key), nested
+        // under the space settings section (also `settings`).
+        subject: [GraphPath.getSpacePath(input.space.id, 'settings', 'settings')],
+        workspace: GraphPath.getSpacePath(input.space.id),
       });
     }),
   ),

package/src/operations/remove-objects.ts

@@ -7,7 +7,7 @@ import { Capabilities } from '@dxos/app-framework';
 import { AppAnnotation, AppCapabilities, LayoutOperation } from '@dxos/app-toolkit';
 import { getSpace } from '@dxos/client/echo';
 import { Operation } from '@dxos/compute';
-import { Annotation, Collection, Entity, Obj } from '@dxos/echo';
+import { Annotation, Collection, Entity, Filter, Obj, Query } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 import { isNonNullable } from '@dxos/util';
 
@@ -37,8 +37,12 @@ const handler: Operation.WithHandler<typeof SpaceOperation.RemoveObjects> = Spac
           : -1,
       );
 
-      const wasActive = entities
-        .map((entity) => layout.active.find((graphId) => graphId.endsWith(entity.id)))
+      // `db.remove` cascades to objects owned via the ECHO parent edge, so those can have planks open
+      // too — a project's chats are the live case. Collected before the removal, while the parent
+      // edges still resolve; a plank left pointing at a removed object cannot be closed by the user.
+      const descendantIds = yield* collectOwnedDescendantIds(entities);
+      const wasActive = [...entities.map((entity) => entity.id), ...descendantIds]
+        .map((id) => layout.active.find((graphId) => graphId.endsWith(id)))
         .filter(isNonNullable);
 
       for (const entity of entities) {
@@ -69,3 +73,38 @@ const handler: Operation.WithHandler<typeof SpaceOperation.RemoveObjects> = Spac
   ),
 );
 export default handler;
+
+/**
+ * Ids of every object owned (transitively, by the ECHO parent edge) by one of `entities` — i.e. what
+ * `db.remove` will cascade to. Must run before the removal, while the parent edges still resolve.
+ * Ownership nests arbitrarily deep, so the walk runs to exhaustion rather than to a depth cap; the
+ * visited set (seeded with the roots, so a parent edge looping back cannot re-enqueue one) is what
+ * bounds it on cyclic data.
+ */
+const collectOwnedDescendantIds = Effect.fnUntraced(function* (entities: readonly unknown[]) {
+  const roots: Obj.Unknown[] = entities.filter(Obj.isObject);
+  const visited = new Set(roots.map((object) => object.id));
+  const descendants = new Set<string>();
+  let frontier = roots;
+  while (frontier.length > 0) {
+    const next: Obj.Unknown[] = [];
+    for (const object of frontier) {
+      const db = Obj.getDatabase(object);
+      if (!db) {
+        continue;
+      }
+
+      const children = yield* Effect.promise(() => db.query(Query.select(Filter.id(object.id)).children()).run());
+      for (const child of children) {
+        if (Obj.isObject(child) && !visited.has(child.id)) {
+          visited.add(child.id);
+          descendants.add(child.id);
+          next.push(child);
+        }
+      }
+    }
+    frontier = next;
+  }
+
+  return [...descendants];
+});

package/src/translations.ts

@@ -4,7 +4,7 @@
 
 import { Collection, Type } from '@dxos/echo';
 import { type Resource } from '@dxos/react-ui';
-import { Event, Message, Organization, Person, Pipeline, Project, Task } from '@dxos/types';
+import { Event, Message, Organization, Person, Pipeline, Task, TaskSet } from '@dxos/types';
 
 import { meta } from '#meta';
 
@@ -89,16 +89,16 @@ export const translations = [
         'delete-object.label': 'Delete pipeline',
         'object-deleted.label': 'Pipeline deleted',
       },
-      [Type.getTypename(Project.Project)]: {
-        'typename.label': 'Project',
-        'typename.label_zero': 'Projects',
-        'typename.label_one': 'Project',
-        'typename.label_other': 'Projects',
-        'object-name.placeholder': 'New project',
-        'add-object.label': 'Add project',
-        'rename-object.label': 'Rename project',
-        'delete-object.label': 'Delete project',
-        'object-deleted.label': 'Project deleted',
+      [Type.getTypename(TaskSet.TaskSet)]: {
+        'typename.label': 'Task set',
+        'typename.label_zero': 'Task sets',
+        'typename.label_one': 'Task set',
+        'typename.label_other': 'Task sets',
+        'object-name.placeholder': 'New task set',
+        'add-object.label': 'Add task set',
+        'rename-object.label': 'Rename task set',
+        'delete-object.label': 'Delete task set',
+        'object-deleted.label': 'Task set deleted',
       },
       [Type.getTypename(Task.Task)]: {
         'typename.label': 'Task',
@@ -113,6 +113,8 @@ export const translations = [
       },
       [meta.profile.key]: {
         'plugin.name': 'Spaces',
+        'navigation-failed-toast.title': 'Link could not be processed',
+        'navigation-failed-toast.description': 'Something went wrong while handling this link. Please try again.',
         'add-object.label': 'Add object',
         'first-run.message': 'Nothing selected.',
         'create-space.label': 'Create space',
@@ -212,12 +214,15 @@ export const translations = [
         'saving-locally.label': 'Writing to disk',
         'downloading.label': 'Replicating from peers',
         'uploading.label': 'Replicating to peers',
+        'stalled.label': 'Replication stalled',
+        'disconnected.label': 'Not connected (changes not replicated)',
         'offline-persisted.label': 'Saved to disk (offline)',
         'remote-synced.label': 'Synced with peers',
         'syncing.label': 'Space syncing',
         'show-all.label': 'Show all',
         'no-sync-status.label': 'No space with missing objects.',
         'create-space-dialog.title': 'Create Space',
+        'create-space-dialog.error.message': 'Failed to create space. Please try again.',
         'create-object-dialog.title': 'Create {{object}}',
         'space-input.placeholder': 'Select space',
         'schema-input.placeholder': 'Select type',
@@ -285,6 +290,9 @@ export const translations = [
         'repair-space.title': 'Repair Space',
         'repair-space.description': 'Run repair operations on the space.',
         'repair-space.label': 'Run repairs',
+        'reset-home.title': 'Reset home layout',
+        'reset-home.description': 'Restore all hidden sections on the space home page.',
+        'reset-home.label': 'Reset',
 
         'danger-zone.title': 'Danger Zone',
         'danger-zone.description': 'Destructive actions that cannot be undone.',
@@ -311,6 +319,29 @@ export const translations = [
         'database-section.label': 'Database',
         'collections-section.label': 'Collections',
         'type-collection-empty.message': 'No objects of this type yet.',
+        'layout.label': 'Layout',
+        'layout-masonry.label': 'Cards',
+        'layout-table.label': 'Table',
+        'layout-duplicates.label': 'Duplicates',
+        'open-object.label': 'Open object',
+        'search-placeholder.label': 'Filter...',
+        'search-no-results.message': 'No matches.',
+        'item-count.label_zero': 'No items',
+        'item-count.label_one': '1 item',
+        'item-count.label_other': '{{count}} items',
+        'delete-selected.label_one': 'Delete {{count}} object',
+        'delete-selected.label_other': 'Delete {{count}} objects',
+        'merge-duplicates.label': 'Merge',
+        'skip-duplicates.label': 'Skip',
+        'previous-duplicate.label': 'Previous group',
+        'next-duplicate.label': 'Next group',
+        'rescan-duplicates.label': 'Rescan',
+        'duplicates-position.label': 'Group',
+        'confirm-merge.label': 'Confirm merge',
+        'cancel-merge.label': 'Cancel',
+        'duplicates-none.label': 'None',
+        'duplicates-none.message': 'No duplicates found.',
+        'duplicates-scanning.message': 'Scanning for duplicates…',
 
         'search.placeholder': 'Search…',
         'auth-code.message': 'Authorization code',
@@ -329,6 +360,16 @@ export const translations = [
         'unnamed-collection.label': 'Unnamed',
         'space-home-node.label': 'Home',
         'space-home.recent.heading': 'Recent',
+        'space-home.dashboard.heading': 'Activity',
+        'space-home.dashboard.objects.label': 'Objects',
+        'space-home.dashboard.types.label': 'Types',
+        'space-home.dashboard.collections.label': 'Collections',
+        'space-home.dashboard.members.label': 'Members',
+        'space-home.dashboard.active-days.label': 'Active days',
+        'space-home.dashboard.plugins.label': 'Plugins',
+        'space-home.dashboard.range-all.label': 'All',
+        'space-home.dashboard.range-month.label': '30d',
+        'space-home.dashboard.range-week.label': '7d',
       },
     },
   },

package/src/type-section-path.test.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import { describe, test } from 'vitest';
+
+import { Key } from '@dxos/echo';
+import { type GraphBuilder } from '@dxos/plugin-graph';
+
+import { findTypeSectionPath } from './type-section-path';
+
+const spaceId = Key.SpaceId.random();
+const objectId = Key.EntityId.random();
+
+describe('findTypeSectionPath', () => {
+  test('matches a grouped section by its trailing typename segment', ({ expect }) => {
+    const extensions = [staticBinding(['system', 'database']), staticBinding(['ai', 'dxos.org.type.Chat'])];
+    expect(findTypeSectionPath(extensions, { spaceId, typename: 'dxos.org.type.Chat', objectId })).toBe(
+      `root/${spaceId}/ai/dxos.org.type.Chat/${objectId}`,
+    );
+  });
+
+  test('matches a space-direct section', ({ expect }) => {
+    const extensions = [staticBinding(['dxos.org.type.Project'])];
+    expect(findTypeSectionPath(extensions, { spaceId, typename: 'dxos.org.type.Project', objectId })).toBe(
+      `root/${spaceId}/dxos.org.type.Project/${objectId}`,
+    );
+  });
+
+  test('ignores dynamic resolvers, singletons, and unrelated static paths', ({ expect }) => {
+    const extensions: Array<Pick<GraphBuilder.BuilderExtension, 'url'>> = [
+      // Dynamic path (nested collections) — locates by runtime data, not a fixed section.
+      { url: { key: 'object', kind: 'item', path: () => Effect.succeed(null) } },
+      // Singleton (settings page) — the trailing segment is the node itself, not a typename.
+      staticBinding(['dxos.org.type.Chat'], 'singleton'),
+      // Static but not this type's section.
+      staticBinding(['system', 'database']),
+      { url: undefined },
+    ];
+    expect(findTypeSectionPath(extensions, { spaceId, typename: 'dxos.org.type.Chat', objectId })).toBeUndefined();
+  });
+});
+
+/** A static url binding as `createTypeSectionExtension` declares one. */
+const staticBinding = (path: string[], kind: 'item' | 'singleton' = 'item') => ({
+  url: { key: path.at(-1) ?? 'key', kind, path },
+});

package/src/type-section-path.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type CapabilityManager } from '@dxos/app-framework';
+import { AppCapabilities, GraphPath } from '@dxos/app-toolkit';
+import { type GraphBuilder } from '@dxos/plugin-graph';
+
+/**
+ * The path under which the nav tree shows an object surfaced by a type section
+ * (`TypeSection.createTypeSectionExtension`): `root/<space>/[<group>/]<typename>/<id>`. Derived from
+ * the graph builder's registered url bindings rather than per-plugin wiring — a type section declares
+ * a static `path` ending in its typename, so the declaration every section already makes for URL
+ * resolution also answers "where does this type live in the tree". Returns undefined when no active
+ * extension declares a section for the typename.
+ */
+export const findTypeSectionPath = (
+  extensions: Iterable<Pick<GraphBuilder.BuilderExtension, 'url'>>,
+  { spaceId, typename, objectId }: { spaceId: string; typename: string; objectId: string },
+): string | undefined => {
+  for (const extension of extensions) {
+    const url = extension.url;
+    // Only item bindings with a static path locate objects at a fixed depth; dynamic resolvers
+    // (nested collections) and singletons (settings pages) address other shapes.
+    if (url?.kind === 'item' && Array.isArray(url.path) && url.path.at(-1) === typename) {
+      return GraphPath.getSpacePath(spaceId, ...url.path, objectId);
+    }
+  }
+  return undefined;
+};
+
+/** {@link findTypeSectionPath} against the app graph's live extension registry, absent-graph safe. */
+export const resolveTypeSectionPath = (
+  capabilities: CapabilityManager.CapabilityManager,
+  params: { spaceId: string; typename: string; objectId: string },
+): string | undefined => {
+  const builder = capabilities.getAll(AppCapabilities.AppGraph).at(0);
+  return builder ? findTypeSectionPath(Object.values(builder.getExtensions()), params) : undefined;
+};

package/src/types/capabilities.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Atom } from '@effect-atom/atom-react';
+import { type Atom } from '@effect-atom/atom';
 import type * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 import type { ComponentType } from 'react';
@@ -10,7 +10,7 @@ import type { ComponentType } from 'react';
 import { Capability } from '@dxos/app-framework';
 import { type Space } from '@dxos/client/echo';
 import { type Operation } from '@dxos/compute';
-import { type Collection, type Database, type Type } from '@dxos/echo';
+import { type Collection, type Database, type Obj, type Type } from '@dxos/echo';
 import { type PublicKey } from '@dxos/keys';
 import { type Label } from '@dxos/ui-types/translations';
 import { type ComplexMap, type Position } from '@dxos/util';
@@ -36,6 +36,18 @@ export namespace SpaceCapabilities {
   /** Persisted state (stored in KVS/localStorage). */
   export const State = Capability.make<Atom.Writable<SpaceState>>(`${meta.profile.key}.capability.state`);
 
+  /**
+   * A proposed merge awaiting confirmation. `preview` is detached (never added to the database),
+   * so abandoning the review writes nothing. Keyed by the type article's URI so the companion
+   * only shows a preview raised by the plank it is companion to.
+   */
+  export type MergePreview = {
+    typeUri: string;
+    typename: string;
+    objectIds: string[];
+    preview: Obj.Unknown;
+  };
+
   /** Ephemeral space plugin state (not persisted). */
   export type SpaceEphemeralState = {
     awaiting: string | undefined;
@@ -43,6 +55,9 @@ export namespace SpaceCapabilities {
     navigableCollections: boolean;
     viewersByObject: Record<string, ComplexMap<PublicKey, ObjectViewerProps>>;
     viewersByIdentity: ComplexMap<PublicKey, Set<string>>;
+    mergePreview: MergePreview | undefined;
+    /** Bumped when a merge commits, so an open duplicates review knows to rescan. */
+    lastMergeAt: number | undefined;
   };
 
   /** Transient/ephemeral state (not persisted). */
@@ -90,6 +105,15 @@ export namespace SpaceCapabilities {
   }>;
   export const CreateObjectEntry = Capability.make<CreateObjectEntry>(`${meta.profile.key}.capability.create-object`);
 
+  /**
+   * The identity rule for a type — how to key an object for duplicate detection and how to merge
+   * two of them. Plugins that own a type contribute one (e.g. plugin-crm for Person); the type
+   * article only offers its Duplicates tab for types that have one.
+   */
+  export const IdentitySpec = Capability.make<import('@dxos/extractor').IdentitySpec<any>>(
+    `${meta.profile.key}.capability.identity-spec`,
+  );
+
   /** Props passed to a `CreateObjectEntry.customPanel`. */
   export type CreateObjectCustomPanelProps = {
     target: Database.Database | Collection.Collection;

package/src/types/surface.ts

@@ -2,7 +2,7 @@
 // Copyright 2026 DXOS.org
 //
 
-import { Surface } from '@dxos/app-framework/ui';
+import { Role } from '@dxos/app-framework';
 import { type Obj } from '@dxos/echo';
 import { type Space } from '@dxos/react-client/echo';
 
@@ -10,22 +10,18 @@ import { type Space } from '@dxos/react-client/echo';
  * Surface role token for the Home article's scrollable content region. Contributors render
  * top-to-bottom (e.g. Welcome, Recent objects, starter-prompt cards).
  */
-export const SpaceHomeContent: Surface.RoleToken<{ space: Space }> = Surface.makeType(
-  'org.dxos.plugin.space.role.homeContent',
-);
+export const SpaceHomeContent: Role.Role<{ space: Space }> = Role.make('org.dxos.plugin.space.role.homeContent');
 
 /**
  * Surface role token for the Home article's pinned-bottom region (the assistant prompt).
  * Rendered with `limit={1}` so only a single prompt contributor mounts.
  */
-export const SpaceHomePinBottom: Surface.RoleToken<{ space: Space }> = Surface.makeType(
-  'org.dxos.plugin.space.role.homePinBottom',
-);
+export const SpaceHomePinBottom: Role.Role<{ space: Space }> = Role.make('org.dxos.plugin.space.role.homePinBottom');
 
 /**
  * Surface role token for assistant prompts (consumed by plugin-assistant).
  * Owned by plugin-space to avoid a circular dependency.
  */
-export const Prompts: Surface.RoleToken<{ subject: Obj.Any; attendableId: string }> = Surface.makeType(
+export const Prompts: Role.Role<{ subject: Obj.Any; attendableId: string }> = Role.make(
   'org.dxos.plugin.assistant.role.prompts',
 );

package/src/types/types.ts

@@ -55,6 +55,13 @@ export type SpacePluginOptions = {
    */
   invitationProp?: string;
 
+  /**
+   * Whether the navigation handler consumes invitation codes from URL query params.
+   * Disable when another plugin (e.g. plugin-onboarding) owns the invitation URL flow.
+   * @default true
+   */
+  invitationUrlHandler?: boolean;
+
   /**
    * Whether to send observability events.
    */

package/dist/lib/neutral/CollectionArticle-BMH7SZ7Q.mjs

@@ -1,93 +0,0 @@
-import "./chunk-J5LGTIGS.mjs";
-
-// src/containers/CollectionArticle/CollectionArticle.tsx
-import React, { useCallback, useMemo } from "react";
-import { useOperationInvoker } from "@dxos/app-framework/ui";
-import { LayoutOperation, Paths } from "@dxos/app-toolkit";
-import { Obj } from "@dxos/echo";
-import { ScrollArea, toLocalizedString, useTranslation } from "@dxos/react-ui";
-import { Card, Icon } from "@dxos/react-ui";
-import { Mosaic } from "@dxos/react-ui-mosaic";
-import { SearchPanel, useSearchListResults } from "@dxos/react-ui-search";
-import { getStyles } from "@dxos/ui-theme";
-import { meta } from "#meta";
-var CollectionArticle = ({ subject, attendableId }) => {
-  const { t } = useTranslation(meta.profile.key);
-  const { items, handleSearch } = useCollectionItems(subject, attendableId);
-  return /* @__PURE__ */ React.createElement(SearchPanel, {
-    onSearch: handleSearch
-  }, /* @__PURE__ */ React.createElement(Mosaic.Container, {
-    asChild: true
-  }, /* @__PURE__ */ React.createElement(ScrollArea.Root, {
-    centered: true,
-    padding: true,
-    thin: true
-  }, /* @__PURE__ */ React.createElement(ScrollArea.Viewport, null, /* @__PURE__ */ React.createElement(Mosaic.Stack, {
-    classNames: "gap-1",
-    draggable: false,
-    items,
-    getId: (item) => item.id,
-    Tile: ObjectTile
-  })))));
-};
-var ObjectTile = ({ data: item }) => {
-  const { t } = useTranslation(meta.profile.key);
-  const { invokePromise } = useOperationInvoker();
-  const typename = Obj.getTypename(item.object) ?? "";
-  const label = Obj.getLabel(item.object) ?? toLocalizedString([
-    "object-name.placeholder",
-    {
-      ns: typename,
-      defaultValue: item.id
-    }
-  ], t);
-  const styles = item.iconHue ? getStyles(item.iconHue) : void 0;
-  const handleClick = useCallback(() => void invokePromise(LayoutOperation.Open, {
-    subject: [
-      item.targetPath
-    ]
-  }), [
-    invokePromise,
-    item.targetPath
-  ]);
-  return /* @__PURE__ */ React.createElement(Card.Root, {
-    fullWidth: true,
-    role: "button",
-    classNames: "cursor-pointer",
-    onClick: handleClick
-  }, /* @__PURE__ */ React.createElement(Card.Header, null, /* @__PURE__ */ React.createElement(Card.Block, null, /* @__PURE__ */ React.createElement(Icon, {
-    icon: item.icon,
-    classNames: styles?.fg
-  })), /* @__PURE__ */ React.createElement(Card.Title, null, label), /* @__PURE__ */ React.createElement(Card.Menu, null)));
-};
-var useCollectionItems = (collection, attendableId) => {
-  const objects = useMemo(() => (collection.objects ?? []).map((ref) => ref.target).filter((obj) => Obj.isObject(obj)), [
-    collection.objects
-  ]);
-  const items = useMemo(() => objects.map((obj) => {
-    const iconAnnotation = Obj.getIcon(obj);
-    const targetPath = attendableId ? Paths.getCollectionObjectPath(attendableId, obj.id) : Paths.getObjectPathFromObject(obj);
-    return {
-      id: Obj.getURI(obj),
-      object: obj,
-      targetPath,
-      icon: iconAnnotation?.icon ?? "ph--circle-dashed--regular",
-      iconHue: iconAnnotation?.hue
-    };
-  }), [
-    objects,
-    attendableId
-  ]);
-  const { results, handleSearch } = useSearchListResults({
-    items,
-    extract: (item) => Obj.getLabel(item.object) ?? item.id
-  });
-  return {
-    items: results,
-    handleSearch
-  };
-};
-export {
-  CollectionArticle as default
-};
-//# sourceMappingURL=CollectionArticle-BMH7SZ7Q.mjs.map