@comapeo/core 2.3.2 → 3.0.0

package/dist/errors.d.ts

@@ -6,4 +6,20 @@ export function nullIfNotFound(err: unknown): null;
 export class NotFoundError extends Error {
     constructor(message?: string);
 }
+export class AlreadyJoinedError extends Error {
+    /** @param {string} [message] */
+    constructor(message?: string | undefined);
+}
+export class InviteSendError extends Error {
+    /** @param {string} [message] */
+    constructor(message?: string | undefined);
+}
+export class InviteAbortedError extends Error {
+    /** @param {string} [message] */
+    constructor(message?: string | undefined);
+}
+export class TimeoutError extends Error {
+    /** @param {string} [message] */
+    constructor(message?: string | undefined);
+}
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,oCAHW,OAAO,GACL,IAAI,CAKhB;AAbD;IACE,8BAEC;CACF"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.js"],"names":[],"mappings":"AAuCA;;;GAGG;AACH,oCAHW,OAAO,GACL,IAAI,CAKhB;AA9CD;IACE,8BAGC;CACF;AAED;IACE,gCAAgC;IAChC,0CAGC;CACF;AAED;IACE,gCAAgC;IAChC,0CAGC;CACF;AAED;IACE,gCAAgC;IAChC,0CAGC;CACF;AAED;IACE,gCAAgC;IAChC,0CAGC;CACF"}

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

