@comapeo/core 2.0.0 → 2.1.0

package/src/member-api.js

@@ -1,4 +1,6 @@
+import * as b4a from 'b4a'
 import * as crypto from 'node:crypto'
+import WebSocket from 'ws'
 import { TypedEmitter } from 'tiny-typed-emitter'
 import { pEvent } from 'p-event'
 import { InviteResponse_Decision } from './generated/rpc.js'
@@ -8,11 +10,15 @@ import {
   ExhaustivenessError,
   projectKeyToId,
   projectKeyToProjectInviteId,
+  projectKeyToPublicId,
 } from './utils.js'
 import { keyBy } from './lib/key-by.js'
 import { abortSignalAny } from './lib/ponyfills.js'
-import timingSafeEqual from './lib/timing-safe-equal.js'
-import { ROLES, isRoleIdForNewInvite } from './roles.js'
+import timingSafeEqual from 'string-timing-safe-equal'
+import { isHostnameIpAddress } from './lib/is-hostname-ip-address.js'
+import { ErrorWithCode, getErrorMessage } from './lib/error.js'
+import { wsCoreReplicator } from './lib/ws-core-replicator.js'
+import { MEMBER_ROLE_ID, ROLES, isRoleIdForNewInvite } from './roles.js'
 /**
  * @import {
  *   DeviceInfo,
@@ -21,11 +27,13 @@ import { ROLES, isRoleIdForNewInvite } from './roles.js'
  *   ProjectSettingsValue
  * } from '@comapeo/schema'
  */
+/** @import { Promisable } from 'type-fest' */
 /** @import { Invite, InviteResponse } from './generated/rpc.js' */
 /** @import { DataType } from './datatype/index.js' */
 /** @import { DataStore } from './datastore/index.js' */
 /** @import { deviceInfoTable } from './schema/project.js' */
 /** @import { projectSettingsTable } from './schema/client.js' */
+/** @import { ReplicationStream } from './types.js' */
 
 /** @typedef {DataType<DataStore<'config'>, typeof deviceInfoTable, "deviceInfo", DeviceInfo, DeviceInfoValue>} DeviceInfoDataType */
 /** @typedef {DataType<DataStore<'config'>, typeof projectSettingsTable, "projectSettings", ProjectSettings, ProjectSettingsValue>} ProjectDataType */
@@ -36,6 +44,8 @@ import { ROLES, isRoleIdForNewInvite } from './roles.js'
  * @prop {DeviceInfo['name']} [name]
  * @prop {DeviceInfo['deviceType']} [deviceType]
  * @prop {DeviceInfo['createdAt']} [joinedAt]
