@comapeo/core 4.1.1 → 4.1.3-prerelease.0

package/dist/blob-store/live-download.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Reduce multiple states into one. Factored out for unit testing because I
+ * don't trust my coding. Probably a smarter way to do this, but this works.
+ *
+ * @param {Iterable<{ state: BlobDownloadState | BlobDownloadStateError }>} liveDownloads
+ * @param {{ signal?: AbortSignal }} options
+ * @returns {BlobDownloadState | BlobDownloadStateError}
+ */
+export function combineStates(liveDownloads: Iterable<{
+    state: BlobDownloadState | BlobDownloadStateError;
+}>, { signal }?: {
+    signal?: AbortSignal;
+}): BlobDownloadState | BlobDownloadStateError;
+/**
+ * @typedef {object} BlobDownloadState
+ * @property {number} haveCount The number of files already downloaded
+ * @property {number} haveBytes The bytes already downloaded
+ * @property {number} wantCount The number of files pending download
+ * @property {number} wantBytes The bytes pending download
+ * @property {null} error If status = 'error' then this will be an Error object
+ * @property {'checking' | 'downloading' | 'downloaded' | 'aborted'} status
+ */
+/** @typedef {Omit<BlobDownloadState, 'error' | 'status'> & { status: 'error', error: Error }} BlobDownloadStateError */
+/**
+ * @typedef {object} BlobDownloadEvents
+ * @property {(state: BlobDownloadState | BlobDownloadStateError ) => void} state Emitted with the current download state whenever it changes (not emitted during initial 'checking' status)
+ */
+/**
+ * LiveDownload class
+ * @extends {TypedEmitter<BlobDownloadEvents>}
+ */
+export class LiveDownload extends TypedEmitter<BlobDownloadEvents> {
+    /**
+     * Like drive.download() but 'live', and for multiple drives
+     * @param {Iterable<import('hyperdrive')>} drives
+     * @param {import('./index.js').InternalDriveEmitter} emitter
+     * @param {object} options
+     * @param {import('../types.js').BlobFilter} [options.filter] Filter blobs of specific types and/or sizes to download
+     * @param {AbortSignal} [options.signal]
+     */
+    constructor(drives: Iterable<import("hyperdrive")>, emitter: import("./index.js").InternalDriveEmitter, { filter, signal }: {
+        filter?: import("../types.js").BlobFilter | undefined;
+        signal?: AbortSignal | undefined;
+    });
+    /**
+     * @returns {BlobDownloadState | BlobDownloadStateError}
+     */
+    get state(): BlobDownloadState | BlobDownloadStateError;
+    #private;
+}
+/**
+ * LiveDownload class
+ * @extends {TypedEmitter<BlobDownloadEvents>}
+ */
+export class DriveLiveDownload extends TypedEmitter<BlobDownloadEvents> {
+    /**
+     * Like drive.download() but 'live',
+     * @param {import('hyperdrive')} drive
+     * @param {object} options
+     * @param {import('../types.js').BlobFilter} [options.filter] Filter blobs of specific types and/or sizes to download
+     * @param {AbortSignal} [options.signal]
+     */
+    constructor(drive: import("hyperdrive"), { filter, signal }?: {
+        filter?: import("../types.js").BlobFilter | undefined;
+        signal?: AbortSignal | undefined;
+    });
+    /**
+     * @returns {BlobDownloadState | BlobDownloadStateError}
+     */
+    get state(): BlobDownloadState | BlobDownloadStateError;
+    #private;
+}
+export type BlobDownloadState = {
+    /**
+     * The number of files already downloaded
+     */
+    haveCount: number;
+    /**
+     * The bytes already downloaded
+     */
+    haveBytes: number;
+    /**
+     * The number of files pending download
+     */
+    wantCount: number;
+    /**
+     * The bytes pending download
+     */
+    wantBytes: number;
+    /**
+     * If status = 'error' then this will be an Error object
+     */
+    error: null;
+    status: "checking" | "downloading" | "downloaded" | "aborted";
+};
+export type BlobDownloadStateError = Omit<BlobDownloadState, "error" | "status"> & {
+    status: "error";
+    error: Error;
+};
+export type BlobDownloadEvents = {
+    /**
+     * Emitted with the current download state whenever it changes (not emitted during initial 'checking' status)
+     */
+    state: (state: BlobDownloadState | BlobDownloadStateError) => void;
+};
+import { TypedEmitter } from 'tiny-typed-emitter';
+//# sourceMappingURL=live-download.d.ts.map

package/dist/blob-store/live-download.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-download.d.ts","sourceRoot":"","sources":["../../src/blob-store/live-download.js"],"names":[],"mappings":"AA+RA;;;;;;;GAOG;AACH,6CAJW,QAAQ,CAAC;IAAE,KAAK,EAAE,iBAAiB,GAAG,sBAAsB,CAAA;CAAE,CAAC,eAC/D;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GACtB,iBAAiB,GAAG,sBAAsB,CAqCtD;AApUD;;;;;;;;GAQG;AAEH,wHAAwH;AAExH;;;GAGG;AAEH;;;GAGG;AACH;IAKE;;;;;;;OAOG;IACH,oBANW,QAAQ,CAAC,OAAO,YAAY,CAAC,CAAC,WAC9B,OAAO,YAAY,EAAE,oBAAoB,sBAEjD;QAAmD,MAAM;QAC3B,MAAM;KAAC,EAiCvC;IAED;;OAEG;IACH,wDAEC;;CACF;AAED;;;GAGG;AACH;IAaE;;;;;;OAMG;IACH,mBALW,OAAO,YAAY,CAAC,uBAE5B;QAAmD,MAAM;QAC3B,MAAM;KAAC,EAmBvC;IAED;;OAEG;IACH,wDAyBC;;CAqIF;;;;;eArRa,MAAM;;;;eACN,MAAM;;;;eACN,MAAM;;;;eACN,MAAM;;;;WACN,IAAI;YACJ,UAAU,GAAG,aAAa,GAAG,YAAY,GAAG,SAAS;;qCAGrD,IAAI,CAAC,iBAAiB,EAAE,OAAO,GAAG,QAAQ,CAAC,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE;;;;;WAI/E,CAAC,KAAK,EAAE,iBAAiB,GAAG,sBAAsB,KAAM,IAAI;;6BApB7C,oBAAoB"}

