@dxos/plugin-space 0.8.4-main.72ec0f3 → 0.8.4-main.7996785055

package/src/capabilities/spaces-ready/spaces-ready.ts

@@ -0,0 +1,351 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities, LayoutOperation, getPersonalSpace, getSpacePath, setPersonalSpace } from '@dxos/app-toolkit';
+import { SubscriptionList } from '@dxos/async';
+import { Filter, Obj } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { AttentionCapabilities } from '@dxos/plugin-attention';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { Graph } from '@dxos/plugin-graph';
+import { EdgeReplicationSetting } from '@dxos/protocols/proto/dxos/echo/metadata';
+import { PublicKey } from '@dxos/react-client';
+import { type Space, SPACE_ID_LENGTH, SpaceState, parseId } from '@dxos/react-client/echo';
+import { Expando } from '@dxos/schema';
+import { ComplexMap, reduceGroupBy } from '@dxos/util';
+
+import { SpaceCapabilities } from '../../types';
+import { SpaceOperation } from '../../operations';
+import { SHARED } from '../../util';
+
+const ACTIVE_NODE_BROADCAST_INTERVAL = 30_000;
+const WAIT_FOR_OBJECT_TIMEOUT = 5_000;
+
+// E.g., dxn:echo:BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE:01J00J9B45YHYSGZQTQMSKMGJ6
+const ECHO_DXN_LENGTH = 3 + 1 + 4 + 1 + 33 + 1 + 26;
+
+/**
+ * Resolve the personal space, migrating from legacy DefaultSpace credential if needed.
+ * Returns undefined for new users who haven't created an identity yet.
+ */
+const resolvePersonalSpace = (client: {
+  spaces: { get(): Space[]; get(id: any): Space | undefined };
+  halo: { queryCredentials(options: { type: string }): any[] };
+}): { space: Space; fromCredential: boolean } | undefined => {
+  // Check for personal space via tags or __DEFAULT__ property.
+  const found = getPersonalSpace(client);
+  if (found) {
+    return { space: found, fromCredential: false };
+  }
+
+  // Migration: read the legacy DefaultSpace credential from HALO.
+  const defaultSpaceCredential = client.halo.queryCredentials({
+    type: 'dxos.halo.credentials.DefaultSpace',
+  })[0];
+  if (!defaultSpaceCredential) {
+    // New user — no credential, no personal space yet.
+    return undefined;
+  }
+
+  const defaultSpaceId = defaultSpaceCredential.subject.assertion.spaceId;
+  const space = client.spaces.get(defaultSpaceId);
+  return space ? { space, fromCredential: true } : undefined;
+};
+
+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.
+    //
+
+    let personalSpaceInitialized = false;
+    const initializePersonalSpace = async (personalSpace: Space, { fromCredential }: { fromCredential: boolean }) => {
+      if (personalSpaceInitialized) {
+        return;
+      }
+
+      await personalSpace.waitUntilReady();
+      personalSpaceInitialized = true;
+
+      // Only set the __DEFAULT__ property when migrating from the legacy credential.
+      // Spaces created with the personal tag don't need it.
+      if (fromCredential) {
+        setPersonalSpace(personalSpace);
+      }
+
+      // Check if deck state indicates we should switch to default space.
+      const layout = registry.get(layoutAtom);
+      if (layout.workspace === 'default') {
+        await invoke(LayoutOperation.SwitchWorkspace, { subject: getSpacePath(personalSpace.id) }).pipe(
+          Effect.runPromise,
+        );
+      }
+
+      const queryResults = await personalSpace.db.query(Filter.type(Expando.Expando, { key: SHARED })).run();
+      const spacesOrder = queryResults[0];
+      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.
+        personalSpace.db.add(Obj.make(Expando.Expando, { key: SHARED, order: [] }));
+      }
+    };
+
+    // Try to find the personal space now, or subscribe to find it later.
+    // Initialization is async (non-blocking) so subscriptions wire immediately.
+    const resolved = resolvePersonalSpace(client);
+    if (resolved) {
+      void initializePersonalSpace(resolved.space, resolved);
+    } else {
+      subscriptions.add(
+        client.spaces.subscribe(() => {
+          const resolved = resolvePersonalSpace(client);
+          if (resolved) {
+            void initializePersonalSpace(resolved.space, resolved);
+          }
+        }).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 && (id.length === ECHO_DXN_LENGTH || 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.
+    subscriptions.add(
+      client.spaces.subscribe(async (spaces) => {
+        // TODO(wittjosiah): Remove. This is a hack to be able to migrate the personal space properties.
+        const resolved = resolvePersonalSpace(client);
+        if (resolved?.space && resolved.space.state.get() === SpaceState.SPACE_REQUIRES_MIGRATION) {
+          const personalSpace = resolved.space;
+          await personalSpace.internal.migrate();
+        }
+
+        spaces
+          .filter((space) => space.state.get() === SpaceState.SPACE_READY)
+          .forEach((space) => {
+            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 - 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;
+            }
+          });
+
+          const removedBySpace = reduceGroupBy(inactive, (id: string) => {
+            try {
+              const { spaceId } = parseId(id);
+              return spaceId;
+            } catch {
+              return null;
+            }
+          });
+
+          // 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, []);
+            }
+          }
+
+          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.
+    subscriptions.add(
+      client.spaces.subscribe((spaces) => {
+        spaceSubscriptions.clear();
+        spaces.forEach((space) => {
+          spaceSubscriptions.add(
+            space.listen('viewing', (message) => {
+              const { added, removed, attended } = message.payload;
+
+              const identityKey = PublicKey.safeFrom(message.payload.identityKey);
+              const currentIdentity = client.halo.identity.get();
+              if (
+                identityKey &&
+                !currentIdentity?.identityKey.equals(identityKey) &&
+                Array.isArray(added) &&
+                Array.isArray(removed)
+              ) {
+                // 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);
+                    }
+                  });
+
+                  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.
+                    }
+                  });
+
+                  return { ...ephemeral };
+                });
+              }
+            }),
+          );
+        });
+      }).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);
+    }
+
+    return Capability.contributes(Capabilities.Null, null, () =>
+      Effect.sync(() => {
+        spaceSubscriptions.clear();
+        subscriptions.clear();
+      }),
+    );
+  }),
+);

