@dxos/plugin-space 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

package/src/capabilities/repair.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capability } from '@dxos/app-framework';
+import { RootCollectionAnnotation } from '@dxos/app-toolkit';
+import { Annotation, Collection, Obj, Ref } from '@dxos/echo';
+import { type Space } from '@dxos/react-client/echo';
+
+import { SpaceCapabilities } from '#types';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(SpaceCapabilities.Repair, async ({ space }: { space: Space }) => {
+      await removeQueryCollections(space);
+    }),
+  ),
+);
+
+/**
+ * Remove all existing query collections from the root collection.
+ */
+const removeQueryCollections = async (space: Space) => {
+  const rootCollectionRef = Annotation.get(space.properties, RootCollectionAnnotation).pipe(Option.getOrUndefined);
+  const rootCollection: Collection.Collection | undefined = await rootCollectionRef?.load();
+  if (!rootCollection) {
+    return;
+  }
+
+  const objects = await Promise.all(rootCollection.objects.map((ref) => ref.load()));
+  const queryCollections = objects.filter((object) => Obj.getTypename(object) === 'org.dxos.type.queryCollection');
+  if (queryCollections.length === 0) {
+    return;
+  }
+
+  Obj.update(rootCollection, (rootCollection) => {
+    rootCollection.objects = objects
+      .filter((object) => Obj.getTypename(object) !== 'org.dxos.type.queryCollection')
+      .map((object) => Ref.make(object));
+  });
+  queryCollections.forEach((object) => space.db.remove(object));
+};

package/src/capabilities/settings.ts

@@ -2,20 +2,30 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes } from '@dxos/app-framework';
-import { live } from '@dxos/live-object';
+import * as Effect from 'effect/Effect';
 
-import { meta } from '../meta';
-import { type SpaceSettingsProps, SpaceSettingsSchema } from '../types';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { createKvsStore } from '@dxos/effect';
 
-export default () => {
-  const settings = live<SpaceSettingsProps>({
-    showHidden: false,
-  });
+import { meta } from '#meta';
+import { Settings, SpaceCapabilities } from '#types';
 
-  return contributes(Capabilities.Settings, {
-    prefix: meta.id,
-    schema: SpaceSettingsSchema,
-    value: settings,
-  });
-};
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const settingsAtom = createKvsStore({
+      key: meta.id,
+      schema: Settings.Settings,
+      defaultValue: () => ({}),
+    });
+
+    return [
+      Capability.contributes(SpaceCapabilities.Settings, settingsAtom),
+      Capability.contributes(AppCapabilities.Settings, {
+        prefix: meta.id,
+        schema: Settings.Settings,
+        atom: settingsAtom,
+      }),
+    ];
+  }),
+);

package/src/capabilities/spaces-ready.ts

@@ -2,177 +2,291 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Option } from 'effect';
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
+import * as Option from 'effect/Option';
 
