@comapeo/ipc 0.16.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Digital Democracy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,85 @@
+# @mapeo/ipc
+
+IPC wrappers for [Mapeo Core](https://github.com/digidem/mapeo-core-next). Meant to be used in contexts where there is a communication boundary between the contexts your code runs in e.g. Electron, React Native (with NodeJS Mobile), and NodeJS worker threads. The [channel messaging API](https://developer.mozilla.org/en-US/docs/Web/API/Channel_Messaging_API) is an example where this usage applies.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [API](#api)
+- [Usage](#usage)
+- [License](#license)
+
+## Installation
+
+Note that [`@mapeo/core`](https://github.com/digidem/mapeo-core-next) is a peer dependency, so you may have to install it manually depending on your package manager.
+
+```sh
+npm install @mapeo/ipc @mapeo/core
+```
+
+## API
+
+### `createMapeoServer(manager: MapeoManager, messagePort: MessagePortLike): { close: () => void }`
+
+Creates the IPC server instance. `manager` is a `@mapeo/core` `MapeoManager` instance and `messagePort` is an interface that resembles a [`MessagePort`](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort).
+
+Returns an object with a `close()` method, which removes relevant event listeners from the `messagePort`. Does not close or destroy the `messagePort`.
+
+### `createMapeoClient(messagePort: MessagePortLike, opts?: { timeout?: number }): ClientApi<MapeoManager>`
+
+Creates the IPC client instance. `messagePort` is an interface that resembles a [`MessagePort`](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort). `opts.timeout` is an optional timeout used for sending and receiving messages over the channel.
+
+Returns a client instance that reflects the interface of the `manager` provided to [`createMapeoServer`](#createmapeoservermanager-mapeomanager-messageport-messageportlike--close---void). Refer to the [`rpc-reflector` docs](https://github.com/digidem/rpc-reflector#const-clientapi--createclientchannel) for additional information about how to use this.
+
+### `closeMapeoClient(mapeoClient: ClientApi<MapeoManager>): void`
+
+Closes the IPC client instance. Does not close or destroy the `messagePort` provided to [`createMapeoClient`](#createmapeoclientmessageport-messageportlike-clientapimapeomanager).
+
+## Usage
+
+In the server:
+
+```ts
+import { MapeoManager } from '@mapeo/core'
+import { createMapeoServer } from '@mapeo/ipc'
+
+// Create Mapeo manager instance
+const manager = new MapeoManager({...})
+
+// Create the server instance
+// `messagePort` can vary based on context (e.g. a port from a MessageChannel, a NodeJS Mobile bridge channel, etc.)
+const server = createMapeoServer(manager, messagePort)
+
+// Maybe at some point later on...
+
+// Close the server
+server.close()
+```
+
+In the client:
+
+```ts
+import { createMapeoClient, closeMapeoClient } from '@mapeo/ipc'
+
+// Create the client instance
+// `messagePort` can vary based on context (e.g. a port from a MessageChannel, a NodeJS Mobile bridge channel, etc.)
+const client = createMapeoClient(messagePort)
+
+// Use the MapeoManager instance from the server via the client!
+const projectId = await client.createProject({...})
+const project = await client.getProject(projectId)
+const projects = await client.listProjects()
+
+client.on('invite-received', (invite) => {
+  // ...
+})
+
+// Maybe at some point later on...
+
+// Close the client
+closeMapeoClient(client)
+```
+
+## License
+
+[MIT](LICENSE)

package/dist/client.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @param {import('./lib/sub-channel.js').MessagePortLike} messagePort
+ * @param {object} [opts]
+ * @param {number} [opts.timeout]
+ *
+ * @returns {MapeoClientApi}
+ */
+export function createMapeoClient(messagePort: import('./lib/sub-channel.js').MessagePortLike, opts?: {
+    timeout?: number | undefined;
+} | undefined): MapeoClientApi;
+/**
+ * @param {MapeoClientApi} client client created with `createMapeoClient`
+ * @returns {Promise<void>}
+ */
+export function closeMapeoClient(client: MapeoClientApi): Promise<void>;
+export type MapeoProjectApi = import('rpc-reflector/client.js').ClientApi<import('@mapeo/core/dist/mapeo-project.js').MapeoProject>;
+export type MapeoClientApi = {
+    addListener: <U extends "local-peers">(event: U, listener: import("@mapeo/core/dist/mapeo-manager.js").MapeoManagerEvents[U]) => import("@mapeo/core").MapeoManager;
+    on: <U_1 extends "local-peers">(event: U_1, listener: import("@mapeo/core/dist/mapeo-manager.js").MapeoManagerEvents[U_1]) => import("@mapeo/core").MapeoManager;
+    once: <U_2 extends "local-peers">(event: U_2, listener: import("@mapeo/core/dist/mapeo-manager.js").MapeoManagerEvents[U_2]) => import("@mapeo/core").MapeoManager;
+    removeListener: <U_3 extends "local-peers">(event: U_3, listener: import("@mapeo/core/dist/mapeo-manager.js").MapeoManagerEvents[U_3]) => import("@mapeo/core").MapeoManager;
+    off: <U_4 extends "local-peers">(event: U_4, listener: import("@mapeo/core/dist/mapeo-manager.js").MapeoManagerEvents[U_4]) => import("@mapeo/core").MapeoManager;
+    removeAllListeners: (event?: "local-peers" | undefined) => import("@mapeo/core").MapeoManager;
+    listeners: <U_5 extends "local-peers">(type: U_5) => import("@mapeo/core/dist/mapeo-manager.js").MapeoManagerEvents[U_5][];
+    rawListeners: <U_6 extends "local-peers">(type: U_6) => import("@mapeo/core/dist/mapeo-manager.js").MapeoManagerEvents[U_6][];
+    emit: <U_7 extends "local-peers">(event: U_7, ...args: Parameters<import("@mapeo/core/dist/mapeo-manager.js").MapeoManagerEvents[U_7]>) => boolean;
+    listenerCount: (type: "local-peers") => number;
+    eventNames: <U_8 extends "local-peers">() => U_8[];
+    readonly deviceId: () => Promise<string>;
+    createProject: ({ name, configPath }?: {
+        name?: string | undefined;
+        configPath?: string | undefined;
+    } | undefined) => Promise<string>;
+    listProjects: () => Promise<(Pick<{
+        schemaName: "projectSettings";
+        name?: string | undefined;
+        defaultPresets?: {
+            point: string[];
+            area: string[];
+            vertex: string[];
+            line: string[];
+            relation: string[];
+        } | undefined;
+        configMetadata?: {
+            name: string;
+            buildDate: string;
+            importDate: string;
+            fileVersion: string;
+        } | undefined;
+    }, "name"> & {
+        projectId: string;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+    })[]>;
+    addProject: ({ projectKey, encryptionKeys, projectName }: Pick<import("@mapeo/core/dist/generated/rpc.js").ProjectJoinDetails, "projectKey" | "encryptionKeys"> & {
+        projectName: string;
+    }, { waitForSync }?: {
+        waitForSync?: boolean | undefined;
+    } | undefined) => Promise<string>;
+    setDeviceInfo: <T extends import("type-fest").IsEqual<import("@mapeo/core/dist/schema/client.js").DeviceInfoParam & {
+        deviceType?: "device_type_unspecified" | "mobile" | "tablet" | "desktop" | "UNRECOGNIZED" | undefined;
+    }, T> extends true ? import("@mapeo/core/dist/schema/client.js").DeviceInfoParam & {
+        deviceType?: "device_type_unspecified" | "mobile" | "tablet" | "desktop" | "UNRECOGNIZED" | undefined;
+    } : import("type-fest/source/exact.js").ExactObject<import("@mapeo/core/dist/schema/client.js").DeviceInfoParam & {
+        deviceType?: "device_type_unspecified" | "mobile" | "tablet" | "desktop" | "UNRECOGNIZED" | undefined;
+    }, T>>(deviceInfo: T) => Promise<void>;
+    getDeviceInfo: () => Promise<{
+        deviceId: string;
+        deviceType: "device_type_unspecified" | "mobile" | "tablet" | "desktop" | "selfHostedServer" | "UNRECOGNIZED";
+    } & Partial<import("@mapeo/core/dist/schema/client.js").DeviceInfoParam>>;
+    readonly invite: import("rpc-reflector/lib/types.js").ClientApi<import("@mapeo/core/dist/invite-api.js").InviteApi> & (() => Promise<import("@mapeo/core/dist/invite-api.js").InviteApi>);
+    startLocalPeerDiscoveryServer: () => Promise<{
+        name: string;
+        port: number;
+    }>;
+    stopLocalPeerDiscoveryServer: (opts?: {
+        force?: boolean | undefined;
+        timeout?: number | undefined;
+    } | undefined) => Promise<void>;
+    connectLocalPeer: (args_0: {
+        address: string;
+        port: number;
+        name: string;
+    }) => Promise<void>;
+    listLocalPeers: () => Promise<import("@mapeo/core/dist/mapeo-manager.js").PublicPeerInfo[]>;
+    onBackgrounded: () => Promise<void>;
+    onForegrounded: () => Promise<void>;
+    leaveProject: (projectPublicId: string) => Promise<void>;
+    getMapStyleJsonUrl: () => Promise<string>;
+    getProject: (projectPublicId: string) => Promise<MapeoProjectApi>;
+};

package/dist/client.js

@@ -0,0 +1,90 @@
+import { createClient } from 'rpc-reflector';
+import pDefer from 'p-defer';
+import { MANAGER_CHANNEL_ID, MAPEO_RPC_ID, SubChannel, } from './lib/sub-channel.js';
+/**
+ * @typedef {import('rpc-reflector/client.js').ClientApi<import('@mapeo/core/dist/mapeo-project.js').MapeoProject>} MapeoProjectApi
+ */
+/**
+ * @typedef {import('rpc-reflector/client.js').ClientApi<
+ *   Omit<
+ *     import('@mapeo/core').MapeoManager,
+ *     'getProject'
+ *   > & {
+ *     getProject: (projectPublicId: string) => Promise<MapeoProjectApi>
+ *   }
+ * >} MapeoClientApi */
+const CLOSE = Symbol('close');
+/**
+ * @param {import('./lib/sub-channel.js').MessagePortLike} messagePort
+ * @param {object} [opts]
+ * @param {number} [opts.timeout]
+ *
+ * @returns {MapeoClientApi}
+ */
+export function createMapeoClient(messagePort, opts = {}) {
+    /** @type {Map<string, Promise<import('rpc-reflector/client.js').ClientApi<import('@mapeo/core/dist/mapeo-project.js').MapeoProject>>>} */
+    const projectClientPromises = new Map();
+    const managerChannel = new SubChannel(messagePort, MANAGER_CHANNEL_ID);
+    const mapeoRpcChannel = new SubChannel(messagePort, MAPEO_RPC_ID);
+    /** @type {import('rpc-reflector').ClientApi<import('@mapeo/core').MapeoManager>} */
+    const managerClient = createClient(managerChannel, opts);
+    /** @type {import('rpc-reflector').ClientApi<import('./server.js').MapeoRpcApi>} */
+    const mapeoRpcClient = createClient(mapeoRpcChannel, opts);
+    mapeoRpcChannel.start();
+    managerChannel.start();
+    const client = new Proxy(managerClient, {
+        get(target, prop, receiver) {
+            if (prop === CLOSE) {
+                return async () => {
+                    managerChannel.close();
+                    createClient.close(managerClient);
+                    const projectClientResults = await Promise.allSettled(projectClientPromises.values());
+                    for (const result of projectClientResults) {
+                        if (result.status === 'fulfilled') {
+                            createClient.close(result.value);
+                        }
+                    }
+                };
+            }
+            if (prop === 'getProject') {
+                return createProjectClient;
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+    // TS can't know the type of the proxy, so we cast it in the function return
+    return /** @type {any} */ (client);
+    /**
+     * @param {string} projectPublicId
+     * @returns {Promise<MapeoProjectApi>}
+     */
+    async function createProjectClient(projectPublicId) {
+        const existingClientPromise = projectClientPromises.get(projectPublicId);
+        if (existingClientPromise)
+            return existingClientPromise;
+        /** @type {import('p-defer').DeferredPromise<import('rpc-reflector/client.js').ClientApi<import('@mapeo/core/dist/mapeo-project.js').MapeoProject>>}*/
+        const deferred = pDefer();
+        projectClientPromises.set(projectPublicId, deferred.promise);
+        try {
+            await mapeoRpcClient.assertProjectExists(projectPublicId);
+        }
+        catch (err) {
+            deferred.reject(err);
+            throw err;
+        }
+        const projectChannel = new SubChannel(messagePort, projectPublicId);
+        /** @type {import('rpc-reflector').ClientApi<import('@mapeo/core/dist/mapeo-project.js').MapeoProject>} */
+        const projectClient = createClient(projectChannel, opts);
+        projectChannel.start();
+        deferred.resolve(projectClient);
+        return projectClient;
+    }
+}
+/**
+ * @param {MapeoClientApi} client client created with `createMapeoClient`
+ * @returns {Promise<void>}
+ */
+export async function closeMapeoClient(client) {
+    // @ts-expect-error
+    return client[CLOSE]();
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { createMapeoServer } from "./server.js";
+export type MapeoClientApi = import('./client.js').MapeoClientApi;
+export type MapeoProjectApi = import('./client.js').MapeoProjectApi;
+export { createMapeoClient, closeMapeoClient } from "./client.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { createMapeoClient, closeMapeoClient } from './client.js';
+export { createMapeoServer } from './server.js';
+/** @typedef {import('./client.js').MapeoClientApi} MapeoClientApi */
+/** @typedef {import('./client.js').MapeoProjectApi} MapeoProjectApi */

package/dist/lib/sub-channel.d.ts

@@ -0,0 +1,38 @@
+export const MAPEO_RPC_ID: "@@mapeo-rpc";
+export const MANAGER_CHANNEL_ID: "@@manager";
+/**
+ * @typedef {Object} Events
+ * @property {(message: any) => void} message
+ */
+/**
+ * Node's built-in types for MessagePort are misleading so we opt for this limited type definition
+ * that fits our usage and works in both Node and browser contexts
+ * @typedef {Pick<EventTarget, 'addEventListener' | 'removeEventListener'> & { postMessage: (message: any) => void }} MessagePortLike
+ */
+export class SubChannel extends EventEmitter<string | symbol, any> {
+    /**
+     * @param {MessagePortLike} messagePort Parent channel to add namespace to
+     * @param {string} id ID for the subchannel
+     */
+    constructor(messagePort: MessagePortLike, id: string);
+    get id(): string;
+    /**
+     * Send messages with the subchannel's ID
+     * @param {any} message
+     */
+    postMessage(message: any): void;
+    start(): void;
+    close(): void;
+    #private;
+}
+export type Events = {
+    message: (message: any) => void;
+};
+/**
+ * Node's built-in types for MessagePort are misleading so we opt for this limited type definition
+ * that fits our usage and works in both Node and browser contexts
+ */
+export type MessagePortLike = Pick<EventTarget, "addEventListener" | "removeEventListener"> & {
+    postMessage: (message: any) => void;
+};
+import { EventEmitter } from 'eventemitter3';

package/dist/lib/sub-channel.js

@@ -0,0 +1,101 @@
+import { EventEmitter } from 'eventemitter3';
+import { extractMessageEventData } from './utils.js';
+// Ideally unique ID used for identifying "global" Mapeo IPC messages
+export const MAPEO_RPC_ID = '@@mapeo-rpc';
+export const MANAGER_CHANNEL_ID = '@@manager';
+/**
+ * @typedef {Object} Events
+ * @property {(message: any) => void} message
+ */
+/**
+ * Node's built-in types for MessagePort are misleading so we opt for this limited type definition
+ * that fits our usage and works in both Node and browser contexts
+ * @typedef {Pick<EventTarget, 'addEventListener' | 'removeEventListener'> & { postMessage: (message: any) => void }} MessagePortLike
+ */
+export class SubChannel extends EventEmitter {
+    #id;
+    #messagePort;
+    /** @type {'idle' | 'active' | 'closed'} */
+    #state;
+    /** @type {Array<{id: string, message: any}>} */
+    #queued;
+    #handleMessageEvent;
+    /**
+     * @param {MessagePortLike} messagePort Parent channel to add namespace to
+     * @param {string} id ID for the subchannel
+     */
+    constructor(messagePort, id) {
+        super();
+        this.#id = id;
+        this.#messagePort = messagePort;
+        this.#state = 'idle';
+        this.#queued = [];
+        /**
+         * @param {unknown} event
+         */
+        this.#handleMessageEvent = (event) => {
+            const value = extractMessageEventData(event);
+            if (!isRelevantEvent(value))
+                return;
+            const { id, message } = value;
+            if (this.#id !== id)
+                return;
+            switch (this.#state) {
+                case 'idle': {
+                    this.#queued.push(value);
+                    break;
+                }
+                case 'active': {
+                    this.emit('message', message);
+                    break;
+                }
+                case 'closed': {
+                    // no-op if closed (the event listener should be removed anyway)
+                    break;
+                }
+            }
+        };
+        this.#messagePort.addEventListener('message', this.#handleMessageEvent);
+    }
+    get id() {
+        return this.#id;
+    }
+    /**
+     * Send messages with the subchannel's ID
+     * @param {any} message
+     */
+    postMessage(message) {
+        this.#messagePort.postMessage({ id: this.#id, message });
+    }
+    start() {
+        if (this.#state !== 'idle')
+            return;
+        this.#state = 'active';
+        /** @type {{id: string, message: any} | undefined} */
+        let event;
+        while ((event = this.#queued.shift())) {
+            this.#handleMessageEvent(event);
+        }
+    }
+    close() {
+        if (this.#state === 'closed')
+            return;
+        this.#state = 'closed';
+        this.#queued = [];
+        // Node types are incorrect (as of v14, Node's MessagePort should also extend [EventTarget](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget))
+        this.#messagePort.removeEventListener('message', this.#handleMessageEvent);
+    }
+}
+/**
+ * @param {unknown} event
+ * @returns {event is { id: string, message: any }}
+ */
+function isRelevantEvent(event) {
+    if (!event || typeof event !== 'object')
+        return false;
+    if (!('id' in event && 'message' in event))
+        return false;
+    if (typeof event.id !== 'string')
+        return false;
+    return true;
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @template T
+ * @param {T} event
+ * @returns {T extends { data: infer D } ? D : T}
+ */
+export function extractMessageEventData<T>(event: T): T extends {
+    data: infer D;
+} ? D : T;

package/dist/lib/utils.js

@@ -0,0 +1,14 @@
+/**
+ * @template T
+ * @param {T} event
+ * @returns {T extends { data: infer D } ? D : T}
+ */
+export function extractMessageEventData(event) {
+    // In browser-like contexts, the actual payload will live in the `event.data` field
+    // https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/message_event#event_properties
+    if (event && typeof event === 'object' && 'data' in event) {
+        return /** @type {any} */ (event.data);
+    }
+    // In Node the event is the actual data that was sent
+    return /** @type {any} */ (event);
+}

package/dist/server.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @param {import('@mapeo/core').MapeoManager} manager
+ * @param {import('./lib/sub-channel.js').MessagePortLike} messagePort
+ */
+export function createMapeoServer(manager: import('@mapeo/core').MapeoManager, messagePort: import('./lib/sub-channel.js').MessagePortLike): {
+    close(): void;
+};
+export class MapeoRpcApi {
+    /**
+     * @param {import('@mapeo/core').MapeoManager} manager
+     */
+    constructor(manager: import('@mapeo/core').MapeoManager);
+    /**
+     * @param {string} projectId
+     * @returns {Promise<boolean>}
+     */
+    assertProjectExists(projectId: string): Promise<boolean>;
+    #private;
+}

package/dist/server.js

@@ -0,0 +1,86 @@
+import { createServer } from 'rpc-reflector';
+import { MANAGER_CHANNEL_ID, MAPEO_RPC_ID, SubChannel, } from './lib/sub-channel.js';
+import { extractMessageEventData } from './lib/utils.js';
+/**
+ * @param {import('@mapeo/core').MapeoManager} manager
+ * @param {import('./lib/sub-channel.js').MessagePortLike} messagePort
+ */
+export function createMapeoServer(manager, messagePort) {
+    /** @type {Map<string, { close: () => void }>} */
+    const existingProjectServers = new Map();
+    /** @type {Map<string, SubChannel>} */
+    const existingProjectChannels = new Map();
+    const mapeoRpcApi = new MapeoRpcApi(manager);
+    const managerChannel = new SubChannel(messagePort, MANAGER_CHANNEL_ID);
+    const mapeoRpcChannel = new SubChannel(messagePort, MAPEO_RPC_ID);
+    const managerServer = createServer(manager, managerChannel);
+    const mapeoRpcServer = createServer(mapeoRpcApi, mapeoRpcChannel);
+    managerChannel.start();
+    mapeoRpcChannel.start();
+    messagePort.addEventListener('message', handleMessage);
+    return {
+        close() {
+            messagePort.removeEventListener('message', handleMessage);
+            for (const [id, server] of existingProjectServers.entries()) {
+                server.close();
+                const channel = existingProjectChannels.get(id);
+                if (channel) {
+                    channel.close();
+                    existingProjectChannels.delete(id);
+                }
+                existingProjectServers.delete(id);
+            }
+            managerServer.close();
+            managerChannel.close();
+            mapeoRpcServer.close();
+            mapeoRpcChannel.close();
+        },
+    };
+    /**
+     * @param {unknown} payload
+     */
+    async function handleMessage(payload) {
+        const data = extractMessageEventData(payload);
+        if (!data || typeof data !== 'object' || !('message' in data))
+            return;
+        const id = 'id' in data && typeof data.id === 'string' ? data.id : null;
+        if (!id || id === MANAGER_CHANNEL_ID || id === MAPEO_RPC_ID)
+            return;
+        if (existingProjectChannels.has(id))
+            return;
+        const projectChannel = new SubChannel(messagePort, id);
+        existingProjectChannels.set(id, projectChannel);
+        let project;
+        try {
+            project = await manager.getProject(id);
+        }
+        catch (err) {
+            // TODO: how to respond to client so that method errors?
+            projectChannel.close();
+            existingProjectChannels.delete(id);
+            existingProjectServers.delete(id);
+            return;
+        }
+        const { close } = createServer(project, projectChannel);
+        existingProjectServers.set(id, { close });
+        projectChannel.emit('message', data.message);
+        projectChannel.start();
+    }
+}
+export class MapeoRpcApi {
+    #manager;
+    /**
+     * @param {import('@mapeo/core').MapeoManager} manager
+     */
+    constructor(manager) {
+        this.#manager = manager;
+    }
+    /**
+     * @param {string} projectId
+     * @returns {Promise<boolean>}
+     */
+    async assertProjectExists(projectId) {
+        const project = await this.#manager.getProject(projectId);
+        return !!project;
+    }
+}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@comapeo/ipc",
+  "version": "0.16.0",
+  "description": "IPC wrappers for Mapeo Core",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "engines": {
+    "node": ">=18.17.1"
+  },
+  "scripts": {
+    "format": "prettier **/*.{js,md} --write",
+    "lint": "eslint . --cache",
+    "types": "tsc -p tsconfig.json",
+    "test:unit": "node --test tests/*.js",
+    "test": "npm-run-all lint types test:unit",
+    "bench": "node bench/bench.js",
+    "build": "tsc -p tsconfig.npm.json",
+    "prepack": "npm run build",
+    "prepare": "husky install",
+    "release": "standard-version"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/digidem/mapeo-ipc.git"
+  },
+  "keywords": [
+    "mapeo",
+    "ipc"
+  ],
+  "author": {
+    "name": "Andrew Chou"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/digidem/mapeo-ipc/issues"
+  },
+  "homepage": "https://github.com/digidem/mapeo-ipc#readme",
+  "dependencies": {
+    "eventemitter3": "^5.0.1",
+    "p-defer": "^4.0.0",
+    "rpc-reflector": "^1.3.11"
+  },
+  "peerDependencies": {
+    "@mapeo/core": "9.0.0-alpha.24"
+  },
+  "devDependencies": {
+    "@digidem/types": "^2.1.0",
+    "@mapeo/crypto": "^1.0.0-alpha.8",
+    "@types/nanobench": "^3.0.0",
+    "@types/node": "^20.7.1",
+    "@types/tmp": "^0.2.6",
+    "eslint": "^8.50.0",
+    "fastify": "^4.26.2",
+    "husky": "^8.0.0",
+    "lint-staged": "^14.0.1",
+    "nanobench": "^3.0.0",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^3.0.3",
+    "random-access-memory": "^6.2.0",
+    "standard-version": "^9.5.0",
+    "tmp": "^0.2.3",
+    "typescript": "^5.2.2"
+  },
+  "prettier": {
+    "semi": false,
+    "singleQuote": true
+  },
+  "eslintConfig": {
+    "env": {
+      "commonjs": true,
+      "es2021": true,
+      "node": true
+    },
+    "extends": "eslint:recommended",
+    "parserOptions": {
+      "ecmaVersion": "latest",
+      "sourceType": "module"
+    }
+  },
+  "lint-staged": {
+    "*.{js,md}": "prettier . --write"
+  }
+}