package/src/capabilities/state/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const SpaceState = Capability.lazy('SpaceState', () => import('./state'));

package/src/capabilities/state/state.ts

@@ -0,0 +1,66 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { createKvsStore } from '@dxos/effect';
+import { PublicKey } from '@dxos/keys';
+import { ComplexMap } from '@dxos/util';
+
+import { meta } from '../../meta';
+import { SpaceCapabilities } from '../../types';
+
+/** Default persisted state. */
+const defaultSpaceState: SpaceCapabilities.SpaceState = {
+  spaceNames: {},
+  enabledEdgeReplication: false,
+};
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const registry = yield* Capability.get(Capabilities.AtomRegistry);
+
+    // Persisted state using KVS store.
+    const stateAtom = createKvsStore({
+      key: `${meta.id}.state`,
+      schema: SpaceCapabilities.StateSchema,
+      defaultValue: () => ({ ...defaultSpaceState }),
+    });
+
+    // Ephemeral state (not persisted, but kept alive to prevent GC resets).
+    const ephemeralAtom = Atom.make<SpaceCapabilities.SpaceEphemeralState>({
+      awaiting: undefined,
+      sdkMigrationRunning: {},
+      navigableCollections: false,
+      viewersByObject: {},
+      viewersByIdentity: new ComplexMap<PublicKey, Set<string>>(PublicKey.hash),
+    }).pipe(Atom.keepAlive);
+
+    const manager = yield* Capability.get(Capabilities.PluginManager);
+    // Update navigableCollections based on plugin state.
+    const updateNavigableCollections = () => {
+      const enabled =
+        manager.getEnabled().includes('org.dxos.plugin.stack') ||
+        manager.getEnabled().includes('org.dxos.plugin.simple-layout');
+      const current = registry.get(ephemeralAtom);
+      if (enabled !== current.navigableCollections) {
+        registry.update(ephemeralAtom, (c) => ({ ...c, navigableCollections: enabled }));
+      }
+    };
+    // Check initial state and subscribe to changes.
+    updateNavigableCollections();
+    const unsubscribe = registry.subscribe(manager.enabled, updateNavigableCollections);
+
+    return [
+      Capability.contributes(SpaceCapabilities.State, stateAtom),
+      Capability.contributes(SpaceCapabilities.EphemeralState, ephemeralAtom, () =>
+        Effect.sync(() => {
+          unsubscribe();
+        }),
+      ),
+    ];
+  }),
+);