-import { Capabilities, LayoutAction, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import {
+  AppCapabilities,
+  LayoutOperation,
+  RootCollectionAnnotation,
+  getSpacePath,
+  resolvePersonalSpace,
+  setPersonalSpace,
+} from '@dxos/app-toolkit';
 import { SubscriptionList } from '@dxos/async';
-import { Filter, Obj, Type } from '@dxos/echo';
-import { scheduledEffect } from '@dxos/echo-signals/core';
+import { Annotation, Collection, Filter, Obj, Type } from '@dxos/echo';
+import { SPACE_ID_LENGTH, parseId } from '@dxos/keys';
 import { log } from '@dxos/log';
+import { MigrationVersionAnnotation, Migrations } from '@dxos/migrations';
 import { AttentionCapabilities } from '@dxos/plugin-attention';
 import { ClientCapabilities } from '@dxos/plugin-client';
-import { DeckCapabilities } from '@dxos/plugin-deck';
+import { Graph } from '@dxos/plugin-graph';
 import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
 import { PublicKey } from '@dxos/react-client';
-import { FQ_ID_LENGTH, SpaceState, parseFullyQualifiedId } from '@dxos/react-client/echo';
+import { type Space, SpaceState } from '@dxos/react-client/echo';
+import { Expando } from '@dxos/schema';
 import { ComplexMap, reduceGroupBy } from '@dxos/util';
 
-import { SpaceAction } from '../types';
-import { COMPOSER_SPACE_LOCK, SHARED } from '../util';
+import { SpaceOperation } from '#operations';
+import { SpaceCapabilities } from '#types';
 
-import { SpaceCapabilities } from './capabilities';
+import { SHARED } from '../util';
 
 const ACTIVE_NODE_BROADCAST_INTERVAL = 30_000;
 const WAIT_FOR_OBJECT_TIMEOUT = 5_000;
 
-export default async (context: PluginContext) => {
-  const subscriptions = new SubscriptionList();
-  const spaceSubscriptions = new SubscriptionList();
-
-  const { dispatchPromise: dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-  const { graph } = context.getCapability(Capabilities.AppGraph);
-  const layout = context.getCapability(Capabilities.Layout);
-  const deck = context.getCapabilities(DeckCapabilities.DeckState)[0];
-  const attention = context.getCapability(AttentionCapabilities.Attention);
-  const state = context.getCapability(SpaceCapabilities.MutableState);
-  const client = context.getCapability(ClientCapabilities.Client);
-
-  const defaultSpace = client.spaces.default;
-  await defaultSpace.waitUntilReady();
-
-  if (deck?.activeDeck === 'default') {
-    await dispatch(createIntent(LayoutAction.SwitchWorkspace, { part: 'workspace', subject: defaultSpace.id }));
-  }
-
-  // Initialize space sharing lock in default space.
-  if (typeof defaultSpace.properties[COMPOSER_SPACE_LOCK] !== 'boolean') {
-    defaultSpace.properties[COMPOSER_SPACE_LOCK] = true;
-  }
-
-  const {
-    objects: [spacesOrder],
-  } = await defaultSpace.db.query(Filter.type(Type.Expando, { key: SHARED })).run();
-  if (!spacesOrder) {
-    // TODO(wittjosiah): Cannot be a Folder because Spaces are not TypedObjects so can't be saved in the database.
-    //  Instead, we store order as an array of space ids.
-    defaultSpace.db.add(Obj.make(Type.Expando, { key: SHARED, order: [] }));
-  }
-
-  // Await missing objects.
-  subscriptions.add(
-    scheduledEffect(
-      () => ({ active: layout.active }),
-      ({ active }) => {
-        if (active.length !== 1) {
-          return;
+const isEchoRef = (id: string) => id.startsWith('echo:/');
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const subscriptions = new SubscriptionList();
+    const spaceSubscriptions = new SubscriptionList();
+
+    const { invoke, invokePromise } = yield* Capability.get(Capabilities.OperationInvoker);
+    const { graph } = yield* Capability.get(AppCapabilities.AppGraph);
+    const registry = yield* Capability.get(Capabilities.AtomRegistry);
+    const layoutAtom = yield* Capability.get(AppCapabilities.Layout);
+    const attention = yield* Capability.get(AttentionCapabilities.Attention);
+    const stateAtom = yield* Capability.get(SpaceCapabilities.State);
+    const ephemeralAtom = yield* Capability.get(SpaceCapabilities.EphemeralState);
+    const client = yield* Capability.get(ClientCapabilities.Client);
+
+    //
+    // Personal space initialization — deferred until found.
+    //
+
+    // Fiber for the one-shot personal-space init Effect; interrupted in cleanup
+    // so it cannot access the db after client.destroy() closes the repo.
+    let personalSpaceInitFiber: Fiber.RuntimeFiber<void, unknown> | undefined;
+    let personalSpaceInitialized = false;
+
+    const personalSpaceInitEffect = (personalSpace: Space, { fromCredential }: { fromCredential: boolean }) =>
+      Effect.gen(function* () {
+        yield* Effect.promise(() => personalSpace.waitUntilReady());
+
+        if (fromCredential) {
+          setPersonalSpace(personalSpace);
         }
 
-        const id = active[0];
-        const node = graph.getNode(id).pipe(Option.getOrNull);
-        if (!node && id.length === FQ_ID_LENGTH) {
-          void graph.initialize(id);
-          const timeout = setTimeout(async () => {
-            const node = graph.getNode(id).pipe(Option.getOrNull);
-            if (!node) {
-              await dispatch(createIntent(SpaceAction.WaitForObject, { id }));
-            }
-          }, WAIT_FOR_OBJECT_TIMEOUT);
+        // Check if deck state indicates we should switch to default space.
+        const layout = registry.get(layoutAtom);
+        if (layout.workspace === 'default') {
+          yield* invoke(LayoutOperation.SwitchWorkspace, { subject: getSpacePath(personalSpace.id) });
+        }
+
+        const queryResults = yield* Effect.promise(() =>
+          personalSpace.db.query(Filter.type(Expando.Expando, { key: SHARED })).run(),
+        );
+        if (!queryResults[0]) {
+          // TODO(wittjosiah): Cannot be a Folder because Spaces are not TypedObjects so can't be saved in the database.
+          //  Instead, we store order as an array of space ids.
+          try {
+            personalSpace.db.add(Obj.make(Expando.Expando, { key: SHARED, order: [] }));
+          } catch (err) {
+            // The space may have been destroyed (e.g. during test teardown) between the query and the add.
+            log.warn('Failed to initialize spaces order, space may be closing', { err });
+          }
+        }
+      });
+
+    const startPersonalSpaceInit = (personalSpace: Space, opts: { fromCredential: boolean }) => {
+      if (personalSpaceInitialized) {
+        return;
+      }
+      // Set before forking so concurrent subscribe callbacks don't start a second initialization.
+      personalSpaceInitialized = true;
+      personalSpaceInitFiber = Effect.runFork(personalSpaceInitEffect(personalSpace, opts));
+    };
 
-          return () => clearTimeout(timeout);
+    // Try to find the personal space now, or subscribe to find it later.
+    // Initialization is non-blocking so subscriptions wire immediately.
+    const resolved = resolvePersonalSpace(client);
+    if (resolved) {
+      startPersonalSpaceInit(resolved.space, resolved);
+    } else {
+      const personalSpaceSub = client.spaces.subscribe(() => {
+        const resolved = resolvePersonalSpace(client);
+        if (resolved) {
+          startPersonalSpaceInit(resolved.space, resolved);
         }
-      },
-    ),
-  );
-
-  // Cache space names.
-  subscriptions.add(
-    client.spaces.subscribe(async (spaces) => {
-      // TODO(wittjosiah): Remove. This is a hack to be able to migrate the default space properties.
-      if (defaultSpace.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION) {
-        await defaultSpace.internal.migrate();
+      });
+      subscriptions.add(() => personalSpaceSub.unsubscribe());
+    }
+
+    //
+    // Space subscriptions — set up immediately, do not depend on personal space.
+    //
+
+    // Await missing objects - subscribe to layout atom changes.
+    // NOTE: Use immediate: true to check initial state (URL handler may have already set active).
+    let lastActiveCleanup: (() => void) | undefined;
+    subscriptions.add(
+      registry.subscribe(
+        layoutAtom,
+        (layout) => {
+          // Clean up previous effect.
+          lastActiveCleanup?.();
+          lastActiveCleanup = undefined;
+
+          // Determine the ID to check - either from active item or workspace.
+          const id = layout.active.length === 1 ? layout.active[0] : layout.workspace;
+          if (!id) {
+            return;
+          }
+
+          const node = Graph.getNode(graph, id).pipe(Option.getOrNull);
+          if (!node && (isEchoRef(id) || id.length === SPACE_ID_LENGTH)) {
+            void Graph.initialize(graph, id);
+            const timeout = setTimeout(async () => {
+              const node = Graph.getNode(graph, id).pipe(Option.getOrNull);
+              if (!node) {
+                await invokePromise(SpaceOperation.WaitForObject, { id });
+              }
+            }, WAIT_FOR_OBJECT_TIMEOUT);
+
+            lastActiveCleanup = () => clearTimeout(timeout);
+          }
+        },
+        { immediate: true },
+      ),
+    );
+    // Also add cleanup for the last effect.
+    subscriptions.add(() => lastActiveCleanup?.());
+
+    // Cache space names.
+    const spaceNamesSub = client.spaces.subscribe(async (spaces) => {
+      // TODO(wittjosiah): Remove. This is a hack to be able to migrate the personal space properties.
+      const personalSpaceForMigration = resolvePersonalSpace(client);
+      if (
+        personalSpaceForMigration?.space &&
+        personalSpaceForMigration.space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION
+      ) {
+        await personalSpaceForMigration.space.internal.migrate();
       }
 
       spaces
         .filter((space) => space.state.get() === SpaceState.SPACE_READY)
         .forEach((space) => {
-          subscriptions.add(
-            scheduledEffect(
-              () => ({ name: space.properties.name }),
-              ({ name }) => (state.spaceNames[space.id] = name),
-            ),
-          );
+          if (Option.isNone(Annotation.get(space.properties, RootCollectionAnnotation))) {
+            const legacyRef = (space.properties as any)[Type.getTypename(Collection.Collection)];
+            if (legacyRef) {
+              Obj.update(space.properties, (properties) => {
+                Annotation.set(properties, RootCollectionAnnotation, legacyRef);
+              });
+            }
+          }
+          if (Migrations.namespace && Option.isNone(Annotation.get(space.properties, MigrationVersionAnnotation))) {
+            const legacyVersion = (space.properties as any)[`${Migrations.namespace}.version`];
+            if (typeof legacyVersion === 'string') {
+              Obj.update(space.properties, (properties) => {
+                Annotation.set(properties, MigrationVersionAnnotation, legacyVersion);
+              });
+            }
+          }
+
+          const updateSpaceName = () => {
+            const name = space.properties.name;
+            if (!name) {
+              registry.update(stateAtom, (current) => {
+                const { [space.id]: _, ...rest } = current.spaceNames;
+                return { ...current, spaceNames: rest };
+              });
+            } else {
+              registry.update(stateAtom, (current) => ({
+                ...current,
+                spaceNames: { ...current.spaceNames, [space.id]: name },
+              }));
+            }
+          };
+          updateSpaceName();
+          subscriptions.add(Obj.subscribe(space.properties, updateSpaceName));
         });
-    }).unsubscribe,
-  );
-
-  // Broadcast active node to other peers in the space.
-  subscriptions.add(
-    scheduledEffect(
-      () => ({ current: attention.current, active: layout.active, inactive: layout.inactive }),
-      ({ current, active, inactive }) => {
-        const send = () => {
-          const spaces = client.spaces.get();
-          const identity = client.halo.identity.get();
-          if (identity) {
-            // Group parts by space for efficient messaging.
-            const idsBySpace = reduceGroupBy(active, (id) => {
-              try {
-                const [spaceId] = parseFullyQualifiedId(id);
-                return spaceId;
-              } catch {
-                return null;
-              }
-            });
-
-            const removedBySpace = reduceGroupBy(inactive, (id) => {
-              try {
-                const [spaceId] = parseFullyQualifiedId(id);
-                return spaceId;
-              } catch {
-                return null;
-              }
-            });
+    });
+    subscriptions.add(() => spaceNamesSub.unsubscribe());
 
-            // NOTE: Ensure all spaces are included so that we send the correct `removed` object arrays.
-            for (const space of spaces) {
-              if (!idsBySpace.has(space.id)) {
-                idsBySpace.set(space.id, []);
-              }
+    // Broadcast active node to other peers in the space - subscribe to both layout and attention.
+    let broadcastCleanup: (() => void) | undefined;
+    const setupBroadcast = () => {
+      broadcastCleanup?.();
+
+      const layout = registry.get(layoutAtom);
+      const current = attention.getCurrent();
+      const active = layout.active;
+      const inactive = layout.inactive;
+
+      const send = () => {
+        const spaces = client.spaces.get();
+        const identity = client.halo.identity.get();
+        if (identity) {
+          // Group parts by space for efficient messaging.
+          const idsBySpace = reduceGroupBy(active, (id: string) => {
+            try {
+              const { spaceId } = parseId(id);
+              return spaceId;
+            } catch {
+              return null;
             }
+          });
 
-            for (const [spaceId, added] of idsBySpace) {
-              const removed = removedBySpace.get(spaceId) ?? [];
-              const space = spaces.find((space) => space.id === spaceId);
-              if (!space) {
-                continue;
-              }
+          const removedBySpace = reduceGroupBy(inactive, (id: string) => {
+            try {
+              const { spaceId } = parseId(id);
+              return spaceId;
+            } catch {
+              return null;
+            }
+          });
 
-              void space
-                .postMessage('viewing', {
-                  identityKey: identity.identityKey.toHex(),
-                  attended: current,
-                  added,
-                  removed,
-                })
-                // TODO(burdon): This seems defensive; why would this fail? Backoff interval.
-                .catch((err) => {
-                  log.warn('Failed to broadcast active node for presence.', { err: err.message });
-                });
+          // NOTE: Ensure all spaces are included so that we send the correct `removed` object arrays.
+          for (const space of spaces) {
+            if (!idsBySpace.has(space.id)) {
+              idsBySpace.set(space.id, []);
             }
           }
-        };
-
-        send();
-        // Send at interval to allow peers to expire entries if they become disconnected.
-        const interval = setInterval(() => send(), ACTIVE_NODE_BROADCAST_INTERVAL);
-        return () => clearInterval(interval);
-      },
-    ),
-  );
-
-  // Listen for active nodes from other peers in the space.
-  subscriptions.add(
-    client.spaces.subscribe((spaces) => {
+
+          for (const [spaceId, added] of idsBySpace) {
+            const removed = removedBySpace.get(spaceId) ?? [];
+            const space = spaces.find((space) => space.id === spaceId);
+            if (!space) {
+              continue;
+            }
+
+            void space
+              .postMessage('viewing', {
+                identityKey: identity.identityKey.toHex(),
+                attended: current,
+                added,
+                removed,
+              })
+              // TODO(burdon): This seems defensive; why would this fail? Backoff interval.
+              .catch((err) => {
+                log.warn('Failed to broadcast active node for presence.', {
+                  err: err.message,
+                });
+              });
+          }
+        }
+      };
+
+      send();
+      // Send at interval to allow peers to expire entries if they become disconnected.
+      const interval = setInterval(() => send(), ACTIVE_NODE_BROADCAST_INTERVAL);
+      broadcastCleanup = () => clearInterval(interval);
+    };
+
+    // Subscribe to layout changes for broadcast.
+    subscriptions.add(registry.subscribe(layoutAtom, setupBroadcast));
+    // Subscribe to attention.current changes.
+    subscriptions.add(attention.subscribeCurrent(() => setupBroadcast()));
+    // Initial setup.
+    setupBroadcast();
+    // Cleanup.
+    subscriptions.add(() => broadcastCleanup?.());
+
+    // Listen for active nodes from other peers in the space.
+    const viewingSub = client.spaces.subscribe((spaces) => {
       spaceSubscriptions.clear();
       spaces.forEach((space) => {
         spaceSubscriptions.add(
@@ -187,48 +301,63 @@ export default async (context: PluginContext) => {
               Array.isArray(added) &&
               Array.isArray(removed)
             ) {
-              added.forEach((id) => {
-                if (typeof id === 'string') {
-                  if (!(id in state.viewersByObject)) {
-                    state.viewersByObject[id] = new ComplexMap(PublicKey.hash);
+              // TODO(wittjosiah): Stop using (Complex)Map inside reactive object.
+              registry.update(ephemeralAtom, (ephemeral) => {
+                added.forEach((id) => {
+                  if (typeof id === 'string') {
+                    if (!(id in ephemeral.viewersByObject)) {
+                      ephemeral.viewersByObject[id] = new ComplexMap(PublicKey.hash);
+                    }
+                    ephemeral.viewersByObject[id]!.set(identityKey, {
+                      lastSeen: Date.now(),
+                      currentlyAttended: new Set(attended).has(id),
+                    });
+                    if (!ephemeral.viewersByIdentity.has(identityKey)) {
+                      ephemeral.viewersByIdentity.set(identityKey, new Set());
+                    }
+                    ephemeral.viewersByIdentity.get(identityKey)!.add(id);
                   }
-                  state.viewersByObject[id]!.set(identityKey, {
-                    lastSeen: Date.now(),
-                    currentlyAttended: new Set(attended).has(id),
-                  });
-                  if (!state.viewersByIdentity.has(identityKey)) {
-                    state.viewersByIdentity.set(identityKey, new Set());
+                });
+
+                removed.forEach((id) => {
+                  if (typeof id === 'string') {
+                    ephemeral.viewersByObject[id]?.delete(identityKey);
+                    ephemeral.viewersByIdentity.get(identityKey)?.delete(id);
+                    // It's okay for these to be empty sets/maps, reduces churn.
                   }
-                  state.viewersByIdentity.get(identityKey)!.add(id);
-                }
-              });
+                });
 
-              removed.forEach((id) => {
-                if (typeof id === 'string') {
-                  state.viewersByObject[id]?.delete(identityKey);
-                  state.viewersByIdentity.get(identityKey)?.delete(id);
-                  // It’s okay for these to be empty sets/maps, reduces churn.
-                }
+                return { ...ephemeral };
               });
             }
           }),
         );
       });
-    }).unsubscribe,
-  );
+    });
+    subscriptions.add(() => viewingSub.unsubscribe());
+
+    // Enable edge replication for all spaces.
+    try {
+      yield* Effect.tryPromise(() =>
+        Promise.all(
+          client.spaces
+            .get()
+            .map((space) => space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED)),
+        ),
+      );
+      registry.update(stateAtom, (current) => ({ ...current, enabledEdgeReplication: true }));
+    } catch (err) {
+      log.catch(err);
+    }
 
-  // Enable edge replication for all spaces.
-  try {
-    await Promise.all(
-      client.spaces.get().map((space) => space.internal.setEdgeReplicationPreference(EdgeReplicationSetting.ENABLED)),
+    return Capability.contributes(Capabilities.Null, null, () =>
+      Effect.gen(function* () {
+        if (personalSpaceInitFiber) {
+          yield* Fiber.interrupt(personalSpaceInitFiber);
+        }
+        spaceSubscriptions.clear();
+        subscriptions.clear();
+      }),
     );
-    state.enabledEdgeReplication = true;
-  } catch (err) {
-    log.catch(err);
-  }
-
-  return contributes(Capabilities.Null, null, () => {
-    spaceSubscriptions.clear();
-    subscriptions.clear();
-  });
-};
+  }),
+);