@dxos/client-services 0.1.56-main.09ca29d → 0.1.56-main.0e9f69e

package/src/packlets/services/platform.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+export type Platform = {
+  type: 'browser' | 'shared-worker' | 'node';
+  userAgent?: string;
+  platform?: string;
+  runtime?: string;
+  uptime?: number;
+  memory?: {
+    rss: number;
+    heapTotal: number;
+    heapUsed: number;
+    external: number;
+    arrayBuffers: number;
+  };
+};
+
+export const getPlatform = (): Platform => {
+  if ((process as any).browser) {
+    if (typeof window !== 'undefined') {
+      // Browser.
+      const { userAgent } = window.navigator;
+      return {
+        type: 'browser',
+        userAgent,
+        uptime: Math.floor((Date.now() - window.performance.timeOrigin) / 1_000),
+      };
+    } else {
+      // Shared worker.
+      return {
+        type: 'shared-worker',
+        uptime: Math.floor((Date.now() - performance.timeOrigin) / 1_000),
+      };
+    }
+  } else {
+    // Node.
+    const { platform, version, arch } = process;
+    return {
+      type: 'node',
+      platform: `${platform} ${version} ${arch}`,
+      runtime: process.version,
+      uptime: Math.floor(process.uptime()),
+      memory: process.memoryUsage(),
+    };
+  }
+};

package/src/packlets/services/service-context.test.ts

@@ -2,9 +2,18 @@
 // Copyright 2023 DXOS.org
 //
 
+import { expect } from 'chai';
+
+import { DocumentModel, DocumentModelState, MutationBuilder } from '@dxos/document-model';
+import { createModelMutation, encodeModelMutation, genesisMutation } from '@dxos/echo-db';
+import { WriteReceipt } from '@dxos/feed-store';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
 import { MemorySignalManagerContext } from '@dxos/messaging';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { describe, test } from '@dxos/test';
+import { Timeframe } from '@dxos/timeframe';
+import { range } from '@dxos/util';
 
 import { createServiceContext, syncItemsLocal } from '../testing';
 import { performInvitation } from '../testing/invitation-utils';
@@ -16,11 +25,61 @@ describe('services/ServiceContext', () => {
     await device1.createIdentity();
     const space1 = await device1.dataSpaceManager!.createSpace();
 
+    const itemId = PublicKey.random().toHex();
+    await space1.dataPipeline.databaseHost!.getWriteStream()?.write({
+      batch: genesisMutation(itemId, DocumentModel.meta.type),
+    });
+
+    let counter = 0;
+
+    for (const _ in range(5)) {
+      const receipts: WriteReceipt[] = [];
+      for (const _ in range(50)) {
+        receipts.push(
+          await space1.dataPipeline.databaseHost!.getWriteStream()!.write({
+            batch: createModelMutation(
+              itemId,
+              encodeModelMutation(DocumentModel.meta, new MutationBuilder().set('counter', ++counter).build()),
+            ),
+          }),
+        );
+      }
+
+      await space1.dataPipeline.pipelineState!.waitUntilTimeframe(
+        Timeframe.merge(...receipts.map((receipt) => new Timeframe([[receipt.feedKey, receipt.seq]]))),
+      );
+
+      await space1.createEpoch();
+      log.info('epoch', { number: space1.dataPipeline.currentEpoch?.subject.assertion.number });
+    }
+
     const device2 = createServiceContext({ signalContext: networkContext });
     await Promise.all(performInvitation({ host: device1, guest: device2, options: { kind: Invitation.Kind.DEVICE } }));
 
     await device2.dataSpaceManager!.waitUntilSpaceReady(space1!.key);
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
+
+    log.info('peer 2', {
+      currentEpoch: space2!.dataPipeline.currentEpoch?.subject.assertion.number,
+      appliedEpoch: space2!.dataPipeline.appliedEpoch?.subject.assertion.number,
+    });
+
+    await space2?.dataPipeline.onNewEpoch.waitForCondition(
+      () =>
+        space2!.dataPipeline.appliedEpoch?.subject.assertion.number ===
+        space1.dataPipeline.currentEpoch?.subject.assertion.number,
+    );
+
+    expect(space2!.dataPipeline.currentEpoch!.subject.assertion.number).to.equal(
+      space1.dataPipeline.currentEpoch!.subject.assertion.number,
+    );
+    expect(space2!.dataPipeline.appliedEpoch!.subject.assertion.number).to.equal(
+      space1.dataPipeline.appliedEpoch!.subject.assertion.number,
+    );
+
+    const item2 = space2!.dataPipeline.itemManager.entities.get(itemId);
+    expect((item2!.state as DocumentModelState).data.counter).to.equal(counter);
+
     await syncItemsLocal(space1.dataPipeline, space2!.dataPipeline);
   });
 