@@ -0,0 +1,112 @@
+/** @import { MapBuffers } from '../types.js' */
+/**
+ * @import {
+ *   Invite as InviteRpcMessage,
+ *   InviteCancel,
+ *   ProjectJoinDetails
+ * } from '../generated/rpc.js'
+ */
+/**
+ * @internal
+ * @typedef {InviteRpcMessage & { receivedAt: number }} InviteInternal
+ */
+/** @typedef {ExtractStateString<import('xstate').StateValueFrom<typeof inviteStateMachine>>} InviteState */
+/** @typedef {import('type-fest').Simplify<MapBuffers<InviteInternal> & { invitorDeviceId: string } & ({ state: Exclude<InviteState, 'error'> } | { state: 'error', error: Error })>} Invite */
+/**
+ * @typedef {import('xstate').ActorRefFrom<typeof inviteStateMachine>} invite.actor
+ */
+/**
+ * @typedef {Object} InviteApiEvents
+ * @property {(invite: Invite) => void} invite-received
+ * @property {(invite: Invite) => void} invite-updated
+ */
+/**
+ * @typedef {(projectDetails: Pick<ProjectJoinDetails, 'projectKey' | 'encryptionKeys'> & { projectName: string }) => Promise<string>} AddProjectQuery
+ */
+/**
+ * @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 {AddProjectQuery} 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: AddProjectQuery;
+        };
+        logger?: Logger | undefined;
+    });
+    rpc: import("../local-peers.js").LocalPeers;
+    /**
+     * Get all invites (in all)
+     *
+     * @returns {Array<Invite>}
+     */
+    getMany(): Array<Invite>;
+    /**
+     * Get an invite by inviteId
+     *
+     * @param {string} inviteIdString
+     * @returns {Invite}
+     */
+    getById(inviteIdString: string): 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 ExtractStateString<T extends import("xstate").StateValue> = T extends string ? T : T extends import("xstate").StateValueMap ? keyof T : never;
+export type InviteInternal = InviteRpcMessage & {
+    receivedAt: number;
+};
+export type InviteState = ExtractStateString<import("xstate").StateValueFrom<typeof inviteStateMachine>>;
+export type Invite = import("type-fest").Simplify<MapBuffers<InviteInternal> & {
+    invitorDeviceId: string;
+} & ({
+    state: Exclude<InviteState, "error">;
+} | {
+    state: "error";
+    error: Error;
+})>;
+export namespace invite {
+    type actor = import("xstate").ActorRefFrom<typeof inviteStateMachine>;
+}
+export type InviteApiEvents = {
+    "invite-received": (invite: Invite) => void;
+    "invite-updated": (invite: Invite) => void;
+};
+export type AddProjectQuery = (projectDetails: Pick<ProjectJoinDetails, "projectKey" | "encryptionKeys"> & {
+    projectName: string;
+}) => Promise<string>;
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { Logger } from '../logger.js';
+import type { Invite as InviteRpcMessage } from '../generated/rpc.js';
+import { inviteStateMachine } from './invite-state-machine.js';
+import type { MapBuffers } from '../types.js';
+import type { ProjectJoinDetails } from '../generated/rpc.js';
+//# sourceMappingURL=invite-api.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"invite-api.d.ts","sourceRoot":"","sources":["../../src/invite/invite-api.js"],"names":[],"mappings":"AAcA,gDAAgD;AAChD;;;;;;GAMG;AAQH;;;GAGG;AACH,4GAA4G;AAC5G,+LAA+L;AAE/L;;GAEG;AAEH;;;;GAIG;AAEH;;GAEG;AAEH;;GAEG;AACH;IAOE;;;;;;;OAOG;IACH,sCANG;QAAwD,GAAG,EAAnD,OAAO,mBAAmB,EAAE,UAAU;QACtB,OAAO,EAC/B;YAAwG,oBAAoB,EAApH,CAAC,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,SAAS,GAAG;gBAAE,eAAe,EAAE,MAAM,CAAA;aAAE;YAC7C,UAAU,EAA3C,eAAe;SACvB;QAAyB,MAAM;KAAC,EAkClC;IA3BC,4CAAc;IA0JhB;;;;OAIG;IACH,WAFa,KAAK,CAAC,MAAM,CAAC,CAUzB;IAED;;;;;OAKG;IACH,wBAHW,MAAM,GACJ,MAAM,CASlB;IAED;;;;;;;;;;;;OAYG;IACH,qCAHW,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GACtB,OAAO,CAAC,MAAM,CAAC,CAgC3B;IAED;;;OAGG;IACH,qCAHW,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GACtB,IAAI,CAWhB;;CACF;+BAmD0C,CAAC,SAA/B,OAAQ,QAAQ,EAAE,UAAW,IAC7B,CAAC,SAAS,MAAM,GAAG,CAAC,GAAG,CAAC,SAAS,OAAO,QAAQ,EAAE,aAAa,GAAG,MAAM,CAAC,GAAG,KAAK;6BAjVjF,gBAAgB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE;0BAExC,kBAAkB,CAAC,OAAO,QAAQ,EAAE,cAAc,CAAC,OAAO,kBAAkB,CAAC,CAAC;qBAC9E,OAAO,WAAW,EAAE,QAAQ,CAAC,WAAW,cAAc,CAAC,GAAG;IAAE,eAAe,EAAE,MAAM,CAAA;CAAE,GAAG,CAAC;IAAE,KAAK,EAAE,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC,CAAC;;iBAGvK,OAAO,QAAQ,EAAE,YAAY,CAAC,OAAO,kBAAkB,CAAC;;;uBAKvD,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI;sBACxB,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI;;8BAIzB,CAAC,cAAc,EAAE,IAAI,CAAC,kBAAkB,EAAE,YAAY,GAAG,gBAAgB,CAAC,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,KAAK,OAAO,CAAC,MAAM,CAAC;6BA/CxG,oBAAoB;uBAK1B,cAAc;gDAe3B,qBAAqB;mCAbI,2BAA2B;gCAO9B,aAAa;wCAMnC,qBAAqB"}

package/dist/invite/invite-state-machine.d.ts