package/dist/capabilities.d.ts

@@ -0,0 +1,121 @@
+export const COORDINATOR_ROLE_ID: "f7c150f5a3a9a855";
+export const MEMBER_ROLE_ID: "012fd2d431c0bf60";
+export const BLOCKED_ROLE_ID: "9e6d29263cba36c9";
+export const LEFT_ROLE_ID: "8ced989b1904606b";
+/**
+ * @typedef {object} DocCapability
+ * @property {boolean} readOwn - can read own data
+ * @property {boolean} writeOwn - can write own data
+ * @property {boolean} readOthers - can read other's data
+ * @property {boolean} writeOthers - can edit or delete other's data
+ */
+/**
+ * @typedef {object} Capability
+ * @property {string} name
+ * @property {Record<import('@mapeo/schema').MapeoDoc['schemaName'], DocCapability>} docs
+ * @property {RoleId[]} roleAssignment
+ * @property {Record<import('./core-manager/core-index.js').Namespace, 'allowed' | 'blocked'>} sync
+ */
+/**
+ * @typedef {typeof COORDINATOR_ROLE_ID | typeof MEMBER_ROLE_ID | typeof BLOCKED_ROLE_ID | typeof LEFT_ROLE_ID} RoleId
+ */
+/**
+ * This is currently the same as 'Coordinator' capabilities, but defined
+ * separately because the creator should always have ALL capabilities, but we
+ * could edit 'Coordinator' capabilities in the future
+ *
+ * @type {Capability}
+ */
+export const CREATOR_CAPABILITIES: Capability;
+/**
+ * These are the capabilities assumed for a device when no capability record can
+ * be found. This can happen when an invited device did not manage to sync with
+ * the device that invited them, and they then try to sync with someone else. We
+ * want them to be able to sync the auth and config store, because that way they
+ * may be able to receive their role record, and they can get the project config
+ * so that they can start collecting data.
+ *
+ * @type {Capability}
+ */
+export const NO_ROLE_CAPABILITIES: Capability;
+/** @type {Record<RoleId, Capability>} */
+export const DEFAULT_CAPABILITIES: Record<RoleId, Capability>;
+export class Capabilities {
+    static NO_ROLE_CAPABILITIES: Capability;
+    /**
+     *
+     * @param {object} opts
+     * @param {import('./datatype/index.js').DataType<
+     *   import('./datastore/index.js').DataStore<'auth'>,
+     *   typeof import('./schema/project.js').roleTable,
+     *   'role',
+     *   import('@mapeo/schema').Role,
+     *   import('@mapeo/schema').RoleValue
+     * >} opts.dataType
+     * @param {import('./core-ownership.js').CoreOwnership} opts.coreOwnership
+     * @param {import('./core-manager/index.js').CoreManager} opts.coreManager
+     * @param {Buffer} opts.projectKey
+     * @param {Buffer} opts.deviceKey public key of this device
+     */
+    constructor({ dataType, coreOwnership, coreManager, projectKey, deviceKey }: {
+        dataType: import('./datatype/index.js').DataType<import('./datastore/index.js').DataStore<'auth'>, typeof import('./schema/project.js').roleTable, 'role', import('@mapeo/schema').Role, import('@mapeo/schema').RoleValue>;
+        coreOwnership: import('./core-ownership.js').CoreOwnership;
+        coreManager: import('./core-manager/index.js').CoreManager;
+        projectKey: Buffer;
+        deviceKey: Buffer;
+    });
+    /**
+     * Get the capabilities for device `deviceId`.
+     *
+     * @param {string} deviceId
+     * @returns {Promise<Capability>}
+     */
+    getCapabilities(deviceId: string): Promise<Capability>;
+    /**
+     * Get capabilities of all devices in the project. For your own device, if you
+     * have not yet synced your own role record, the "no role" capabilties is
+     * returned. The project creator will have `CREATOR_CAPABILITIES` unless a
+     * different role has been assigned.
+     *
+     * @returns {Promise<Record<string, Capability>>} Map of deviceId to Capability
+     */
+    getAll(): Promise<Record<string, Capability>>;
+    /**
+     * Assign a role to the specified `deviceId`. Devices without an assigned role
+     * are unable to sync, except the project creator that defaults to having all
+     * capabilities. Only the project creator can assign their own role. Will
+     * throw if the device trying to assign the role lacks the `roleAssignment`
+     * capability for the given roleId
+     *
+     * @param {string} deviceId
+     * @param {keyof typeof DEFAULT_CAPABILITIES} roleId
+     */
+    assignRole(deviceId: string, roleId: keyof typeof DEFAULT_CAPABILITIES): Promise<void>;
+    #private;
+}
+export type DocCapability = {
+    /**
+     * - can read own data
+     */
+    readOwn: boolean;
+    /**
+     * - can write own data
+     */
+    writeOwn: boolean;
+    /**
+     * - can read other's data
+     */
+    readOthers: boolean;
+    /**
+     * - can edit or delete other's data
+     */
+    writeOthers: boolean;
+};
+export type Capability = {
+    name: string;
+    docs: Record<import('@mapeo/schema').MapeoDoc['schemaName'], DocCapability>;
+    roleAssignment: RoleId[];
+    sync: Record<import('./core-manager/core-index.js').Namespace, 'allowed' | 'blocked'>;
+};
+export type RoleId = typeof COORDINATOR_ROLE_ID | typeof MEMBER_ROLE_ID | typeof BLOCKED_ROLE_ID | typeof LEFT_ROLE_ID;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../src/capabilities.js"],"names":[],"mappings":"AAKA,qDAAqD;AACrD,gDAAgD;AAChD,iDAAiD;AACjD,8CAA8C;AAE9C;;;;;;GAMG;AAEH;;;;;;GAMG;AAEH;;GAEG;AAEH;;;;;;GAMG;AACH,mCAFU,UAAU,CAkBnB;AAED;;;;;;;;;GASG;AACH,mCAFU,UAAU,CAkBnB;AAED,yCAAyC;AACzC,mCADW,OAAO,MAAM,EAAE,UAAU,CAAC,CAgFpC;AAED;IAOE,wCAAkD;IAElD;;;;;;;;;;;;;;OAcG;IACH;QANW,QAAQ,EANR,OAAO,qBAAqB,EAAE,QAAQ,CAChD,OAAW,sBAAsB,EAAE,SAAS,CAAC,MAAM,CAAC,EACpD,cAAkB,qBAAqB,EAAE,SAAS,EAClD,MAAU,EACV,OAAW,eAAe,EAAE,IAAI,EAChC,OAAW,eAAe,EAAE,SAAS,CAClC;QACyD,aAAa,EAA/D,OAAO,qBAAqB,EAAE,aAAa;QACS,WAAW,EAA/D,OAAO,yBAAyB,EAAE,WAAW;QAChC,UAAU,EAAvB,MAAM;QACO,SAAS,EAAtB,MAAM;OAQhB;IAED;;;;;OAKG;IACH,0BAHW,MAAM,GACJ,QAAQ,UAAU,CAAC,CAuB/B;IAED;;;;;;;OAOG;IACH,UAFa,QAAQ,OAAO,MAAM,EAAE,UAAU,CAAC,CAAC,CAkC/C;IAED;;;;;;;;;OASG;IACH,qBAHW,MAAM,UACN,MAAM,2BAA2B,iBAyD3C;;CAQF;;;;;aAzUa,OAAO;;;;cACP,OAAO;;;;gBACP,OAAO;;;;iBACP,OAAO;;;UAKP,MAAM;UACN,OAAO,OAAO,eAAe,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC;oBACrE,MAAM,EAAE;UACR,OAAO,OAAO,8BAA8B,EAAE,SAAS,EAAE,SAAS,GAAG,SAAS,CAAC;;qBAIhF,0BAA0B,GAAG,qBAAqB,GAAG,sBAAsB,GAAG,mBAAmB"}