package/src/capabilities/undo-mappings/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const UndoMappings = Capability.lazy('UndoMappings', () => import('./undo-mappings'));

package/src/capabilities/undo-mappings/undo-mappings.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability, UndoMapping } from '@dxos/app-framework';
+import { Obj } from '@dxos/echo';
+
+import { meta } from '../../meta';
+import { SpaceOperation } from '../../operations';
+import { SpaceOperationConfig } from '../../operations/helpers';
+
+type UndoMappingsOptions = {
+  createInvitationUrl: (invitationCode: string) => string;
+  observability?: boolean;
+};
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* ({ createInvitationUrl, observability }: UndoMappingsOptions) {
+    return [
+      Capability.contributes(Capabilities.UndoMapping, [
+        UndoMapping.make({
+          operation: SpaceOperation.DeleteField,
+          inverse: SpaceOperation.RestoreField,
+          deriveContext: (input, output) => ({
+            view: input.view,
+            field: output.field,
+            props: output.props,
+            index: output.index,
+          }),
+          message: ['field deleted label', { ns: meta.id }],
+        }),
+        UndoMapping.make({
+          operation: SpaceOperation.RemoveObjects,
+          inverse: SpaceOperation.RestoreObjects,
+          deriveContext: (_input, output) => ({
+            objects: output.objects,
+            parentCollection: output.parentCollection,
+            indices: output.indices,
+            nestedObjectsList: output.nestedObjectsList,
+            wasActive: output.wasActive,
+          }),
+          message: (input, _output) => {
+            const ns = Obj.getTypename(input.objects[0]);
+            return ns && input.objects.length === 1
+              ? ['object deleted label', { ns }]
+              : ['objects deleted label', { ns: meta.id }];
+          },
+        }),
+      ]),
+      Capability.contributes(SpaceOperationConfig, {
+        createInvitationUrl,
+        observability: observability ?? false,
+      }),
+    ];
+  }),
+);

package/src/cli/commands/database/add.ts

@@ -0,0 +1,110 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+import * as Options from '@effect/cli/Options';
+import * as Prompt from '@effect/cli/Prompt';
+import * as Console from 'effect/Console';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import type * as Schema from 'effect/Schema';
+
+// eslint-disable-next-line unused-imports/no-unused-imports
+import { type Capability, Plugin } from '@dxos/app-framework';
+import { AppActivationEvents, AppCapabilities } from '@dxos/app-toolkit';
+import { CommandConfig, Common, flushAndSync, print, spaceLayer } from '@dxos/cli-util';
+import { SpaceProperties } from '@dxos/client/echo';
+import { Database, Filter, Obj, Type } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
+import { EntityKind, getTypeAnnotation } from '@dxos/echo/internal';
+// eslint-disable-next-line unused-imports/no-unused-imports
+import type { Operation } from '@dxos/operation';
+
+import { type CreateObject } from '../../../types';
+
+import { printObject } from './util';
+
+export type Metadata = {
+  createObject: CreateObject;
+  inputSchema?: Schema.Schema.AnyNoContext;
+};
+
+export const add = Command.make(
+  'add',
+  {
+    spaceId: Common.spaceId.pipe(Options.optional),
+    typename: Options.text('typename').pipe(Options.withDescription('The typename to create.'), Options.optional),
+  },
+  ({ typename }) =>
+    Effect.gen(function* () {
+      const { json } = yield* CommandConfig;
+      const manager = yield* Plugin.Service;
+      const { db } = yield* Database.Service;
+
+      yield* manager.activate(AppActivationEvents.SetupMetadata);
+
+      const resolve = (typename: string) => {
+        const metadata = manager.capabilities
+          .getAll(AppCapabilities.Metadata)
+          .find(({ id }) => id === typename)?.metadata;
+        return metadata?.createObject ? (metadata as Metadata) : undefined;
+      };
+
+      const [properties] = yield* Database.runQuery(Filter.type(SpaceProperties));
+      const collection = yield* Database.load<Collection.Collection>(properties[Collection.Collection.typename]);
+
+      const selectedTypename = yield* Option.match(typename, {
+        onNone: () => selectTypename(resolve),
+        onSome: (t) => Effect.succeed(t),
+      });
+      const metadata = resolve(selectedTypename);
+      if (!metadata) {
+        return yield* Effect.fail(new Error(`Unknown typename: ${selectedTypename}`));
+      }
+
+      const result = yield* metadata.createObject({}, { db, target: collection });
+      const object = result.object;
+      if (!Obj.isObject(object)) {
+        return yield* Effect.fail(new Error(`Invalid object: ${object}`));
+      }
+
+      if (json) {
+        yield* Console.log(JSON.stringify(object, null, 2));
+      } else {
+        yield* Console.log(print(printObject(object)));
+      }
+
+      yield* flushAndSync({ indexes: true });
+    }),
+).pipe(
+  Command.withDescription('Add an object to a space.'),
+  Command.provide(({ spaceId }) => spaceLayer(spaceId, true)),
+);
+
+/**
+ * Prompts for typename selection if not provided.
+ */
+const selectTypename = Effect.fn(function* (resolve: (typename: string) => Metadata | undefined) {
+  const schemas = yield* Database.runSchemaQuery({
+    location: ['database', 'runtime'],
+    includeSystem: false,
+  }).pipe(
+    Effect.map((schemas) => schemas.filter((schema) => getTypeAnnotation(schema)?.kind !== EntityKind.Relation)),
+    Effect.map((schemas) => schemas.filter((schema) => !!resolve(Type.getTypename(schema)))),
+  );
+
+  const choices = schemas.map((schema) => ({
+    // TODO(wittjosiah): Translations.
+    title: Type.getTypename(schema),
+    value: Type.getTypename(schema),
+    description: Type.getTypename(schema),
+  }));
+
+  const selected = yield* Prompt.select({
+    message: 'Select a type:',
+    choices,
+  });
+
+  return selected;
+});