package/src/packlets/services/service-context.ts

@@ -3,6 +3,7 @@
 //
 
 import { Trigger } from '@dxos/async';
+import { Context } from '@dxos/context';
 import { CredentialProcessor, getCredentialAssertion } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
 import {
@@ -26,6 +27,8 @@ import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { Storage } from '@dxos/random-access-storage';
 import { BlobStore } from '@dxos/teleport-extension-object-sync';
+import { trace as Trace } from '@dxos/tracing';
+import { safeInstanceof } from '@dxos/util';
 
 import { CreateIdentityOptions, IdentityManager, JoinIdentityParams } from '../identity';
 import {
@@ -40,6 +43,9 @@ import { DataSpaceManager, SigningContext } from '../spaces';
  * Shared backend for all client services.
  */
 // TODO(burdon): Rename/break-up into smaller components. And/or make members private.
+// TODO(dmaretskyi): Gets duplicated in CJS build between normal and testing bundles.
+@safeInstanceof('dxos.client-services.ServiceContext')
+@Trace.resource()
 export class ServiceContext {
   public readonly initialized = new Trigger();
   public readonly dataServiceSubscriptions = new DataServiceSubscriptions();
@@ -121,21 +127,21 @@ export class ServiceContext {
     );
   }
 
-  async open() {
-    log.trace('dxos.sdk.service-context.open', trace.begin({ id: this._instanceId }));
-
+  @Trace.span()
+  async open(ctx: Context) {
     await this._checkStorageVersion();
 
     log('opening...');
+    log.trace('dxos.sdk.service-context.open', trace.begin({ id: this._instanceId }));
     await this.signalManager.open();
     await this.networkManager.open();
     await this.spaceManager.open();
-    await this.identityManager.open();
+    await this.identityManager.open(ctx);
     if (this.identityManager.identity) {
-      await this._initialize();
+      await this._initialize(ctx);
     }
-    log('opened');
     log.trace('dxos.sdk.service-context.open', trace.end({ id: this._instanceId }));
+    log('opened');
   }
 
   async close() {
@@ -156,7 +162,7 @@ export class ServiceContext {
   async createIdentity(params: CreateIdentityOptions = {}) {
     const identity = await this.identityManager.createIdentity(params);
 
-    await this._initialize();
+    await this._initialize(new Context());
     return identity;
   }
 
@@ -169,7 +175,7 @@ export class ServiceContext {
   private async _acceptIdentity(params: JoinIdentityParams) {
     const identity = await this.identityManager.acceptIdentity(params);
 
-    await this._initialize();
+    await this._initialize(new Context());
     return identity;
   }
 
@@ -182,7 +188,8 @@ export class ServiceContext {
   }
 
   // Called when identity is created.
-  private async _initialize() {
+  @Trace.span()
+  private async _initialize(ctx: Context) {
     log('initializing spaces...');
     const identity = this.identityManager.identity ?? failUndefined();
     const signingContext: SigningContext = {

package/src/packlets/services/service-host.test.ts

@@ -8,6 +8,7 @@ import { rmSync } from 'node:fs';
 
 import { asyncTimeout, latch, Trigger } from '@dxos/async';
 import { Config } from '@dxos/config';
+import { Context } from '@dxos/context';
 import { verifyPresentation } from '@dxos/credentials';
 import { PublicKey } from '@dxos/keys';
 import { MemorySignalManagerContext } from '@dxos/messaging';
@@ -30,7 +31,7 @@ describe('ClientServicesHost', () => {
 
   test('queryCredentials', async () => {
     const host = createServiceHost(new Config(), new MemorySignalManagerContext());
-    await host.open();
+    await host.open(new Context());
     afterTest(() => host.close());
 
     await host.services.IdentityService!.createIdentity({});
@@ -49,14 +50,14 @@ describe('ClientServicesHost', () => {
 
   test('write and query credentials', async () => {
     const host = createServiceHost(new Config(), new MemorySignalManagerContext());
-    await host.open();
+    await host.open(new Context());
     afterTest(() => host.close());
 
     await host.services.IdentityService!.createIdentity({});
 
     const testCredential = await createMockCredential({
-      signer: host._serviceContext.keyring,
-      issuer: host._serviceContext.identityManager.identity!.deviceKey,
+      signer: host.context.keyring,
+      issuer: host.context.identityManager.identity!.deviceKey,
     });
 
     // Test if Identity exposes haloSpace key.
@@ -86,14 +87,14 @@ describe('ClientServicesHost', () => {
 
   test('sign presentation', async () => {
     const host = createServiceHost(new Config(), new MemorySignalManagerContext());
-    await host.open();
+    await host.open(new Context());
     afterTest(() => host.close());
 
     await host.services.IdentityService!.createIdentity({});
 
     const testCredential = await createMockCredential({
-      signer: host._serviceContext.keyring,
-      issuer: host._serviceContext.identityManager.identity!.deviceKey,
+      signer: host.context.keyring,
+      issuer: host.context.identityManager.identity!.deviceKey,
     });
 
     const nonce = new Uint8Array([0, 0, 0, 0]);
@@ -117,11 +118,11 @@ describe('ClientServicesHost', () => {
     });
     {
       const host = createServiceHost(config, new MemorySignalManagerContext());
-      await host.open();
+      await host.open(new Context());
 
       await host.services.IdentityService?.createIdentity({});
 
-      expect(host._serviceContext.storage.size).to.exist;
+      expect(host.context.storage.size).to.exist;
 
       await asyncTimeout(host.reset(), 1000);
       await host.close();
@@ -129,7 +130,7 @@ describe('ClientServicesHost', () => {
 
     {
       const host = createServiceHost(config, new MemorySignalManagerContext());
-      await host.open();
+      await host.open(new Context());
       const trigger = new Trigger<Identity>();
 
       const stream = host.services.IdentityService?.queryIdentity();

package/src/packlets/services/service-host.ts

@@ -5,6 +5,7 @@
 import { Event, synchronized } from '@dxos/async';
 import { clientServiceBundle, ClientServices } from '@dxos/client-protocol';
 import { Config } from '@dxos/config';
+import { Context } from '@dxos/context';
 import { DocumentModel } from '@dxos/document-model';
 import { DataServiceImpl } from '@dxos/echo-pipeline';
 import { invariant } from '@dxos/invariant';
@@ -17,6 +18,7 @@ import { trace } from '@dxos/protocols';
 import { SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
 import { Storage } from '@dxos/random-access-storage';
 import { TextModel } from '@dxos/text-model';
+import { TRACE_PROCESSOR, trace as Trace } from '@dxos/tracing';
 
 import { DevicesServiceImpl } from '../devices';
 import { DevtoolsServiceImpl, DevtoolsHostEvents } from '../devtools';
@@ -28,6 +30,7 @@ import { NetworkServiceImpl } from '../network';
 import { SpacesServiceImpl } from '../spaces';
 import { createStorageObjects } from '../storage';
 import { SystemServiceImpl } from '../system';
+import { createDiagnostics } from './diagnostics';
 import { ServiceContext } from './service-context';
 import { ServiceRegistry } from './service-registry';
 
@@ -64,11 +67,13 @@ export type InitializeOptions = {
 /**
  * Remote service implementation.
  */
+@Trace.resource()
 export class ClientServicesHost {
   private readonly _resourceLock?: ResourceLock;
   private readonly _serviceRegistry: ServiceRegistry<ClientServices>;
   private readonly _systemService: SystemServiceImpl;
   private readonly _loggingService: LoggingServiceImpl;
+  private readonly _tracingService = TRACE_PROCESSOR.createTraceSender();
 
   private _config?: Config;
   private readonly _statusUpdate = new Event<void>();
@@ -78,17 +83,19 @@ export class ClientServicesHost {
   private _storage?: Storage;
   private _callbacks?: ClientServicesHostCallbacks;
 
-  _serviceContext!: ServiceContext;
+  private _serviceContext!: ServiceContext;
+
+  @Trace.info()
   private _opening = false;
+
+  @Trace.info()
   private _open = false;
 
   constructor({
     config,
     modelFactory = createDefaultModelFactory(),
-    // TODO(burdon): Create ApolloLink abstraction (see Client).
     transportFactory,
     signalManager,
-    connectionLog,
     storage,
     // TODO(wittjosiah): Turn this on by default.
     lockKey,
@@ -107,7 +114,7 @@ export class ClientServicesHost {
         lockKey,
         onAcquire: () => {
           if (!this._opening) {
-            void this.open();
+            void this.open(new Context());
           }
         },
         onRelease: () => this.close(),
@@ -116,11 +123,11 @@ export class ClientServicesHost {
 
     this._systemService = new SystemServiceImpl({
       config: this._config,
-
       statusUpdate: this._statusUpdate,
-
       getCurrentStatus: () => (this.isOpen ? SystemStatus.ACTIVE : SystemStatus.INACTIVE),
-
+      getDiagnostics: () => {
+        return createDiagnostics(this._serviceRegistry.services, this._serviceContext, this._config!);
+      },
       onUpdateStatus: async (status: SystemStatus) => {
         if (!this.isOpen && status === SystemStatus.ACTIVE) {
           await this._resourceLock?.acquire();
@@ -128,7 +135,6 @@ export class ClientServicesHost {
           await this._resourceLock?.release();
         }
       },
-
       onReset: async () => {
         await this.reset();
       },
@@ -136,9 +142,9 @@ export class ClientServicesHost {
 
     this._loggingService = new LoggingServiceImpl();
 
-    // TODO(burdon): Start to think of DMG (dynamic services).
     this._serviceRegistry = new ServiceRegistry<ClientServices>(clientServiceBundle, {
       SystemService: this._systemService,
+      TracingService: this._tracingService,
     });
   }
 
@@ -146,6 +152,14 @@ export class ClientServicesHost {
     return this._open;
   }
 
+  get config() {
+    return this._config;
+  }
+
+  get context() {
+    return this._serviceContext;
+  }
+
   get serviceRegistry() {
     return this._serviceRegistry;
   }
@@ -165,10 +179,10 @@ export class ClientServicesHost {
    */
   initialize({ config, ...options }: InitializeOptions) {
     invariant(!this._open, 'service host is open');
+    log('initializing...');
 
     if (config) {
       invariant(!this._config, 'config already set');
-
       this._config = config;
       if (!this._storage) {
         this._storage = createStorageObjects(config.get('runtime.client.storage', {})!).storage;
@@ -190,16 +204,19 @@ export class ClientServicesHost {
       transportFactory,
       signalManager,
     });
+
+    log('initialized');
   }
 
   @synchronized
-  async open() {
+  @Trace.span()
+  async open(ctx: Context) {
     if (this._open) {
       return;
     }
 
     const traceId = PublicKey.random().toHex();
-    log.trace('dxos.sdk.client-services-host.open', trace.begin({ id: traceId }));
+    log.trace('dxos.client-services.host.open', trace.begin({ id: traceId }));
 
     invariant(this._config, 'config not set');
     invariant(this._storage, 'storage not set');
@@ -212,8 +229,6 @@ export class ClientServicesHost {
 
     await this._loggingService.open();
 
-    // TODO(wittjosiah): Make re-entrant.
-    // TODO(burdon): Break into components.
     this._serviceContext = new ServiceContext(
       this._storage,
       this._networkManager,
@@ -221,11 +236,14 @@ export class ClientServicesHost {
       this._modelFactory,
     );
 
-    // TODO(burdon): Start to think of DMG (dynamic services).
     this._serviceRegistry.setServices({
       SystemService: this._systemService,
 
-      IdentityService: new IdentityServiceImpl(this._serviceContext),
+      IdentityService: new IdentityServiceImpl(
+        (params) => this._serviceContext.createIdentity(params),
+        this._serviceContext.identityManager,
+        this._serviceContext.keyring,
+      ),
 
       InvitationsService: new InvitationsServiceImpl(this._serviceContext.invitations, (invitation) =>
         this._serviceContext.getInvitationHandler(invitation),
@@ -248,6 +266,7 @@ export class ClientServicesHost {
       NetworkService: new NetworkServiceImpl(this._serviceContext.networkManager, this._serviceContext.signalManager),
 
       LoggingService: this._loggingService,
+      TracingService: this._tracingService,
 
       // TODO(burdon): Move to new protobuf definitions.
       DevtoolsHost: new DevtoolsServiceImpl({
@@ -257,16 +276,17 @@ export class ClientServicesHost {
       }),
     });
 
-    await this._serviceContext.open();
+    await this._serviceContext.open(ctx);
     this._opening = false;
     this._open = true;
     this._statusUpdate.emit();
     const deviceKey = this._serviceContext.identityManager.identity?.deviceKey;
     log('opened', { deviceKey });
-    log.trace('dxos.sdk.client-services-host.open', trace.end({ id: traceId }));
+    log.trace('dxos.client-services.host.open', trace.end({ id: traceId }));
   }
 
   @synchronized
+  @Trace.span()
   async close() {
     if (!this._open) {
       return;

package/src/packlets/services/service-registry.test.ts

@@ -7,6 +7,7 @@ import { expect } from 'chai';
 import { Event } from '@dxos/async';
 import { ClientServices } from '@dxos/client-protocol';
 import { Config } from '@dxos/config';
+import { Context } from '@dxos/context';
 import { log } from '@dxos/log';
 import { schema } from '@dxos/protocols';
 import { SystemService, SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
@@ -31,12 +32,13 @@ describe('service registry', () => {
   test('builds a service registry', async () => {
     const remoteSource = 'https://remote.source';
     const serviceContext = createServiceContext();
-    await serviceContext.open();
+    await serviceContext.open(new Context());
 
     const serviceRegistry = new ServiceRegistry(serviceBundle, {
       SystemService: new SystemServiceImpl({
         config: new Config({ runtime: { client: { remoteSource } } }),
         getCurrentStatus: () => SystemStatus.ACTIVE,
+        getDiagnostics: async () => ({}),
         onReset: () => {},
         onUpdateStatus: () => {},
         statusUpdate: new Event(),

package/src/packlets/services/util.ts

@@ -0,0 +1,33 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { PublicKey } from '@dxos/keys';
+import { humanize } from '@dxos/util';
+
+// TODO(burdon): Move to util.
+
+export type JsonStringifyOptions = {
+  truncate?: boolean;
+  humanize?: boolean;
+};
+
+export const jsonStringify = <T>(data: T, options: JsonStringifyOptions) => {
+  if (options.humanize || options.truncate) {
+    return JSON.parse(JSON.stringify(data, jsonKeyReplacer(options)));
+  }
+
+  return data;
+};
+
+const jsonKeyReplacer = (options: JsonStringifyOptions) => (key: string, value: any) => {
+  if (typeof value === 'string') {
+    // Infer if key.
+    const key = PublicKey.fromHex(value);
+    if (key.toHex() === value) {
+      return options.humanize ? humanize(key) : key.truncate();
+    }
+  }
+
+  return value;
+};

package/src/packlets/spaces/data-space-manager.test.ts

@@ -13,9 +13,11 @@ import { writeMessages } from '@dxos/feed-store';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { SpaceState } from '@dxos/protocols/proto/dxos/client/services';
+import { SpaceSnapshot } from '@dxos/protocols/proto/dxos/echo/snapshot';
 import { Epoch } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { StorageType } from '@dxos/random-access-storage';
 import { afterTest, describe, openAndClose, test } from '@dxos/test';
+import { Timeframe } from '@dxos/timeframe';
 import { range } from '@dxos/util';
 
 import { TestBuilder, syncItemsLocal } from '../testing';
@@ -156,33 +158,34 @@ describe('DataSpaceManager', () => {
   });
 
   describe('Epochs', () => {
-    test('Epoch truncates feeds', async () => {
-      const builder = new TestBuilder();
-      afterTest(async () => builder.destroy());
+    test
+      .skip('Epoch truncates feeds', async () => {
+        const builder = new TestBuilder();
+        afterTest(async () => builder.destroy());
 
-      const peer = builder.createPeer({
-        storageType: typeof window === 'undefined' ? StorageType.NODE : StorageType.WEBFS,
-      });
-      await peer.createIdentity();
-      await openAndClose(peer.dataSpaceManager);
-      const space = await peer.dataSpaceManager.createSpace();
-      await space.inner.controlPipeline.state.waitUntilTimeframe(space.inner.controlPipeline.state.endTimeframe);
+        const peer = builder.createPeer({
+          storageType: typeof window === 'undefined' ? StorageType.NODE : StorageType.WEBFS,
+        });
+        await peer.createIdentity();
+        await openAndClose(peer.dataSpaceManager);
+        const space = await peer.dataSpaceManager.createSpace();
+        await space.inner.controlPipeline.state.waitUntilTimeframe(space.inner.controlPipeline.state.endTimeframe);
 
-      const feedDataPath = path.join(space.inner.dataPipeline.pipelineState!.feeds[0].key.toHex(), 'data');
-      const directory = peer.storage.createDirectory('feeds');
-      const file = directory.getOrCreateFile(feedDataPath);
-      afterTest(() => file.close());
+        const feedDataPath = path.join(space.inner.dataPipeline.pipelineState!.feeds[0].key.toHex(), 'data');
+        const directory = peer.storage.createDirectory('feeds');
+        const file = directory.getOrCreateFile(feedDataPath);
+        afterTest(() => file.close());
 
-      expect((await file.stat()).size === 0).to.be.true;
+        expect((await file.stat()).size === 0).to.be.true;
 
-      for (const _ in range(10)) {
-        await testLocalDatabase(space.dataPipeline);
-      }
+        for (const _ in range(10)) {
+          await testLocalDatabase(space.dataPipeline);
+        }
 
-      expect((await file.stat()).size !== 0).to.be.true;
-      await space.createEpoch();
-      expect((await file.stat()).size === 0).to.be.true;
-    })
+        expect((await file.stat()).size !== 0).to.be.true;
+        await space.createEpoch();
+        expect((await file.stat()).size === 0).to.be.true;
+      })
       .onlyEnvironments('nodejs', 'chromium', 'firefox')
       .tag('flaky');
 
@@ -228,6 +231,61 @@ describe('DataSpaceManager', () => {
         expect(epochs).to.deep.equal([epochsNumber]);
       }
     });
+
+    test('Items are cleared before epoch applied', async () => {
+      const builder = new TestBuilder();
+      afterTest(async () => builder.destroy());
+      const peer = builder.createPeer();
+      await peer.createIdentity();
+      await openAndClose(peer.dataSpaceManager);
+
+      // Create space and fill it with Items.
+      const space = await peer.dataSpaceManager.createSpace();
+      await space.inner.controlPipeline.state.waitUntilTimeframe(space.inner.controlPipeline.state.endTimeframe);
+      const itemsNumber = 2;
+      for (const _ of range(itemsNumber)) {
+        await testLocalDatabase(space.dataPipeline);
+      }
+
+      // Create empty Epoch and check if it clears items.
+      {
+        const processedFirstEpoch = space.dataPipeline.onNewEpoch.waitFor(
+          (epoch) => epoch.subject.assertion.number === 1,
+        );
+
+        // Empty snapshot.
+        const snapshot: SpaceSnapshot = {
+          spaceKey: space.key.asUint8Array(),
+          timeframe: space.inner.dataPipeline.pipelineState!.timeframe,
+          database: {},
+        };
+
+        const snapshotCid = await peer.snapshotStore.saveSnapshot(snapshot);
+
+        const epoch: Epoch = {
+          previousId: space.dataPipeline.currentEpoch?.id,
+          timeframe: space.inner.dataPipeline.pipelineState!.timeframe,
+          number: (space.dataPipeline.currentEpoch?.subject.assertion as Epoch).number + 1,
+          snapshotCid,
+        };
+
+        const receipt = await space.inner.controlPipeline.writer.write({
+          credential: {
+            credential: await peer.props.signingContext!.credentialSigner.createCredential({
+              subject: space.key,
+              assertion: {
+                '@type': 'dxos.halo.credentials.Epoch',
+                ...epoch,
+              },
+            }),
+          },
+        });
+        await space.inner.controlPipeline.state.waitUntilTimeframe(new Timeframe([[receipt.feedKey, receipt.seq]]));
+        await processedFirstEpoch;
+      }
+
+      expect(Array.from(space.dataPipeline.itemManager.entities.keys()).length).to.equal(0);
+    });
   });
 
   describe('activation', () => {