@comapeo/core 2.1.0 → 2.3.0

package/src/blob-store/hyperdrive-index.js

@@ -0,0 +1,122 @@
+import b4a from 'b4a'
+import { discoveryKey } from 'hypercore-crypto'
+import Hyperdrive from 'hyperdrive'
+import util from 'node:util'
+import { TypedEmitter } from 'tiny-typed-emitter'
+
+/** @typedef {HyperdriveIndexImpl} THyperdriveIndex */
+
+/**
+ * @extends {TypedEmitter<{ 'add-drive': (drive: Hyperdrive) => void }>}
+ */
+export class HyperdriveIndexImpl extends TypedEmitter {
+  /** @type {Map<string, Hyperdrive>} */
+  #hyperdrives = new Map()
+  #writer
+  #writerKey
+  /** @param {import('../core-manager/index.js').CoreManager} coreManager */
+  constructor(coreManager) {
+    super()
+    /** @type {undefined | Hyperdrive} */
+    let writer
+    const corestore = new PretendCorestore({ coreManager })
+    const blobIndexCores = coreManager.getCores('blobIndex')
+    const writerCoreRecord = coreManager.getWriterCore('blobIndex')
+    this.#writerKey = writerCoreRecord.key
+    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(this.#writerKey)) {
+        writer = drive
+      }
+    }
+    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.emit('add-drive', drive)
+    })
+  }
+  get writer() {
+    return this.#writer
+  }
+  get writerKey() {
+    return this.#writerKey
+  }
+  [Symbol.iterator]() {
+    return this.#hyperdrives.values()
+  }
+  /** @param {string} driveId */
+  get(driveId) {
+    return this.#hyperdrives.get(driveId)
+  }
+}
+
+/**
+ * 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
+ */
+function getDiscoveryId(key) {
+  return discoveryKey(key).toString('hex')
+}

package/src/blob-store/index.js

@@ -1,22 +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} */ ({
@@ -37,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)
   }
 
   /**
@@ -95,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
   }
@@ -116,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))
   }
 
   /**
@@ -154,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`
@@ -163,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()
 
@@ -206,7 +192,7 @@ export class BlobStore {
    */
   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
   }
 
@@ -218,7 +204,7 @@ export class BlobStore {
    */
   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,
     })
@@ -236,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)
@@ -255,6 +241,11 @@ export class BlobStore {
 
     return drive.clear(path, options)
   }
+
+  close() {
+    this.#downloader.removeAllListeners()
+    this.#downloader.destroy()
+  }
 }
 
 /**
@@ -282,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/core-manager/index.js

@@ -298,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

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/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' */
 
 /**
@@ -182,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 })
   }
 
@@ -202,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
+}

package/src/fastify-plugins/blobs.js

@@ -1,9 +1,11 @@
 import fp from 'fastify-plugin'
 import { filetypemime } from 'magic-bytes.js'
+import { pEvent } from 'p-event'
 import { Type as T } from '@sinclair/typebox'
 
 import { SUPPORTED_BLOB_VARIANTS } from '../blob-store/index.js'
 import { HEX_REGEX_32_BYTES, Z_BASE_32_REGEX_32_BYTES } from './constants.js'
+import { getErrorMessage } from '../lib/error.js'
 
 /** @import { BlobId } from '../types.js' */
 
@@ -93,12 +95,25 @@ async function routes(fastify, options) {
 
       let blobStream
       try {
-        blobStream = await blobStore.createEntryReadStream(driveId, entry)
+        blobStream = await blobStore.createReadStreamFromEntry(driveId, entry)
       } catch (e) {
         reply.code(404)
         throw e
       }
 
+      try {
+        await pEvent(blobStream, 'readable', { rejectionEvents: ['error'] })
+      } catch (err) {
+        // This matches [how Hyperblobs checks if a blob is unavailable][0].
+        // [0]: https://github.com/holepunchto/hyperblobs/blob/518088d2b828082fd70a276fa2c8848a2cf2a56b/index.js#L49
+        if (getErrorMessage(err) === 'Block not available') {
+          reply.code(404)
+          throw new Error('Blob not found')
+        } else {
+          throw err
+        }
+      }
+
       // Extract the 'mimeType' property of the metadata and use it for the response header if found
       if (
         metadata &&

package/src/fastify-plugins/maps.js

@@ -5,6 +5,7 @@ import { ReaderWatch, Server as SMPServerPlugin } from 'styled-map-package'
 
 import { noop } from '../utils.js'
 import { NotFoundError, ENOENTError } from './utils.js'
+import { getErrorCode } from '../lib/error.js'
 
 /** @import { FastifyPluginAsync } from 'fastify' */
 /** @import { Stats } from 'node:fs' */
@@ -56,7 +57,7 @@ export async function plugin(fastify, opts) {
       try {
         stats = await fs.stat(customMapPath)
       } catch (err) {
-        if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+        if (getErrorCode(err) === 'ENOENT') {
           throw new ENOENTError(customMapPath)
         }