@dxos/client-services 0.8.2-staging.7ac8446 → 0.8.2

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

@@ -41,7 +41,7 @@ export class IdentityServiceImpl extends Resource implements IdentityService {
     super();
   }
 
-  protected override async _open() {
+  protected override async _open(): Promise<void> {
     const identity = this._identityManager.identity;
     if (identity && !identity.defaultSpaceId) {
       await this._fixIdentityWithoutDefaultSpace(identity);
@@ -49,13 +49,13 @@ export class IdentityServiceImpl extends Resource implements IdentityService {
   }
 
   async createIdentity(request: CreateIdentityRequest): Promise<IdentityProto> {
-    await this._createIdentity({ displayName: request.profile?.displayName, deviceProfile: request.deviceProfile });
+    await this._createIdentity({ profile: request.profile, deviceProfile: request.deviceProfile });
     const dataSpaceManager = this._dataSpaceManagerProvider();
     await this._createDefaultSpace(dataSpaceManager);
     return this._getIdentity()!;
   }
 
-  private async _createDefaultSpace(dataSpaceManager: DataSpaceManager) {
+  private async _createDefaultSpace(dataSpaceManager: DataSpaceManager): Promise<void> {
     const space = await dataSpaceManager!.createDefaultSpace();
     const identity = this._identityManager.identity;
     invariant(identity);
@@ -141,7 +141,7 @@ export class IdentityServiceImpl extends Resource implements IdentityService {
     });
   }
 
-  private async _fixIdentityWithoutDefaultSpace(identity: Identity) {
+  private async _fixIdentityWithoutDefaultSpace(identity: Identity): Promise<void> {
     let recodedDefaultSpace = false;
     let foundDefaultSpace = false;
     const dataSpaceManager = this._dataSpaceManagerProvider();

package/src/packlets/identity/identity.test.ts

@@ -4,6 +4,7 @@
 
 import { onTestFinished, describe, expect, test } from 'vitest';
 
+import { Event } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { createDidFromIdentityKey, CredentialGenerator, verifyCredential } from '@dxos/credentials';
 import {
@@ -22,6 +23,7 @@ import { Keyring } from '@dxos/keyring';
 import { type PublicKey } from '@dxos/keys';
 import { MemorySignalManager, MemorySignalManagerContext } from '@dxos/messaging';
 import { MemoryTransportFactory, SwarmNetworkManager } from '@dxos/network-manager';
+import { EdgeStatus } from '@dxos/protocols/proto/dxos/client/services';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { AdmittedFeed } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { createStorage, StorageType } from '@dxos/random-access-storage';
@@ -107,21 +109,22 @@ describe('identity/identity', () => {
 
   test('edge feed replicator', async () => {
     let replicationStarted = false;
-    let isConnected = false;
+    let status = EdgeStatus.NOT_CONNECTED;
     const listeners: Array<() => void> = [];
     const setup = await setupIdentity({
       edgeConnection: {
+        statusChanged: new Event(),
+        get status() {
+          return status;
+        },
         onReconnected: (listener) => {
-          if (isConnected) {
+          if (status === EdgeStatus.CONNECTED) {
             listener();
           } else {
             listeners.push(listener);
           }
           return () => {};
         },
-        get isConnected() {
-          return isConnected;
-        },
         open: async () => {},
         close: async () => {},
         onMessage: (_: MessageListener): (() => void) => {
@@ -135,7 +138,7 @@ describe('identity/identity', () => {
 
     await writeGenesisCredential(setup);
     listeners.forEach((callback) => callback());
-    isConnected = true;
+    status = EdgeStatus.CONNECTED;
 
     await expect.poll(() => replicationStarted).toBeTruthy();
   });

package/src/packlets/identity/identity.ts

@@ -116,7 +116,7 @@ export class Identity {
   }
 
   @trace.span()
-  async open(ctx: Context) {
+  async open(ctx: Context): Promise<void> {
     await this._presence?.open();
     await this.space.spaceState.addCredentialProcessor(this._deviceStateMachine);
     await this.space.spaceState.addCredentialProcessor(this._profileStateMachine);
@@ -127,13 +127,13 @@ export class Identity {
     await this.space.open(ctx);
   }
 
-  public async joinNetwork() {
+  public async joinNetwork(): Promise<void> {
     await this.space.startProtocol();
     await this._edgeFeedReplicator?.open();
   }
 
   @trace.span()
-  async close(ctx: Context) {
+  async close(ctx: Context): Promise<void> {
     await this._presence?.close();
     await this.authVerifier.close();
     await this.space.spaceState.removeCredentialProcessor(this._defaultSpaceStateMachine);
@@ -149,7 +149,7 @@ export class Identity {
     await this.space.close();
   }
 
-  async ready() {
+  async ready(): Promise<void> {
     await this._deviceStateMachine.deviceChainReady.wait();
 
     await this.controlPipeline.state.waitUntilReachedTargetTimeframe({ timeout: LOAD_CONTROL_FEEDS_TIMEOUT });
@@ -210,7 +210,7 @@ export class Identity {
     return createCredentialSignerWithKey(this._signer, this.deviceKey);
   }
 
-  async updateDefaultSpace(spaceId: SpaceId) {
+  async updateDefaultSpace(spaceId: SpaceId): Promise<void> {
     const credential = await this.getDeviceCredentialSigner().createCredential({
       subject: this.identityKey,
       assertion: { '@type': 'dxos.halo.credentials.DefaultSpace', spaceId },

package/src/packlets/invitations/device-invitation-protocol.ts

@@ -66,7 +66,7 @@ export class DeviceInvitationProtocol implements InvitationProtocol {
     };
   }
 
-  checkInvitation(invitation: Partial<Invitation>) {
+  checkInvitation(invitation: Partial<Invitation>): AlreadyJoinedError | undefined {
     try {
       const identity = this._getIdentity();
       if (identity) {

package/src/packlets/invitations/edge-invitation-handler.ts

@@ -61,7 +61,7 @@ export class EdgeInvitationHandler implements FlowLockHolder {
     guardedState: GuardedInvitationState,
     protocol: InvitationProtocol,
     deviceProfile?: DeviceProfileDocument,
-  ) {
+  ): void {
     if (!this._client) {
       log('edge disabled');
       return;
@@ -118,7 +118,7 @@ export class EdgeInvitationHandler implements FlowLockHolder {
     guardedState: GuardedInvitationState,
     admissionRequest: SpaceAdmissionRequest,
     spaceId: SpaceId,
-  ) {
+  ): Promise<void> {
     try {
       log('edge invitation flow');
       this._flowLock = await tryAcquireBeforeContextDisposed(ctx, guardedState.mutex);
@@ -182,7 +182,7 @@ export class EdgeInvitationHandler implements FlowLockHolder {
     return this._flowLock != null;
   }
 
-  private _calculateNextRetryMs() {
+  private _calculateNextRetryMs(): number {
     return this._retryInterval + Math.random() * this._retryJitter;
   }
 }

package/src/packlets/invitations/invitation-guest-extenstion.ts

@@ -82,7 +82,7 @@ export class InvitationGuestExtension
     };
   }
 
-  override async onOpen(context: ExtensionContext) {
+  override async onOpen(context: ExtensionContext): Promise<void> {
     await super.onOpen(context);
 
     try {
@@ -115,7 +115,7 @@ export class InvitationGuestExtension
     }
   }
 
-  override async onClose() {
+  override async onClose(): Promise<void> {
     await this._destroy();
   }
 
@@ -123,7 +123,7 @@ export class InvitationGuestExtension
     await this._destroy();
   }
 
-  private async _destroy() {
+  private async _destroy(): Promise<void> {
     await this._ctx.dispose();
     if (this._invitationFlowLock != null) {
       this._invitationFlowLock.release();

package/src/packlets/invitations/invitation-host-extension.ts

@@ -232,7 +232,7 @@ export class InvitationHostExtension
     };
   }
 
-  override async onOpen(context: ExtensionContext) {
+  override async onOpen(context: ExtensionContext): Promise<void> {
     await super.onOpen(context);
 
     try {
@@ -272,7 +272,7 @@ export class InvitationHostExtension
     return invitation;
   }
 
-  private _assertInvitationState(stateOrMany: Invitation.State | Invitation.State[]) {
+  private _assertInvitationState(stateOrMany: Invitation.State | Invitation.State[]): void {
     const invitation = this._requireActiveInvitation();
     const validStates = Array.isArray(stateOrMany) ? stateOrMany : [stateOrMany];
     if (!validStates.includes(invitation.state)) {
@@ -283,15 +283,15 @@ export class InvitationHostExtension
     }
   }
 
-  override async onClose() {
+  override async onClose(): Promise<void> {
     await this._destroy();
   }
 
-  override async onAbort() {
+  override async onAbort(): Promise<void> {
     await this._destroy();
   }
 
-  private async _destroy() {
+  private async _destroy(): Promise<void> {
     await this._ctx.dispose();
     if (this._invitationFlowLock != null) {
       this._invitationFlowLock?.release();

package/src/packlets/invitations/invitation-topology.ts

@@ -81,7 +81,7 @@ export class InvitationTopology implements Topology {
     this._seenPeers.clear();
   }
 
-  toString() {
+  toString(): string {
     return `InvitationTopology(${this._role === InvitationOptions.Role.GUEST ? 'guest' : 'host'})`;
   }
 }

package/src/packlets/invitations/invitations-handler.ts

@@ -453,7 +453,7 @@ export class InvitationsHandler {
     setState: (newState: Invitation.State) => void,
     authenticated: Trigger<string>,
     options: { timeout: number },
-  ) {
+  ): Promise<void> {
     for (let attempt = 1; attempt <= MAX_OTP_ATTEMPTS; attempt++) {
       log('guest waiting for authentication code...');
       setState(Invitation.State.READY_FOR_AUTHENTICATION);
@@ -482,7 +482,7 @@ export class InvitationsHandler {
     setState: (newState: Invitation.State) => void,
     invitation: Invitation,
     introductionResponse: IntroductionResponse,
-  ) {
+  ): Promise<void> {
     if (invitation.guestKeypair?.privateKey == null) {
       throw new Error('keypair missing in the invitation');
     }

package/src/packlets/invitations/invitations-manager.ts

@@ -182,7 +182,7 @@ export class InvitationsManager {
     return [...this._acceptInvitations.values()].map((i) => i.get());
   }
 
-  onPersistentInvitationsLoaded(ctx: Context, callback: () => void) {
+  onPersistentInvitationsLoaded(ctx: Context, callback: () => void): void {
     if (this._persistentInvitationsLoaded) {
       callback();
     } else {
@@ -231,7 +231,10 @@ export class InvitationsManager {
     } satisfies Invitation;
   }
 
-  private _createObservableInvitation(handler: InvitationProtocol, invitation: Invitation) {
+  private _createObservableInvitation(
+    handler: InvitationProtocol,
+    invitation: Invitation,
+  ): { ctx: Context; stream: PushStream<Invitation>; observableInvitation: CancellableInvitation } {
     const stream = new PushStream<Invitation>();
     const ctx = new Context({
       onError: (err) => {
@@ -254,7 +257,15 @@ export class InvitationsManager {
     return { ctx, stream, observableInvitation };
   }
 
-  private _createObservableAcceptingInvitation(handler: InvitationProtocol, initialState: Invitation) {
+  private _createObservableAcceptingInvitation(
+    handler: InvitationProtocol,
+    initialState: Invitation,
+  ): {
+    ctx: Context;
+    invitation: AuthenticatingInvitation;
+    stream: PushStream<Invitation>;
+    otpEnteredTrigger: Trigger<string>;
+  } {
     const otpEnteredTrigger = new Trigger<string>();
     const stream = new PushStream<Invitation>();
     const ctx = new Context({
@@ -310,7 +321,7 @@ export class InvitationsManager {
     }
   }
 
-  private _onInvitationComplete(invitation: CancellableInvitation, callback: () => void) {
+  private _onInvitationComplete(invitation: CancellableInvitation, callback: () => void): void {
     invitation.subscribe(
       () => {},
       () => {},

package/src/packlets/invitations/space-invitation-protocol.ts

@@ -145,7 +145,7 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     await writeMessages(space.inner.controlPipeline.writer, [credential]);
   }
 
-  checkInvitation(invitation: Partial<Invitation>) {
+  checkInvitation(invitation: Partial<Invitation>): InvalidInvitationError | AlreadyJoinedError | undefined {
     if (invitation.spaceKey == null) {
       return new InvalidInvitationError('No spaceKey was provided for a space invitation.');
     }

package/src/packlets/locks/browser.ts

@@ -33,7 +33,7 @@ export class Lock implements ResourceLock {
     return this._lockKey;
   }
 
-  async acquire() {
+  async acquire(): Promise<void> {
     this._broadcastChannel.postMessage({
       message: Message.ACQUIRING,
     });
@@ -49,17 +49,17 @@ export class Lock implements ResourceLock {
     }
   }
 
-  async release() {
+  async release(): Promise<void> {
     this._releaseTrigger.wake();
   }
 
-  private _onMessage(event: MessageEvent<any>) {
+  private _onMessage(event: MessageEvent<any>): void {
     if (event.data.message === Message.ACQUIRING) {
       this._releaseTrigger.wake();
     }
   }
 
-  private async _requestLock(steal = false) {
+  private async _requestLock(steal = false): Promise<void> {
     log('requesting lock...', { steal });
     const acquired = new Trigger();
 

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

@@ -3,6 +3,7 @@
 //
 
 import { Stream } from '@dxos/codec-protobuf/stream';
+import { type EdgeConnection } from '@dxos/edge-client';
 import { type SignalManager } from '@dxos/messaging';
 import { type SwarmNetworkManager } from '@dxos/network-manager';
 import {
@@ -23,10 +24,11 @@ export class NetworkServiceImpl implements NetworkService {
   constructor(
     private readonly networkManager: SwarmNetworkManager,
     private readonly signalManager: SignalManager,
+    private readonly edgeConnection?: EdgeConnection,
   ) {}
 
-  queryStatus() {
-    return new Stream<NetworkStatus>(({ next }) => {
+  queryStatus(): Stream<NetworkStatus> {
+    return new Stream<NetworkStatus>(({ ctx, next }) => {
       const update = () => {
         next({
           swarm: this.networkManager.connectionState,
@@ -35,18 +37,13 @@ export class NetworkServiceImpl implements NetworkService {
         });
       };
 
-      const unsubscribeSwarm = this.networkManager.connectionStateChanged.on(() => update());
-      const unsubscribeSignal = this.signalManager.statusChanged?.on(() => update());
+      this.networkManager.connectionStateChanged.on(ctx, () => update());
+      this.signalManager.statusChanged?.on(ctx, () => update());
       update();
-
-      return () => {
-        unsubscribeSwarm();
-        unsubscribeSignal?.();
-      };
     });
   }
 
-  async updateConfig(request: UpdateConfigRequest) {
+  async updateConfig(request: UpdateConfigRequest): Promise<void> {
     await this.networkManager.setConnectionState(request.swarm);
   }
 
@@ -63,13 +60,12 @@ export class NetworkServiceImpl implements NetworkService {
   }
 
   subscribeSwarmState(request: SubscribeSwarmStateRequest): Stream<SwarmResponse> {
-    return new Stream<SwarmResponse>(({ next }) => {
-      const unsubscribe = this.signalManager.swarmState?.on((state) => {
+    return new Stream<SwarmResponse>(({ ctx, next }) => {
+      this.signalManager.swarmState?.on(ctx, (state) => {
         if (request.topic.equals(state.swarmKey)) {
           next(state);
         }
       });
-      return unsubscribe;
     });
   }
 
@@ -78,14 +74,12 @@ export class NetworkServiceImpl implements NetworkService {
   }
 
   subscribeMessages(peer: Peer): Stream<Message> {
-    return new Stream<Message>(({ next }) => {
-      const unsubscribe = this.signalManager.onMessage.on((message) => {
+    return new Stream<Message>(({ ctx, next }) => {
+      this.signalManager.onMessage.on(ctx, (message) => {
         if (message.recipient.peerKey === peer.peerKey) {
           next(message);
         }
       });
-
-      return unsubscribe;
     });
   }
 }

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;
     }
@@ -329,7 +333,11 @@ export class ClientServicesHost {
       DataService: this._serviceContext.echoHost.dataService,
       QueryService: this._serviceContext.echoHost.queryService,
 
-      NetworkService: new NetworkServiceImpl(this._serviceContext.networkManager, this._serviceContext.signalManager),
+      NetworkService: new NetworkServiceImpl(
+        this._serviceContext.networkManager,
+        this._serviceContext.signalManager,
+        this._edgeConnection,
+      ),
 
       LoggingService: this._loggingService,
       TracingService: this._tracingService,
@@ -369,7 +377,7 @@ export class ClientServicesHost {
 
   @synchronized
   @Trace.span()
-  async close() {
+  async close(): Promise<void> {
     if (!this._open) {
       return;
     }
@@ -387,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-reader.ts

@@ -2,7 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import type { DocumentId } from '@dxos/automerge/automerge-repo';
+import type { DocumentId } from '@automerge/automerge-repo';
+
 import { assertArgument, failedInvariant, invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { SpaceArchiveFileStructure, type SpaceArchiveMetadata } from '@dxos/protocols';

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);