@dxos/echo-db 2.33.5-dev.cf9f6681 → 2.33.5-dev.fa6b779b

package/src/parties/party-manager.ts

@@ -9,7 +9,7 @@ import unionWith from 'lodash.unionwith';
 import { Event, synchronized } from '@dxos/async';
 import { KeyHint, KeyType, SecretProvider } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
-import { timed } from '@dxos/debug';
+import { failUndefined, timed } from '@dxos/debug';
 import { PartyKey, PartySnapshot } from '@dxos/echo-protocol';
 import { ComplexMap, boolGuard } from '@dxos/util';
 
@@ -94,9 +94,13 @@ export class PartyManager {
       const partyKey = partyKeys[i];
       if (!this._parties.has(partyKey)) {
         const snapshot = await this._snapshotStore.load(partyKey);
+
+        const metadata = this._metadataStore.getParty(partyKey) ?? failUndefined();
+
         const party = snapshot
           ? await this._partyFactory.constructPartyFromSnapshot(snapshot)
           : await this._partyFactory.constructParty(partyKey);
+        party._setFeedHints(metadata.feedKeys ?? []);
 
         const isActive = identity?.preferences?.isPartyActive(partyKey) ?? true;
         if (isActive) {
@@ -157,11 +161,9 @@ export class PartyManager {
 
   /**
    * Construct a party object and start replicating with the remote peer that created that party.
-   * @param partyKey
-   * @param hints
    */
   @synchronized
-  async addParty (partyKey: PartyKey, hints: KeyHint[] = []) {
+  async addParty (partyKey: PartyKey, feedHints: PublicKey[] = []) {
     assert(this._open, 'PartyManager is not open.');
 
     /*
@@ -174,8 +176,9 @@ export class PartyManager {
       return this._parties.get(partyKey);
     }
 
-    log(`Adding party partyKey=${partyKey.toHex()} hints=${hints.length}`);
-    const party = await this._partyFactory.constructParty(partyKey, hints);
+    log(`Adding party partyKey=${partyKey.toHex()} hints=${feedHints.length}`);
+    const party = await this._partyFactory.constructParty(partyKey);
+    party._setFeedHints(feedHints);
     await party.open();
     await this._metadataStore.addParty(party.key);
     this._setParty(party);

package/src/pipeline/{pipeline.test.ts → feed-muxer.test.ts}

@@ -10,19 +10,19 @@ import { waitForCondition, latch } from '@dxos/async';
 import { createPartyGenesisMessage, Keyring, KeyType } from '@dxos/credentials';
 import { createId, createKeyPair, PublicKey } from '@dxos/crypto';
 import { codec, createFeedWriter, FeedSelector, FeedStoreIterator, IEchoStream, Timeframe } from '@dxos/echo-protocol';
-import { FeedStore, createWritableFeedStream, createWritable, WritableArray } from '@dxos/feed-store';
+import { FeedStore, createWritableFeedStream } from '@dxos/feed-store';
 import { createSetPropertyMutation } from '@dxos/model-factory';
 import { createStorage, StorageType } from '@dxos/random-access-multi-storage';
 import { jsonReplacer } from '@dxos/util';
 
 import { TimeframeClock } from '../packlets/database';
+import { FeedMuxer } from './feed-muxer';
 import { PartyProcessor } from './party-processor';
-import { Pipeline } from './pipeline';
 
 const log = debug('dxos:echo:pipeline:test');
 
 // TODO(burdon): Test read-only.
-describe('pipeline', () => {
+describe('FeedMuxer', () => {
   test('streams', async () => {
     const storage = createStorage('', StorageType.RAM);
     const feedStore = new FeedStore(storage.directory('feed'), { valueEncoding: codec });
@@ -56,9 +56,6 @@ describe('pipeline', () => {
         seq: 0
       }
     });
-    const pipeline = new Pipeline(partyProcessor, feedReadStream, new TimeframeClock());
-    const [readStream] = await pipeline.open();
-    expect(readStream).toBeTruthy();
 
     //
     // Pipeline consumer.
@@ -66,10 +63,14 @@ describe('pipeline', () => {
     //
     const numMessages = 5;
     const [counter, updateCounter] = latch(numMessages);
-    readStream.pipe(createWritable<IEchoStream>(async message => {
+    const echoProcessor = async (message: IEchoStream) => {
       log('Processed:', JSON.stringify(message, jsonReplacer, 2));
       updateCounter();
-    }));
+    };
+
+    const pipeline = new FeedMuxer(partyProcessor, feedReadStream, new TimeframeClock());
+    pipeline.setEchoProcessor(echoProcessor);
+    await pipeline.open();
 
     //
     // Write directly to feed store.
@@ -105,17 +106,21 @@ describe('pipeline', () => {
     });
 
     const partyProcessor = new PartyProcessor(partyKey.publicKey);
-    const pipeline = new Pipeline(
+
+    const echoMessages: IEchoStream[] = [];
+    const echoProcessor = async (msg: IEchoStream) => {
+      echoMessages.push(msg);
+    };
+
+    const pipeline = new FeedMuxer(
       partyProcessor,
       feedReadStream,
       new TimeframeClock(),
       createFeedWriter(feed)
     );
+    pipeline.setEchoProcessor(echoProcessor);
     await pipeline.open();
 
-    const writable = new WritableArray();
-    pipeline.inboundEchoStream!.pipe(writable);
-
     await pipeline.outboundHaloStream!.write(createPartyGenesisMessage(keyring, partyKey, feedKey.publicKey, identityKey));
     await waitForCondition(() => !partyProcessor.genesisRequired);
 
@@ -126,10 +131,10 @@ describe('pipeline', () => {
       }
     });
 
-    await waitForCondition(() => writable.objects.length === 1);
+    await waitForCondition(() => echoMessages.length === 1);
 
     expect(partyProcessor.genesisRequired).toEqual(false);
-    expect((writable.objects[0] as any).data).toEqual({
+    expect((echoMessages[0] as any).data).toEqual({
       itemId: '123',
       genesis: {
         itemType: 'foo'

package/src/pipeline/{pipeline.ts → feed-muxer.ts}

@@ -4,7 +4,6 @@
 
 import assert from 'assert';
 import debug from 'debug';
-import { Readable } from 'stream';
 
 import { Event } from '@dxos/async';
 import { Message as HaloMessage } from '@dxos/credentials';
@@ -13,10 +12,9 @@ import { checkType } from '@dxos/debug';
 import {
   createFeedMeta, EchoEnvelope, FeedMessage, FeedStoreIterator, FeedWriter, IEchoStream, mapFeedWriter, Timeframe
 } from '@dxos/echo-protocol';
-import { createReadable } from '@dxos/feed-store';
 import { jsonReplacer } from '@dxos/util';
 
-import { TimeframeClock } from '../packlets/database';
+import { EchoProcessor, TimeframeClock } from '../packlets/database';
 import { CredentialProcessor, PartyStateProvider } from './party-processor';
 
 interface Options {
@@ -28,14 +26,12 @@ const log = debug('dxos:echo-db:pipeline');
 
 /**
  * Manages the inbound and outbound message streams for an individual party.
+ * Reads messages from individual feeds and splits them into ECHO and HALO streams.
  */
-export class Pipeline {
+export class FeedMuxer {
   private readonly _errors = new Event<Error>();
 
-  /**
-   * Messages to be consumed from the pipeline (e.g., mutations to model).
-   */
-  private _inboundEchoStream: Readable | undefined;
+  private _isOpen = false;
 
   /**
    * Messages to write into pipeline (e.g., mutations from model).
@@ -47,6 +43,8 @@ export class Pipeline {
    */
   private _outboundHaloStream: FeedWriter<HaloMessage> | undefined;
 
+  private _echoProcessor: EchoProcessor | undefined
+
   /**
    * @param _partyProcessor Processes HALO messages to update party state.
    * @param _feedStorIterator Inbound messages from the feed store.
@@ -60,20 +58,32 @@ export class Pipeline {
     private readonly _timeframeClock: TimeframeClock,
     private readonly _feedWriter?: FeedWriter<FeedMessage>,
     private readonly _options: Options = {}
-  ) {}
+  ) {
+    if (this._feedWriter) {
+      const loggingWriter = mapFeedWriter<FeedMessage, FeedMessage>(async msg => {
+        this._options.writeLogger?.(msg);
+        return msg;
+      }, this._feedWriter);
+
+      this._outboundEchoStream = mapFeedWriter<EchoEnvelope, FeedMessage>(async message => ({
+        timeframe: this._timeframeClock.timeframe,
+        echo: message
+      }), loggingWriter);
+      this._outboundHaloStream = mapFeedWriter<HaloMessage, FeedMessage>(async message => ({
+        timeframe: this._timeframeClock.timeframe,
+        halo: message
+      }), loggingWriter);
+    }
+  }
 
   get isOpen () {
-    return this._inboundEchoStream !== undefined;
+    return this._isOpen;
   }
 
   get readOnly () {
     return this._outboundEchoStream === undefined;
   }
 
-  get inboundEchoStream () {
-    return this._inboundEchoStream;
-  }
-
   get outboundEchoStream () {
     return this._outboundEchoStream;
   }
@@ -86,6 +96,10 @@ export class Pipeline {
     return this._errors;
   }
 
+  setEchoProcessor (processor: EchoProcessor) {
+    this._echoProcessor = processor;
+  }
+
   /**
    * Create inbound and outbound pipielines.
    * https://nodejs.org/api/stream.html#stream_stream_pipeline_source_transforms_destination_callback
@@ -96,10 +110,8 @@ export class Pipeline {
    *       Transform(dxos.echo.IEchoEnvelope => dxos.IFeedMessage): update clock
    *         Feed
    */
-  async open (): Promise<[NodeJS.ReadableStream, FeedWriter<EchoEnvelope>?]> {
-    const { readLogger, writeLogger } = this._options;
-
-    this._inboundEchoStream = createReadable();
+  async open (): Promise<FeedWriter<EchoEnvelope> | undefined> {
+    const { readLogger } = this._options;
 
     // This will exit cleanly once FeedStoreIterator is closed.
     setImmediate(async () => {
@@ -109,8 +121,6 @@ export class Pipeline {
         try {
           const { data: message } = block;
 
-          this._timeframeClock.updateTimeframe(PublicKey.from(block.key), block.seq);
-
           //
           // HALO
           //
@@ -133,8 +143,8 @@ export class Pipeline {
             // Validate messge.
             const { itemId } = message.echo;
             if (itemId) {
-              assert(this._inboundEchoStream);
-              this._inboundEchoStream.push(checkType<IEchoStream>({
+              assert(this._echoProcessor);
+              await this._echoProcessor(checkType<IEchoStream>({
                 meta: {
                   seq: block.seq,
                   feedKey: block.key,
@@ -150,6 +160,8 @@ export class Pipeline {
             // TODO(burdon): Can we throw and have the pipeline log (without breaking the stream)?
             log(`Skipping invalid message: ${JSON.stringify(message, jsonReplacer)}`);
           }
+
+          this._timeframeClock.updateTimeframe(PublicKey.from(block.key), block.seq);
         } catch (err: any) {
           console.error('Error in message processing.');
           console.error(err);
@@ -157,30 +169,7 @@ export class Pipeline {
       }
     });
 
-    //
-    // Processes outbound messages (piped to the feed).
-    // Sets the current timeframe.
-    //
-    if (this._feedWriter) {
-      const loggingWriter = mapFeedWriter<FeedMessage, FeedMessage>(async msg => {
-        writeLogger?.(msg);
-        return msg;
-      }, this._feedWriter);
-
-      this._outboundEchoStream = mapFeedWriter<EchoEnvelope, FeedMessage>(async message => ({
-        timeframe: this._timeframeClock.timeframe,
-        echo: message
-      }), loggingWriter);
-      this._outboundHaloStream = mapFeedWriter<HaloMessage, FeedMessage>(async message => ({
-        timeframe: this._timeframeClock.timeframe,
-        halo: message
-      }), loggingWriter);
-    }
-
-    return [
-      this._inboundEchoStream,
-      this._outboundEchoStream
-    ];
+    return this._outboundEchoStream;
   }
 
   /**
@@ -190,11 +179,9 @@ export class Pipeline {
   async close () {
     await this._feedStorIterator.close();
 
-    if (this._inboundEchoStream) {
-      this._inboundEchoStream.destroy();
-      this._inboundEchoStream = undefined;
-    }
-
     this._outboundEchoStream = undefined;
+    this._outboundHaloStream = undefined;
+    this._echoProcessor = undefined;
+    this._isOpen = false;
   }
 }

package/src/pipeline/index.ts

@@ -6,6 +6,6 @@ export * from './message-selector';
 export * from './party-feed-provider';
 export * from './party-processor';
 export * from '../protocol/party-protocol-factory';
-export * from './pipeline';
-export * from './party-core';
+export * from './feed-muxer';
+export * from './party-pipeline';
 export * from './metadata-store';

package/src/pipeline/metadata-store.ts

@@ -7,7 +7,7 @@ import debug from 'debug';
 
 import { PublicKey } from '@dxos/crypto';
 import { failUndefined } from '@dxos/debug';
-import { EchoMetadata, PartyMetadata, schema } from '@dxos/echo-protocol';
+import { EchoMetadata, PartyMetadata, schema, Timeframe } from '@dxos/echo-protocol';
 import { Directory } from '@dxos/random-access-multi-storage';
 
 /**
@@ -158,4 +158,10 @@ export class MetadataStore {
     }
     return !!party.feedKeys?.find(fk => feedKey.equals(fk));
   }
+
+  async setTimeframe (partyKey: PublicKey, timeframe: Timeframe) {
+    const party = this.getParty(partyKey) ?? failUndefined();
+    party.latestTimeframe = timeframe;
+    await this._save();
+  }
 }

package/src/pipeline/party-feed-provider.ts

@@ -8,7 +8,7 @@ import debug from 'debug';
 import { Event, synchronized } from '@dxos/async';
 import { Keyring, KeyType } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
-import { FeedStoreIterator, MessageSelector, Timeframe } from '@dxos/echo-protocol';
+import { FeedSelector, FeedStoreIterator, MessageSelector, Timeframe } from '@dxos/echo-protocol';
 import { FeedDescriptor, FeedStore } from '@dxos/feed-store';
 import { ComplexMap } from '@dxos/util';
 
@@ -33,19 +33,6 @@ export class PartyFeedProvider {
     return Array.from(this._feeds.values());
   }
 
-  @synchronized
-  async openKnownFeeds () {
-    for (const feedKey of this._metadataStore.getParty(this._partyKey)?.feedKeys ?? []) {
-      if (!this._feeds.has(feedKey)) {
-        const fullKey = this._keyring.getFullKey(feedKey);
-        const feed = fullKey?.secretKey
-          ? await this._feedStore.openReadWriteFeed(fullKey.publicKey, fullKey.secretKey)
-          : await this._feedStore.openReadOnlyFeed(feedKey);
-        this._trackFeed(feed);
-      }
-    }
-  }
-
   @synchronized
   async createOrOpenWritableFeed () {
     const partyMetadata = this._metadataStore.getParty(this._partyKey);
@@ -103,8 +90,8 @@ export class PartyFeedProvider {
     return feed;
   }
 
-  async createIterator (messageSelector: MessageSelector, initialTimeframe?: Timeframe) {
-    const iterator = new FeedStoreIterator(() => true, messageSelector, initialTimeframe ?? new Timeframe());
+  async createIterator (messageSelector: MessageSelector, feedSelector: FeedSelector, initialTimeframe?: Timeframe) {
+    const iterator = new FeedStoreIterator(feedSelector, messageSelector, initialTimeframe ?? new Timeframe());
     for (const feed of this._feeds.values()) {
       iterator.addFeedDescriptor(feed);
     }

package/src/pipeline/{party-core.test.ts → party-pipeline.test.ts}

@@ -17,12 +17,12 @@ import { ObjectModel } from '@dxos/object-model';
 import { createStorage, StorageType } from '@dxos/random-access-multi-storage';
 import { afterTest } from '@dxos/testutils';
 
-import { MetadataStore, PartyFeedProvider } from '../pipeline';
+import { MetadataStore, PartyFeedProvider } from '.';
 import { createReplicatorPlugin } from '../protocol/replicator-plugin';
 import { SnapshotStore } from '../snapshots';
-import { PartyCore } from './party-core';
+import { PartyPipeline } from './party-pipeline';
 
-describe('PartyCore', () => {
+describe('PartyPipeline', () => {
   const setup = async () => {
     const storage = createStorage('', StorageType.RAM);
     const feedStore = new FeedStore(storage.directory('feed'), { valueEncoding: codec });
@@ -39,7 +39,7 @@ describe('PartyCore', () => {
 
     const partyFeedProvider = new PartyFeedProvider(metadataStore, keyring, feedStore, partyKey.publicKey);
 
-    const party = new PartyCore(
+    const party = new PartyPipeline(
       partyKey.publicKey,
       partyFeedProvider,
       modelFactory,
@@ -48,7 +48,7 @@ describe('PartyCore', () => {
     );
 
     const feed = await partyFeedProvider.createOrOpenWritableFeed();
-    await party.open();
+    await party.open({ feedHints: [feed.key] });
     afterTest(async () => party.close());
 
     // PartyGenesis (self-signed by Party).
@@ -88,7 +88,7 @@ describe('PartyCore', () => {
   });
 
   test('create item with parent and then reload', async () => {
-    const { party } = await setup();
+    const { party, feedKey } = await setup();
 
     {
       const parent = await party.database.createItem({ model: ObjectModel, type: 'parent' });
@@ -103,7 +103,7 @@ describe('PartyCore', () => {
     }
 
     await party.close();
-    await party.open();
+    await party.open({ feedHints: [feedKey] });
 
     {
       await party.database.select().exec().update.waitFor(result => result.entities.length === 2);
@@ -149,7 +149,7 @@ describe('PartyCore', () => {
 
     const otherFeedKey = PublicKey.random();
 
-    const party = new PartyCore(
+    const party = new PartyPipeline(
       partyKey.publicKey,
       partyFeedProvider,
       modelFactory,
@@ -161,7 +161,7 @@ describe('PartyCore', () => {
 
     const feedOpened = feedStore.feedOpenedEvent.waitForCount(1);
 
-    await party.open([{ type: KeyType.FEED, publicKey: otherFeedKey }]);
+    await party.open({ feedHints: [otherFeedKey] });
     afterTest(async () => party.close());
 
     await feedOpened;
@@ -250,6 +250,28 @@ describe('PartyCore', () => {
     await promiseTimeout(party.database.waitForItem({ id: itemId }), 1000, new Error('timeout'));
   });
 
+  test('wait to reach specific timeframe', async () => {
+    const { party, feedKey } = await setup();
+
+    {
+      const parent = await party.database.createItem({ model: ObjectModel, type: 'parent' });
+      const child = await party.database.createItem({
+        model: ObjectModel,
+        parent: parent.id,
+        type: 'child'
+      });
+
+      expect(child.parent).toEqual(parent);
+      expect(parent.children).toContain(child);
+    }
+
+    const timeframe = party.timeframe;
+    expect(timeframe.isEmpty()).toBeFalsy();
+
+    await party.close();
+    await party.open({ feedHints: [feedKey], targetTimeframe: timeframe });
+  });
+
   test('two instances replicating', async () => {
     const peer1 = await setup();
 
@@ -264,7 +286,7 @@ describe('PartyCore', () => {
 
     const partyFeedProvider = new PartyFeedProvider(metadataStore, peer1.keyring, feedStore, peer1.party.key);
 
-    const party2 = new PartyCore(
+    const party2 = new PartyPipeline(
       peer1.party.key,
       partyFeedProvider,
       modelFactory,
@@ -281,10 +303,9 @@ describe('PartyCore', () => {
       [peer1.partyKey]
     ));
 
-    await party2.open([{
-      publicKey: peer1.feedKey,
-      type: KeyType.FEED
-    }]);
+    await party2.open({
+      feedHints: [peer1.feedKey]
+    });
     afterTest(async () => party2.close());
 
     createTestProtocolPair(

package/src/pipeline/{party-core.ts → party-pipeline.ts}

@@ -5,20 +5,20 @@
 import assert from 'assert';
 
 import { synchronized } from '@dxos/async';
-import { KeyHint, KeyType, Message as HaloMessage } from '@dxos/credentials';
+import { KeyType, Message as HaloMessage } from '@dxos/credentials';
 import { PublicKey } from '@dxos/crypto';
 import { timed } from '@dxos/debug';
-import { createFeedWriter, DatabaseSnapshot, FeedWriter, PartyKey, PartySnapshot, Timeframe } from '@dxos/echo-protocol';
+import { createFeedWriter, DatabaseSnapshot, FeedSelector, FeedWriter, PartyKey, PartySnapshot, Timeframe } from '@dxos/echo-protocol';
 import { ModelFactory } from '@dxos/model-factory';
 import { SubscriptionGroup } from '@dxos/util';
 
+import { createMessageSelector, PartyProcessor, PartyFeedProvider, FeedMuxer } from '.';
 import { Database, FeedDatabaseBackend, TimeframeClock } from '../packlets/database';
-import { createMessageSelector, PartyProcessor, PartyFeedProvider, Pipeline } from '../pipeline';
 import { createAutomaticSnapshots, SnapshotStore } from '../snapshots';
 
 const DEFAULT_SNAPSHOT_INTERVAL = 100; // Every 100 messages.
 
-export interface PartyOptions {
+export interface PipelineOptions {
   readLogger?: (msg: any) => void;
   writeLogger?: (msg: any) => void;
   readOnly?: boolean;
@@ -28,6 +28,22 @@ export interface PartyOptions {
   snapshotInterval?: number;
 }
 
+export interface OpenOptions {
+  /**
+   * Keys of initial feeds needed to bootstrap the party.
+   */
+  feedHints?: PublicKey[]
+  /**
+   * Timeframe to start processing feed messages from.
+   */
+  initialTimeframe?: Timeframe
+  /**
+   * Timeframe which must be reached until further processing.
+   * PartyCore.open will block until this timeframe is reached.
+   */
+  targetTimeframe?: Timeframe
+}
+
 /**
  * Encapsulates core components needed by a party:
  * - ECHO database with item-manager & item-demuxer.
@@ -36,7 +52,7 @@ export interface PartyOptions {
  *
  * The core class also handles the combined ECHO and HALO state snapshots.
  */
-export class PartyCore {
+export class PartyPipeline {
   /**
    * Snapshot to be restored from when party.open() is called.
    */
@@ -45,7 +61,7 @@ export class PartyCore {
   private readonly _subscriptions = new SubscriptionGroup();
 
   private _database?: Database;
-  private _pipeline?: Pipeline;
+  private _pipeline?: FeedMuxer;
   private _partyProcessor?: PartyProcessor;
   private _timeframeClock?: TimeframeClock;
 
@@ -55,8 +71,7 @@ export class PartyCore {
     private readonly _modelFactory: ModelFactory,
     private readonly _snapshotStore: SnapshotStore,
     private readonly _memberKey: PublicKey,
-    private readonly _initialTimeframe?: Timeframe,
-    private readonly _options: PartyOptions = {}
+    private readonly _options: PipelineOptions = {}
   ) { }
 
   get key (): PartyKey {
@@ -108,15 +123,19 @@ export class PartyCore {
    */
   @synchronized
   @timed(1_000)
-  async open (keyHints: KeyHint[] = []) {
+  async open (options: OpenOptions = {}) {
+    const {
+      feedHints = [],
+      initialTimeframe,
+      targetTimeframe
+    } = options;
+
     if (this.isOpen) {
       return this;
     }
 
-    this._timeframeClock = new TimeframeClock(this._initialTimeframe);
+    this._timeframeClock = new TimeframeClock(initialTimeframe);
 
-    // Open all feeds known from metadata and open or create a writable feed to the party.
-    await this._feedProvider.openKnownFeeds();
     const writableFeed = await this._feedProvider.createOrOpenWritableFeed();
 
     if (!this._partyProcessor) {
@@ -128,12 +147,8 @@ export class PartyCore {
       void this._feedProvider.createOrOpenReadOnlyFeed(feed);
     }));
 
-    // Hint at our own writable feed.
-    // TODO(dmaretskyi): Does not seem like it should be required, but without it replication between devices (B -> A) breaks.
-    await this._partyProcessor.takeHints([{ type: KeyType.FEED, publicKey: writableFeed.key }]);
-
-    if (keyHints.length > 0) {
-      await this._partyProcessor.takeHints(keyHints);
+    if (feedHints.length > 0) {
+      await this._partyProcessor.takeHints(feedHints.map(publicKey => ({ publicKey, type: KeyType.FEED })));
     }
 
     //
@@ -142,26 +157,34 @@ export class PartyCore {
 
     const iterator = await this._feedProvider.createIterator(
       createMessageSelector(this._partyProcessor, this._timeframeClock),
-      this._initialTimeframe
+      createFeedSelector(this._partyProcessor, feedHints),
+      initialTimeframe
     );
 
-    this._pipeline = new Pipeline(
-      this._partyProcessor, iterator, this._timeframeClock, createFeedWriter(writableFeed.feed), this._options);
+    this._pipeline = new FeedMuxer(
+      this._partyProcessor,
 
-    // TODO(burdon): Support read-only parties.
-    const [readStream, writeStream] = await this._pipeline.open();
+      iterator,
+      this._timeframeClock,
+      createFeedWriter(writableFeed.feed),
+      this._options
+    );
 
     //
     // Database
     //
 
+    const databaseBackend = new FeedDatabaseBackend(this._pipeline.outboundEchoStream, this._databaseSnapshot, { snapshots: true });
     this._database = new Database(
       this._modelFactory,
-      new FeedDatabaseBackend(readStream, writeStream, this._databaseSnapshot, { snapshots: true }),
+      databaseBackend,
       this._memberKey
     );
 
+    // Open pipeline and connect it to the database.
     await this._database.initialize();
+    this._pipeline.setEchoProcessor(databaseBackend.echoProcessor);
+    await this._pipeline.open();
 
     // TODO(burdon): Propagate errors.
     this._subscriptions.push(this._pipeline.errors.on(err => console.error(err)));
@@ -175,6 +198,10 @@ export class PartyCore {
       );
     }
 
+    if (targetTimeframe) {
+      await this._timeframeClock.waitUntilReached(targetTimeframe);
+    }
+
     return this;
   }
 
@@ -228,3 +255,5 @@ export class PartyCore {
     this._databaseSnapshot = snapshot.database;
   }
 }
+
+const createFeedSelector = (partyProcessor: PartyProcessor, hints: PublicKey[]): FeedSelector => feed => hints.some(hint => hint.equals(feed.key)) || partyProcessor.isFeedAdmitted(feed.key);