+ * @prop {object} [selfHostedServerDetails]
+ * @prop {string} selfHostedServerDetails.baseUrl
  */
 
 export class MemberApi extends TypedEmitter {
@@ -43,8 +53,11 @@ export class MemberApi extends TypedEmitter {
   #roles
   #coreOwnership
   #encryptionKeys
+  #getProjectName
   #projectKey
   #rpc
+  #getReplicationStream
+  #waitForInitialSyncWithPeer
   #dataTypes
 
   /** @type {Map<string, { abortController: AbortController }>} */
@@ -56,8 +69,11 @@ export class MemberApi extends TypedEmitter {
    * @param {import('./roles.js').Roles} opts.roles
    * @param {import('./core-ownership.js').CoreOwnership} opts.coreOwnership
    * @param {import('./generated/keys.js').EncryptionKeys} opts.encryptionKeys
+   * @param {() => Promisable<undefined | string>} opts.getProjectName
    * @param {Buffer} opts.projectKey
    * @param {import('./local-peers.js').LocalPeers} opts.rpc
+   * @param {() => ReplicationStream} opts.getReplicationStream
+   * @param {(deviceId: string, abortSignal: AbortSignal) => Promise<void>} opts.waitForInitialSyncWithPeer
    * @param {Object} opts.dataTypes
    * @param {Pick<DeviceInfoDataType, 'getByDocId' | 'getMany'>} opts.dataTypes.deviceInfo
    * @param {Pick<ProjectDataType, 'getByDocId'>} opts.dataTypes.project
@@ -67,8 +83,11 @@ export class MemberApi extends TypedEmitter {
     roles,
     coreOwnership,
     encryptionKeys,
+    getProjectName,
     projectKey,
     rpc,
+    getReplicationStream,
+    waitForInitialSyncWithPeer,
     dataTypes,
   }) {
     super()
@@ -76,8 +95,11 @@ export class MemberApi extends TypedEmitter {
     this.#roles = roles
     this.#coreOwnership = coreOwnership
     this.#encryptionKeys = encryptionKeys
+    this.#getProjectName = getProjectName
     this.#projectKey = projectKey
     this.#rpc = rpc
+    this.#getReplicationStream = getReplicationStream
+    this.#waitForInitialSyncWithPeer = waitForInitialSyncWithPeer
     this.#dataTypes = dataTypes
   }
 
@@ -245,6 +267,181 @@ export class MemberApi extends TypedEmitter {
     this.#outboundInvitesByDevice.get(deviceId)?.abortController.abort()
   }
 
+  /**
+   * Add a server peer.
+   *
+   * Can reject with any of the following error codes (accessed via `err.code`):
+   *
+   * - `INVALID_URL`: the base URL is invalid, likely due to user error.
+   * - `MISSING_DATA`: some required data is missing in order to add the server
+   *   peer. For example, the project must have a name.
+   * - `NETWORK_ERROR`: there was an issue connecting to the server. Is the
+   *   device online? Is the server online?
+   * - `INVALID_SERVER_RESPONSE`: we connected to the server but it returned
+   *   an unexpected response. Is the server running a compatible version of
+   *   CoMapeo Cloud?
+   *
+   * If `err.code` is not specified, that indicates a bug in this module.
+   *
+   * @param {string} baseUrl
+   * @param {object} [options]
+   * @param {boolean} [options.dangerouslyAllowInsecureConnections] Allow insecure network connections. Should only be used in tests.
+   * @returns {Promise<void>}
+   */
+  async addServerPeer(
+    baseUrl,
+    { dangerouslyAllowInsecureConnections = false } = {}
+  ) {
+    if (
+      !isValidServerBaseUrl(baseUrl, { dangerouslyAllowInsecureConnections })
+    ) {
+      throw new ErrorWithCode('INVALID_URL', 'Server base URL is invalid')
+    }
+
+    const { serverDeviceId } = await this.#addServerToProject(baseUrl)
+
+    await this.#roles.assignRole(serverDeviceId, MEMBER_ROLE_ID)
+
+    await this.#waitForInitialSyncWithServer({
+      baseUrl,
+      serverDeviceId,
+      dangerouslyAllowInsecureConnections,
+    })
+  }
+
+  /**
+   * @param {string} baseUrl Server base URL. Should already be validated.
+   * @returns {Promise<{ serverDeviceId: string }>}
+   */
+  async #addServerToProject(baseUrl) {
+    const projectName = await this.#getProjectName()
+    if (!projectName) {
+      throw new ErrorWithCode(
+        'MISSING_DATA',
+        'Project must have name to add server peer'
+      )
+    }
+
+    const requestUrl = new URL('projects', baseUrl)
+    const requestBody = {
+      projectName,
+      projectKey: encodeBufferForServer(this.#projectKey),
+      encryptionKeys: {
+        auth: encodeBufferForServer(this.#encryptionKeys.auth),
+        data: encodeBufferForServer(this.#encryptionKeys.data),
+        config: encodeBufferForServer(this.#encryptionKeys.config),
+        blobIndex: encodeBufferForServer(this.#encryptionKeys.blobIndex),
+        blob: encodeBufferForServer(this.#encryptionKeys.blob),
+      },
+    }
+
+    /** @type {Response} */ let response
+    try {
+      response = await fetch(requestUrl, {
+        method: 'PUT',
+        body: JSON.stringify(requestBody),
+        headers: { 'Content-Type': 'application/json' },
+      })
+    } catch (err) {
+      throw new ErrorWithCode(
+        'NETWORK_ERROR',
+        `Failed to add server peer due to network error: ${getErrorMessage(
+          err
+        )}`
+      )
+    }
+
+    if (response.status !== 200 && response.status !== 201) {
+      throw new ErrorWithCode(
+        'INVALID_SERVER_RESPONSE',
+        `Failed to add server peer due to HTTP status code ${response.status}`
+      )
+    }
+
+    try {
+      const responseBody = await response.json()
+      assert(
+        responseBody &&
+          typeof responseBody === 'object' &&
+          'data' in responseBody &&
+          responseBody.data &&
+          typeof responseBody.data === 'object' &&
+          'deviceId' in responseBody.data &&
+          typeof responseBody.data.deviceId === 'string',
+        'Response body is valid'
+      )
+      return { serverDeviceId: responseBody.data.deviceId }
+    } catch (err) {
+      throw new ErrorWithCode(
+        'INVALID_SERVER_RESPONSE',
+        "Failed to add server peer because we couldn't parse the response"
+      )
+    }
+  }
+
+  /**
+   * @param {object} options
+   * @param {string} options.baseUrl
+   * @param {string} options.serverDeviceId
+   * @param {boolean} options.dangerouslyAllowInsecureConnections
+   * @returns {Promise<void>}
+   */
+  async #waitForInitialSyncWithServer({
+    baseUrl,
+    serverDeviceId,
+    dangerouslyAllowInsecureConnections,
+  }) {
+    const projectPublicId = projectKeyToPublicId(this.#projectKey)
+    const websocketUrl = new URL('sync/' + projectPublicId, baseUrl)
+    websocketUrl.protocol =
+      dangerouslyAllowInsecureConnections && websocketUrl.protocol === 'http:'
+        ? 'ws:'
+        : 'wss:'
+
+    const websocket = new WebSocket(websocketUrl)
+
+    try {
+      await pEvent(websocket, 'open', { rejectionEvents: ['error'] })
+    } catch (rejectionEvent) {
+      throw new ErrorWithCode(
+        // It's difficult for us to reliably disambiguate between "network error"
+        // and "invalid response from server" here, so we just say it was an
+        // invalid server response.
+        'INVALID_SERVER_RESPONSE',
+        'Failed to open the socket',
+        rejectionEvent &&
+        typeof rejectionEvent === 'object' &&
+        'error' in rejectionEvent
+          ? { cause: rejectionEvent.error }
+          : { cause: rejectionEvent }
+      )
+    }
+
+    const onErrorPromise = pEvent(websocket, 'error')
+
+    const replicationStream = this.#getReplicationStream()
+    wsCoreReplicator(websocket, replicationStream)
+
+    const syncAbortController = new AbortController()
+    const syncPromise = this.#waitForInitialSyncWithPeer(
+      serverDeviceId,
+      syncAbortController.signal
+    )
+
+    const errorEvent = await Promise.race([onErrorPromise, syncPromise])
+
+    if (errorEvent) {
+      syncAbortController.abort()
+      websocket.close()
+      throw errorEvent.error
+    } else {
+      const onClosePromise = pEvent(websocket, 'close')
+      onErrorPromise.cancel()
+      websocket.close()
+      await onClosePromise
+    }
+  }
+
   /**
    * @param {string} deviceId
    * @returns {Promise<MemberInfo>}
@@ -304,6 +501,8 @@ export class MemberApi extends TypedEmitter {
           memberInfo.name = deviceInfo?.name
           memberInfo.deviceType = deviceInfo?.deviceType
           memberInfo.joinedAt = deviceInfo?.createdAt
+          memberInfo.selfHostedServerDetails =
+            deviceInfo?.selfHostedServerDetails
         } catch (err) {
           // Attempting to get someone else may throw because sync hasn't occurred or completed
           // Only throw if attempting to get themself since the relevant information should be available
@@ -324,3 +523,55 @@ export class MemberApi extends TypedEmitter {
     return this.#roles.assignRole(deviceId, roleId)
   }
 }
+
+/**
+ * @param {string} baseUrl
+ * @param {object} options
+ * @param {boolean} options.dangerouslyAllowInsecureConnections
+ * @returns {boolean}
+ */
+function isValidServerBaseUrl(
+  baseUrl,
+  { dangerouslyAllowInsecureConnections }
+) {
+  if (baseUrl.length > 2000) return false
+
+  /** @type {URL} */ let url
+  try {
+    url = new URL(baseUrl)
+  } catch (_err) {
+    return false
+  }
+
+  const isProtocolValid =
+    url.protocol === 'https:' ||
+    (dangerouslyAllowInsecureConnections && url.protocol === 'http:')
+  if (!isProtocolValid) return false
+
+  if (url.username) return false
+  if (url.password) return false
+  if (url.search) return false
+  if (url.hash) return false
+
+  // We may want to support this someday. See <https://github.com/digidem/comapeo-core/issues/908>.
+  if (url.pathname !== '/') return false
+
+  if (
+    !isHostnameIpAddress(url.hostname) &&
+    !dangerouslyAllowInsecureConnections
+  ) {
+    const parts = url.hostname.split('.')
+    const isDomainValid = parts.length >= 2 && parts.every(Boolean)
+    if (!isDomainValid) return false
+  }
+
+  return true
+}
+
+/**
+ * @param {undefined | Uint8Array} buffer
+ * @returns {undefined | string}
+ */
+function encodeBufferForServer(buffer) {
+  return buffer ? b4a.toString(buffer, 'hex') : undefined
+}

package/src/schema/client.js

@@ -1,7 +1,7 @@
 // These schemas are all in a "client" database. There is only one client
 // database and it contains information that is shared across all projects on a
 // device
-import { blob, sqliteTable, text } from 'drizzle-orm/sqlite-core'
+import { blob, sqliteTable, text, int } from 'drizzle-orm/sqlite-core'
 import { dereferencedDocSchemas as schemas } from '@comapeo/schema'
 import { jsonSchemaToDrizzleColumns as toColumns } from './schema-to-drizzle.js'
 import { backlinkTable, customJson } from './utils.js'
@@ -49,7 +49,8 @@ const deviceInfoColumn =
   )
 
 // This table only ever has one row in it.
-export const localDeviceInfoTable = sqliteTable('localDeviceInfo', {
+export const deviceSettingsTable = sqliteTable('deviceSettings', {
   deviceId: text('deviceId').notNull().unique(),
-  deviceInfo: deviceInfoColumn('deviceInfo').notNull(),
+  deviceInfo: deviceInfoColumn('deviceInfo'),
+  isArchiveDevice: int('isArchiveDevice', { mode: 'boolean' }),
 })

package/src/schema/project.js

@@ -15,6 +15,10 @@ export const observationTable = sqliteTable(
   toColumns(schemas.observation)
 )
 export const trackTable = sqliteTable('track', toColumns(schemas.track))
+export const remoteDetectionAlertTable = sqliteTable(
+  'remoteDetectionAlert',
+  toColumns(schemas.remoteDetectionAlert)
+)
 export const presetTable = sqliteTable('preset', toColumns(schemas.preset))
 export const fieldTable = sqliteTable('field', toColumns(schemas.field))
 export const coreOwnershipTable = sqliteTable(
@@ -31,6 +35,9 @@ export const iconTable = sqliteTable('icon', toColumns(schemas.icon))
 export const translationBacklinkTable = backlinkTable(translationTable)
 export const observationBacklinkTable = backlinkTable(observationTable)
 export const trackBacklinkTable = backlinkTable(trackTable)
+export const remoteDetectionAlertBacklinkTable = backlinkTable(
+  remoteDetectionAlertTable
+)
 export const presetBacklinkTable = backlinkTable(presetTable)
 export const fieldBacklinkTable = backlinkTable(fieldTable)
 export const coreOwnershipBacklinkTable = backlinkTable(coreOwnershipTable)

package/src/sync/peer-sync-controller.js

@@ -152,6 +152,7 @@ export class PeerSyncController {
 
     if (didUpdate.auth) {
       try {
+        this.#log('reading role for %h', this.peerId)
         const cap = await this.#roles.getRole(this.peerId)
         this.#syncCapability = cap.sync
       } catch (e) {

package/src/sync/sync-api.js

@@ -1,4 +1,5 @@
 import { TypedEmitter } from 'tiny-typed-emitter'
+import WebSocket from 'ws'
 import { SyncState } from './sync-state.js'
 import { PeerSyncController } from './peer-sync-controller.js'
 import { Logger } from '../logger.js'
@@ -8,15 +9,23 @@ import {
   PRESYNC_NAMESPACES,
 } from '../constants.js'
 import { ExhaustivenessError, assert, keyToId, noop } from '../utils.js'
+import { getOwn } from '../lib/get-own.js'
+import { wsCoreReplicator } from '../lib/ws-core-replicator.js'
 import { NO_ROLE_ID } from '../roles.js'
 /** @import { CoreOwnership as CoreOwnershipDoc } from '@comapeo/schema' */
+/** @import * as http from 'node:http' */
 /** @import { CoreOwnership } from '../core-ownership.js' */
 /** @import { OpenedNoiseStream } from '../lib/noise-secret-stream-helpers.js' */
+/** @import { ReplicationStream } from '../types.js' */
 
 export const kHandleDiscoveryKey = Symbol('handle discovery key')
 export const kSyncState = Symbol('sync state')
 export const kRequestFullStop = Symbol('background')
 export const kRescindFullStopRequest = Symbol('foreground')
+export const kWaitForInitialSyncWithPeer = Symbol(
+  'wait for initial sync with peer'
+)
+export const kSetBlobDownloadFilter = Symbol('set isArchiveDevice')
 
 /**
  * @typedef {'initial' | 'full'} SyncType
@@ -65,6 +74,7 @@ export class SyncApi extends TypedEmitter {
   /** @type {Map<string, PeerSyncController>} */
   #pscByPeerId = new Map()
   #wantsToSyncData = false
+  #wantsToConnectToServers = false
   #hasRequestedFullStop = false
   /** @type {SyncEnabledState} */
   #previousSyncEnabledState = 'none'
@@ -77,22 +87,41 @@ export class SyncApi extends TypedEmitter {
   /** @type {Map<import('protomux'), Set<Buffer>>} */
   #pendingDiscoveryKeys = new Map()
   #l
+  #getServerWebsocketUrls
+  #getReplicationStream
+  /** @type {Map<string, WebSocket>} */
+  #serverWebsockets = new Map()
+  #blobDownloadFilter
 
   /**
-   *
    * @param {object} opts
    * @param {import('../core-manager/index.js').CoreManager} opts.coreManager
    * @param {CoreOwnership} opts.coreOwnership
    * @param {import('../roles.js').Roles} opts.roles
+   * @param {() => Promise<Iterable<string>>} opts.getServerWebsocketUrls
+   * @param {() => ReplicationStream} opts.getReplicationStream
+   * @param {import('../types.js').BlobFilter | null} opts.blobDownloadFilter
    * @param {number} [opts.throttleMs]
    * @param {Logger} [opts.logger]
    */
-  constructor({ coreManager, throttleMs = 200, roles, logger, coreOwnership }) {
+  constructor({
+    coreManager,
+    throttleMs = 200,
+    roles,
+    getServerWebsocketUrls,
+    getReplicationStream,
+    logger,
+    coreOwnership,
+    blobDownloadFilter,
+  }) {
     super()
     this.#l = Logger.create('syncApi', logger)
+    this.#blobDownloadFilter = blobDownloadFilter
     this.#coreManager = coreManager
     this.#coreOwnership = coreOwnership
     this.#roles = roles
+    this.#getServerWebsocketUrls = getServerWebsocketUrls
+    this.#getReplicationStream = getReplicationStream
     this[kSyncState] = new SyncState({
       coreManager,
       throttleMs,
@@ -123,6 +152,15 @@ export class SyncApi extends TypedEmitter {
       .catch(noop)
   }
 
+  /** @param {import('../types.js').BlobFilter | null} blobDownloadFilter */
+  [kSetBlobDownloadFilter](blobDownloadFilter) {
+    this.#blobDownloadFilter = blobDownloadFilter
+    if (!blobDownloadFilter) return // No download intents = intend to download everything
+    for (const peer of this.#coreManager.creatorCore.peers) {
+      this.#coreManager.sendDownloadIntents(blobDownloadFilter, peer)
+    }
+  }
+
   /** @type {import('../local-peers.js').LocalPeersEvents['discovery-key']} */
   [kHandleDiscoveryKey](discoveryKey, protomux) {
     const peerSyncController = this.#peerSyncControllers.get(protomux)
@@ -274,6 +312,74 @@ export class SyncApi extends TypedEmitter {
     this.emit('sync-state', this.#getState(namespaceSyncState))
   }
 
+  /**
+   * @returns {void}
+   */
+  connectServers() {
+    this.#wantsToConnectToServers = true
+
+    this.#getServerWebsocketUrls()
+      .then((urls) => {
+        const hasDisconnectedSinceWebsocketUrlsRequestFinished =
+          !this.#wantsToConnectToServers
+        if (hasDisconnectedSinceWebsocketUrlsRequestFinished) return
+
+        for (const url of urls) {
+          const existingWebsocket = this.#serverWebsockets.get(url)
+          if (
+            existingWebsocket &&
+            (existingWebsocket.readyState === WebSocket.OPEN ||
+              existingWebsocket.readyState === WebSocket.CONNECTING)
+          ) {
+            continue
+          }
+
+          const websocket = new WebSocket(url)
+
+          /** @param {Error} err */
+          const onWebsocketError = (err) => {
+            this.#l.log('Ignoring WebSocket error to %s: %o', url, err)
+          }
+          websocket.on('error', onWebsocketError)
+
+          /**
+           * @param {unknown} _req
+           * @param {http.IncomingMessage} res
+           */
+          const onWebsocketUnexpectedResponse = (_req, res) => {
+            this.#l.log(
+              'Ignoring unexpected %d WebSocket response to %s',
+              res.statusCode,
+              url
+            )
+          }
+          websocket.on('unexpected-response', onWebsocketUnexpectedResponse)
+
+          const replicationStream = this.#getReplicationStream()
+          wsCoreReplicator(websocket, replicationStream)
+
+          this.#serverWebsockets.set(url, websocket)
+          websocket.once('close', () => {
+            websocket.off('error', onWebsocketError)
+            websocket.off('unexpected-response', onWebsocketUnexpectedResponse)
+            this.#serverWebsockets.delete(url)
+          })
+        }
+      })
+      .catch(noop)
+  }
+
+  /**
+   * @returns {void}
+   */
+  disconnectServers() {
+    for (const websocket of this.#serverWebsockets.values()) {
+      websocket.close()
+    }
+    this.#serverWebsockets.clear()
+    this.#wantsToConnectToServers = false
+  }
+
   /**
    * Start syncing data cores.
    *
@@ -348,6 +454,40 @@ export class SyncApi extends TypedEmitter {
     })
   }
 
+  /**
+   * @param {string} deviceId
+   * @param {AbortSignal} abortSignal
+   * @returns {Promise<void>}
+   */
+  async [kWaitForInitialSyncWithPeer](deviceId, abortSignal) {
+    abortSignal.throwIfAborted()
+
+    const state = this[kSyncState].getState()
+    if (isInitiallySyncedWithPeer(state, deviceId)) return
+
+    return new Promise((resolve, reject) => {
+      /** @param {import('./sync-state.js').State} state */
+      const onState = (state) => {
+        if (isInitiallySyncedWithPeer(state, deviceId)) {
+          cleanup()
+          resolve()
+        }
+      }
+      const onAbort = () => {
+        cleanup()
+        reject(abortSignal.reason)
+      }
+
+      const cleanup = () => {
+        this[kSyncState].off('state', onState)
+        abortSignal.removeEventListener('abort', onAbort)
+      }
+
+      this[kSyncState].on('state', onState)
+      abortSignal.addEventListener('abort', onAbort)
+    })
+  }
+
   #clearAutostopDataSyncTimeoutIfExists() {
     if (this.#autostopDataSyncTimeout) {
       clearTimeout(this.#autostopDataSyncTimeout)
@@ -363,7 +503,7 @@ export class SyncApi extends TypedEmitter {
    * will then handle validation of role records to ensure that the peer is
    * actually still part of the project.
    *
-   * @param {{ protomux: import('protomux')<OpenedNoiseStream> }} peer
+   * @param {import('../types.js').HypercorePeer & { protomux: import('protomux')<OpenedNoiseStream> }} peer
    */
   #handlePeerAdd = (peer) => {
     const { protomux } = peer
@@ -374,6 +514,9 @@ export class SyncApi extends TypedEmitter {
       )
       return
     }
+    if (this.#blobDownloadFilter) {
+      this.#coreManager.sendDownloadIntents(this.#blobDownloadFilter, peer)
+    }
     const peerSyncController = new PeerSyncController({
       protomux,
       coreManager: this.#coreManager,
@@ -524,6 +667,31 @@ function isSynced(state, type, peerSyncControllers) {
   return true
 }
 
+/**
+ * @param {import('./sync-state.js').State} state
+ * @param {string} peerId
+ */
+function isInitiallySyncedWithPeer(state, peerId) {
+  for (const ns of PRESYNC_NAMESPACES) {
+    const remoteDeviceSyncState = getOwn(state[ns].remoteStates, peerId)
+    if (!remoteDeviceSyncState) return false
+
+    switch (remoteDeviceSyncState.status) {
+      case 'starting':
+        return false
+      case 'started':
+      case 'stopped': {
+        const { want, wanted } = remoteDeviceSyncState
+        if (want || wanted) return false
+        break
+      }
+      default:
+        throw new ExhaustivenessError(remoteDeviceSyncState.status)
+    }
+  }
+  return true
+}
+
 /**
  * @param {import('./sync-state.js').State} namespaceSyncState
  * @param {Iterable<PeerSyncController>} peerSyncControllers

package/src/translation-api.js

@@ -2,6 +2,7 @@ import { and, sql } from 'drizzle-orm'
 import { kCreateWithDocId, kSelect } from './datatype/index.js'
 import { hashObject } from './utils.js'
 import { NotFoundError } from './errors.js'
+import { omit } from './lib/omit.js'
 /** @import { Translation, TranslationValue } from '@comapeo/schema' */
 /** @import { SetOptional } from 'type-fest' */
 
@@ -47,8 +48,7 @@ export default class TranslationApi {
    * @param {TranslationValue} value
    */
   async put(value) {
-    /* eslint-disable no-unused-vars */
-    const { message, ...identifiers } = value
+    const identifiers = omit(value, ['message'])
     const docId = hashObject(identifiers)
     try {
       const doc = await this.#dataType.getByDocId(docId)

package/src/types.ts

@@ -41,12 +41,13 @@ export type BlobId = Simplify<
   }>
 >
 
-type ArrayAtLeastOne<T> = [T, ...T[]]
-
 export type BlobFilter = RequireAtLeastOne<{
-  [KeyType in BlobType]: ArrayAtLeastOne<BlobVariant<KeyType>>
+  [KeyType in BlobType]: Array<BlobVariant<KeyType>>
 }>
 
+/** Map of blob types to array of blob variants */
+export type GenericBlobFilter = Record<string, string[]>
+
 export type MapeoDocMap = {
   [K in MapeoDoc['schemaName']]: Extract<MapeoDoc, { schemaName: K }>
 }