@dxos/client-services 0.4.9-main.4fd47cd → 0.4.9-main.7750cb2

package/src/packlets/services/diagnostics.ts

@@ -6,11 +6,8 @@ import { type ClientServices } from '@dxos/client-protocol';
 import { getFirstStreamValue } from '@dxos/codec-protobuf';
 import { type Config, type ConfigProto } from '@dxos/config';
 import { credentialTypeFilter } from '@dxos/credentials';
-import { DocumentModel, type DocumentModelState } from '@dxos/document-model';
-import { TYPE_PROPERTIES } from '@dxos/echo-db';
 import { invariant } from '@dxos/invariant';
 import { type PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
 import { STORAGE_VERSION } from '@dxos/protocols';
 import {
   type Device,
@@ -180,25 +177,6 @@ export const createDiagnostics = async (
   return diagnostics;
 };
 
-const getProperties = (space: DataSpace) => {
-  let properties: any = {};
-  try {
-    // Add properties to cache.
-    const propertiesItem = space.dataPipeline.itemManager.items.find(
-      (item) =>
-        item.modelMeta?.type === DocumentModel.meta.type &&
-        (item.state as DocumentModelState)?.type?.itemId === TYPE_PROPERTIES,
-    );
-
-    const state = propertiesItem?.state as DocumentModelState;
-    properties = state?.data;
-  } catch (err: any) {
-    log.warn(err.message);
-  }
-
-  return properties;
-};
-
 const getSpaceStats = async (space: DataSpace): Promise<SpaceStats> => {
   const stats: SpaceStats = {
     key: space.key,
@@ -226,33 +204,16 @@ const getSpaceStats = async (space: DataSpace): Promise<SpaceStats> => {
 
     pipeline: {
       // TODO(burdon): Pick properties from credentials if needed.
-      // currentEpoch: space.dataPipeline.currentEpoch,
-      // appliedEpoch: space.dataPipeline.appliedEpoch,
+      currentEpoch: space.automergeSpaceState.lastEpoch,
+      appliedEpoch: space.automergeSpaceState.lastEpoch,
 
       controlFeeds: space.inner.controlPipeline.state.feeds.map((feed) => feed.key),
       currentControlTimeframe: space.inner.controlPipeline.state.timeframe,
       targetControlTimeframe: space.inner.controlPipeline.state.targetTimeframe,
       totalControlTimeframe: space.inner.controlPipeline.state.endTimeframe,
-
-      // TODO(burdon): Empty?
-      dataFeeds: space.dataPipeline.pipelineState?.feeds.map((feed) => feed.key) ?? [],
-      startDataTimeframe: space.dataPipeline.pipelineState?.startTimeframe,
-      currentDataTimeframe: space.dataPipeline.pipelineState?.timeframe,
-      targetDataTimeframe: space.dataPipeline.pipelineState?.targetTimeframe,
-      totalDataTimeframe: space.dataPipeline.pipelineState?.endTimeframe,
     },
   };
 
-  // TODO(burdon): May not be open?
-  if (space.dataPipeline.itemManager) {
-    Object.assign(stats, {
-      properties: getProperties(space),
-      db: {
-        objects: space.dataPipeline.itemManager.entities.size,
-      },
-    } as SpaceStats);
-  }
-
   // TODO(burdon): Factor out.
   if (stats.metrics) {
     const { open, ready } = stats.metrics;

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

@@ -2,87 +2,14 @@
 // Copyright 2023 DXOS.org
 //
 
-import { expect } from 'chai';
-
-import { DocumentModel, type DocumentModelState, MutationBuilder } from '@dxos/document-model';
-import { createModelMutation, encodeModelMutation, genesisMutation } from '@dxos/echo-db';
-import { type 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 { createServiceContext } from '../testing';
 import { performInvitation } from '../testing/invitation-utils';
 
 describe('services/ServiceContext', () => {
-  test('existing space is synchronized on device invitations', async () => {
-    const networkContext = new MemorySignalManagerContext();
-    const device1 = createServiceContext({ signalContext: networkContext });
-    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('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('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);
-  });
-
   test('new space is synchronized on device invitations', async () => {
     const networkContext = new MemorySignalManagerContext();
     const device1 = createServiceContext({ signalContext: networkContext });
@@ -94,7 +21,7 @@ describe('services/ServiceContext', () => {
     const space1 = await device1.dataSpaceManager!.createSpace();
     await device2.dataSpaceManager!.waitUntilSpaceReady(space1!.key);
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
-    await syncItemsLocal(space1.dataPipeline, space2!.dataPipeline);
+    await space2!.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.timeframe);
   }).tag('flaky');
 
   test('joined space is synchronized on device invitations', async () => {
@@ -118,6 +45,6 @@ describe('services/ServiceContext', () => {
 
     await device2.dataSpaceManager!.waitUntilSpaceReady(space1!.key);
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
-    await syncItemsLocal(space1.dataPipeline, space2!.dataPipeline);
+    await space2!.inner.controlPipeline.state.waitUntilTimeframe(space1.inner.controlPipeline.state.timeframe);
   });
 });

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

@@ -4,16 +4,9 @@
 
 import { Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
-import { type CredentialProcessor, getCredentialAssertion } from '@dxos/credentials';
+import { getCredentialAssertion, type CredentialProcessor } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
-import {
-  valueEncoding,
-  MetadataStore,
-  SpaceManager,
-  DataServiceSubscriptions,
-  SnapshotStore,
-  AutomergeHost,
-} from '@dxos/echo-pipeline';
+import { AutomergeHost, MetadataStore, SnapshotStore, SpaceManager, valueEncoding } from '@dxos/echo-pipeline';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { IndexMetadataStore, IndexStore, Indexer } from '@dxos/indexing';
 import { invariant } from '@dxos/invariant';
@@ -26,15 +19,15 @@ import { type NetworkManager } from '@dxos/network-manager';
 import { InvalidStorageVersionError, STORAGE_VERSION, trace } from '@dxos/protocols';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
-import { type ProfileDocument, type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { type Credential, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type 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 {
-  type CreateIdentityOptions,
   IdentityManager,
+  type CreateIdentityOptions,
   type IdentityManagerRuntimeParams,
   type JoinIdentityParams,
 } from '../identity';
@@ -42,8 +35,8 @@ import { createGetAllDocuments, createLoadDocuments } from '../indexing';
 import {
   DeviceInvitationProtocol,
   InvitationsHandler,
-  type InvitationProtocol,
   SpaceInvitationProtocol,
+  type InvitationProtocol,
 } from '../invitations';
 import { DataSpaceManager, type DataSpaceManagerRuntimeParams, type SigningContext } from '../spaces';
 
@@ -57,7 +50,6 @@ export type ServiceContextRuntimeParams = IdentityManagerRuntimeParams & DataSpa
 @Trace.resource()
 export class ServiceContext {
   public readonly initialized = new Trigger();
-  public readonly dataServiceSubscriptions = new DataServiceSubscriptions();
   public readonly metadataStore: MetadataStore;
   /**
    * @deprecated
@@ -186,7 +178,6 @@ export class ServiceContext {
     await this.feedStore.close();
     await this.networkManager.close();
     await this.signalManager.close();
-    this.dataServiceSubscriptions.clear();
     await this.metadataStore.close();
     await this.indexer.destroy();
     log('closed');
@@ -246,7 +237,6 @@ export class ServiceContext {
     this.dataSpaceManager = new DataSpaceManager(
       this.spaceManager,
       this.metadataStore,
-      this.dataServiceSubscriptions,
       this.keyring,
       signingContext,
       this.feedStore,

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

@@ -268,17 +268,13 @@ export class ClientServicesHost {
       SpacesService: new SpacesServiceImpl(
         this._serviceContext.identityManager,
         this._serviceContext.spaceManager,
-        this._serviceContext.dataServiceSubscriptions,
         async () => {
           await this._serviceContext.initialized.wait();
           return this._serviceContext.dataSpaceManager!;
         },
       ),
 
-      DataService: new DataServiceImpl(
-        this._serviceContext.dataServiceSubscriptions,
-        this._serviceContext.automergeHost,
-      ),
+      DataService: new DataServiceImpl(this._serviceContext.automergeHost),
 
       IndexService: new IndexServiceImpl({
         indexer: this._serviceContext.indexer,

package/src/packlets/spaces/automerge-space-state.ts

@@ -2,6 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Event } from '@dxos/async';
 import { type CredentialProcessor, type SpecificCredential, checkCredentialType } from '@dxos/credentials';
 import { type Credential, type Epoch } from '@dxos/protocols/proto/dxos/halo/credentials';
 
@@ -9,6 +10,8 @@ export class AutomergeSpaceState implements CredentialProcessor {
   public rootUrl: string | undefined = undefined;
   public lastEpoch: SpecificCredential<Epoch> | undefined = undefined;
 
+  public readonly onNewEpoch = new Event<SpecificCredential<Epoch>>();
+
   private _isProcessingRootDocs = false;
 
   constructor(private readonly _onNewRoot: (rootUrl: string) => void) {}
@@ -26,6 +29,8 @@ export class AutomergeSpaceState implements CredentialProcessor {
         this._onNewRoot(this.rootUrl);
       }
     }
+
+    this.onNewEpoch.emit(credential);
   }
 
   startProcessingRootDocs() {
@@ -38,4 +43,8 @@ export class AutomergeSpaceState implements CredentialProcessor {
     }
     this._isProcessingRootDocs = true;
   }
+
+  async ensureEpochInitialized() {
+    await this.onNewEpoch.waitForCondition(() => !!this.lastEpoch);
+  }
 }

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

@@ -3,24 +3,16 @@
 //
 
 import { expect } from 'chai';
-import path from 'node:path';
 
 import { asyncTimeout, latch } from '@dxos/async';
-import { type SpecificCredential, createAdmissionCredentials } from '@dxos/credentials';
+import { createAdmissionCredentials } from '@dxos/credentials';
 import { AuthStatus } from '@dxos/echo-pipeline';
-import { testLocalDatabase } from '@dxos/echo-pipeline/testing';
 import { writeMessages } from '@dxos/feed-store';
-import { type PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { SpaceState } from '@dxos/protocols/proto/dxos/client/services';
-import { type SpaceSnapshot } from '@dxos/protocols/proto/dxos/echo/snapshot';
-import { type 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 { describe, openAndClose, test } from '@dxos/test';
 
-import { TestBuilder, syncItemsLocal } from '../testing';
+import { TestBuilder } from '../testing';
 
 describe('DataSpaceManager', () => {
   test('create space', async () => {
@@ -103,8 +95,6 @@ describe('DataSpaceManager', () => {
     });
     log.break();
 
-    await syncItemsLocal(space1.dataPipeline, space2.dataPipeline);
-
     expect(space1.inner.protocol.sessions.get(peer2.identity.deviceKey)).to.exist;
     expect(space1.inner.protocol.sessions.get(peer2.identity.deviceKey)?.authStatus).to.equal(AuthStatus.SUCCESS);
     expect(space2.inner.protocol.sessions.get(peer1.identity.deviceKey)).to.exist;
@@ -157,137 +147,6 @@ describe('DataSpaceManager', () => {
     await receivedMessage();
   });
 
-  describe('Epochs', () => {
-    test
-      .skip('Epoch truncates feeds', async () => {
-        const builder = new TestBuilder();
-        afterTest(async () => builder.destroy());
-
-        const peer = builder.createPeer({
-          dataStore: 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());
-
-        expect((await file.stat()).size === 0).to.be.true;
-
-        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;
-      })
-      .onlyEnvironments('nodejs', 'chromium', 'firefox')
-      .tag('flaky');
-
-    test('Loads only last epoch', async () => {
-      const builder = new TestBuilder();
-      afterTest(async () => builder.destroy());
-
-      const peer = builder.createPeer();
-      await peer.createIdentity();
-      const epochsNumber = 10;
-      let spaceKey: PublicKey;
-      {
-        // Create space and create epochs in it.s
-        await openAndClose(peer.dataSpaceManager);
-
-        const space = await peer.dataSpaceManager.createSpace();
-        spaceKey = space.key;
-        await space.inner.controlPipeline.state.waitUntilTimeframe(space.inner.controlPipeline.state.endTimeframe);
-
-        for (const _ of range(epochsNumber)) {
-          await testLocalDatabase(space.dataPipeline);
-          await space.createEpoch();
-        }
-        await space.close();
-        await peer.dataSpaceManager.close();
-        peer.props.dataSpaceManager = undefined;
-      }
-      {
-        // Load same space and check if it loads only last epoch.s
-        await openAndClose(peer.dataSpaceManager);
-
-        const space = peer.dataSpaceManager.spaces.get(spaceKey)!;
-
-        const epochs: number[] = [];
-        space.dataPipeline.onNewEpoch.on((epoch: SpecificCredential<Epoch>) => {
-          epochs.push(epoch.subject.assertion.number);
-        });
-        const processedFirstEpoch = space.dataPipeline.onNewEpoch.waitFor(() => true);
-
-        await space.inner.controlPipeline.state.waitUntilTimeframe(space.inner.controlPipeline.state.endTimeframe);
-
-        await processedFirstEpoch;
-        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', () => {
     test('can activate and deactivate a space', async () => {
       const builder = new TestBuilder();
@@ -308,7 +167,6 @@ describe('DataSpaceManager', () => {
         space.stateUpdate.waitForCondition(() => space.state === SpaceState.READY),
         500,
       );
-      await testLocalDatabase(space.dataPipeline);
     });
   });
 });

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

@@ -3,15 +3,9 @@
 //
 
 import { Event, synchronized, trackLeaks } from '@dxos/async';
-import { cancelWithContext, Context } from '@dxos/context';
-import { type CredentialSigner, getCredentialAssertion } from '@dxos/credentials';
-import {
-  type AutomergeHost,
-  type DataServiceSubscriptions,
-  type MetadataStore,
-  type Space,
-  type SpaceManager,
-} from '@dxos/echo-pipeline';
+import { Context, cancelWithContext } from '@dxos/context';
+import { getCredentialAssertion, type CredentialSigner } from '@dxos/credentials';
+import { type AutomergeHost, type MetadataStore, type Space, type SpaceManager } from '@dxos/echo-pipeline';
 import { type FeedStore } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
@@ -80,7 +74,6 @@ export class DataSpaceManager {
   constructor(
     private readonly _spaceManager: SpaceManager,
     private readonly _metadataStore: MetadataStore,
-    private readonly _dataServiceSubscriptions: DataServiceSubscriptions,
     private readonly _keyring: Keyring,
     private readonly _signingContext: SigningContext,
     private readonly _feedStore: FeedStore<FeedMessage>,
@@ -270,10 +263,6 @@ export class DataSpaceManager {
       callbacks: {
         beforeReady: async () => {
           log('before space ready', { space: space.key });
-          await this._dataServiceSubscriptions.registerSpace(
-            space.key,
-            dataSpace.dataPipeline.databaseHost!.createDataServiceHost(),
-          );
         },
         afterReady: async () => {
           log('after space ready', { space: space.key, open: this._isOpen });
@@ -283,7 +272,6 @@ export class DataSpaceManager {
         },
         beforeClose: async () => {
           log('before space close', { space: space.key });
-          await this._dataServiceSubscriptions.unregisterSpace(space.key);
         },
       },
       cache: metadata.cache,
@@ -297,9 +285,6 @@ export class DataSpaceManager {
     if (metadata.controlTimeframe) {
       dataSpace.inner.controlPipeline.state.setTargetTimeframe(metadata.controlTimeframe);
     }
-    if (metadata.dataTimeframe) {
-      dataSpace.dataPipeline.setTargetTimeframe(metadata.dataTimeframe);
-    }
 
     this._spaces.set(metadata.key, dataSpace);
     return dataSpace;

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

@@ -6,14 +6,7 @@ import { Event, asyncTimeout, scheduleTask, sleep, synchronized, trackLeaks } fr
 import { AUTH_TIMEOUT } from '@dxos/client-protocol';
 import { cancelWithContext, Context, ContextDisposedError } from '@dxos/context';
 import { timed, warnAfterTimeout } from '@dxos/debug';
-import {
-  type MetadataStore,
-  type Space,
-  createMappedFeedWriter,
-  type DataPipeline,
-  type CreateEpochOptions,
-  type AutomergeHost,
-} from '@dxos/echo-pipeline';
+import { type MetadataStore, type Space, createMappedFeedWriter, type AutomergeHost } from '@dxos/echo-pipeline';
 import { type FeedStore } from '@dxos/feed-store';
 import { failedInvariant, invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
@@ -71,11 +64,9 @@ export type DataSpaceParams = {
   automergeHost: AutomergeHost;
 };
 
-/**
- * Delete feed blocks after an epoch is created.
- */
-// TODO(dmaretskyi): Disabled till better times https://github.com/dxos/dxos/issues/3949.
-const ENABLE_FEED_PURGE = false;
+export type CreateEpochOptions = {
+  migration?: CreateEpochRequest.Migration;
+};
 
 @trackLeaks('open', 'close')
 @trace.resource()
@@ -160,10 +151,6 @@ export class DataSpace {
     return this._inner;
   }
 
-  get dataPipeline(): DataPipeline {
-    return this._inner.dataPipeline;
-  }
-
   get presence() {
     return this._presence;
   }
@@ -278,20 +265,8 @@ export class DataSpace {
 
     this._automergeSpaceState.startProcessingRootDocs();
 
-    await this._inner.initializeDataPipeline();
-
-    this.metrics.dataPipelineOpen = new Date();
-
     // Wait for the first epoch.
-    await cancelWithContext(this._ctx, this._inner.dataPipeline.ensureEpochInitialized());
-
-    log('waiting for data pipeline to reach target timeframe');
-    // Wait for the data pipeline to catch up to its desired timeframe.
-    await this._inner.dataPipeline.pipelineState!.waitUntilReachedTargetTimeframe({
-      ctx: this._ctx,
-      breakOnStall: false,
-    });
-    this.metrics.dataPipelineReady = new Date();
+    await cancelWithContext(this._ctx, this.automergeSpaceState.ensureEpochInitialized());
 
     log('data pipeline ready');
     await this._callbacks.beforeReady?.();
@@ -426,7 +401,12 @@ export class DataSpace {
       case CreateEpochRequest.Migration.NONE:
         {
           // TODO(dmaretskyi): Unify epoch construction.
-          epoch = await this.dataPipeline.createEpoch();
+          epoch = {
+            previousId: this._automergeSpaceState.lastEpoch?.id,
+            number: (this._automergeSpaceState.lastEpoch?.subject.assertion.number ?? -1) + 1,
+            timeframe: this._automergeSpaceState.lastEpoch?.subject.assertion.timeframe ?? new Timeframe(),
+            automergeRoot: this._automergeSpaceState.lastEpoch?.subject.assertion?.automergeRoot,
+          };
         }
         break;
       case CreateEpochRequest.Migration.INIT_AUTOMERGE:
@@ -476,18 +456,6 @@ export class DataSpace {
     });
 
     await this.inner.controlPipeline.state.waitUntilTimeframe(new Timeframe([[receipt.feedKey, receipt.seq]]));
-
-    // Clear feed blocks before epoch.
-    if (ENABLE_FEED_PURGE) {
-      for (const feed of this.inner.dataPipeline.pipelineState?.feeds ?? []) {
-        const indexBeforeEpoch = epoch.timeframe.get(feed.key);
-        if (indexBeforeEpoch === undefined) {
-          continue;
-        }
-
-        await feed.safeClear(0, indexBeforeEpoch + 1);
-      }
-    }
   }
 
   @synchronized

package/src/packlets/spaces/spaces-service.test.ts

@@ -24,15 +24,10 @@ describe('SpacesService', () => {
   beforeEach(async () => {
     serviceContext = createServiceContext();
     await serviceContext.open(new Context());
-    spacesService = new SpacesServiceImpl(
-      serviceContext.identityManager,
-      serviceContext.spaceManager,
-      serviceContext.dataServiceSubscriptions,
-      async () => {
-        await serviceContext.initialized.wait();
-        return serviceContext.dataSpaceManager!;
-      },
-    );
+    spacesService = new SpacesServiceImpl(serviceContext.identityManager, serviceContext.spaceManager, async () => {
+      await serviceContext.initialized.wait();
+      return serviceContext.dataSpaceManager!;
+    });
   });
 
   afterEach(async () => {