@dxos/echo-db 2.33.5-dev.9e11cb97 → 2.33.5-dev.b4e42956

package/src/parties/party-factory.ts

@@ -9,7 +9,6 @@ import {
   createEnvelopeMessage,
   createFeedAdmitMessage,
   createPartyGenesisMessage,
-  KeyHint,
   KeyType,
   SecretProvider,
   wrapMessage
@@ -26,7 +25,7 @@ import {
   GreetingInitiator, InvitationDescriptor, InvitationDescriptorType, OfflineInvitationClaimer
 } from '../invitations';
 import { IdentityNotInitializedError } from '../packlets/errors';
-import { PartyFeedProvider, PartyOptions } from '../pipeline';
+import { MetadataStore, PartyFeedProvider, PipelineOptions } from '../pipeline';
 import { IdentityCredentialsProvider } from '../protocol/identity-credentials';
 import { SnapshotStore } from '../snapshots';
 import { DataParty, PARTY_ITEM_TYPE } from './data-party';
@@ -43,7 +42,8 @@ export class PartyFactory {
     private readonly _modelFactory: ModelFactory,
     private readonly _snapshotStore: SnapshotStore,
     private readonly _feedProviderFactory: (partyKey: PublicKey) => PartyFeedProvider,
-    private readonly _options: PartyOptions = {}
+    private readonly _metadataStore: MetadataStore,
+    private readonly _options: PipelineOptions = {}
   ) {}
 
   /**
@@ -57,11 +57,13 @@ export class PartyFactory {
     const partyKey = await identity.keyring.createKeyRecord({ type: KeyType.PARTY });
     const party = await this.constructParty(partyKey.publicKey);
 
+    const writableFeed = await party.getWriteFeed();
+    // Hint at the newly created writable feed so that we can start replicating from it.
+    party._setFeedHints([writableFeed.key]);
+
     // Connect the pipeline.
     await party.open();
 
-    const writableFeed = await party.getWriteFeed();
-
     // PartyGenesis (self-signed by Party).
     await party.credentialsWriter.write(createPartyGenesisMessage(
       identity.keyring,
@@ -111,12 +113,9 @@ export class PartyFactory {
    * @param partyKey
    * @param hints
    */
-  async constructParty (partyKey: PartyKey, hints: KeyHint[] = [], initialTimeframe?: Timeframe) {
+  async constructParty (partyKey: PartyKey, initialTimeframe?: Timeframe) {
     const identity = this._identityProvider() ?? raise(new IdentityNotInitializedError());
 
-    // TODO(marik-d): Support read-only parties if this feed doesn't exist?
-    const feedProvider = this._feedProviderFactory(partyKey);
-
     //
     // Create the party.
     //
@@ -124,11 +123,11 @@ export class PartyFactory {
       partyKey,
       this._modelFactory,
       this._snapshotStore,
-      feedProvider,
+      this._feedProviderFactory(partyKey),
+      this._metadataStore,
       identity.createCredentialsSigner(),
       identity.preferences,
       this._networkManager,
-      hints,
       initialTimeframe,
       this._options
     );
@@ -140,7 +139,7 @@ export class PartyFactory {
     assert(snapshot.partyKey);
     log(`Constructing ${humanize(snapshot.partyKey)} from snapshot at ${JSON.stringify(snapshot.timeframe)}.`);
 
-    const party = await this.constructParty(PublicKey.from(snapshot.partyKey), [], snapshot.timeframe);
+    const party = await this.constructParty(PublicKey.from(snapshot.partyKey), snapshot.timeframe);
     await party.restoreFromSnapshot(snapshot);
     return party;
   }
@@ -173,7 +172,8 @@ export class PartyFactory {
 
     await initiator.connect();
     const { partyKey, hints } = await initiator.redeemInvitation(secretProvider);
-    const party = await this.constructParty(partyKey, hints);
+    const party = await this.constructParty(partyKey);
+    party._setFeedHints(hints);
     await party.open();
     await initiator.destroy();
 
@@ -198,11 +198,13 @@ export class PartyFactory {
     const partyKey = await identity.keyring.createKeyRecord({ type: KeyType.PARTY });
     const party = await this.constructParty(partyKey.publicKey);
 
+    const writableFeed = await party.getWriteFeed();
+    // Hint at the newly created writable feed so that we can start replicating from it.
+    party._setFeedHints([writableFeed.key]);
+
     // Connect the pipeline.
     await party.open();
 
-    const writableFeed = await party.getWriteFeed();
-
     // PartyGenesis (self-signed by Party).
     await party.credentialsWriter.write(createPartyGenesisMessage(
       identity.keyring,
@@ -254,6 +256,7 @@ export class PartyFactory {
     const feedWriter = createFeedWriter(writableFeed.feed);
     for (const item of snapshot.database?.items || []) {
       const message: FeedMessage = {
+        timeframe: new Timeframe(),
         echo: {
           itemId: item.itemId ?? failUndefined(),
           genesis: {
@@ -264,8 +267,7 @@ export class PartyFactory {
           itemMutation: {
             parentId: item.parentId
           },
-          snapshot: item.model,
-          timeframe: new Timeframe()
+          snapshot: item.model
         }
       };
       await feedWriter.write(message);

package/src/parties/party-manager.test.ts

@@ -71,6 +71,7 @@ const setup = async () => {
     modelFactory,
     snapshotStore,
     feedProviderFactory,
+    metadataStore,
     {
       writeLogger: messageLogger('<<<'),
       readLogger: messageLogger('>>>')
@@ -140,16 +141,12 @@ describe('Party manager', () => {
     const feedStream = createWritableFeedStream(feed);
     feedStream.write(createPartyGenesisMessage(keyring, partyKey, feedKey.publicKey, identityKey));
 
-    await partyManager.addParty(partyKey.publicKey, [{
-      type: KeyType.FEED,
-      publicKey: PublicKey.from(feed.key)
-    }]);
+    await partyManager.addParty(partyKey.publicKey, [PublicKey.from(feed.key)]);
 
     await update;
   });
 
   test('Create from cold start', async () => {
-
     const storage = createStorage('', StorageType.RAM);
     const feedStore = new FeedStore(storage.directory('feed'), { valueEncoding: codec });
     const keyring = new Keyring();
@@ -165,7 +162,8 @@ describe('Party manager', () => {
       networkManager,
       modelFactory,
       snapshotStore,
-      feedProviderFactory
+      feedProviderFactory,
+      metadataStore
     );
     const partyManager = new PartyManager(metadataStore, snapshotStore, () => identity, partyFactory);
 
@@ -191,15 +189,23 @@ describe('Party manager', () => {
       assert(feedKey);
 
       const feedStream = createWritableFeedStream(feed);
-      feedStream.write({ halo: createPartyGenesisMessage(keyring, partyKey, feedKey.publicKey, identity.identityKey) });
       feedStream.write({
+        timeframe: new Timeframe(),
+        halo: createPartyGenesisMessage(
+          keyring,
+          partyKey,
+          feedKey.publicKey,
+          identity.identityKey
+        )
+      });
+      feedStream.write({
+        timeframe: new Timeframe(),
         echo: checkType<EchoEnvelope>({
           itemId: 'foo',
           genesis: {
             itemType: PARTY_ITEM_TYPE,
             modelType: ObjectModel.meta.type
-          },
-          timeframe: new Timeframe()
+          }
         })
       });
     }

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,15 +131,14 @@ 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'
-      },
-      timeframe: expect.any(Timeframe)
+      }
     });
   });
 });

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 () => {
@@ -125,20 +137,19 @@ export class Pipeline {
           //
 
           if (message.echo) {
-            this._timeframeClock.updateTimeframe(PublicKey.from(block.key), block.seq);
             const memberKey = this._partyProcessor.getFeedOwningMember(PublicKey.from(block.key));
             assert(memberKey, `Ownership of feed ${keyToString(block.key)} could not be determined.`);
 
             // 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,
                   memberKey,
-                  timeframe: message.echo.timeframe ?? new Timeframe()
+                  timeframe: message.timeframe ?? new Timeframe()
                 },
                 data: message.echo
               }));
@@ -149,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);
@@ -156,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 => ({
-        echo: {
-          ...message,
-          timeframe: this._timeframeClock.timeframe
-        }
-      }), loggingWriter);
-      this._outboundHaloStream =
-        mapFeedWriter<HaloMessage, FeedMessage>(async message => ({ halo: message }), loggingWriter);
-    }
-
-    return [
-      this._inboundEchoStream,
-      this._outboundEchoStream
-    ];
+    return this._outboundEchoStream;
   }
 
   /**
@@ -189,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/message-selector.ts

@@ -26,27 +26,28 @@ const log = debug('dxos:echo-db:message-selector');
 export const createMessageSelector = (partyProcessor: PartyStateProvider, timeframeClock: TimeframeClock): MessageSelector => candidates => {
   // Check ECHO message candidates first since they are less expensive than HALO cancidates.
   for (let i = 0; i < candidates.length; i++) {
-    const { data: { echo } } = candidates[i];
+    const { data: { timeframe, echo } } = candidates[i];
     const feedKey = PublicKey.from(candidates[i].key);
     if (!echo) {
       continue;
     }
 
-    assert(echo.timeframe);
-    if (partyProcessor.isFeedAdmitted(feedKey) && !timeframeClock.hasGaps(echo.timeframe)) {
+    assert(timeframe);
+    if (partyProcessor.isFeedAdmitted(feedKey) && !timeframeClock.hasGaps(timeframe)) {
       return i;
     }
   }
 
   // Check HALO message candidates.
   for (let i = 0; i < candidates.length; i++) {
-    const { data: { halo } } = candidates[i];
+    const { data: { timeframe, halo } } = candidates[i];
     const feedKey = PublicKey.from(candidates[i].key);
     if (!halo) {
       continue;
     }
 
-    if (partyProcessor.isFeedAdmitted(feedKey)) {
+    assert(timeframe);
+    if (partyProcessor.isFeedAdmitted(feedKey) && !timeframeClock.hasGaps(timeframe)) {
       return i;
     }
 

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';
 
 /**
@@ -90,7 +90,7 @@ export class MetadataStore {
    */
   async clear (): Promise<void> {
     log('Clearing all echo metadata...');
-    await this._directory.destroy();
+    await this._directory.delete();
   }
 
   /**
@@ -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);
     }