package/src/cli/commands/database/index.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Command from '@effect/cli/Command';
+
+import { add } from './add';
+import { query } from './query';
+import { remove } from './remove';
+import { stats } from './stats';
+
+// TODO(wittjosiah): Alias to `db`.
+export const database: Command.Command<any, any, any, any> = Command.make('database').pipe(
+  Command.withDescription('Database access.'),
+  Command.withSubcommands([add, query, remove, stats]),
+);

package/src/cli/commands/database/query/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './query';

package/src/cli/commands/database/query/query.test.ts

@@ -0,0 +1,53 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+
+import { spaceLayer } from '@dxos/cli-util';
+import { TestConsole, TestLayer } from '@dxos/cli-util/testing';
+import { ClientService } from '@dxos/client';
+import { Obj } from '@dxos/echo';
+import { runAndForwardErrors } from '@dxos/effect';
+import { Task } from '@dxos/types';
+
+import { handler } from './query';
+
+describe('spaces query', () => {
+  it('should query empty space', () =>
+    Effect.gen(function* () {
+      // TODO(wittjosiah): Create test runtime so that client service can be shared with `beforeEach`.
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.halo.createIdentity());
+      const space = yield* Effect.tryPromise(() => client.spaces.create());
+      yield* Effect.tryPromise(() => space.waitUntilReady());
+      yield* handler({ typename: Option.some(Task.Task.typename) }).pipe(
+        Effect.provide(spaceLayer(Option.some(space.id))),
+      );
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      expect(TestConsole.extractJsonString(logs[0])).toEqual('[]');
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+
+  it('should query space for objects', () =>
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      yield* Effect.tryPromise(() => client.addTypes([Task.Task]));
+      yield* Effect.tryPromise(() => client.halo.createIdentity());
+      const space = yield* Effect.tryPromise(() => client.spaces.create());
+      yield* Effect.tryPromise(() => space.waitUntilReady());
+      space.db.add(Obj.make(Task.Task, { title: 'Task 1' }));
+      space.db.add(Obj.make(Task.Task, { title: 'Task 2' }));
+      yield* handler({ typename: Option.some(Task.Task.typename) }).pipe(
+        Effect.provide(spaceLayer(Option.some(space.id))),
+      );
+      const logger = yield* TestConsole.TestConsole;
+      const logs = logger.logs;
+      expect(logs).toHaveLength(1);
+      const formattedObjects = TestConsole.parseJson(logs[0]);
+      expect(formattedObjects).toHaveLength(2);
+    }).pipe(Effect.provide(TestLayer), Effect.scoped, runAndForwardErrors));
+});