@@ -0,0 +1,510 @@
+/** @import { StringToTaggedUnion } from '../types.js' */
+/** @import { ProjectJoinDetails } from '../generated/rpc.js' */
+/**
+ * @internal
+ * @typedef {object} Context
+ * @property {null | Error} error
+ * @property {null | string} projectPublicId
+ */
+/**
+ * @typedef {object} MachineSetupTypes
+ * @property {Context} context
+ * @property {{ projectPublicId: string | null }} output
+ * @property {StringToTaggedUnion<'ACCEPT_INVITE' | 'CANCEL_INVITE' | 'REJECT_INVITE' | 'ALREADY_IN_PROJECT' | 'ADDED_PROJECT' | 'PEER_DISCONNECTED'> | ({ type: 'RECEIVE_PROJECT_DETAILS' } & ProjectJoinDetails)} events
+ */
+export const inviteStateMachine: import("xstate").StateMachine<Context, {
+    type: "ACCEPT_INVITE";
+} | {
+    type: "CANCEL_INVITE";
+} | {
+    type: "REJECT_INVITE";
+} | {
+    type: "ALREADY_IN_PROJECT";
+} | {
+    type: "ADDED_PROJECT";
+} | {
+    type: "PEER_DISCONNECTED";
+} | ({
+    type: "RECEIVE_PROJECT_DETAILS";
+} & ProjectJoinDetails), {
+    [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<void, {
+        decision: InviteResponse_Decision;
+    }, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<string, ProjectJoinDetails, import("xstate").EventObject>> | undefined;
+}, import("xstate").Values<{
+    sendInviteResponse: {
+        src: "sendInviteResponse";
+        logic: import("xstate").PromiseActorLogic<void, {
+            decision: InviteResponse_Decision;
+        }, import("xstate").EventObject>;
+        id: string | undefined;
+    };
+    addProject: {
+        src: "addProject";
+        logic: import("xstate").PromiseActorLogic<string, ProjectJoinDetails, import("xstate").EventObject>;
+        id: string | undefined;
+    };
+}>, never, {
+    type: "isNotAlreadyJoiningOrInProject";
+    params: unknown;
+}, "receiveTimeout" | "addProjectTimeout", "error" | "rejected" | "pending" | "canceled" | "respondedAlready" | "joined" | {
+    responding: "default" | "accept" | "reject" | "already";
+} | {
+    joining: "awaitingDetails" | "addingProject";
+}, string, import("xstate").NonReducibleUnknown, {
+    projectPublicId: string | null;
+}, import("xstate").EventObject, import("xstate").MetaObject, {
+    readonly id: "invite";
+    readonly context: {
+        readonly error: null;
+        readonly projectPublicId: null;
+    };
+    readonly initial: "pending";
+    readonly states: {
+        readonly pending: {
+            readonly description: "Pending invite awaiting response";
+            readonly on: {
+                readonly CANCEL_INVITE: {
+                    readonly target: "canceled";
+                };
+                readonly ACCEPT_INVITE: readonly [{
+                    readonly target: "responding.accept";
+                    readonly guard: {
+                        readonly type: "isNotAlreadyJoiningOrInProject";
+                    };
+                }, {
+                    readonly actions: import("xstate").ActionFunction<Context, {
+                        type: "ACCEPT_INVITE";
+                    }, {
+                        type: "ACCEPT_INVITE";
+                    } | {
+                        type: "CANCEL_INVITE";
+                    } | {
+                        type: "REJECT_INVITE";
+                    } | {
+                        type: "ALREADY_IN_PROJECT";
+                    } | {
+                        type: "ADDED_PROJECT";
+                    } | {
+                        type: "PEER_DISCONNECTED";
+                    } | ({
+                        type: "RECEIVE_PROJECT_DETAILS";
+                    } & ProjectJoinDetails), undefined, never, never, never, "receiveTimeout" | "addProjectTimeout", never>;
+                }];
+                readonly ALREADY_IN_PROJECT: {
+                    readonly target: "responding.already";
+                };
+                readonly REJECT_INVITE: {
+                    readonly target: "responding.reject";
+                };
+            };
+        };
+        readonly responding: {
+            readonly description: "Responding to invite";
+            readonly initial: "default";
+            readonly on: {
+                readonly CANCEL_INVITE: {
+                    readonly target: "#invite.canceled";
+                };
+            };
+            readonly states: {
+                readonly default: {
+                    readonly always: {
+                        readonly target: "#invite.error";
+                        readonly actions: import("xstate").ActionFunction<Context, {
+                            type: "ACCEPT_INVITE";
+                        } | {
+                            type: "CANCEL_INVITE";
+                        } | {
+                            type: "REJECT_INVITE";
+                        } | {
+                            type: "ALREADY_IN_PROJECT";
+                        } | {
+                            type: "ADDED_PROJECT";
+                        } | {
+                            type: "PEER_DISCONNECTED";
+                        } | ({
+                            type: "RECEIVE_PROJECT_DETAILS";
+                        } & ProjectJoinDetails), {
+                            type: "ACCEPT_INVITE";
+                        } | {
+                            type: "CANCEL_INVITE";
+                        } | {
+                            type: "REJECT_INVITE";
+                        } | {
+                            type: "ALREADY_IN_PROJECT";
+                        } | {
+                            type: "ADDED_PROJECT";
+                        } | {
+                            type: "PEER_DISCONNECTED";
+                        } | ({
+                            type: "RECEIVE_PROJECT_DETAILS";
+                        } & ProjectJoinDetails), undefined, import("xstate").Values<{
+                            sendInviteResponse: {
+                                src: "sendInviteResponse";
+                                logic: import("xstate").PromiseActorLogic<void, {
+                                    decision: InviteResponse_Decision;
+                                }, import("xstate").EventObject>;
+                                id: string | undefined;
+                            };
+                            addProject: {
+                                src: "addProject";
+                                logic: import("xstate").PromiseActorLogic<string, ProjectJoinDetails, import("xstate").EventObject>;
+                                id: string | undefined;
+                            };
+                        }>, never, never, never, never>;
+                    };
+                };
+                readonly accept: {
+                    readonly description: "Sending accept response";
+                    readonly invoke: {
+                        readonly src: "sendInviteResponse";
+                        readonly input: {
+                            readonly decision: "ACCEPT";
+                        };
+                        readonly onDone: "#invite.joining";
+                        readonly onError: "#invite.error";
+                    };
+                    readonly on: {
+                        readonly RECEIVE_PROJECT_DETAILS: {
+                            readonly target: "#invite.joining.addingProject";
+                        };
+                    };
+                };
+                readonly reject: {
+                    readonly description: "Sending reject response";
+                    readonly invoke: {
+                        readonly src: "sendInviteResponse";
+                        readonly input: {
+                            readonly decision: "REJECT";
+                        };
+                        readonly onDone: "#invite.rejected";
+                        readonly onError: "#invite.error";
+                    };
+                };
+                readonly already: {
+                    readonly description: "Sending already response";
+                    readonly invoke: {
+                        readonly src: "sendInviteResponse";
+                        readonly input: {
+                            readonly decision: "ALREADY";
+                        };
+                        readonly onDone: "#invite.respondedAlready";
+                        readonly onError: "#invite.error";
+                    };
+                };
+            };
+        };
+        readonly joining: {
+            readonly initial: "awaitingDetails";
+            readonly description: "Joining project from invite";
+            readonly states: {
+                readonly awaitingDetails: {
+                    readonly description: "Waiting for project details";
+                    readonly on: {
+                        readonly RECEIVE_PROJECT_DETAILS: {
+                            readonly target: "addingProject";
+                        };
+                        readonly CANCEL_INVITE: {
+                            readonly target: "#invite.canceled";
+                        };
+                    };
+                    readonly after: {
+                        readonly receiveTimeout: {
+                            readonly target: "#invite.error";
+                            readonly actions: import("xstate").ActionFunction<Context, {
+                                type: "ACCEPT_INVITE";
+                            } | {
+                                type: "CANCEL_INVITE";
+                            } | {
+                                type: "REJECT_INVITE";
+                            } | {
+                                type: "ALREADY_IN_PROJECT";
+                            } | {
+                                type: "ADDED_PROJECT";
+                            } | {
+                                type: "PEER_DISCONNECTED";
+                            } | ({
+                                type: "RECEIVE_PROJECT_DETAILS";
+                            } & ProjectJoinDetails), {
+                                type: "ACCEPT_INVITE";
+                            } | {
+                                type: "CANCEL_INVITE";
+                            } | {
+                                type: "REJECT_INVITE";
+                            } | {
+                                type: "ALREADY_IN_PROJECT";
+                            } | {
+                                type: "ADDED_PROJECT";
+                            } | {
+                                type: "PEER_DISCONNECTED";
+                            } | ({
+                                type: "RECEIVE_PROJECT_DETAILS";
+                            } & ProjectJoinDetails), undefined, import("xstate").Values<{
+                                sendInviteResponse: {
+                                    src: "sendInviteResponse";
+                                    logic: import("xstate").PromiseActorLogic<void, {
+                                        decision: InviteResponse_Decision;
+                                    }, import("xstate").EventObject>;
+                                    id: string | undefined;
+                                };
+                                addProject: {
+                                    src: "addProject";
+                                    logic: import("xstate").PromiseActorLogic<string, ProjectJoinDetails, import("xstate").EventObject>;
+                                    id: string | undefined;
+                                };
+                            }>, never, never, never, never>;
+                        };
+                    };
+                };
+                readonly addingProject: {
+                    readonly description: "Adding project from invite";
+                    readonly invoke: {
+                        readonly src: "addProject";
+                        readonly input: ({ event }: {
+                            context: Context;
+                            event: {
+                                type: "ACCEPT_INVITE";
+                            } | {
+                                type: "CANCEL_INVITE";
+                            } | {
+                                type: "REJECT_INVITE";
+                            } | {
+                                type: "ALREADY_IN_PROJECT";
+                            } | {
+                                type: "ADDED_PROJECT";
+                            } | {
+                                type: "PEER_DISCONNECTED";
+                            } | ({
+                                type: "RECEIVE_PROJECT_DETAILS";
+                            } & ProjectJoinDetails);
+                            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<Context, {
+                                type: "ACCEPT_INVITE";
+                            } | {
+                                type: "CANCEL_INVITE";
+                            } | {
+                                type: "REJECT_INVITE";
+                            } | {
+                                type: "ALREADY_IN_PROJECT";
+                            } | {
+                                type: "ADDED_PROJECT";
+                            } | {
+                                type: "PEER_DISCONNECTED";
+                            } | ({
+                                type: "RECEIVE_PROJECT_DETAILS";
+                            } & ProjectJoinDetails), Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
+                                type: "ACCEPT_INVITE";
+                            } | {
+                                type: "CANCEL_INVITE";
+                            } | {
+                                type: "REJECT_INVITE";
+                            } | {
+                                type: "ALREADY_IN_PROJECT";
+                            } | {
+                                type: "ADDED_PROJECT";
+                            } | {
+                                type: "PEER_DISCONNECTED";
+                            } | ({
+                                type: "RECEIVE_PROJECT_DETAILS";
+                            } & ProjectJoinDetails), import("xstate").AnyEventObject>;
+                        }) => Omit<{
+                            type: "RECEIVE_PROJECT_DETAILS";
+                        } & ProjectJoinDetails, "type">;
+                        readonly onDone: {
+                            readonly target: "#invite.joined";
+                            readonly actions: import("xstate").ActionFunction<Context, import("xstate").DoneActorEvent<string, string>, {
+                                type: "ACCEPT_INVITE";
+                            } | {
+                                type: "CANCEL_INVITE";
+                            } | {
+                                type: "REJECT_INVITE";
+                            } | {
+                                type: "ALREADY_IN_PROJECT";
+                            } | {
+                                type: "ADDED_PROJECT";
+                            } | {
+                                type: "PEER_DISCONNECTED";
+                            } | ({
+                                type: "RECEIVE_PROJECT_DETAILS";
+                            } & ProjectJoinDetails), undefined, import("xstate").Values<{
+                                sendInviteResponse: {
+                                    src: "sendInviteResponse";
+                                    logic: import("xstate").PromiseActorLogic<void, {
+                                        decision: InviteResponse_Decision;
+                                    }, import("xstate").EventObject>;
+                                    id: string | undefined;
+                                };
+                                addProject: {
+                                    src: "addProject";
+                                    logic: import("xstate").PromiseActorLogic<string, ProjectJoinDetails, import("xstate").EventObject>;
+                                    id: string | undefined;
+                                };
+                            }>, never, never, never, never>;
+                        };
+                        readonly onError: "#invite.error";
+                    };
+                    readonly after: {
+                        readonly addProjectTimeout: {
+                            readonly target: "#invite.error";
+                            readonly actions: import("xstate").ActionFunction<Context, {
+                                type: "ACCEPT_INVITE";
+                            } | {
+                                type: "CANCEL_INVITE";
+                            } | {
+                                type: "REJECT_INVITE";
+                            } | {
+                                type: "ALREADY_IN_PROJECT";
+                            } | {
+                                type: "ADDED_PROJECT";
+                            } | {
+                                type: "PEER_DISCONNECTED";
+                            } | ({
+                                type: "RECEIVE_PROJECT_DETAILS";
+                            } & ProjectJoinDetails), {
+                                type: "ACCEPT_INVITE";
+                            } | {
+                                type: "CANCEL_INVITE";
+                            } | {
+                                type: "REJECT_INVITE";
+                            } | {
+                                type: "ALREADY_IN_PROJECT";
+                            } | {
+                                type: "ADDED_PROJECT";
+                            } | {
+                                type: "PEER_DISCONNECTED";
+                            } | ({
+                                type: "RECEIVE_PROJECT_DETAILS";
+                            } & ProjectJoinDetails), undefined, import("xstate").Values<{
+                                sendInviteResponse: {
+                                    src: "sendInviteResponse";
+                                    logic: import("xstate").PromiseActorLogic<void, {
+                                        decision: InviteResponse_Decision;
+                                    }, import("xstate").EventObject>;
+                                    id: string | undefined;
+                                };
+                                addProject: {
+                                    src: "addProject";
+                                    logic: import("xstate").PromiseActorLogic<string, ProjectJoinDetails, import("xstate").EventObject>;
+                                    id: string | undefined;
+                                };
+                            }>, never, never, never, never>;
+                        };
+                    };
+                };
+            };
+        };
+        readonly canceled: {
+            readonly description: "The invite has been canceled";
+            readonly type: "final";
+        };
+        readonly rejected: {
+            readonly description: "Rejected invite";
+            readonly type: "final";
+        };
+        readonly respondedAlready: {
+            readonly description: "Responded that already in project";
+            readonly type: "final";
+        };
+        readonly joined: {
+            readonly description: "Successfully joined project";
+            readonly type: "final";
+        };
+        readonly error: {
+            readonly entry: import("xstate").ActionFunction<Context, {
+                type: "ACCEPT_INVITE";
+            } | {
+                type: "CANCEL_INVITE";
+            } | {
+                type: "REJECT_INVITE";
+            } | {
+                type: "ALREADY_IN_PROJECT";
+            } | {
+                type: "ADDED_PROJECT";
+            } | {
+                type: "PEER_DISCONNECTED";
+            } | ({
+                type: "RECEIVE_PROJECT_DETAILS";
+            } & ProjectJoinDetails), {
+                type: "ACCEPT_INVITE";
+            } | {
+                type: "CANCEL_INVITE";
+            } | {
+                type: "REJECT_INVITE";
+            } | {
+                type: "ALREADY_IN_PROJECT";
+            } | {
+                type: "ADDED_PROJECT";
+            } | {
+                type: "PEER_DISCONNECTED";
+            } | ({
+                type: "RECEIVE_PROJECT_DETAILS";
+            } & ProjectJoinDetails), undefined, import("xstate").Values<{
+                sendInviteResponse: {
+                    src: "sendInviteResponse";
+                    logic: import("xstate").PromiseActorLogic<void, {
+                        decision: InviteResponse_Decision;
+                    }, import("xstate").EventObject>;
+                    id: string | undefined;
+                };
+                addProject: {
+                    src: "addProject";
+                    logic: import("xstate").PromiseActorLogic<string, ProjectJoinDetails, import("xstate").EventObject>;
+                    id: string | undefined;
+                };
+            }>, never, never, never, never>;
+            readonly type: "final";
+            readonly description: "Error joining project";
+        };
+    };
+    readonly output: ({ context }: {
+        context: Context;
+        event: import("xstate").DoneStateEvent<unknown>;
+        self: import("xstate").ActorRef<import("xstate").MachineSnapshot<Context, {
+            type: "ACCEPT_INVITE";
+        } | {
+            type: "CANCEL_INVITE";
+        } | {
+            type: "REJECT_INVITE";
+        } | {
+            type: "ALREADY_IN_PROJECT";
+        } | {
+            type: "ADDED_PROJECT";
+        } | {
+            type: "PEER_DISCONNECTED";
+        } | ({
+            type: "RECEIVE_PROJECT_DETAILS";
+        } & ProjectJoinDetails), Record<string, import("xstate").AnyActorRef>, import("xstate").StateValue, string, unknown, any, any>, {
+            type: "ACCEPT_INVITE";
+        } | {
+            type: "CANCEL_INVITE";
+        } | {
+            type: "REJECT_INVITE";
+        } | {
+            type: "ALREADY_IN_PROJECT";
+        } | {
+            type: "ADDED_PROJECT";
+        } | {
+            type: "PEER_DISCONNECTED";
+        } | ({
+            type: "RECEIVE_PROJECT_DETAILS";
+        } & ProjectJoinDetails), import("xstate").AnyEventObject>;
+    }) => {
+        projectPublicId: string | null;
+    };
+}>;
+export type Context = {
+    error: null | Error;
+    projectPublicId: null | string;
+};
+export type MachineSetupTypes = {
+    context: Context;
+    output: {
+        projectPublicId: string | null;
+    };
+    events: StringToTaggedUnion<"ACCEPT_INVITE" | "CANCEL_INVITE" | "REJECT_INVITE" | "ALREADY_IN_PROJECT" | "ADDED_PROJECT" | "PEER_DISCONNECTED"> | ({
+        type: "RECEIVE_PROJECT_DETAILS";
+    } & ProjectJoinDetails);
+};
+import type { ProjectJoinDetails } from '../generated/rpc.js';
+import { InviteResponse_Decision } from '../generated/rpc.js';
+import type { StringToTaggedUnion } from '../types.js';
+//# sourceMappingURL=invite-state-machine.d.ts.map