package/dist/core-manager/compat.d.ts

@@ -0,0 +1,4 @@
+/// <reference path="../../types/quickbit-universal.d.ts" />
+export let quickbit: typeof universal;
+import universal = require("quickbit-universal");
+//# sourceMappingURL=compat.d.ts.map

package/dist/core-manager/compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compat.d.ts","sourceRoot":"","sources":["../../src/core-manager/compat.js"],"names":[],"mappings":";AAOA,sCAAwB"}

package/dist/discovery/dns-sd.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @typedef {object} MapeoService
+ * @property {string} address IPv4 address of service
+ * @property {number} port
+ * @property {string} name Instance name
+ */
+/**
+ * @typedef {object} DnsSdEvents
+ * @property {(service: MapeoService) => void} up
+ * @property {(service: MapeoService) => void} down
+ */
+/**
+ * @extends {TypedEmitter<DnsSdEvents>}
+ */
+export class DnsSd extends TypedEmitter<DnsSdEvents> {
+    /**
+     *
+     * @param {object} [opts]
+     * @param {string} [opts.name]
+     * @param {boolean} [opts.disableIpv6]
+     * @param {Logger} [opts.logger]
+     */
+    constructor({ name, disableIpv6, logger }?: {
+        name?: string | undefined;
+        disableIpv6?: boolean | undefined;
+        logger?: Logger | undefined;
+    } | undefined);
+    get name(): string;
+    /** @param {number} port */
+    advertise(port: number): Promise<void>;
+    browse(): void;
+    stopAdvertising(): Promise<void>;
+    stopBrowsing(): void;
+    destroy(): Promise<void>;
+    #private;
+}
+export type MapeoService = {
+    /**
+     * IPv4 address of service
+     */
+    address: string;
+    port: number;
+    /**
+     * Instance name
+     */
+    name: string;
+};
+export type DnsSdEvents = {
+    up: (service: MapeoService) => void;
+    down: (service: MapeoService) => void;
+};
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { Logger } from '../logger.js';
+//# sourceMappingURL=dns-sd.d.ts.map

package/dist/discovery/dns-sd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dns-sd.d.ts","sourceRoot":"","sources":["../../src/discovery/dns-sd.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AAEH;;;;GAIG;AAEH;;GAEG;AACH;IAoDE;;;;;;OAMG;IACH;;;;mBAMC;IAED,mBAEC;IAED,2BAA2B;IAC3B,gBADY,MAAM,iBA+BjB;IAED,eAiBC;IAED,iCAeC;IAED,qBAKC;IAED,yBA0BC;;CA+BF;;;;;aA1Na,MAAM;UACN,MAAM;;;;UACN,MAAM;;;kBAKI,YAAY,KAAK,IAAI;oBACrB,YAAY,KAAK,IAAI;;6BApBhB,oBAAoB;uBAM1B,cAAc"}

