@comapeo/core 2.0.1 → 2.2.0

package/src/blob-store/index.js

@@ -1,21 +1,23 @@
-import Hyperdrive from 'hyperdrive'
-import b4a from 'b4a'
-import util from 'node:util'
+import { pipeline } from 'node:stream'
 import { discoveryKey } from 'hypercore-crypto'
+import { Downloader } from './downloader.js'
+import { createEntriesStream } from './entries-stream.js'
+import { FilterEntriesStream } from './utils.js'
+import { noop } from '../utils.js'
 import { TypedEmitter } from 'tiny-typed-emitter'
-import { LiveDownload } from './live-download.js'
+import { HyperdriveIndexImpl as HyperdriveIndex } from './hyperdrive-index.js'
+
+/** @import Hyperdrive from 'hyperdrive' */
+/** @import { JsonObject } from 'type-fest' */
 /** @import { Readable as NodeReadable } from 'node:stream' */
 /** @import { Readable as StreamxReadable, Writable } from 'streamx' */
-/** @import { BlobId } from '../types.js' */
-/** @import { BlobDownloadEvents } from './live-download.js' */
+/** @import { BlobFilter, BlobId, BlobStoreEntriesStream } from '../types.js' */
 
 /**
  * @internal
  * @typedef {NodeReadable | StreamxReadable} Readable
  */
 
