@dxos/client-services 0.8.2-main.fbd8ed0 → 0.8.2-staging.4d6ad0f

package/src/packlets/locks/node.ts

@@ -28,7 +28,7 @@ export class Lock implements ResourceLock {
     return this._lockPath;
   }
 
-  async acquire() {
+  async acquire(): Promise<void> {
     log('acquiring lock...');
     this._fileHandle = await LockFile.acquire(this._lockPath);
 
@@ -37,7 +37,7 @@ export class Lock implements ResourceLock {
     log('acquired lock');
   }
 
-  async release() {
+  async release(): Promise<void> {
     await this._onRelease?.();
     invariant(this._fileHandle, 'Lock is not acquired');
     await LockFile.release(this._fileHandle);

package/src/packlets/logging/logging-service.ts

@@ -32,11 +32,11 @@ export class LoggingServiceImpl implements LoggingService {
   private readonly _started = Date.now();
   private readonly _sessionId = PublicKey.random().toHex();
 
-  async open() {
+  async open(): Promise<void> {
     log.runtimeConfig.processors.push(this._logProcessor);
   }
 
-  async close() {
+  async close(): Promise<void> {
     const index = log.runtimeConfig.processors.findIndex((processor) => processor === this._logProcessor);
     log.runtimeConfig.processors.splice(index, 1);
   }

package/src/packlets/network/network-service.ts

@@ -27,7 +27,7 @@ export class NetworkServiceImpl implements NetworkService {
     private readonly edgeConnection?: EdgeConnection,
   ) {}
 
-  queryStatus() {
+  queryStatus(): Stream<NetworkStatus> {
     return new Stream<NetworkStatus>(({ ctx, next }) => {
       const update = () => {
         next({
@@ -43,7 +43,7 @@ export class NetworkServiceImpl implements NetworkService {
     });
   }
 
-  async updateConfig(request: UpdateConfigRequest) {
+  async updateConfig(request: UpdateConfigRequest): Promise<void> {
     await this.networkManager.setConnectionState(request.swarm);
   }
 

package/src/packlets/services/client-rpc-server.ts

@@ -80,11 +80,11 @@ export class ClientRpcServer {
     });
   }
 
-  async open() {
+  async open(): Promise<void> {
     await this._rpcPeer.open();
   }
 
-  async close() {
+  async close(): Promise<void> {
     await this._rpcPeer.close();
   }
 

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

@@ -59,6 +59,7 @@ export type ServiceContextRuntimeParams = Pick<
   DataSpaceManagerRuntimeParams & {
     invitationConnectionDefaultParams?: InvitationConnectionParams;
     disableP2pReplication?: boolean;
+    enableVectorIndexing?: boolean;
   };
 /**
  * Shared backend for all client services.
@@ -155,6 +156,9 @@ export class ServiceContext extends Resource {
       kv: this.level,
       peerIdProvider: () => this.identityManager.identity?.deviceKey?.toHex(),
       getSpaceKeyByRootDocumentId: (documentId) => this.spaceManager.findSpaceByRootDocumentId(documentId)?.key,
+      indexing: {
+        vector: this._runtimeParams?.enableVectorIndexing,
+      },
     });
 
     this._meshReplicator = new MeshEchoReplicator();
@@ -193,7 +197,7 @@ export class ServiceContext extends Resource {
   }
 
   @Trace.span()
-  protected override async _open(ctx: Context) {
+  protected override async _open(ctx: Context): Promise<void> {
     await this._checkStorageVersion();
 
     log('opening...');
@@ -231,7 +235,7 @@ export class ServiceContext extends Resource {
     log('opened');
   }
 
-  protected override async _close(ctx: Context) {
+  protected override async _close(ctx: Context): Promise<void> {
     log('closing...');
     if (this._deviceSpaceSync && this.identityManager.identity) {
       await this.identityManager.identity.space.spaceState.removeCredentialProcessor(this._deviceSpaceSync);
@@ -268,7 +272,7 @@ export class ServiceContext extends Resource {
     return factory(invitation);
   }
 
-  async broadcastProfileUpdate(profile: ProfileDocument | undefined) {
+  async broadcastProfileUpdate(profile: ProfileDocument | undefined): Promise<void> {
     if (!profile || !this.dataSpaceManager) {
       return;
     }
@@ -287,7 +291,7 @@ export class ServiceContext extends Resource {
     return identity;
   }
 
-  private async _checkStorageVersion() {
+  private async _checkStorageVersion(): Promise<void> {
     await this.metadataStore.load();
     if (this.metadataStore.version !== STORAGE_VERSION) {
       throw new InvalidStorageVersionError(STORAGE_VERSION, this.metadataStore.version);
@@ -297,7 +301,7 @@ export class ServiceContext extends Resource {
 
   // Called when identity is created.
   @Trace.span()
-  private async _initialize(ctx: Context) {
+  private async _initialize(ctx: Context): Promise<void> {
     log('initializing spaces...');
     const identity = this.identityManager.identity ?? failUndefined();
     const signingContext: SigningContext = {
@@ -375,7 +379,7 @@ export class ServiceContext extends Resource {
     await identity.space.spaceState.addCredentialProcessor(this._deviceSpaceSync);
   }
 
-  private async _setNetworkIdentity(params?: { deviceCredential: Credential }) {
+  private async _setNetworkIdentity(params?: { deviceCredential: Credential }): Promise<void> {
     using _ = await this._edgeIdentityUpdateMutex.acquire();
 
     let edgeIdentity: EdgeIdentity;

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

@@ -125,6 +125,10 @@ export class ClientServicesHost {
       this._runtimeParams.disableP2pReplication = config?.get('runtime.client.disableP2pReplication', false);
     }
 
+    if (this._runtimeParams.enableVectorIndexing === undefined) {
+      this._runtimeParams.enableVectorIndexing = config?.get('runtime.client.enableVectorIndexing', false);
+    }
+
     if (config) {
       this.initialize({ config, transportFactory, signalManager });
     }
@@ -199,7 +203,7 @@ export class ClientServicesHost {
    * Config can also be provided in the constructor.
    * Can only be called once.
    */
-  initialize({ config, ...options }: InitializeOptions) {
+  initialize({ config, ...options }: InitializeOptions): void {
     invariant(!this._open, 'service host is open');
     log('initializing...');
 
@@ -252,7 +256,7 @@ export class ClientServicesHost {
 
   @synchronized
   @Trace.span()
-  async open(ctx: Context) {
+  async open(ctx: Context): Promise<void> {
     if (this._open) {
       return;
     }
@@ -373,7 +377,7 @@ export class ClientServicesHost {
 
   @synchronized
   @Trace.span()
-  async close() {
+  async close(): Promise<void> {
     if (!this._open) {
       return;
     }
@@ -391,7 +395,7 @@ export class ClientServicesHost {
     log('closed', { deviceKey });
   }
 
-  async reset() {
+  async reset(): Promise<void> {
     const traceId = PublicKey.random().toHex();
     log.trace('dxos.sdk.client-services-host.reset', trace.begin({ id: traceId }));
 

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

@@ -22,15 +22,15 @@ export class ServiceRegistry<Services> {
     return this._handlers;
   }
 
-  setServices(services: Partial<Services>) {
+  setServices(services: Partial<Services>): void {
     this._handlers = services;
   }
 
-  addService(name: keyof Services, service: Services[keyof Services]) {
+  addService(name: keyof Services, service: Services[keyof Services]): void {
     this._handlers[name] = service;
   }
 
-  removeService(name: keyof Services) {
+  removeService(name: keyof Services): void {
     delete this._handlers[name];
   }
 }

package/src/packlets/space-export/space-archive-writer.ts

@@ -36,21 +36,21 @@ export class SpaceArchiveWriter extends Resource {
     return Promise.resolve();
   }
 
-  async begin(meta: SpaceArchiveBeginProps) {
+  async begin(meta: SpaceArchiveBeginProps): Promise<void> {
     assertState(this._tar, 'Not open');
     assertState(!this._meta, 'Already started');
     this._meta = meta;
     this._archive = new this._tar.Archive();
   }
 
-  async setCurrentRootUrl(url: string) {
+  async setCurrentRootUrl(url: string): Promise<void> {
     assertArgument(url.startsWith('automerge:'), 'Invalid root URL');
     assertState(this._tar, 'Not open');
     assertState(this._meta, 'Not started');
     this._currentRootUrl = url;
   }
 
-  async writeDocument(documentId: string, data: Uint8Array) {
+  async writeDocument(documentId: string, data: Uint8Array): Promise<void> {
     assertArgument(!documentId.startsWith('automerge:'), 'Invalid document ID');
     assertState(this._archive, 'Not open');
     this._archive.addBinaryFile(`${SpaceArchiveFileStructure.documents}/${documentId}.bin`, data);

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

@@ -25,7 +25,7 @@ export class AutomergeSpaceState extends Resource implements CredentialProcessor
     this._isProcessingRootDocs = false;
   }
 
-  async processCredential(credential: Credential) {
+  async processCredential(credential: Credential): Promise<void> {
     if (!checkCredentialType(credential, 'dxos.halo.credentials.Epoch')) {
       return;
     }
@@ -42,7 +42,7 @@ export class AutomergeSpaceState extends Resource implements CredentialProcessor
     this.onNewEpoch.emit(credential);
   }
 
-  startProcessingRootDocs() {
+  startProcessingRootDocs(): void {
     if (this._isProcessingRootDocs) {
       return;
     }
@@ -53,7 +53,7 @@ export class AutomergeSpaceState extends Resource implements CredentialProcessor
     this._isProcessingRootDocs = true;
   }
 
-  async ensureEpochInitialized() {
+  async ensureEpochInitialized(): Promise<void> {
     await this.onNewEpoch.waitForCondition(() => !!this.lastEpoch);
   }
 }

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

@@ -35,7 +35,7 @@ import {
   createIdFromSpaceKey,
   encodeReference,
   type ObjectStructure,
-  type SpaceDoc,
+  type DatabaseDirectory,
 } from '@dxos/echo-protocol';
 import { ObjectId, getTypeReference } from '@dxos/echo-schema';
 import type { EdgeConnection, EdgeHttpClient } from '@dxos/edge-client';
@@ -178,7 +178,7 @@ export class DataSpaceManager extends Resource {
           Array.from(this._spaces.values()).map(async (space) => {
             const rootUrl = space.automergeSpaceState.rootUrl;
             const rootHandle = rootUrl
-              ? await this._echoHost.automergeRepo.find<Doc<SpaceDoc>>(rootUrl as AutomergeUrl, FIND_PARAMS)
+              ? await this._echoHost.automergeRepo.find<Doc<DatabaseDirectory>>(rootUrl as AutomergeUrl, FIND_PARAMS)
               : undefined;
             await rootHandle?.whenReady();
             const rootDoc = rootHandle?.doc();
@@ -211,7 +211,7 @@ export class DataSpaceManager extends Resource {
   }
 
   @synchronized
-  protected override async _open() {
+  protected override async _open(): Promise<void> {
     log('open');
     log.trace('dxos.echo.data-space-manager.open', Trace.begin({ id: this._instanceId }));
     log('metadata loaded', { spaces: this._metadataStore.spaces.length });
@@ -231,7 +231,7 @@ export class DataSpaceManager extends Resource {
   }
 
   @synchronized
-  protected override async _close() {
+  protected override async _close(): Promise<void> {
     log('close');
     for (const space of this._spaces.values()) {
       await space.close();
@@ -243,7 +243,7 @@ export class DataSpaceManager extends Resource {
    * Creates a new space writing the genesis credentials to the control feed.
    */
   @synchronized
-  async createSpace(options: CreateSpaceOptions = {}) {
+  async createSpace(options: CreateSpaceOptions = {}): Promise<DataSpace> {
     assertArgument(!!options.rootUrl === !!options.documents, 'root url must be required when providing documents');
 
     assertState(this._lifecycleState === LifecycleState.OPEN, 'Not open.');
@@ -285,7 +285,7 @@ export class DataSpaceManager extends Resource {
     let root: DatabaseRoot;
     if (options.rootUrl) {
       const newRootDocId = documentIdMapping[interpretAsDocumentId(options.rootUrl)] ?? failedInvariant();
-      const rootDocHandle = await this._echoHost.loadDoc<SpaceDoc>(Context.default(), newRootDocId);
+      const rootDocHandle = await this._echoHost.loadDoc<DatabaseDirectory>(Context.default(), newRootDocId);
       DatabaseRoot.mapLinks(rootDocHandle, documentIdMapping);
 
       root = await this._echoHost.openSpaceRoot(spaceId, `automerge:${newRootDocId}` as AutomergeUrl);
@@ -338,7 +338,7 @@ export class DataSpaceManager extends Resource {
     }
   }
 
-  async createDefaultSpace() {
+  async createDefaultSpace(): Promise<DataSpace> {
     const space = await this.createSpace();
     const document = await this._getSpaceRootDocument(space);
 
@@ -356,7 +356,7 @@ export class DataSpaceManager extends Resource {
     };
 
     const propertiesId = ObjectId.random();
-    document.change((doc: SpaceDoc) => {
+    document.change((doc: DatabaseDirectory) => {
       setDeep(doc, ['objects', propertiesId], properties);
     });
 
@@ -364,10 +364,10 @@ export class DataSpaceManager extends Resource {
     return space;
   }
 
-  private async _getSpaceRootDocument(space: DataSpace): Promise<DocHandle<SpaceDoc>> {
+  private async _getSpaceRootDocument(space: DataSpace): Promise<DocHandle<DatabaseDirectory>> {
     const automergeIndex = space.automergeSpaceState.rootUrl;
     invariant(automergeIndex);
-    const document = await this._echoHost.automergeRepo.find<SpaceDoc>(automergeIndex as any, FIND_PARAMS);
+    const document = await this._echoHost.automergeRepo.find<DatabaseDirectory>(automergeIndex as any, FIND_PARAMS);
     await document.whenReady();
     return document;
   }
@@ -429,7 +429,7 @@ export class DataSpaceManager extends Resource {
    * Used by invitation handler.
    * TODO(dmaretskyi): Consider removing.
    */
-  async waitUntilSpaceReady(spaceKey: PublicKey) {
+  async waitUntilSpaceReady(spaceKey: PublicKey): Promise<void> {
     await cancelWithContext(
       this._ctx,
       this.updated.waitForCondition(() => {
@@ -453,7 +453,7 @@ export class DataSpaceManager extends Resource {
     });
   }
 
-  async setSpaceEdgeReplicationSetting(spaceKey: PublicKey, setting: EdgeReplicationSetting) {
+  async setSpaceEdgeReplicationSetting(spaceKey: PublicKey, setting: EdgeReplicationSetting): Promise<void> {
     const space = this._spaces.get(spaceKey);
     invariant(space, 'Space not found.');
 
@@ -473,7 +473,7 @@ export class DataSpaceManager extends Resource {
     space.stateUpdate.emit();
   }
 
-  private async _constructSpace(metadata: SpaceMetadata) {
+  private async _constructSpace(metadata: SpaceMetadata): Promise<DataSpace> {
     log('construct space', { metadata });
     const gossip = new Gossip({
       localPeerId: this._signingContext.deviceKey,
@@ -597,7 +597,7 @@ export class DataSpaceManager extends Resource {
     return dataSpace;
   }
 
-  private async _connectEchoMeshReplicator(space: Space, session: Teleport) {
+  private async _connectEchoMeshReplicator(space: Space, session: Teleport): Promise<void> {
     const replicator = this._meshReplicator;
     if (!replicator) {
       log.warn('p2p automerge replication disabled', { space: space.key });

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

@@ -18,7 +18,7 @@ import {
   type Space,
   FIND_PARAMS,
 } from '@dxos/echo-pipeline';
-import { SpaceDocVersion, type SpaceDoc } from '@dxos/echo-protocol';
+import { SpaceDocVersion, type DatabaseDirectory } from '@dxos/echo-protocol';
 import type { EdgeConnection, EdgeHttpClient } from '@dxos/edge-client';
 import { type FeedStore, type FeedWrapper } from '@dxos/feed-store';
 import { failedInvariant, invariant } from '@dxos/invariant';
@@ -229,13 +229,13 @@ export class DataSpace {
   }
 
   @synchronized
-  async open() {
+  async open(): Promise<void> {
     if (this._state === SpaceState.SPACE_CLOSED) {
       await this._open();
     }
   }
 
-  private async _open() {
+  private async _open(): Promise<void> {
     await this._presence.open();
     await this._gossip.open();
     await this._notarizationPlugin.open();
@@ -262,11 +262,11 @@ export class DataSpace {
   }
 
   @synchronized
-  async close() {
+  async close(): Promise<void> {
     await this._close();
   }
 
-  private async _close() {
+  private async _close(): Promise<void> {
     await this._callbacks.beforeClose?.();
 
     await this.preClose.callSerial();
@@ -294,18 +294,18 @@ export class DataSpace {
     await this._gossip.close();
   }
 
-  async postMessage(channel: string, message: any) {
+  async postMessage(channel: string, message: any): Promise<void> {
     return this._gossip.postMessage(channel, message);
   }
 
-  listen(channel: string, callback: (message: GossipMessage) => void) {
+  listen(channel: string, callback: (message: GossipMessage) => void): { unsubscribe: () => void } {
     return this._gossip.listen(channel, callback);
   }
 
   /**
    * Initialize the data pipeline in a separate task.
    */
-  initializeDataPipelineAsync() {
+  initializeDataPipelineAsync(): void {
     scheduleTask(this._ctx, async () => {
       try {
         this.metrics.pipelineInitBegin = new Date();
@@ -328,7 +328,7 @@ export class DataSpace {
   }
 
   @trace.span({ showInBrowserTimeline: true })
-  async initializeDataPipeline() {
+  async initializeDataPipeline(): Promise<void> {
     if (this._state !== SpaceState.SPACE_CONTROL_ONLY) {
       throw new SystemError('Invalid operation');
     }
@@ -365,7 +365,7 @@ export class DataSpace {
     }
   }
 
-  private async _enterReadyState() {
+  private async _enterReadyState(): Promise<void> {
     await this._callbacks.beforeReady?.();
 
     this._state = SpaceState.SPACE_READY;
@@ -376,7 +376,7 @@ export class DataSpace {
   }
 
   @trace.span({ showInBrowserTimeline: true })
-  private async _initializeAndReadControlPipeline() {
+  private async _initializeAndReadControlPipeline(): Promise<void> {
     await this._inner.controlPipeline.state.waitUntilReachedTargetTimeframe({
       ctx: this._ctx,
       timeout: 10_000,
@@ -402,7 +402,7 @@ export class DataSpace {
   }
 
   @timed(10_000)
-  private async _createWritableFeeds() {
+  private async _createWritableFeeds(): Promise<void> {
     const credentials: Credential[] = [];
     if (!this.inner.controlFeedKey) {
       const controlFeed = await this._feedStore.openFeed(await this._keyring.createKey(), { writable: true });
@@ -459,10 +459,10 @@ export class DataSpace {
     }
   }
 
-  private _onNewAutomergeRoot(rootUrl: string) {
+  private _onNewAutomergeRoot(rootUrl: string): void {
     log('loading automerge root doc for space', { space: this.key, rootUrl });
 
-    let handle: DocHandle<SpaceDoc>;
+    let handle: DocHandle<DatabaseDirectory>;
 
     // TODO(dmaretskyi): Make this single-threaded (but doc loading should still be parallel to not block epoch processing).
     queueMicrotask(async () => {
@@ -470,7 +470,7 @@ export class DataSpace {
         await warnAfterTimeout(5_000, 'Automerge root doc load timeout (DataSpace)', async () => {
           handle = await cancelWithContext(
             this._ctx,
-            this._echoHost.automergeRepo.find<SpaceDoc>(rootUrl as any, FIND_PARAMS),
+            this._echoHost.automergeRepo.find<DatabaseDirectory>(rootUrl as any, FIND_PARAMS),
           );
           await cancelWithContext(this._ctx, handle.whenReady());
         });
@@ -513,7 +513,7 @@ export class DataSpace {
   }
 
   // TODO(dmaretskyi): Use profile from signing context.
-  async updateOwnProfile(profile: ProfileDocument) {
+  async updateOwnProfile(profile: ProfileDocument): Promise<void> {
     const credential = await this._signingContext.credentialSigner.createCredential({
       subject: this._signingContext.identityKey,
       assertion: {
@@ -568,7 +568,7 @@ export class DataSpace {
   }
 
   @synchronized
-  async activate() {
+  async activate(): Promise<void> {
     if (![SpaceState.SPACE_CLOSED, SpaceState.SPACE_INACTIVE].includes(this._state)) {
       return;
     }
@@ -579,7 +579,7 @@ export class DataSpace {
   }
 
   @synchronized
-  async deactivate() {
+  async deactivate(): Promise<void> {
     if (this._state === SpaceState.SPACE_INACTIVE) {
       return;
     }

package/src/packlets/spaces/edge-feed-replicator.ts

@@ -85,7 +85,7 @@ export class EdgeFeedReplicator extends Resource {
     );
   }
 
-  private async _handleReconnect() {
+  private async _handleReconnect(): Promise<void> {
     await this._resetConnection();
     if (this._messenger.status === EdgeStatus.CONNECTED) {
       this._startReplication();
@@ -97,7 +97,7 @@ export class EdgeFeedReplicator extends Resource {
     await this._resetConnection();
   }
 
-  private _startReplication() {
+  private _startReplication(): void {
     this._connected = true;
     const connectionCtx = this._createConnectionContext();
     this._connectionCtx = connectionCtx;
@@ -109,7 +109,7 @@ export class EdgeFeedReplicator extends Resource {
     });
   }
 
-  private async _resetConnection() {
+  private async _resetConnection(): Promise<void> {
     log('resetConnection');
     this._connected = false;
     await this._connectionCtx?.dispose();
@@ -117,7 +117,7 @@ export class EdgeFeedReplicator extends Resource {
     this._remoteLength.clear();
   }
 
-  async addFeed(feed: FeedWrapper<any>) {
+  async addFeed(feed: FeedWrapper<any>): Promise<void> {
     log('addFeed', { key: feed.key, connected: this._connected, hasConnectionCtx: !!this._connectionCtx });
     this._feeds.set(feed.key, feed);
 
@@ -126,11 +126,11 @@ export class EdgeFeedReplicator extends Resource {
     }
   }
 
-  private _getPushMutex(key: PublicKey) {
+  private _getPushMutex(key: PublicKey): Mutex {
     return defaultMap(this._pushMutex, key, () => new Mutex());
   }
 
-  private async _replicateFeed(ctx: Context, feed: FeedWrapper<any>) {
+  private async _replicateFeed(ctx: Context, feed: FeedWrapper<any>): Promise<void> {
     log('replicateFeed', { key: feed.key });
     await this._sendMessage({
       type: 'get-metadata',
@@ -142,7 +142,7 @@ export class EdgeFeedReplicator extends Resource {
     });
   }
 
-  private async _sendMessage(message: ProtocolMessage) {
+  private async _sendMessage(message: ProtocolMessage): Promise<void> {
     if (!this._connectionCtx) {
       log('message dropped because connection was disposed');
       return;
@@ -171,7 +171,7 @@ export class EdgeFeedReplicator extends Resource {
     );
   }
 
-  private _onMessage(message: ProtocolMessage) {
+  private _onMessage(message: ProtocolMessage): void {
     if (!this._connectionCtx) {
       log.warn('received message after connection context was disposed');
       return;
@@ -229,7 +229,7 @@ export class EdgeFeedReplicator extends Resource {
     });
   }
 
-  private async _pushBlocks(feed: FeedWrapper<any>, from: number, to: number) {
+  private async _pushBlocks(feed: FeedWrapper<any>, from: number, to: number): Promise<void> {
     log('pushing blocks', { feed: feed.key.toHex(), from, to });
 
     const blocks: FeedBlock[] = await Promise.all(
@@ -255,7 +255,7 @@ export class EdgeFeedReplicator extends Resource {
     this._remoteLength.set(feed.key, to);
   }
 
-  private async _integrateBlocks(feed: FeedWrapper<any>, blocks: FeedBlock[]) {
+  private async _integrateBlocks(feed: FeedWrapper<any>, blocks: FeedBlock[]): Promise<void> {
     log('integrating blocks', { feed: feed.key.toHex(), blocks: blocks.length });
 
     for (const block of blocks) {
@@ -273,7 +273,7 @@ export class EdgeFeedReplicator extends Resource {
     }
   }
 
-  private async _pushBlocksIfNeeded(feed: FeedWrapper<any>) {
+  private async _pushBlocksIfNeeded(feed: FeedWrapper<any>): Promise<void> {
     using _ = await this._getPushMutex(feed.key).acquire();
 
     if (!this._remoteLength.has(feed.key)) {
@@ -287,7 +287,7 @@ export class EdgeFeedReplicator extends Resource {
     }
   }
 
-  private _createConnectionContext() {
+  private _createConnectionContext(): Context {
     const connectionCtx = new Context({
       onError: async (err: any) => {
         if (connectionCtx !== this._connectionCtx) {

package/src/packlets/spaces/notarization-plugin.test.ts

@@ -30,7 +30,7 @@ class TestAgent extends TestPeer {
     });
   }
 
-  enableWriting() {
+  enableWriting(): void {
     this.notarizationPlugin.setWriter(this.feed);
   }