package/dist/invite/invite-state-machine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invite-state-machine.d.ts","sourceRoot":"","sources":["../../src/invite/invite-state-machine.js"],"names":[],"mappings":"AASA,yDAAyD;AACzD,gEAAgE;AAChE;;;;;GAKG;AACH;;;;;GAKG;AAEH;;;;;;;;;;;;;UAHiK,yBAAyB;;;kBAQpJ,uBAAuB;;;;;;sBAAvB,uBAAuB;;;;;;;;;;;;;;;;;qBAT5B,MAAM,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BACmH,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAzB,yBAAyB;;;;;;;;;;;;;;kCAAzB,yBAAyB;;;;;8CAQpJ,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCARoG,yBAAyB;;;;;;;;;;;;;;sCAAzB,yBAAyB;;;;;kDAQpJ,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCARoG,yBAAyB;;;;;;;;;;;;;;;sCAAzB,yBAAyB;;;;;;;;;;;;;;sCAAzB,yBAAyB;;;kCAAzB,yBAAyB;;;;;;;;;;;;;;;;;sCAAzB,yBAAyB;;;;;kDAQpJ,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCARoG,yBAAyB;;;;;;;;;;;;;;sCAAzB,yBAAyB;;;;;kDAQpJ,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBARoG,yBAAyB;;;;;;;;;;;;;;sBAAzB,yBAAyB;;;;;kCAQpJ,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBARoG,yBAAyB;;;;;;;;;;;;;;kBAAzB,yBAAyB;;;;;GA0LxL;;WAjMY,IAAI,GAAG,KAAK;qBACZ,IAAI,GAAG,MAAM;;;aAIb,OAAO;YACP;QAAE,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;YAClC,oBAAoB,eAAe,GAAG,eAAe,GAAG,eAAe,GAAG,oBAAoB,GAAG,eAAe,GAAG,mBAAmB,CAAC,GAAG,CAAC;QAAE,IAAI,EAAE,yBAAyB,CAAA;KAAE,GAAG,kBAAkB,CAAC;;wCAX1K,qBAAqB;wCARrB,qBAAqB;yCAOpB,aAAa"}

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