-/** @typedef {TypedEmitter<{ 'add-drive': (drive: import('hyperdrive')) => void }>} InternalDriveEmitter */
-
 // prop = blob type name
 // value = array of blob variants supported for that type
 const SUPPORTED_BLOB_VARIANTS = /** @type {const} */ ({
@@ -36,57 +38,31 @@ class ErrNotFound extends Error {
   }
 }
 
-export class BlobStore {
-  /** @type {Map<string, Hyperdrive>} Indexed by hex-encoded discovery key */
-  #hyperdrives = new Map()
-  #writer
-  /**
-   * Used to communicate to live download instances when new drives are added
-   * @type {InternalDriveEmitter}
-   */
-  #driveEmitter = new TypedEmitter()
+/** @extends {TypedEmitter<{ error: (error: Error) => void }>} */
+export class BlobStore extends TypedEmitter {
+  #driveIndex
+  /** @type {Downloader} */
+  #downloader
 
   /**
    * @param {object} options
    * @param {import('../core-manager/index.js').CoreManager} options.coreManager
+   * @param {BlobFilter | null} options.downloadFilter - Filter blob types and/or variants to download. Set to `null` to download all blobs.
    */
-  constructor({ coreManager }) {
-    /** @type {undefined | (Hyperdrive & { key: Buffer })} */
-    let writer
-    const corestore = new PretendCorestore({ coreManager })
-    const blobIndexCores = coreManager.getCores('blobIndex')
-    const { key: writerKey } = coreManager.getWriterCore('blobIndex')
-    for (const { key } of blobIndexCores) {
-      // @ts-ignore - we know pretendCorestore is not actually a Corestore
-      const drive = new Hyperdrive(corestore, key)
-      // We use the discovery key to derive the id for a drive
-      this.#hyperdrives.set(getDiscoveryId(key), drive)
-      if (key.equals(writerKey)) {
-        writer = proxyProps(drive, { key: writerKey })
-      }
-    }
-    if (!writer) {
-      throw new Error('Could not find a writer for the blobIndex namespace')
-    }
-    this.#writer = writer
-
-    coreManager.on('add-core', ({ key, namespace }) => {
-      if (namespace !== 'blobIndex') return
-      // We use the discovery key to derive the id for a drive
-      const driveId = getDiscoveryId(key)
-      if (this.#hyperdrives.has(driveId)) return
-      // @ts-ignore - we know pretendCorestore is not actually a Corestore
-      const drive = new Hyperdrive(corestore, key)
-      this.#hyperdrives.set(driveId, drive)
-      this.#driveEmitter.emit('add-drive', drive)
+  constructor({ coreManager, downloadFilter }) {
+    super()
+    this.#driveIndex = new HyperdriveIndex(coreManager)
+    this.#downloader = new Downloader(this.#driveIndex, {
+      filter: downloadFilter,
     })
+    this.#downloader.on('error', (error) => this.emit('error', error))
   }
 
   /**
    * @returns {string}
    */
   get writerDriveId() {
-    return getDiscoveryId(this.#writer.key)
+    return getDiscoveryId(this.#driveIndex.writerKey)
   }
 
   /**
@@ -94,7 +70,7 @@ export class BlobStore {
    * @returns {Hyperdrive}
    */
   #getDrive(driveId) {
-    const drive = this.#hyperdrives.get(driveId)
+    const drive = this.#driveIndex.get(driveId)
     if (!drive) throw new Error('Drive not found ' + driveId.slice(0, 7))
     return drive
   }
@@ -115,23 +91,18 @@ export class BlobStore {
   }
 
   /**
-   * Download blobs from all drives, optionally filtering particular blob types
-   * or blob variants. Download will be 'live' and will continue downloading new
-   * data as it becomes available from any replicating drive.
+   * Set the filter for downloading blobs.
    *
-   * If no filter is specified, all blobs will be downloaded. If a filter is
-   * specified, then _only_ blobs that match the filter will be downloaded.
-   *
-   * @param {import('../types.js').BlobFilter} [filter] Filter blob types and/or variants to download. Filter is { [BlobType]: BlobVariants[] }. At least one blob variant must be specified for each blob type.
-   * @param {object} options
-   * @param {AbortSignal} [options.signal] Optional AbortSignal to cancel in-progress download
-   * @returns {TypedEmitter<BlobDownloadEvents>}
+   * @param {import('../types.js').BlobFilter | null} filter Filter blob types and/or variants to download. Filter is { [BlobType]: BlobVariants[] }. At least one blob variant must be specified for each blob type.
+   * @returns {void}
    */
-  download(filter, { signal } = {}) {
-    return new LiveDownload(this.#hyperdrives.values(), this.#driveEmitter, {
+  setDownloadFilter(filter) {
+    this.#downloader.removeAllListeners()
+    this.#downloader.destroy()
+    this.#downloader = new Downloader(this.#driveIndex, {
       filter,
-      signal,
     })
+    this.#downloader.on('error', (error) => this.emit('error', error))
   }
 
   /**
@@ -153,6 +124,22 @@ export class BlobStore {
     return drive.createReadStream(path, options)
   }
 
+  /**
+   * This is a low-level method to create a stream of entries from all drives.
+   * It includes entries for unknown blob types and variants.
+   *
+   * @param {object} opts
+   * @param {boolean} [opts.live=false] Set to `true` to get a live stream of entries
+   * @param {import('./utils.js').GenericBlobFilter | null} [opts.filter] Filter blob types and/or variants in returned entries. Filter is { [BlobType]: BlobVariants[] }.
+   * @returns {BlobStoreEntriesStream}
+   */
+  createEntriesReadStream({ live = false, filter } = {}) {
+    const entriesStream = createEntriesStream(this.#driveIndex, { live })
+    if (!filter) return entriesStream
+    const filterStream = new FilterEntriesStream(filter)
+    return pipeline(entriesStream, filterStream, noop)
+  }
+
   /**
    * Optimization for creating the blobs read stream when you have
    * previously read the entry from Hyperdrive using `drive.entry`
@@ -162,7 +149,7 @@ export class BlobStore {
    * @param {boolean} [options.wait=false] Set to `true` to wait for a blob to download, otherwise will throw if blob is not available locally
    * @returns {Promise<Readable>}
    */
-  async createEntryReadStream(driveId, entry, options = { wait: false }) {
+  async createReadStreamFromEntry(driveId, entry, options = { wait: false }) {
     const drive = this.#getDrive(driveId)
     const blobs = await drive.getBlobs()
 
@@ -200,24 +187,24 @@ export class BlobStore {
    * @param {Omit<BlobId, 'driveId'>} blobId
    * @param {Buffer} blob
    * @param {object} [options]
-   * @param {{mimeType: string}} [options.metadata] Metadata to store with the blob
+   * @param {JsonObject} [options.metadata] Metadata to store with the blob
    * @returns {Promise<string>} discovery key as hex string of hyperdrive where blob is stored
    */
   async put({ type, variant, name }, blob, options) {
     const path = makePath({ type, variant, name })
-    await this.#writer.put(path, blob, options)
+    await this.#driveIndex.writer.put(path, blob, options)
     return this.writerDriveId
   }
 
   /**
    * @param {Omit<BlobId, 'driveId'>} blobId
    * @param {object} [options]
-   * @param {{mimeType: string}} [options.metadata] Metadata to store with the blob
+   * @param {JsonObject} [options.metadata] Metadata to store with the blob
    * @returns {Writable & { driveId: string }}
    */
   createWriteStream({ type, variant, name }, options) {
     const path = makePath({ type, variant, name })
-    const stream = this.#writer.createWriteStream(path, options)
+    const stream = this.#driveIndex.writer.createWriteStream(path, options)
     return proxyProps(stream, {
       driveId: this.writerDriveId,
     })
@@ -235,7 +222,7 @@ export class BlobStore {
     { type, variant, name, driveId },
     options = { follow: false, wait: false }
   ) {
-    const drive = this.#hyperdrives.get(driveId)
+    const drive = this.#driveIndex.get(driveId)
     if (!drive) throw new Error('Drive not found ' + driveId.slice(0, 7))
     const path = makePath({ type, variant, name })
     const entry = await drive.entry(path, options)
@@ -254,6 +241,11 @@ export class BlobStore {
 
     return drive.clear(path, options)
   }
+
+  close() {
+    this.#downloader.removeAllListeners()
+    this.#downloader.destroy()
+  }
 }
 
 /**
@@ -281,56 +273,6 @@ function makePath({ type, variant, name }) {
   return `/${type}/${variant}/${name}`
 }
 
-/**
- * Implements the `get()` method as used by hyperdrive-next. It returns the
- * relevant cores from the Mapeo CoreManager.
- */
-class PretendCorestore {
-  #coreManager
-  /**
-   * @param {object} options
-   * @param {import('../core-manager/index.js').CoreManager} options.coreManager
-   */
-  constructor({ coreManager }) {
-    this.#coreManager = coreManager
-  }
-
-  /**
-   * @param {Buffer | { publicKey: Buffer } | { name: string }} opts
-   * @returns {import('hypercore')<"binary", Buffer> | undefined}
-   */
-  get(opts) {
-    if (b4a.isBuffer(opts)) {
-      opts = { publicKey: opts }
-    }
-    if ('key' in opts) {
-      // @ts-ignore
-      opts.publicKey = opts.key
-    }
-    if ('publicKey' in opts) {
-      // NB! We should always add blobIndex (Hyperbee) cores to the core manager
-      // before we use them here. We would only reach the addCore path if the
-      // blob core is read from the hyperbee header (before it is added to the
-      // core manager)
-      return (
-        this.#coreManager.getCoreByKey(opts.publicKey) ||
-        this.#coreManager.addCore(opts.publicKey, 'blob').core
-      )
-    } else if (opts.name === 'db') {
-      return this.#coreManager.getWriterCore('blobIndex').core
-    } else if (opts.name.includes('blobs')) {
-      return this.#coreManager.getWriterCore('blob').core
-    } else {
-      throw new Error(
-        'Unsupported corestore.get() with opts ' + util.inspect(opts)
-      )
-    }
-  }
-
-  /** no-op */
-  close() {}
-}
-
 /**
  * @param {Buffer} key Public key of hypercore
  * @returns {string} Hex-encoded string of derived discovery key

package/src/blob-store/utils.js

@@ -0,0 +1,54 @@
+/**
+ * This is a more generic version of the BlobFilter type that can filter unknown
+ * blob types and variants from the blob store.
+ *
+ * @typedef {{ [type: string]: readonly string[] }} GenericBlobFilter
+ */
+
+import { Transform } from 'node:stream'
+
+/**
+ * @param {GenericBlobFilter} filter
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+export function filePathMatchesFilter(filter, filePath) {
+  const pathParts = filePath.split('/', 4)
+  const [shouldBeEmpty, type, variant] = pathParts
+
+  if (typeof shouldBeEmpty !== 'string' || shouldBeEmpty) return false
+
+  if (!type) return false
+  if (!Object.hasOwn(filter, type)) return false
+
+  const allowedVariants = filter[type] ?? []
+  if (allowedVariants.length === 0) {
+    return pathParts.length >= 3
+  } else {
+    return (
+      pathParts.length >= 4 &&
+      typeof variant === 'string' &&
+      allowedVariants.includes(variant)
+    )
+  }
+}
+
+/** @type {import("../types.js").BlobStoreEntriesStream} */
+export class FilterEntriesStream extends Transform {
+  #isIncludedInFilter
+  /** @param {GenericBlobFilter} filter */
+  constructor(filter) {
+    super({ objectMode: true })
+    this.#isIncludedInFilter = filePathMatchesFilter.bind(null, filter)
+  }
+  /**
+   * @param {import("hyperdrive").HyperdriveEntry} entry
+   * @param {Parameters<Transform['_transform']>[1]} _
+   * @param {Parameters<Transform['_transform']>[2]} callback
+   */
+  _transform(entry, _, callback) {
+    const { key: filePath } = entry
+    if (this.#isIncludedInFilter(filePath)) this.push(entry)
+    callback()
+  }
+}

package/src/constants.js

@@ -19,7 +19,7 @@ export const DATA_NAMESPACES = NAMESPACES.filter(
 )
 
 export const NAMESPACE_SCHEMAS = /** @type {const} */ ({
-  data: ['observation', 'track'],
+  data: ['observation', 'track', 'remoteDetectionAlert'],
   config: [
     'translation',
     'preset',
@@ -32,3 +32,6 @@ export const NAMESPACE_SCHEMAS = /** @type {const} */ ({
 })
 
 export const SUPPORTED_CONFIG_VERSION = 1
+
+// WARNING: This value is persisted. Be careful when changing it.
+export const DRIZZLE_MIGRATIONS_TABLE = '__drizzle_migrations'

package/src/core-manager/index.js

@@ -4,16 +4,21 @@ import { debounce } from 'throttle-debounce'
 import assert from 'node:assert/strict'
 import { sql, eq } from 'drizzle-orm'
 
-import { HaveExtension, ProjectExtension } from '../generated/extensions.js'
+import {
+  HaveExtension,
+  ProjectExtension,
+  DownloadIntentExtension,
+} from '../generated/extensions.js'
 import { Logger } from '../logger.js'
 import { NAMESPACES } from '../constants.js'
 import { noop } from '../utils.js'
 import { coresTable } from '../schema/project.js'
 import * as rle from './bitfield-rle.js'
 import { CoreIndex } from './core-index.js'
+import mapObject from 'map-obj'
 
 /** @import Hypercore from 'hypercore' */
-/** @import { HypercorePeer, Namespace } from '../types.js' */
+/** @import { BlobFilter, GenericBlobFilter, HypercorePeer, Namespace } from '../types.js' */
 
 const WRITER_CORE_PREHAVES_DEBOUNCE_DELAY = 1000
 
@@ -25,6 +30,7 @@ export const kCoreManagerReplicate = Symbol('replicate core manager')
  * @typedef {Object} Events
  * @property {(coreRecord: CoreRecord) => void} add-core
  * @property {(namespace: Namespace, msg: { coreDiscoveryId: string, peerId: string, start: number, bitfield: Uint32Array }) => void} peer-have
+ * @property {(blobFilter: GenericBlobFilter, peerId: string) => void} peer-download-intent
  */
 
 /**
@@ -46,6 +52,7 @@ export class CoreManager extends TypedEmitter {
   #deviceId
   #l
   #autoDownload
+  #downloadIntentExtension
 
   static get namespaces() {
     return NAMESPACES
@@ -158,6 +165,16 @@ export class CoreManager extends TypedEmitter {
       },
     })
 
+    this.#downloadIntentExtension = this.creatorCore.registerExtension(
+      'mapeo/download-intent',
+      {
+        encoding: DownloadIntentCodec,
+        onmessage: (msg, peer) => {
+          this.#handleDownloadIntentMessage(msg, peer)
+        },
+      }
+    )
+
     this.creatorCore.on('peer-add', (peer) => {
       this.#sendHaves(peer, this.#coreIndex).catch(() => {
         this.#l.log('Failed to send pre-haves to newly-connected peer')
@@ -281,7 +298,8 @@ export class CoreManager extends TypedEmitter {
       keyPair,
       encryptionKey: this.#encryptionKeys[namespace],
     })
-    if (this.#autoDownload) {
+    if (this.#autoDownload && namespace !== 'blob') {
+      // Blob downloads are managed by BlobStore
       core.download({ start: 0, end: -1 })
     }
     // Every peer adds a listener, so could have many peers
@@ -395,6 +413,23 @@ export class CoreManager extends TypedEmitter {
     })
   }
 
+  /**
+   * @param {GenericBlobFilter} blobFilter
+   * @param {HypercorePeer} peer
+   */
+  #handleDownloadIntentMessage(blobFilter, peer) {
+    const peerId = peer.remotePublicKey.toString('hex')
+    this.emit('peer-download-intent', blobFilter, peerId)
+  }
+
+  /**
+   * @param {BlobFilter} blobFilter
+   * @param {HypercorePeer} peer
+   */
+  sendDownloadIntents(blobFilter, peer) {
+    this.#downloadIntentExtension.send(blobFilter, peer)
+  }
+
   /**
    *
    * @param {HypercorePeer} peer
@@ -505,3 +540,25 @@ const HaveExtensionCodec = {
     }
   },
 }
+
+const DownloadIntentCodec = {
+  /** @param {BlobFilter} filter */
+  encode(filter) {
+    const downloadIntents = mapObject(filter, (key, value) => [
+      key,
+      { variants: value || [] },
+    ])
+    return DownloadIntentExtension.encode({ downloadIntents }).finish()
+  },
+  /**
+   * @param {Buffer | Uint8Array} buf
+   * @returns {GenericBlobFilter}
+   */
+  decode(buf) {
+    const msg = DownloadIntentExtension.decode(buf)
+    return mapObject(msg.downloadIntents, (key, value) => [
+      key + '', // keep TS happy
+      value.variants,
+    ])
+  },
+}

package/src/core-ownership.js

@@ -16,6 +16,7 @@ import pDefer from 'p-defer'
 import { NAMESPACES } from './constants.js'
 import { TypedEmitter } from 'tiny-typed-emitter'
 import { omit } from './lib/omit.js'
+import { NotFoundError } from './errors.js'
 /**
  * @import {
  *   CoreOwnershipWithSignatures,
@@ -86,13 +87,10 @@ export class CoreOwnership extends TypedEmitter {
     for (const namespace of NAMESPACES) {
       expressions.push(eq(table[`${namespace}CoreId`], coreId))
     }
-    // prettier-ignore
     const result = (await this.#dataType[kSelect]())
       .where(or.apply(null, expressions))
       .get()
-    if (!result) {
-      throw new Error('NotFound')
-    }
+    if (!result) throw new NotFoundError()
     return result.docId
   }
 

package/src/datastore/README.md

@@ -19,6 +19,7 @@ const datastore = new DataStore({
     // Process entries here using an indexer...
   },
   namespace: 'data',
+  reindex: false,
 })
 
 /** @type {MapeoDoc} */
@@ -33,8 +34,6 @@ datastore.on('index-state', ({ current, remaining, entriesPerSecond }) => {
     // show state to user that indexing is happening
   }
 })
-
-const { current, remaining, entriesPerSecond } = datastore.getIndexState()
 ```
 
 ## API docs

package/src/datastore/index.js

@@ -5,6 +5,7 @@ import pDefer from 'p-defer'
 import { discoveryKey } from 'hypercore-crypto'
 import { NAMESPACE_SCHEMAS } from '../constants.js'
 import { createMap } from '../utils.js'
+import { NotFoundError } from '../errors.js'
 /** @import { MapeoDoc } from '@comapeo/schema' */
 
 /**
@@ -51,8 +52,9 @@ export class DataStore extends TypedEmitter {
    * @param {TNamespace} opts.namespace
    * @param {(entries: MultiCoreIndexer.Entry<'binary'>[]) => Promise<import('../index-writer/index.js').IndexedDocIds>} opts.batch
    * @param {MultiCoreIndexer.StorageParam} opts.storage
+   * @param {boolean} opts.reindex
    */
-  constructor({ coreManager, namespace, batch, storage }) {
+  constructor({ coreManager, namespace, batch, storage, reindex }) {
     super()
     this.#coreManager = coreManager
     this.#namespace = namespace
@@ -66,6 +68,7 @@ export class DataStore extends TypedEmitter {
     this.#coreIndexer = new MultiCoreIndexer(cores, {
       storage,
       batch: (entries) => this.#handleEntries(entries),
+      reindex,
     })
     coreManager.on('add-core', (coreRecord) => {
       if (coreRecord.namespace !== namespace) return
@@ -91,10 +94,6 @@ export class DataStore extends TypedEmitter {
     return this.#writerCore
   }
 
-  getIndexState() {
-    return this.#coreIndexer.state
-  }
-
   /**
    *
    * @param {MultiCoreIndexer.Entry<'binary'>[]} entries
@@ -167,6 +166,7 @@ export class DataStore extends TypedEmitter {
     const deferred = pDefer()
     this.#pendingIndex.set(versionId, deferred)
     await deferred.promise
+    this.#pendingIndex.delete(versionId)
 
     return /** @type {Extract<MapeoDoc, TDoc>} */ (
       decode(block, { coreDiscoveryKey, index })
@@ -183,7 +183,7 @@ export class DataStore extends TypedEmitter {
     const coreRecord = this.#coreManager.getCoreByDiscoveryKey(coreDiscoveryKey)
     if (!coreRecord) throw new Error('Invalid versionId')
     const block = await coreRecord.core.get(index, { wait: false })
-    if (!block) throw new Error('Not Found')
+    if (!block) throw new NotFoundError('Not Found')
     return decode(block, { coreDiscoveryKey, index })
   }
 
@@ -203,9 +203,9 @@ export class DataStore extends TypedEmitter {
   async readRaw(versionId) {
     const { coreDiscoveryKey, index } = parseVersionId(versionId)
     const coreRecord = this.#coreManager.getCoreByDiscoveryKey(coreDiscoveryKey)
-    if (!coreRecord) throw new Error('core not found')
+    if (!coreRecord) throw new NotFoundError('core not found')
     const block = await coreRecord.core.get(index, { wait: false })
-    if (!block) throw new Error('Not Found')
+    if (!block) throw new NotFoundError()
     return block
   }
 

package/src/datatype/index.d.ts

@@ -87,8 +87,12 @@ export class DataType<
 
   getByDocId(
     docId: string,
-    opts?: { lang?: string }
+    opts?: { mustBeFound?: true; lang?: string }
   ): Promise<TDoc & { forks: string[] }>
+  getByDocId(
+    docId: string,
+    opts?: { mustBeFound?: boolean; lang?: string }
+  ): Promise<null | (TDoc & { forks: string[] })>
 
   getByVersionId(versionId: string, opts?: { lang?: string }): Promise<TDoc>
 

package/src/datatype/index.js

@@ -164,16 +164,30 @@ export class DataType extends TypedEmitter {
   }
 
   /**
+   * @overload
    * @param {string} docId
-   * @param {{ lang?: string }} [opts]
+   * @param {object} [options]
+   * @param {true} [options.mustBeFound]
+   * @param {string} [options.lang]
+   * @returns {Promise<TDoc & { forks: string[] }>}
+   */
+  /**
+   * @param {string} docId
+   * @param {object} [options]
+   * @param {boolean} [options.mustBeFound]
+   * @param {string} [options.lang]
+   * @returns {Promise<null | (TDoc & { forks: string[] })>}
    */
-  async getByDocId(docId, { lang } = {}) {
+  async getByDocId(docId, { mustBeFound = true, lang } = {}) {
     await this.#dataStore.indexer.idle()
-    const result = /** @type {undefined | MapeoDoc} */ (
-      this.#sql.getByDocId.get({ docId })
-    )
-    if (!result) throw new NotFoundError()
-    return this.#translate(deNullify(result), { lang })
+    const result = this.#sql.getByDocId.get({ docId })
+    if (result) {
+      return this.#translate(deNullify(result), { lang })
+    } else if (mustBeFound) {
+      throw new NotFoundError()
+    } else {
+      return null
+    }
   }
 
   /**
@@ -186,7 +200,7 @@ export class DataType extends TypedEmitter {
   }
 
   /**
-   * @param {MapeoDoc} doc
+   * @param {any} doc
    * @param {{ lang?: string }} [opts]
    */
   async #translate(doc, { lang } = {}) {
@@ -278,7 +292,6 @@ export class DataType extends TypedEmitter {
     const doc = {
       ...existingDoc,
       updatedAt: new Date().toISOString(),
-      // @ts-expect-error - TS just doesn't work in this class
       links: [existingDoc.versionId, ...existingDoc.forks],
       deleted: true,
     }

package/src/discovery/local-discovery.js

@@ -9,6 +9,7 @@ import StartStopStateMachine from 'start-stop-state-machine'
 import pTimeout from 'p-timeout'
 import { keyToPublicId } from '@mapeo/crypto'
 import { Logger } from '../logger.js'
+import { getErrorCode } from '../lib/error.js'
 /** @import { OpenedNoiseStream } from '../lib/noise-secret-stream-helpers.js' */
 
 /** @typedef {{ publicKey: Buffer, secretKey: Buffer }} Keypair */
@@ -117,7 +118,7 @@ export class LocalDiscovery extends TypedEmitter {
 
     /** @param {Error} e */
     function onSocketError(e) {
-      if ('code' in e && e.code === 'EPIPE') {
+      if (getErrorCode(e) === 'EPIPE') {
         socket.destroy()
         if (secretStream) {
           secretStream.destroy()

package/src/errors.js

@@ -1,5 +1,14 @@
 export class NotFoundError extends Error {
-  constructor() {
-    super('Not found')
+  constructor(message = 'Not found') {
+    super(message)
   }
 }
+
+/**
+ * @param {unknown} err
+ * @returns {null}
+ */
+export function nullIfNotFound(err) {
+  if (err instanceof NotFoundError) return null
+  throw err
+}