package/dist/discovery/local-discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-discovery.d.ts","sourceRoot":"","sources":["../../src/discovery/local-discovery.js"],"names":[],"mappings":"AAqBA,mDAAmD;AAEnD;;;GAGG;AAEH;;GAEG;AACH;IAaE;;;;OAIG;IACH,yCAHG;QAAsB,eAAe,EAA7B,OAAO;QACO,MAAM;KAAC,EAqB/B;IAED,yDAAyD;IACzD,SADc,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAIpD;IAqBD;;;;;;OAMG;IACH,qCALG;QAAqB,OAAO,EAApB,MAAM;QACO,IAAI,EAAjB,MAAM;QACO,IAAI,EAAjB,MAAM;KACd,GAAU,IAAI,CAkBhB;IAqJD;;;;;;;;;OASG;IACH;;;oBAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;;CA+BF;sBAxSa;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;mCACxC,kBAAkB,GAAG,CAAC,MAAM,CAAC;;gBAU7B,CAAC,UAAU,EAAE,oBAAoB,KAAK,IAAI;;6BAzB3B,oBAAoB;uBAU1B,cAAc;gBATrB,UAAU;uCAWa,uCAAuC"}
+{"version":3,"file":"local-discovery.d.ts","sourceRoot":"","sources":["../../src/discovery/local-discovery.js"],"names":[],"mappings":"AAyBA,mDAAmD;AAEnD;;;GAGG;AAEH;;GAEG;AACH;IAaE;;;;OAIG;IACH,yCAHG;QAAsB,eAAe,EAA7B,OAAO;QACO,MAAM;KAAC,EAqB/B;IAED,yDAAyD;IACzD,SADc,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAIpD;IAqBD;;;;;;OAMG;IACH,qCALG;QAAqB,OAAO,EAApB,MAAM;QACO,IAAI,EAAjB,MAAM;QACO,IAAI,EAAjB,MAAM;KACd,GAAU,IAAI,CAkBhB;IAqJD;;;;;;;;;OASG;IACH;;;oBAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;;CA+BF;sBA5Sa;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;mCACxC,kBAAkB,GAAG,CAAC,MAAM,CAAC;;gBAc7B,CAAC,UAAU,EAAE,oBAAoB,KAAK,IAAI;;6BA7B3B,oBAAoB;uBAU1B,cAAc;gBATrB,UAAU;uCAWa,uCAAuC"}

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