@@ -1 +1 @@
-{"version":3,"file":"local-peers.d.ts","sourceRoot":"","sources":["../src/local-peers.js"],"names":[],"mappings":"AAsCA,mDAAqE;AAuLrE;;;;;;;;;;GAUG;AAEH,gDAAgD;AAChD;IAYE;;;;OAIG;IACH;;mBAGC;IAED;gBAjNqC,WAAW;qBAAe,MAAM;kBAAY,QAAQ,CAAC,OAAO,2BAA2B,CAAC,CAAC;;gBACzF,cAAc;wBAAkB,MAAM;UAsN1E;IAED;;;;OAIG;IACH,qBAJW,MAAM,UACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;;OAIG;IACH,2BAJW,MAAM,gBACN,YAAY,GACV,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;;;OAKG;IACH,6BAHW,MAAM,kBACN,cAAc,iBAMxB;IAED;;;OAGG;IACH,iCAHW,MAAM,WACN,kBAAkB,iBAM5B;IAED;;;;OAIG;IACH,yBAHW,MAAM,cACN,UAAU,iBAMpB;IAYD;;;;;OAKG;IACH,gBAHW,YAAY,GAAG,CAAC,GACd,OAAO,YAAY,EAAE,iBAAiB,CAuDlD;IArED;;;OAGG;IACH,mCAHW,MAAM,OACN,MAAM,iBAMhB;;CA2RF;;AAID;IACE,gCAAgC;IAChC,0CAGC;CACF;AAED;IACE,gCAAgC;IAChC,0CAGC;CACF;AAED;IACE,gCAAgC;IAChC,0CAGC;CACF;;cAllBa,MAAM;UACN,MAAM,GAAG,SAAS;gBAClB,OAAO,oBAAoB,EAAE,UAAU,CAAC,YAAY,CAAC;;iCAErD,YAAY,GAAG;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE;gCACvC,YAAY,GAAG;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,2BAA2B,CAAC,CAAC,CAAA;CAAE;mCACpH,YAAY,GAAG;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE;+BAEjE,kBAAkB,GAAG,iBAAiB,GAAG,oBAAoB;uBAC7D,iBAAiB,GAAG,oBAAoB;wBACxC,gBAAgB,CAAC,QAAQ,CAAC;;;;;WA2K1B,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,IAAI;;;;gBAC3B,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI;;;;YACjC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI;;;;qBACxC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,KAAK,IAAI;;;;uBAC9C,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,cAAc,KAAK,IAAI;;;;2BACxD,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,KAAK,IAAI;;;;qBACrD,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,OAAO,2BAA2B,CAAC,CAAC,KAAK,IAAI;;;;gCACvF,CAAC,WAAW,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,KAAK,IAAI;;6BAtOrC,oBAAoB;qBAC5B,UAAU;uBAUxB,oBAAoB;6BAApB,oBAAoB;+BAApB,oBAAoB;mCAApB,oBAAoB;2BAApB,oBAAoB;6BAIE,2BAA2B;uBAFjC,aAAa;6BACG,WAAW"}
+{"version":3,"file":"local-peers.d.ts","sourceRoot":"","sources":["../src/local-peers.js"],"names":[],"mappings":"AAsCA,mDAAqE;AAkOrE;;;;;;;;;;GAUG;AAEH,gDAAgD;AAChD;IAYE;;;;OAIG;IACH;;mBAGC;IAED;gBA5PqC,WAAW;qBAAe,MAAM;kBAAY,QAAQ,CAAC,OAAO,2BAA2B,CAAC,CAAC;;gBACzF,cAAc;wBAAkB,MAAM;UAiQ1E;IAED;;;;OAIG;IACH,qBAJW,MAAM,UACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;;OAIG;IACH,2BAJW,MAAM,gBACN,YAAY,GACV,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;;;OAKG;IACH,6BAHW,MAAM,kBACN,cAAc,iBAMxB;IAED;;;OAGG;IACH,iCAHW,MAAM,WACN,kBAAkB,iBAM5B;IAED;;;;OAIG;IACH,yBAHW,MAAM,cACN,UAAU,iBAMpB;IAYD;;;;;OAKG;IACH,gBAHW,YAAY,GAAG,CAAC,GACd,OAAO,YAAY,EAAE,iBAAiB,CAuDlD;IArED;;;OAGG;IACH,mCAHW,MAAM,OACN,MAAM,iBAMhB;;CA8RF;;AAID;IACE,gCAAgC;IAChC,0CAGC;CACF;AAED;IACE,gCAAgC;IAChC,0CAGC;CACF;AAED;IACE,gCAAgC;IAChC,0CAGC;CACF;;cAhoBa,MAAM;UACN,MAAM,GAAG,SAAS;gBAClB,OAAO,oBAAoB,EAAE,UAAU,CAAC,YAAY,CAAC;;iCAErD,YAAY,GAAG;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE;gCACvC,YAAY,GAAG;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,2BAA2B,CAAC,CAAC,CAAA;CAAE;mCACpH,YAAY,GAAG;IAAE,MAAM,EAAE,cAAc,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE;+BAEjE,kBAAkB,GAAG,iBAAiB,GAAG,oBAAoB;uBAC7D,iBAAiB,GAAG,oBAAoB;wBACxC,gBAAgB,CAAC,QAAQ,CAAC;;;;;WAsN1B,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,IAAI;;;;gBAC3B,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI;;;;YACjC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI;;;;qBACxC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,KAAK,IAAI;;;;uBAC9C,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,cAAc,KAAK,IAAI;;;;2BACxD,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,KAAK,IAAI;;;;qBACrD,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,OAAO,2BAA2B,CAAC,CAAC,KAAK,IAAI;;;;gCACvF,CAAC,WAAW,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,KAAK,IAAI;;6BAjRrC,oBAAoB;qBAC5B,UAAU;uBAUxB,oBAAoB;6BAApB,oBAAoB;+BAApB,oBAAoB;mCAApB,oBAAoB;2BAApB,oBAAoB;6BAIE,2BAA2B;uBAFjC,aAAa;6BACG,WAAW"}