@comapeo/core 1.0.0 → 2.0.0

package/src/member-api.js

@@ -9,6 +9,7 @@ import {
   projectKeyToId,
   projectKeyToProjectInviteId,
 } 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'
@@ -89,6 +90,7 @@ export class MemberApi extends TypedEmitter {
    * @param {import('./roles.js').RoleIdForNewInvite} opts.roleId
    * @param {string} [opts.roleName]
    * @param {string} [opts.roleDescription]
+   * @param {Buffer} [opts.__testOnlyInviteId] Hard-code the invite ID. Only for tests.
    * @returns {Promise<(
    *   typeof InviteResponse_Decision.ACCEPT |
    *   typeof InviteResponse_Decision.REJECT |
@@ -97,7 +99,12 @@ export class MemberApi extends TypedEmitter {
    */
   async invite(
     deviceId,
-    { roleId, roleName = ROLES[roleId]?.name, roleDescription }
+    {
+      roleId,
+      roleName = ROLES[roleId]?.name,
+      roleDescription,
+      __testOnlyInviteId,
+    }
   ) {
     assert(isRoleIdForNewInvite(roleId), 'Invalid role ID for new invite')
     assert(
@@ -120,7 +127,7 @@ export class MemberApi extends TypedEmitter {
 
       abortSignal.throwIfAborted()
 
-      const inviteId = crypto.randomBytes(32)
+      const inviteId = __testOnlyInviteId || crypto.randomBytes(32)
       const projectId = projectKeyToId(this.#projectKey)
       const projectInviteId = projectKeyToProjectInviteId(this.#projectKey)
       const project = await this.#dataTypes.project.getByDocId(projectId)
@@ -279,6 +286,8 @@ export class MemberApi extends TypedEmitter {
       this.#dataTypes.deviceInfo.getMany(),
     ])
 
+    const deviceInfoByConfigCoreId = keyBy(allDeviceInfo, ({ docId }) => docId)
+
     return Promise.all(
       [...allRoles.entries()].map(async ([deviceId, role]) => {
         /** @type {MemberInfo} */
@@ -290,9 +299,7 @@ export class MemberApi extends TypedEmitter {
             'config'
           )
 
-          const deviceInfo = allDeviceInfo.find(
-            ({ docId }) => docId === configCoreId
-          )
+          const deviceInfo = deviceInfoByConfigCoreId.get(configCoreId)
 
           memberInfo.name = deviceInfo?.name
           memberInfo.deviceType = deviceInfo?.deviceType

package/src/sync/core-sync-state.js

@@ -2,6 +2,7 @@ import { keyToId } from '../utils.js'
 import RemoteBitfield, {
   BITS_PER_PAGE,
 } from '../core-manager/remote-bitfield.js'
+import { Logger } from '../logger.js'
 /** @import { HypercorePeer, HypercoreRemoteBitfield, Namespace } from '../types.js' */
 
 /**
@@ -22,7 +23,7 @@ import RemoteBitfield, {
  * @typedef {object} LocalCoreState
  * @property {number} have blocks we have
  * @property {number} want unique blocks we want from any other peer
- * @property {number} wanted blocks we want from this peer
+ * @property {number} wanted unique blocks any other peer wants from us
  */
 /**
  * @typedef {object} PeerNamespaceState
@@ -71,14 +72,18 @@ export class CoreSyncState {
   #update
   #peerSyncControllers
   #namespace
+  #l
 
   /**
    * @param {object} opts
    * @param {() => void} opts.onUpdate Called when a state update is available (via getState())
    * @param {Map<string, import('./peer-sync-controller.js').PeerSyncController>} opts.peerSyncControllers
    * @param {Namespace} opts.namespace
+   * @param {Logger} [opts.logger]
    */
-  constructor({ onUpdate, peerSyncControllers, namespace }) {
+  constructor({ onUpdate, peerSyncControllers, namespace, logger }) {
+    // The logger parameter is already namespaced by NamespaceSyncState
+    this.#l = logger || Logger.create('css')
     this.#peerSyncControllers = peerSyncControllers
     this.#namespace = namespace
     // Called whenever the state changes, so we clear the cache because next
@@ -150,12 +155,24 @@ export class CoreSyncState {
    * @param {Uint32Array} bitfield
    */
   insertPreHaves(peerId, start, bitfield) {
-    const peerState = this.#getPeerState(peerId)
+    const peerState = this.#getOrCreatePeerState(peerId)
     peerState.insertPreHaves(start, bitfield)
+    const previousLength = Math.max(
+      this.#preHavesLength,
+      this.#core?.length || 0
+    )
     this.#preHavesLength = Math.max(
       this.#preHavesLength,
       peerState.preHavesBitfield.lastSet(start + bitfield.length * 32) + 1
     )
+    if (this.#preHavesLength > previousLength) {
+      this.#l.log(
+        'Updated peer %S pre-haves length from %d to %d',
+        peerId,
+        previousLength,
+        this.#preHavesLength
+      )
+    }
     this.#update()
   }
 
@@ -168,7 +185,7 @@ export class CoreSyncState {
    * @param {Array<{ start: number, length: number }>} ranges
    */
   setPeerWants(peerId, ranges) {
-    const peerState = this.#getPeerState(peerId)
+    const peerState = this.#getOrCreatePeerState(peerId)
     for (const { start, length } of ranges) {
       peerState.setWantRange({ start, length })
     }
@@ -187,7 +204,17 @@ export class CoreSyncState {
   /**
    * @param {PeerId} peerId
    */
-  #getPeerState(peerId) {
+  disconnectPeer(peerId) {
+    const wasRemoved = this.#remoteStates.delete(peerId)
+    if (wasRemoved) {
+      this.#update()
+    }
+  }
+
+  /**
+   * @param {PeerId} peerId
+   */
+  #getOrCreatePeerState(peerId) {
     let peerState = this.#remoteStates.get(peerId)
     if (!peerState) {
       peerState = new PeerState()
@@ -207,7 +234,7 @@ export class CoreSyncState {
     const peerId = keyToId(peer.remotePublicKey)
 
     // Update state to ensure this peer is in the state correctly
-    const peerState = this.#getPeerState(peerId)
+    const peerState = this.#getOrCreatePeerState(peerId)
     peerState.status = 'starting'
 
     this.#core?.update({ wait: true }).then(() => {
@@ -243,7 +270,8 @@ export class CoreSyncState {
    */
   #onPeerRemove = (peer) => {
     const peerId = keyToId(peer.remotePublicKey)
-    const peerState = this.#getPeerState(peerId)
+    const peerState = this.#remoteStates.get(peerId)
+    if (!peerState) return
     peerState.status = 'stopped'
     this.#update()
   }

package/src/sync/namespace-sync-state.js

@@ -1,3 +1,4 @@
+import { Logger } from '../logger.js'
 import { CoreSyncState } from './core-sync-state.js'
 import { discoveryKey } from 'hypercore-crypto'
 /** @import { Namespace } from '../types.js' */
@@ -18,6 +19,7 @@ export class NamespaceSyncState {
   /** @type {SyncState | null} */
   #cachedState = null
   #peerSyncControllers
+  #logger
 
   /**
    * @param {object} opts
@@ -25,8 +27,17 @@ export class NamespaceSyncState {
    * @param {import('../core-manager/index.js').CoreManager} opts.coreManager
    * @param {() => void} opts.onUpdate Called when a state update is available (via getState())
    * @param {Map<string, import('./peer-sync-controller.js').PeerSyncController>} opts.peerSyncControllers
+   * @param {Logger} [opts.logger]
    */
-  constructor({ namespace, coreManager, onUpdate, peerSyncControllers }) {
+  constructor({
+    namespace,
+    coreManager,
+    onUpdate,
+    peerSyncControllers,
+    logger,
+  }) {
+    // Currently we don't create a logger for this class, just pass it down
+    this.#logger = logger
     this.#namespace = namespace
     this.#peerSyncControllers = peerSyncControllers
     // Called whenever the state changes, so we clear the cache because next
@@ -62,7 +73,7 @@ export class NamespaceSyncState {
     const state = {
       dataToSync: false,
       coreCount: this.#coreCount,
-      localState: createState(),
+      localState: { want: 0, have: 0, wanted: 0 },
       remoteStates: {},
     }
     for (const css of this.#coreStates.values()) {
@@ -94,6 +105,15 @@ export class NamespaceSyncState {
     }
   }
 
+  /**
+   * @param {string} peerId
+   */
+  disconnectPeer(peerId) {
+    for (const css of this.#coreStates.values()) {
+      css.disconnectPeer(peerId)
+    }
+  }
+
   /**
    * @param {import('hypercore')<"binary", Buffer>} core
    * @param {Buffer} coreKey
@@ -122,10 +142,14 @@ export class NamespaceSyncState {
   #getCoreState(discoveryId) {
     let coreState = this.#coreStates.get(discoveryId)
     if (!coreState) {
+      const logPrefix = `[${discoveryId.slice(0, 7)}] `
       coreState = new CoreSyncState({
         onUpdate: this.#handleUpdate,
         peerSyncControllers: this.#peerSyncControllers,
         namespace: this.#namespace,
+        logger: Logger.create('css:' + this.#namespace, this.#logger, {
+          prefix: logPrefix,
+        }),
       })
       this.#coreStates.set(discoveryId, coreState)
     }
@@ -133,28 +157,6 @@ export class NamespaceSyncState {
   }
 }
 
-/**
- * @overload
- * @returns {SyncState['localState']}
- */
-
-/**
- * @overload
- * @param {import('./core-sync-state.js').PeerNamespaceState['status']} status
- * @returns {import('./core-sync-state.js').PeerNamespaceState}
- */
-
-/**
- * @param {import('./core-sync-state.js').PeerNamespaceState['status']} [status]
- */
-export function createState(status) {
-  if (status) {
-    return { want: 0, have: 0, wanted: 0, status }
-  } else {
-    return { want: 0, have: 0, wanted: 0 }
-  }
-}
-
 /**
  * @overload
  * @param {SyncState['localState']} accumulator
@@ -184,7 +186,7 @@ function mutatingAddPeerState(accumulator, currentValue) {
       accumulator.status === 'stopped'
     } else if (
       currentValue.status === 'starting' &&
-      accumulator.status === 'starting'
+      accumulator.status === 'started'
     ) {
       accumulator.status = 'starting'
     }

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

@@ -32,6 +32,7 @@ export class PeerSyncController {
   #downloadingRanges = new Map()
   /** @type {SyncStatus} */
   #prevSyncStatus = createNamespaceMap('unknown')
+  /** @type {import('debug').Debugger} */
   #log
 
   /**
@@ -43,25 +44,16 @@ export class PeerSyncController {
    * @param {Logger} [opts.logger]
    */
   constructor({ protomux, coreManager, syncState, roles, logger }) {
-    /**
-     * @param {string} formatter
-     * @param {unknown[]} args
-     * @returns {void}
-     */
-    this.#log = (formatter, ...args) => {
-      const log = Logger.create('peer', logger).log
-      return log.apply(null, [
-        `[%h] ${formatter}`,
-        protomux.stream.remotePublicKey,
-        ...args,
-      ])
-    }
+    const logPrefix = `[${protomux.stream.remotePublicKey
+      ?.toString('hex')
+      .slice(0, 7)}] `
+    this.#log = Logger.create('peer', logger, { prefix: logPrefix }).log
     this.#coreManager = coreManager
     this.#protomux = protomux
     this.#roles = roles
 
     // Always need to replicate the project creator core
-    this.#replicateCore(coreManager.creatorCore)
+    this.#replicateCoreRecord(coreManager.creatorCoreRecord)
 
     coreManager.on('add-core', this.#handleAddCore)
     syncState.on('state', this.#handleStateChange)
@@ -98,14 +90,18 @@ export class PeerSyncController {
     // If we already know about this core, then we will add it to the
     // replication stream when we are ready
     if (coreRecord) {
-      this.#log(
-        'Received discovery key %h, but already have core in namespace %s',
-        discoveryKey,
-        coreRecord.namespace
-      )
       if (this.#enabledNamespaces.has(coreRecord.namespace)) {
-        this.#replicateCore(coreRecord.core)
+        this.#replicateCoreRecord(coreRecord)
+      } else {
+        this.#log(
+          'Received discovery key %h, for core %h, but namespace %s is disabled',
+          discoveryKey,
+          coreRecord.key,
+          coreRecord.namespace
+        )
       }
+    } else {
+      this.#log('Received unknown discovery key %h', discoveryKey)
     }
   }
 
@@ -115,9 +111,9 @@ export class PeerSyncController {
    *
    * @param {CoreRecord} coreRecord
    */
-  #handleAddCore = ({ core, namespace }) => {
-    if (!this.#enabledNamespaces.has(namespace)) return
-    this.#replicateCore(core)
+  #handleAddCore = (coreRecord) => {
+    if (!this.#enabledNamespaces.has(coreRecord.namespace)) return
+    this.#replicateCoreRecord(coreRecord)
   }
 
   /**
@@ -235,25 +231,36 @@ export class PeerSyncController {
   }
 
   /**
-   * @param {import('hypercore')<'binary', any>} core
+   * @param {CoreRecord} coreRecord
    */
-  #replicateCore(core) {
+  #replicateCoreRecord({ core, namespace }) {
     if (core.closed) return
     if (this.#replicatingCores.has(core)) return
-    this.#log('replicating core %k', core.key)
+    this.#log('replicating %s core %k', namespace, core.key)
     core.replicate(this.#protomux)
-    core.on('peer-remove', (peer) => {
-      if (!peer.remotePublicKey.equals(this.peerKey)) return
-      this.#log('peer-remove %h from core %k', peer.remotePublicKey, core.key)
-    })
     this.#replicatingCores.add(core)
+
+    if (!this.#log.enabled) return
+
+    /** @type {(peer: any) => void} */
+    const handlePeerRemove = (peer) => {
+      if (!peer.remotePublicKey.equals(this.peerKey)) return
+      core.off('peer-remove', handlePeerRemove)
+      this.#log(
+        'peer-remove %h from %s core %k',
+        peer.remotePublicKey,
+        namespace,
+        core.key
+      )
+    }
+    core.on('peer-remove', handlePeerRemove)
   }
 
   /**
-   * @param {import('hypercore')<'binary', any>} core
+   * @param {CoreRecord} coreRecord
    * @returns {Promise<void>}
    */
-  async #unreplicateCore(core) {
+  async #unreplicateCoreRecord({ core, namespace }) {
     if (core === this.#coreManager.creatorCore) return
 
     this.#replicatingCores.delete(core)
@@ -266,7 +273,7 @@ export class PeerSyncController {
     }
 
     unreplicate(core, this.#protomux)
-    this.#log('unreplicated core %k', core.key)
+    this.#log('unreplicated %s core %k', namespace, core.key)
   }
 
   /**
@@ -274,8 +281,8 @@ export class PeerSyncController {
    */
   #enableNamespace(namespace) {
     if (this.#enabledNamespaces.has(namespace)) return
-    for (const { core } of this.#coreManager.getCores(namespace)) {
-      this.#replicateCore(core)
+    for (const coreRecord of this.#coreManager.getCores(namespace)) {
+      this.#replicateCoreRecord(coreRecord)
     }
     this.#enabledNamespaces.add(namespace)
     this.#log('enabled namespace %s', namespace)
@@ -286,8 +293,8 @@ export class PeerSyncController {
    */
   #disableNamespace(namespace) {
     if (!this.#enabledNamespaces.has(namespace)) return
-    for (const { core } of this.#coreManager.getCores(namespace)) {
-      this.#unreplicateCore(core)
+    for (const coreRecord of this.#coreManager.getCores(namespace)) {
+      this.#unreplicateCoreRecord(coreRecord)
     }
     this.#enabledNamespaces.delete(namespace)
     this.#log('disabled namespace %s', namespace)

package/src/sync/sync-api.js

@@ -97,6 +97,7 @@ export class SyncApi extends TypedEmitter {
       coreManager,
       throttleMs,
       peerSyncControllers: this.#pscByPeerId,
+      logger,
     })
     this[kSyncState].setMaxListeners(0)
     this[kSyncState].on('state', (namespaceSyncState) => {
@@ -104,7 +105,7 @@ export class SyncApi extends TypedEmitter {
     })
 
     this.#coreManager.creatorCore.on('peer-add', this.#handlePeerAdd)
-    this.#coreManager.creatorCore.on('peer-remove', this.#handlePeerRemove)
+    this.#coreManager.creatorCore.on('peer-remove', this.#handlePeerDisconnect)
 
     roles.on('update', this.#handleRoleUpdate)
     coreOwnership.on('update', this.#handleCoreOwnershipUpdate)
@@ -261,7 +262,9 @@ export class SyncApi extends TypedEmitter {
       syncEnabledState = 'presync'
     }
 
-    this.#l.log(`Setting sync enabled state to "${syncEnabledState}"`)
+    if (syncEnabledState !== this.#previousSyncEnabledState) {
+      this.#l.log(`Setting sync enabled state to "${syncEnabledState}"`)
+    }
     for (const peerSyncController of this.#peerSyncControllers.values()) {
       peerSyncController.setSyncEnabledState(syncEnabledState)
     }
@@ -403,7 +406,7 @@ export class SyncApi extends TypedEmitter {
    *
    * @param {{ protomux: import('protomux')<import('@hyperswarm/secret-stream')>, remotePublicKey: Buffer }} peer
    */
-  #handlePeerRemove = (peer) => {
+  #handlePeerDisconnect = (peer) => {
     const { protomux } = peer
     if (!this.#peerSyncControllers.has(protomux)) {
       this.#l.log(
@@ -416,6 +419,8 @@ export class SyncApi extends TypedEmitter {
     const peerId = keyToId(peer.remotePublicKey)
     this.#pscByPeerId.delete(peerId)
     this.#pendingDiscoveryKeys.delete(protomux)
+    this[kSyncState].disconnectPeer(peerId)
+    this.#updateState()
   }
 
   /**
@@ -435,7 +440,6 @@ export class SyncApi extends TypedEmitter {
     for (const result of ownershipResults) {
       if (result.status === 'rejected') continue
       await this.#validateRoleAndAddCoresForPeer(result.value)
-      this.#l.log('Added cores for device %S', result.value.docId)
     }
   }
 
@@ -457,10 +461,8 @@ export class SyncApi extends TypedEmitter {
               coreOwnershipDocId
             )
             await this.#validateRoleAndAddCoresForPeer(coreOwnershipDoc)
-            this.#l.log('Added cores for device %S', coreOwnershipDocId)
           } catch (_) {
             // Ignore, we'll add these when the role is added
-            this.#l.log('No role for device %S', coreOwnershipDocId)
           }
         })()
       )
@@ -485,6 +487,7 @@ export class SyncApi extends TypedEmitter {
       const coreKey = Buffer.from(coreOwnership[`${ns}CoreId`], 'hex')
       this.#coreManager.addCore(coreKey, ns)
     }
+    this.#l.log('Added non-auth cores for peer %S', peerDeviceId)
   }
 }
 

package/src/sync/sync-state.js

@@ -24,8 +24,9 @@ export class SyncState extends TypedEmitter {
    * @param {import('../core-manager/index.js').CoreManager} opts.coreManager
    * @param {Map<string, import('./peer-sync-controller.js').PeerSyncController>} opts.peerSyncControllers
    * @param {number} [opts.throttleMs]
+   * @param {import('../logger.js').Logger} [opts.logger]
    */
-  constructor({ coreManager, peerSyncControllers, throttleMs = 200 }) {
+  constructor({ coreManager, peerSyncControllers, throttleMs = 200, logger }) {
     super()
     const throttledHandleUpdate = throttle(throttleMs, this.#handleUpdate)
     for (const namespace of NAMESPACES) {
@@ -34,6 +35,7 @@ export class SyncState extends TypedEmitter {
         coreManager,
         onUpdate: throttledHandleUpdate,
         peerSyncControllers,
+        logger,
       })
     }
   }
@@ -47,6 +49,15 @@ export class SyncState extends TypedEmitter {
     }
   }
 
+  /**
+   * @param {string} peerId
+   */
+  disconnectPeer(peerId) {
+    for (const nss of Object.values(this.#syncStates)) {
+      nss.disconnectPeer(peerId)
+    }
+  }
+
   /**
    * @returns {State}
    */

package/src/translation-api.js

@@ -14,7 +14,6 @@ export default class TranslationApi {
    * Set<import('@comapeo/schema/dist/types.js').SchemaName>>} */
   #translatedLanguageCodeToSchemaNames = new Map()
   #dataType
-  #table
   #indexPromise
 
   /**
@@ -26,11 +25,9 @@ export default class TranslationApi {
    *   Translation,
    *   TranslationValue
    * >}  opts.dataType
-   * @param {typeof import('./schema/project.js').translationTable} opts.table
    */
-  constructor({ dataType, table }) {
+  constructor({ dataType }) {
     this.#dataType = dataType
-    this.#table = table
     this.#indexPromise = this.#dataType
       .getMany()
       .then((docs) => {

package/src/types.ts

@@ -133,7 +133,6 @@ export type HypercorePeer = {
   onrange: (options: { drop: boolean; start: number; length: number }) => void
 }
 
-export { NoiseStream }
 type ProtocolStream = Omit<NoiseStream, 'userData'> & {
   userData: Protomux
 }

package/src/utils.js

@@ -1,4 +1,3 @@
-import b4a from 'b4a'
 import sodium from 'sodium-universal'
 import { keyToPublicId } from '@mapeo/crypto'
 import { createHash } from 'node:crypto'
@@ -6,18 +5,6 @@ import stableStringify from 'json-stable-stringify'
 
 const PROJECT_INVITE_ID_SALT = Buffer.from('mapeo project invite id', 'ascii')
 
-/**
- * @param {String|Buffer} id
- * @returns {Buffer | Uint8Array}
- */
-export function idToKey(id) {
-  if (b4a.isBuffer(id)) {
-    return /** @type {Buffer} */ (id)
-  }
-
-  return b4a.from(/** @type {String} */ (id), 'hex')
-}
-
 /**
  *
  * @param {Buffer|String} key
@@ -31,18 +18,6 @@ export function keyToId(key) {
   return key.toString('hex')
 }
 
-/**
- * @param {String} version
- * @returns {{coreId: String, blockIndex: Number}}
- */
-export function parseVersion(version) {
-  const [coreId, blockIndex] = version.split('@')
-  return {
-    coreId,
-    blockIndex: Number(blockIndex),
-  }
-}
-
 export class ExhaustivenessError extends Error {
   /** @param {never} value */
   constructor(value) {

package/dist/fastify-plugins/maps/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fastify-plugins/maps/index.js"],"names":[],"mappings":"AAYA,uCAAuC;AACvC,8FACwD;;;;;;;qBA8B1C,MAAM,OAAO,CAAC,MAAM,CAAC"}

package/dist/fastify-plugins/maps/offline-fallback-map.d.ts

@@ -1,12 +0,0 @@
-export const PLUGIN_NAME: "mapeo-static-maps";
-export function plugin(instance: import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>, opts: OfflineFallbackMapPluginOpts): Promise<void>;
-export type OfflineFallbackMapPluginOpts = {
-    prefix?: string | undefined;
-    styleJsonPath: string;
-    sourcesDir: string;
-};
-export type FallbackMapPluginDecorator = {
-    getResolvedStyleJson: (serverAddress: string) => Promise<any>;
-    getStyleJsonStats: () => Promise<import("node:fs").Stats>;
-};
-//# sourceMappingURL=offline-fallback-map.d.ts.map

package/dist/fastify-plugins/maps/offline-fallback-map.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"offline-fallback-map.d.ts","sourceRoot":"","sources":["../../../src/fastify-plugins/maps/offline-fallback-map.js"],"names":[],"mappings":"AAWA,8CAA8C;;;;mBAUhC,MAAM;gBACN,MAAM;;;0BAKN,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC;uBACvC,MAAM,OAAO,CAAC,OAAO,SAAS,EAAE,KAAK,CAAC"}

package/dist/fastify-plugins/maps/static-maps.d.ts

@@ -1,11 +0,0 @@
-export const PLUGIN_NAME: "mapeo-static-maps";
-export function plugin(instance: import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>, opts: StaticMapsPluginOpts): Promise<void>;
-export type StaticMapsPluginOpts = {
-    prefix?: string | undefined;
-    staticRootDir: string;
-};
-export type StaticMapsPluginDecorator = {
-    getResolvedStyleJson: (styleId: string, serverAddress: string) => Promise<string>;
-    getStyleJsonStats: (styleId: string) => Promise<import("node:fs").Stats>;
-};
-//# sourceMappingURL=static-maps.d.ts.map

package/dist/fastify-plugins/maps/static-maps.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"static-maps.d.ts","sourceRoot":"","sources":["../../../src/fastify-plugins/maps/static-maps.js"],"names":[],"mappings":"AAeA,8CAA8C;;;;mBAUhC,MAAM;;;0BAKN,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC;uBAC3D,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,SAAS,EAAE,KAAK,CAAC"}