@@ -0,0 +1,11 @@
+export const PLUGIN_NAME: "mapeo-maps";
+export const DEFAULT_MAPBOX_STYLE_URL: "https://api.mapbox.com/styles/v1/mapbox/outdoors-v12";
+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: MapsPluginOpts): Promise<void>;
+export type MapsPluginOpts = {
+    prefix?: string | undefined;
+    defaultOnlineStyleUrl?: string | undefined;
+};
+export type MapsPluginContext = {
+    getStyleJsonUrl: () => Promise<string>;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1 @@
+{"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"}

package/dist/index-writer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index-writer/index.js"],"names":[],"mappings":"AAMA,mEAAmE;AACnE,6DAA6D;AAE7D;;GAEG;AACH;;GAEG;AAEH;;GAEG;AACH,yBAF+B,OAAO,SAAzB,cAAgB;IAY3B;;;;;;;;OAQG;IACH,2DANG;QAAgD,MAAM,EAA9C,OAAO,gBAAgB,EAAE,QAAQ;QACjB,MAAM,EAAtB,OAAO,EAAE;QAC4D,MAAM,UAArE,gBAAgB,WAAW,eAAe,KAAK,QAAQ;QACE,SAAS;QAC1D,MAAM;KAAC,EAiB/B;IAED;;OAEG;IACH,8CAEC;IAED;;;OAGG;IACH,eAHW,OAAO,oBAAoB,EAAE,KAAK,EAAE,GAClC,OAAO,CAAC,aAAa,CAAC,CA+ClC;IAED;;OAEG;IACH,qDAMC;;CACF;4BAjHY,GAAG,CAA2B,IAAtB,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,GAAE;+BAG5C,UAAU,CAAC,OAAO,MAAM,CAAC;oCANF,sBAAsB;qCADX,iBAAiB;8BAAjB,iBAAiB;uBADzC,cAAc;uBALd,iBAAiB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index-writer/index.js"],"names":[],"mappings":"AAMA,mEAAmE;AACnE,6DAA6D;AAE7D;;GAEG;AACH;;GAEG;AAEH;;GAEG;AACH,yBAF+B,OAAO,SAAzB,cAAgB;IAY3B;;;;;;;;OAQG;IACH,2DANG;QAAgD,MAAM,EAA9C,OAAO,gBAAgB,EAAE,QAAQ;QACjB,MAAM,EAAtB,OAAO,EAAE;QAC4D,MAAM,UAArE,gBAAgB,WAAW,eAAe,KAAK,QAAQ;QACE,SAAS;QAC1D,MAAM;KAAC,EAiB/B;IAED;;OAEG;IACH,8CAEC;IAED;;;OAGG;IACH,eAHW,OAAO,oBAAoB,EAAE,KAAK,EAAE,GAClC,OAAO,CAAC,aAAa,CAAC,CAiDlC;IAED;;OAEG;IACH,qDAMC;;CACF;4BAnHY,GAAG,CAA2B,IAAtB,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,GAAE;+BAG5C,UAAU,CAAC,OAAO,MAAM,CAAC;oCANF,sBAAsB;qCADX,iBAAiB;8BAAjB,iBAAiB;uBADzC,cAAc;uBALd,iBAAiB"}

package/dist/index.d.ts

@@ -1,13 +1,31 @@
 export { plugin as CoMapeoMapsFastifyPlugin } from "./fastify-plugins/maps.js";
 export { FastifyController } from "./fastify-controller.js";
 export { MapeoManager } from "./mapeo-manager.js";
-export function replicateProject(project: MapeoProject, isInitiatorOrStream: boolean | import("streamx").Duplex<any, any, any, any, true, true, import("streamx").DuplexEvents<any, any>> | import("stream").Duplex): ReturnType<(isInitiatorOrStream: (boolean | import("stream").Duplex | import("streamx").Duplex)) => import("./types.js").ReplicationStream>;
+export function replicateProject(project: MapeoProject, isInitiatorOrStream: (boolean | import("stream").Duplex | import("streamx").Duplex)): import("./types.js").ReplicationStream;
 export namespace roles {
     export { CREATOR_ROLE_ID };
     export { COORDINATOR_ROLE_ID };
     export { MEMBER_ROLE_ID };
 }
-import type { MapeoProject } from './mapeo-project.js';
+export type MapeoProject = import("./mapeo-project.js").MapeoProject;
+export type EditableProjectSettings = import("./mapeo-project.js").EditableProjectSettings;
+export namespace IconApi {
+    type BitmapOpts = import("./icon-api.js").BitmapOpts;
+    type SvgOpts = import("./icon-api.js").SvgOpts;
+}
+export namespace BlobApi {
+    type BlobId = import("./types.js").BlobId;
+    type Metadata = import("./blob-api.js").Metadata;
+    type BlobVariant<TBlobType extends import("./types.js").BlobType> = import("./types.js").BlobVariant<TBlobType>;
+}
+export namespace InviteApi {
+    type Invite = import("./invite/invite-api.js").Invite;
+}
+export namespace MemberApi {
+    type MemberInfo = import("./member-api.js").MemberInfo;
+    type RoleId = import("./roles.js").RoleId;
+    type RoleIdForNewInvite = import("./roles.js").RoleIdForNewInvite;
+}
 import { CREATOR_ROLE_ID } from './roles.js';
 import { COORDINATOR_ROLE_ID } from './roles.js';
 import { MEMBER_ROLE_ID } from './roles.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";;;AAgBO,0CAJI,YAAY,gKAEV,UAAU,yCAU4kmB,QAAQ,kBAAyB,SAAS,qDAV3kmB,CAG7B;;;;;;kCARH,oBAAoB;gCAL/C,YAAY;oCAAZ,YAAY;+BAAZ,YAAY"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";;;AA+CO,0CARI,YAAY,uBACZ,CACV,OAAW,GACX,OAAW,QAAQ,EAAE,MAAM,GAC3B,OAAW,SAAS,EAAE,MAAM,CACzB,GACS,OAAO,YAAY,EAAE,iBAAiB,CAGF;;;;;;2BArCnC,OAAO,oBAAoB,EAAE,YAAY;sCACzC,OAAO,oBAAoB,EAAE,uBAAuB;;sBAGrD,OAAO,eAAe,EAAE,UAAU;mBAClC,OAAO,eAAe,EAAE,OAAO;;;kBAI/B,OAAO,YAAY,EAAE,MAAM;oBAC3B,OAAO,eAAe,EAAE,QAAQ;qBAIA,SAAS,SAAzC,OAAQ,YAAY,EAAE,QAAS,IAC/B,OAAO,YAAY,EAAE,WAAW,CAAC,SAAS,CAAC;;;kBAI3C,OAAO,wBAAwB,EAAE,MAAM;;;sBAIvC,OAAO,iBAAiB,EAAE,UAAU;kBACpC,OAAO,YAAY,EAAE,MAAM;8BAC3B,OAAO,YAAY,EAAE,kBAAkB;;gCAhC7C,YAAY;oCAAZ,YAAY;+BAAZ,YAAY"}

package/dist/invite-api.d.ts

@@ -0,0 +1,70 @@
+/**
+ * @typedef {Object} InviteApiEvents
+ * @property {(invite: Invite) => void} invite-received
+ * @property {(invite: Invite, removalReason: InviteRemovalReason) => void} invite-removed
+ */
+/**
+ * @extends {TypedEmitter<InviteApiEvents>}
+ */
+export class InviteApi extends TypedEmitter<InviteApiEvents> {
+    /**
+     * @param {Object} options
+     * @param {import('./local-peers.js').LocalPeers} options.rpc
+     * @param {object} options.queries
+     * @param {(projectInviteId: Readonly<Buffer>) => undefined | { projectPublicId: string }} options.queries.getProjectByInviteId
+     * @param {(projectDetails: Pick<ProjectJoinDetails, 'projectKey' | 'encryptionKeys'> & { projectName: string }) => Promise<string>} options.queries.addProject
+     * @param {Logger} [options.logger]
+     */
+    constructor({ rpc, queries, logger }: {
+        rpc: import("./local-peers.js").LocalPeers;
+        queries: {
+            getProjectByInviteId: (projectInviteId: Readonly<Buffer>) => undefined | {
+                projectPublicId: string;
+            };
+            addProject: (projectDetails: Pick<ProjectJoinDetails, "projectKey" | "encryptionKeys"> & {
+                projectName: string;
+            }) => Promise<string>;
+        };
+        logger?: Logger | undefined;
+    });
+    rpc: import("./local-peers.js").LocalPeers;
+    /**
+     * @returns {Array<Invite>}
+     */
+    getPending(): Array<Invite>;
+    /**
+     * Attempt to accept the invite.
+     *
+     * This can fail if the invitor has canceled the invite or if you cannot
+     * connect to the invitor's device.
+     *
+     * If the invite is accepted and you had other invites to the same project,
+     * those invites are removed, and the invitors are told that you're already
+     * part of this project.
+     *
+     * @param {Pick<Invite, 'inviteId'>} invite
+     * @returns {Promise<string>}
+     */
+    accept({ inviteId: inviteIdString }: Pick<Invite, "inviteId">): Promise<string>;
+    /**
+     * @param {Pick<Invite, 'inviteId'>} invite
+     * @returns {void}
+     */
+    reject({ inviteId: inviteIdString }: Pick<Invite, "inviteId">): void;
+    #private;
+}
+export type InviteInternal = InviteRpcMessage & {
+    receivedAt: number;
+};
+export type Invite = MapBuffers<InviteInternal>;
+export type InviteRemovalReason = ("accepted" | "rejected" | "canceled" | "accepted other" | "connection error" | "internal error");
+export type InviteApiEvents = {
+    "invite-received": (invite: Invite) => void;
+    "invite-removed": (invite: Invite, removalReason: InviteRemovalReason) => void;
+};
+import { TypedEmitter } from 'tiny-typed-emitter';
+import type { ProjectJoinDetails } from './generated/rpc.js';
+import { Logger } from './logger.js';
+import type { Invite as InviteRpcMessage } from './generated/rpc.js';
+import type { MapBuffers } from './types.js';
+//# sourceMappingURL=invite-api.d.ts.map

package/dist/invite-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invite-api.d.ts","sourceRoot":"","sources":["../src/invite-api.js"],"names":[],"mappings":"AAiJA;;;;GAIG;AAEH;;GAEG;AACH;IAME;;;;;;;OAOG;IACH,sCANG;QAAuD,GAAG,EAAlD,OAAO,kBAAkB,EAAE,UAAU;QACrB,OAAO,EAC/B;YAAwG,oBAAoB,EAApH,CAAC,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,SAAS,GAAG;gBAAE,eAAe,EAAE,MAAM,CAAA;aAAE;YAC4D,UAAU,EAApJ,CAAC,cAAc,EAAE,IAAI,CAAC,kBAAkB,EAAE,YAAY,GAAG,gBAAgB,CAAC,GAAG;gBAAE,WAAW,EAAE,MAAM,CAAA;aAAE,KAAK,OAAO,CAAC,MAAM,CAAC;SAChI;QAAyB,MAAM;KAAC,EA0BlC;IAnBC,2CAAc;IAsFhB;;OAEG;IACH,cAFa,KAAK,CAAC,MAAM,CAAC,CAMzB;IAED;;;;;;;;;;;;OAYG;IACH,qCAHW,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GACtB,OAAO,CAAC,MAAM,CAAC,CAkI3B;IAED;;;OAGG;IACH,qCAHW,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GACtB,IAAI,CAuBhB;;CACF;6BA7ZY,gBAAgB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE;qBAGxC,WAAW,cAAc,CAAC;kCAG3B,CACZ,UAAa,GACb,UAAa,GACb,UAAa,GACb,gBAAmB,GACnB,kBAAqB,GACrB,gBAAmB,CAChB;;uBA8GU,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI;sBACxB,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,mBAAmB,KAAK,IAAI;;6BApJ7C,oBAAoB;wCAavC,oBAAoB;uBAPP,aAAa;gDAO1B,oBAAoB;gCANE,YAAY"}

package/dist/lib/timing-safe-equal.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Compare two values in constant time.
+ *
+ * Useful when you want to avoid leaking data.
+ *
+ * Like `crypto.timingSafeEqual`, but works with strings and doesn't throw if
+ * lengths differ.
+ *
+ * @template {string | Uint8Array} T
+ * @param {T} a
+ * @param {T} b
+ * @returns {boolean}
+ */
+export default function timingSafeEqual<T extends string | Uint8Array>(a: T, b: T): boolean;
+//# sourceMappingURL=timing-safe-equal.d.ts.map

package/dist/lib/timing-safe-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing-safe-equal.d.ts","sourceRoot":"","sources":["../../src/lib/timing-safe-equal.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;GAYG;AACH,wCALmC,CAAC,SAAtB,MAAM,GAAG,UAAW,KACvB,CAAC,KACD,CAAC,GACC,OAAO,CASnB"}

package/dist/media-server.d.ts

@@ -0,0 +1,36 @@
+export const BLOBS_PREFIX: "blobs";
+export const ICONS_PREFIX: "icons";
+/**
+ * @typedef {Object} StartOpts
+ *
+ * @property {string} [host]
+ * @property {number} [port]
+ */
+export class MediaServer {
+    /**
+     * @param {object} params
+     * @param {(projectPublicId: string) => Promise<import('./mapeo-project.js').MapeoProject>} params.getProject
+     * @param {import('fastify').FastifyServerOptions['logger']} [params.logger]
+     */
+    constructor({ getProject, logger }: {
+        getProject: (projectPublicId: string) => Promise<import('./mapeo-project.js').MapeoProject>;
+        logger?: import('fastify').FastifyServerOptions['logger'];
+    });
+    /**
+     * @param {StartOpts} [opts]
+     */
+    start(opts?: StartOpts | undefined): Promise<void>;
+    started(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * @param {'blobs' | 'icons'} mediaType
+     * @returns {Promise<string>}
+     */
+    getMediaAddress(mediaType: 'blobs' | 'icons'): Promise<string>;
+    #private;
+}
+export type StartOpts = {
+    host?: string | undefined;
+    port?: number | undefined;
+};
+//# sourceMappingURL=media-server.d.ts.map

package/dist/media-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-server.d.ts","sourceRoot":"","sources":["../src/media-server.js"],"names":[],"mappings":"AAWA,mCAAmC;AACnC,mCAAmC;AAEnC;;;;;GAKG;AAEH;IAOE;;;;OAIG;IACH;sCAH6B,MAAM,KAAK,QAAQ,OAAO,oBAAoB,EAAE,YAAY,CAAC;iBAC/E,OAAO,SAAS,EAAE,oBAAoB,CAAC,QAAQ,CAAC;OA0B1D;IAoDD;;OAEG;IACH,mDAEC;IAED,yBAEC;IAED,sBAEC;IAED;;;OAGG;IACH,2BAHW,OAAO,GAAG,OAAO,GACf,QAAQ,MAAM,CAAC,CAuB3B;;CACF"}

package/dist/server/ws-core-replicator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {import('ws').WebSocket} ws
+ * @param {import('../types.js').ReplicationStream} replicationStream
+ */
+export function wsCoreReplicator(ws: import("ws").WebSocket, replicationStream: import("../types.js").ReplicationStream): Promise<void>;
+//# sourceMappingURL=ws-core-replicator.d.ts.map

package/dist/server/ws-core-replicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-core-replicator.d.ts","sourceRoot":"","sources":["../../src/server/ws-core-replicator.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,qCAHW,OAAO,IAAI,EAAE,SAAS,qBACtB,OAAO,aAAa,EAAE,iBAAiB,iBAmBjD"}

package/dist/sync/peer-sync-controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"peer-sync-controller.d.ts","sourceRoot":"","sources":["../../src/sync/peer-sync-controller.js"],"names":[],"mappings":"AAKA,6DAA6D;AAC7D,0CAA0C;AAC1C,wDAAwD;AACxD,+CAA+C;AAC/C,iFAAiF;AAEjF;;GAEG;AAEH;IAsBE;;;;;;;OAOG;IACH,iEANG;QAAoD,QAAQ,EAApD,OAAO,UAAU,EAAE,iBAAiB,CAAC;QACgB,WAAW,EAAhE,OAAO,0BAA0B,EAAE,WAAW;QACJ,SAAS,EAAnD,OAAO,iBAAiB,EAAE,SAAS;QACD,KAAK,EAAvC,OAAO,aAAa,EAAE,KAAK;QACb,MAAM;KAAC,EAkB/B;IAED,sBAEC;IAED,qBAEC;IAED,gGAEC;IAED,iDAAiD;IACjD,sCADY,gBAAgB,QAO3B;IAED;;OAEG;IACH,iCAFW,MAAM,QAoBhB;;CAqMF;wBAGY,GAAG,SAAsB,IAAT,SAAS,CAAC,CAAC,EAAE,OAAO,sBAAsB,EAAE,kBAAkB,GAAE;yBAG/E,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;6BAxSpD,IAAI,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,SAAS;sCALV,eAAe;uCAEd,uCAAuC;uBAPvD,cAAc;+BAMN,aAAa;0BAFlB,aAAa"}
+{"version":3,"file":"peer-sync-controller.d.ts","sourceRoot":"","sources":["../../src/sync/peer-sync-controller.js"],"names":[],"mappings":"AAKA,6DAA6D;AAC7D,0CAA0C;AAC1C,wDAAwD;AACxD,+CAA+C;AAC/C,iFAAiF;AAEjF;;GAEG;AAEH;IAsBE;;;;;;;OAOG;IACH,iEANG;QAAoD,QAAQ,EAApD,OAAO,UAAU,EAAE,iBAAiB,CAAC;QACgB,WAAW,EAAhE,OAAO,0BAA0B,EAAE,WAAW;QACJ,SAAS,EAAnD,OAAO,iBAAiB,EAAE,SAAS;QACD,KAAK,EAAvC,OAAO,aAAa,EAAE,KAAK;QACb,MAAM;KAAC,EAkB/B;IAED,sBAEC;IAED,qBAEC;IAED,gGAEC;IAED,iDAAiD;IACjD,sCADY,gBAAgB,QAO3B;IAED;;OAEG;IACH,iCAFW,MAAM,QAoBhB;;CAuMF;wBAGY,GAAG,SAAsB,IAAT,SAAS,CAAC,CAAC,EAAE,OAAO,sBAAsB,EAAE,kBAAkB,GAAE;yBAG/E,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;6BA1SpD,IAAI,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,GAAG,SAAS;sCALV,eAAe;uCAEd,uCAAuC;uBAPvD,cAAc;+BAMN,aAAa;0BAFlB,aAAa"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comapeo/core",
-  "version": "4.1.1",
+  "version": "4.1.3-prerelease.0",
   "description": "Offline p2p mapping library",
   "main": "src/index.js",
   "types": "dist/index.d.ts",

package/src/discovery/local-discovery.js

@@ -15,9 +15,13 @@ import { getErrorCode } from '../lib/error.js'
 /** @typedef {{ publicKey: Buffer, secretKey: Buffer }} Keypair */
 /** @typedef {OpenedNoiseStream<net.Socket>} OpenedNetNoiseStream */
 
+/** @satisfies {import('node:net').ServerOpts | import('node:net').TcpNetConnectOpts} */
 const TCP_KEEP_ALIVE_OPTIONS = {
   keepAlive: true,
-  keepAliveInitialDelay: 10_000,
+  keepAliveInitialDelay: 30_000,
+  // Turn off Nagle's algorythm, to reduce latency
+  // https://github.com/digidem/comapeo-core/issues/1070
+  noDelay: true,
 }
 export const ERR_DUPLICATE = 'Duplicate connection'
 
@@ -108,9 +112,9 @@ export class LocalDiscovery extends TypedEmitter {
       return
     }
     const socket = net.connect({
+      ...TCP_KEEP_ALIVE_OPTIONS,
       host: address,
       port,
-      ...TCP_KEEP_ALIVE_OPTIONS,
     })
     socket.on('error', this.#handleSocketError)
     socket.once('connect', () => {

package/src/index-writer/index.js

@@ -97,16 +97,18 @@ export class IndexWriter {
       const indexer = this.#indexers.get(schemaName)
       if (!indexer) continue // Won't happen, but TS doesn't know that
       indexer.batch(docs)
-      if (this.#l.log.enabled) {
-        for (const doc of docs) {
-          this.#l.log(
-            'Indexed %s %S @ %S',
-            doc.schemaName,
-            doc.docId,
-            doc.versionId
-          )
-        }
-      }
+      // TODO: selectively turn this on when log level is 'trace' or 'debug'
+      // Otherwise this has a big performance overhead because this is all synchronous
+      // if (this.#l.log.enabled) {
+      //   for (const doc of docs) {
+      //     this.#l.log(
+      //       'Indexed %s %S @ %S',
+      //       doc.schemaName,
+      //       doc.docId,
+      //       doc.versionId
+      //     )
+      //   }
+      // }
     }
     return indexed
   }

package/src/index.js

@@ -7,15 +7,46 @@ import { kProjectReplicate } from './mapeo-project.js'
 export { plugin as CoMapeoMapsFastifyPlugin } from './fastify-plugins/maps.js'
 export { FastifyController } from './fastify-controller.js'
 export { MapeoManager } from './mapeo-manager.js'
-/** @import { MapeoProject } from './mapeo-project.js' */
 
+// Type exports
+/** @typedef {import('./mapeo-project.js').MapeoProject} MapeoProject */
+/** @typedef {import('./mapeo-project.js').EditableProjectSettings} EditableProjectSettings */
+/**
+ * @namespace IconApi
+ * @typedef {import('./icon-api.js').BitmapOpts} IconApi.BitmapOpts
+ * @typedef {import('./icon-api.js').SvgOpts} IconApi.SvgOpts
+ */
+/**
+ * @namespace BlobApi
+ * @typedef {import('./types.js').BlobId} BlobApi.BlobId
+ * @typedef {import('./blob-api.js').Metadata} BlobApi.Metadata
+ */
+// This needs to be defined in a separate comment block so that the @template definition works.
+/**
+ * @template {import('./types.js').BlobType} TBlobType
+ * @typedef {import('./types.js').BlobVariant<TBlobType>} BlobApi.BlobVariant
+ */
+/**
+ * @namespace InviteApi
+ * @typedef {import('./invite/invite-api.js').Invite} InviteApi.Invite
+ */
+/**
+ * @namespace MemberApi
+ * @typedef {import('./member-api.js').MemberInfo} MemberApi.MemberInfo
+ * @typedef {import('./roles.js').RoleId} MemberApi.RoleId
+ * @typedef {import('./roles.js').RoleIdForNewInvite} MemberApi.RoleIdForNewInvite
+ */
 /**
  * @param {MapeoProject} project
- * @param {Parameters<MapeoProject.prototype[kProjectReplicate]>} args
- * @returns {ReturnType<MapeoProject.prototype[kProjectReplicate]>}
+ * @param {(
+ *   boolean |
+ *   import('stream').Duplex |
+ *   import('streamx').Duplex
+ * )} isInitiatorOrStream
+ * @returns {import('./types.js').ReplicationStream}
  */
-export const replicateProject = (project, ...args) =>
-  project[kProjectReplicate](...args)
+export const replicateProject = (project, isInitiatorOrStream) =>
+  project[kProjectReplicate](isInitiatorOrStream)
 
 export const roles = /** @type {const} */ ({
   CREATOR_ROLE_ID,

package/src/invite/invite-state-machine.js

@@ -4,8 +4,8 @@ import { InviteResponse_Decision } from '../generated/rpc.js'
 import ensureError from 'ensure-error'
 import { TimeoutError } from '../errors.js'
 
-const RECEIVE_PROJECT_DETAILS_TIMEOUT_MS = 10_000
-const ADD_PROJECT_TIMEOUT_MS = 10_000
+const RECEIVE_PROJECT_DETAILS_TIMEOUT_MS = 45_000
+const ADD_PROJECT_TIMEOUT_MS = 45_000
 
 /** @import { StringToTaggedUnion } from '../types.js' */
 /** @import { ProjectJoinDetails } from '../generated/rpc.js' */

package/src/mapeo-manager.js

@@ -708,14 +708,14 @@ export class MapeoManager extends TypedEmitter {
    *
    * @param {MapeoProject} project
    * @param {object} [opts]
-   * @param {number} [opts.timeoutMs=5000] Timeout in milliseconds for max time
+   * @param {number} [opts.timeoutMs=300_000] Timeout in milliseconds for max time
    * to wait between sync status updates before giving up. As long as syncing is
    * happening, this will never timeout, but if more than timeoutMs passes
    * without any sync activity, then this will resolve `false` e.g. data has not
    * synced
    * @returns {Promise<boolean>}
    */
-  async #waitForInitialSync(project, { timeoutMs = 5000 } = {}) {
+  async #waitForInitialSync(project, { timeoutMs = 300_000 } = {}) {
     const [ownRole, isProjectSettingsSynced] = await Promise.all([
       project.$getOwnRole(),
       project.$hasSyncedProjectSettings(),

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

@@ -132,7 +132,9 @@ export class PeerSyncController {
     const localState = mapObject(state, (ns, nsState) => {
       return [ns, nsState.localState]
     })
-    this.#log('state %X', state)
+    // TODO: Turn this on when log level is 'trace' or 'debug'
+    // This logs _a lot_ of data, which has a performance overhead
+    // this.#log('state %X', state)
 
     // Map of which namespaces have received new data since last sync change
     const didUpdate = mapObject(state, (ns) => {