Publish

- jazz-example-todo@0.0.22
 - cojson@0.1.7
 - cojson-simple-sync@0.1.8
 - cojson-storage-sqlite@0.1.5
 - jazz-browser@0.1.7
 - jazz-browser-auth-local@0.1.7
 - jazz-react@0.1.8
 - jazz-react-auth-local@0.1.8
 - jazz-storage-indexeddb@0.1.7

.github/workflows/build-and-deploy.yaml

@@ -71,11 +71,7 @@ jobs:
         export DOCKER_PASSWORD=${{ secrets.DOCKER_PULL_PAT }};
         export DOCKER_TAG=${{ env.DOCKER_TAG }};
 
-        for region in ${{ vars.DEPLOY_REGIONS }}
-        do
-          export REGION=$region;
-          envsubst '${DOCKER_USER} ${DOCKER_PASSWORD} ${DOCKER_TAG} ${BRANCH_SUFFIX} ${BRANCH_SUBDOMAIN} ${REGION}' < job-template.nomad > job-instance.nomad;
-          cat job-instance.nomad;
-          NOMAD_ADDR='${{ secrets.NOMAD_ADDR }}' nomad job run job-instance.nomad;
-        done
+        envsubst '${DOCKER_USER} ${DOCKER_PASSWORD} ${DOCKER_TAG} ${BRANCH_SUFFIX} ${BRANCH_SUBDOMAIN}' < job-template.nomad > job-instance.nomad;
+        cat job-instance.nomad;
+        NOMAD_ADDR='http://control1v2-london:4646' nomad job run job-instance.nomad;
       working-directory: ./examples/todo

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "typescript.tsdk": "node_modules/typescript/lib"
+}

README.md

@@ -1,9 +1,488 @@
 # Jazz - instant sync
 
-Jazz is an open-source toolkit for telepathic data.
+Homepage: [jazz.tools](https://jazz.tools) — [Discord](https://discord.gg/utDMjHYg42)
 
-Ship faster and simplify frontend, backend & devops by building with Telepathic Data.
-Get real-time multiplayer and cross-device sync for free.
+Jazz is an open-source toolkit for *secure telepathic data.*
 
-## What is Telepathic Data?
-...
+- Ship faster & simplify your frontend and backend
+- Get cross-device sync, real-time collaboration & offline support for free
+
+[Jazz Global Mesh](https://jazz.tools/mesh) is serverless sync & storage for Jazz apps. (currently free!)
+
+
+
+## What is Secure Telepathic Data?
+
+**Telepathic** means:
+
+- **Read and write data as if it was local,** from anywhere in your app.
+- **Always have that data synced, instantly.** Across devices of the same user — or to other users (coming soon: to your backend, workers, etc.)
+
+**Secure** means:
+
+- **Fine-grained, role-based permissions are *baked into* your data.**
+- **Permissions are enforced everywhere, locally.** (using cryptography instead of through an API)
+- Roles can be changed dynamically, supporting changing teams, invite links and more.
+
+## How to build an app with Jazz?
+
+### Building a new app, completely with Jazz
+
+It's still a bit early, but these are the rough steps:
+
+1. Define your data model with [CoJSON Values](#cojson).
+2. Implement permission logic using [CoJSON Groups](#group).
+3. Hook up a user interface with [jazz-react](#jazz-react).
+
+The best example is currently the [Todo List app](#example-app-todo-list).
+
+### Gradually adding Jazz to an existing app
+
+Coming soon: Jazz will support gradual adoption by integrating with your existing UI, auth and database.
+
+## Example App: Todo List
+
+The best example of Jazz is currently the Todo List app.
+
+- Live version: https://example-todo.jazz.tools
+- Source code: [`./examples/todo`](./examples/todo). See the README there for a walk-through and running instructions.
+
+# API Reference
+
+Note: Since it's early days, this is the only source of documentation so far.
+
+If you want to build something with Jazz, [join the Jazz Discord](https://discord.gg/utDMjHYg42) for encouragement and help!
+
+## Overview: Main Packages
+
+**`cojson`**
+
+A library implementing abstractions and protocols for "Collaborative JSON". This will soon be standardized and forms the basis of secure telepathic data.
+
+**`jazz-react`**
+
+Provides you with everything you need to build react apps around CoJSON, including reactive hooks for telepathic data, local IndexedDB persistence, support for different auth providers and helpers for simple invite links for CoJSON groups.
+
+### Supporting packages
+<small>
+
+**`cojson-simple-sync`**
+
+A generic CoJSON sync server you can run locally if you don't want to use Jazz Global Mesh (the default sync backend, at `wss://sync.jazz.tools`)
+
+**`jazz-browser`**
+
+framework-agnostic primitives that allow you to use CoJSON in the browser. Used to implement `jazz-react`, will be used to implement bindings for other frameworks in the future.
+
+**`jazz-react-auth-local`** (and `jazz-browser-auth-local`): A simple auth provider that stores cryptographic keys on user devices using WebAuthentication/Passkeys. Lets you build Jazz apps completely without a backend, with end-to-end encryption by default.
+
+**`jazz-storage-indexeddb`**
+
+Provides local, offline-capable persistence. Included and enabled in `jazz-react` by default.
+</small>
+
+## `CoJSON`
+
+CoJSON is the core implementation of secure telepathic data. It provides abstractions for Collaborative JSON values ("`CoValues`"), groups for permission management and a protocol for syncing between nodes. Our goal is to standardise CoJSON soon and port it to other languages and platforms.
+
+---
+
+### `LocalNode`
+
+A `LocalNode` represents a local view of a set of loaded `CoValue`s, from the perspective of a particular account (or primitive cryptographic agent).
+
+A `LocalNode` can have peers that it syncs to, for example some form of local persistence, or a sync server, such as `sync.jazz.tools` (Jazz Global Mesh).
+
+You typically get hold of a `LocalNode` using `jazz-react`'s `useJazz()`:
+
+```typescript
+const { localNode } = useJazz();
+```
+
+#### `LocalNode.load(id)`
+```typescript
+load<T extends ContentType>(id: CoID<T>): Promise<T>
+```
+
+Loads a CoValue's content, syncing from peers as necessary and resolving the returned promise once a first version has been loaded. See `ContentType.subscribe()` and `useTelepathicData` for listening to subsequent updates to the CoValue.
+
+#### `LocalNode.loadProfile(id)`
+```typescript
+loadProfile(accountID: AccountID): Promise<Profile>
+```
+
+Loads a profile associated with an account. `Profile` is at least a `CoMap<{string: name}>`, but might contain other, app-specific properties.
+
+#### `LocalNode.acceptInvite(valueOrGroup, inviteSecret)`
+```typescript
+acceptInvite<T extends ContentType>(
+    valueOrGroup: CoID<T>,
+    inviteSecret: InviteSecret
+): Promise<void>
+```
+
+Accepts an invite for a group, or infers the group if given the `CoID` of a value owned by that group. Resolves upon successful joining of that group, at which point you should be able to `LocalNode.load` the value.
+
+Invites can be created with `Group.createInvite(role)`.
+
+#### `LocalNode.createGroup()`
+```typescript
+createGroup(): Group
+```
+
+Creates a new group (with the current account as the group's first admin).
+
+---
+
+### `Group`
+
+A CoJSON group manages permissions of its members. A `Group` object exposes those capabilities and allows you to create new CoValues owned by that group.
+
+(Internally, a `Group` is also just a `CoMap`, mapping member accounts to roles and containing some state management for making cryptographic keys available to current members)
+
+#### `Group.id`
+
+Returns the `CoID` of the `Group`.
+
+#### `Group.roleOf(accountID)`
+
+```typescript
+roleOf(accountID: AccountID): "reader" | "writer" | "admin" | undefined
+```
+
+Returns the current role of a given account.
+
+#### `Group.myRole()`
+
+```typescript
+myRole(accountID: AccountID): "reader" | "writer" | "admin" | undefined
+```
+
+Returns the role of the current account in the group.
+
+#### `Group.addMember(accountID, role)`
+
+```typescript
+addMember(
+  accountID: AccountID,
+  role:  "reader" | "writer" | "admin"
+)
+```
+
+Directly grants a new member a role in the group. The current account must be an admin to be able to do so. Throws otherwise.
+
+#### `Group.createInvite(role)`
+
+```typescript
+createInvite(role: "reader" | "writer" | "admin"): InviteSecret
+```
+
+Creates an invite for new members to indirectly join the group, allowing them to grant themselves the specified role with the InviteSecret (a string starting with "inviteSecret_") - use `LocalNode.acceptInvite()` for this purpose.
+
+#### `Group.removeMember(accountID)`
+
+```typescript
+removeMember(accountID: AccountID)
+```
+
+Strips the specified member of all roles (preventing future writes) and rotates the read encryption key for that group (preventing reads of new content, including in covalues owned by this group)
+
+#### `Group.createMap(meta?)`
+```typescript
+createMap<M extends CoMap<{ [key: string]: JsonValue }, JsonObject | null>>(
+  meta?: M["meta"]
+): M
+```
+
+Creates a new `CoMap` within this group, with the specified specialized `CoMap` type `M` and optional static metadata.
+
+#### `Group.createList(meta?)`
+```typescript
+createList<L extends CoList<JsonValue, JsonObject | null>>(
+  meta?: L["meta"]
+): L
+```
+
+Creates a new `CoList` within this group, with the specified specialized `CoList` type `L` and optional static metadata.
+
+#### `Group.createStream(meta?)` (coming soon)
+#### `Group.createStatic(meta)` (coming soon)
+
+---
+### `CoValue` ContentType: `CoMap`
+
+```typescript
+class CoMap<
+    M extends { [key: string]: JsonValue; },
+    Meta extends JsonObject | null = null,
+>
+```
+
+#### `CoMap.id`
+
+```typescript
+id: CoID<CoMap<M, Meta>>
+```
+
+Returns the CoMap's (precisely typed) `CoID`
+
+#### `CoMap.meta`
+
+```typescript
+meta: Meta
+```
+
+Returns the CoMap's (precisely typed) static metadata
+
+#### `CoMap.keys()`
+
+```typescript
+keys(): (keyof M & string)[]
+```
+
+#### `CoMap.get(key)`
+
+```typescript
+get<K extends keyof M>(key: K): M[K] | undefined
+```
+
+Returns the current value for the given key.
+
+#### `CoMap.whoEdited(key)`
+
+```typescript
+whoEdited<K extends keyof M>(key: K): AccountID | undefined
+```
+
+Returns the accountID of the last account to modify the value for the given key.
+
+#### `CoMap.toJSON()`
+
+```typescript
+toJSON(): JsonObject
+```
+
+Returns a JSON representation of the state of the CoMap.
+
+#### `CoMap.subscribe(listener)`
+
+```typescript
+subscribe(
+  listener: (coMap: CoMap<M, Meta>) => void
+): () => void
+```
+Lets you subscribe to future updates to this CoMap (whether made locally or by other users). Takes a listener function that will be called with the current state for each update. Returns an unsubscribe function.
+
+Used internally by `useTelepathicData()` for reactive updates on changes to a `CoMap`.
+
+#### `CoMap.edit(editable => {...})`
+
+```typescript
+edit(changer: (editable: WriteableCoMap<M, Meta>) => void): CoMap<M, Meta>
+```
+
+Lets you apply edits to a `CoMap`, inside the changer callback, which receives a `WriteableCoMap`. A `WritableCoMap` has all the same methods as a `CoMap`, but all edits made to it with `set` or `delete` are reflected in it immediately - so it behaves mutably, whereas a `CoMap` is always immutable (you need to use `subscribe` to receive new versions of it).
+
+```typescript
+export class WriteableCoMap<
+    M extends { [key: string]: JsonValue; },
+    Meta extends JsonObject | null = null,
+> extends CoMap<M, Meta>
+```
+
+#### `WritableCoMap.set(key, value)`
+
+```typescript
+set<K extends keyof M>(
+  key: K,
+  value: M[K],
+  privacy: "private" | "trusting" = "private"
+): void
+```
+
+Sets a new value for the given key.
+
+If `privacy` is `"private"` **(default)**, both `key` and `value` are encrypted in the transaction, only readable by other members of the group this `CoMap` belongs to. Not even sync servers can see the content in plaintext.
+
+If `privacy` is `"trusting"`, both `key` and `value` are stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers.
+
+#### `WritableCoMap.delete(key)`
+
+```typescript
+delete<K extends keyof M>(
+  key: K,
+  privacy: "private" | "trusting" = "private"
+): void
+```
+
+Deletes the value for the given key (setting it to undefined).
+
+If `privacy` is `"private"` **(default)**, `key` is encrypted in the transaction, only readable by other members of the group this `CoMap` belongs to. Not even sync servers can see the content in plaintext.
+
+If `privacy` is `"trusting"`, `key` is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers.
+
+---
+### `CoValue` ContentType: `CoList`
+
+```typescript
+class CoList<
+    T extends JsonValue,
+    Meta extends JsonObject | null = null
+>
+```
+
+#### `CoList.id`
+
+```typescript
+id: CoID<CoList<T, Meta>>
+```
+
+Returns the CoList's (precisely typed) `CoID`
+
+#### `CoList.meta`
+
+```typescript
+meta: Meta
+```
+
+Returns the CoList's (precisely typed) static metadata
+
+### `CoList.asArray()`
+
+```typescript
+asArray(): T[]
+```
+
+Returns the current items in the CoList as an array.
+
+### `CoList.toJSON()`
+
+```typescript
+toJSON(): T[]
+```
+
+Returns the current items in the CoList as an array. (alias of asArray)
+
+#### `CoList.whoInserted(idx)`
+
+```typescript
+whoInserted(idx: number): AccountID | undefined
+```
+
+Returns the accountID of the account that inserted value at the given index.
+
+#### `CoList.subscribe(listener)`
+
+```typescript
+subscribe(
+  listener: (coMap: CoList<T, Meta>) => void
+): () => void
+```
+Lets you subscribe to future updates to this CoList (whether made locally or by other users). Takes a listener function that will be called with the current state for each update. Returns an unsubscribe function.
+
+Used internally by `useTelepathicData()` for reactive updates on changes to a `CoList`.
+
+#### `CoList.edit(editable => {...})`
+
+```typescript
+edit(changer: (editable: WriteableCoList<T, Meta>) => void): CoList<T, Meta>
+```
+
+Lets you apply edits to a `CoList`, inside the changer callback, which receives a `WriteableCoList`. A `WritableCoList` has all the same methods as a `CoList`, but all edits made to it with `append`, `push`, `prepend` or `delete` are reflected in it immediately - so it behaves mutably, whereas a `CoList` is always immutable (you need to use `subscribe` to receive new versions of it).
+
+```typescript
+export class WriteableCoList<
+    T extends JsonValue,
+    Meta extends JsonObject | null = null,
+> extends CoList<T, Meta>
+```
+
+#### `WritableCoList.append(after, value)`
+
+```typescript
+append(
+  after: number,
+  value: T,
+  privacy: "private" | "trusting" = "private"
+): void
+```
+
+Appends a new item after index `after`.
+
+If `privacy` is `"private"` **(default)**, both `value` is encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
+
+If `privacy` is `"trusting"`, both `value` is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers.
+
+#### `WritableCoList.prepend(after, value)`
+
+```typescript
+prepend(
+  before: number,
+  value: T,
+  privacy: "private" | "trusting" = "private"
+): void
+```
+
+Prepends a new item before index `before`.
+
+If `privacy` is `"private"` **(default)**, both `value` is encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
+
+If `privacy` is `"trusting"`, both `value` is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers.
+
+#### `WritableCoList.push(value)`
+
+```typescript
+push(
+  value: T,
+  privacy: "private" | "trusting" = "private"
+): void
+```
+
+Pushes a new item to the end of the list.
+
+If `privacy` is `"private"` **(default)**, both `value` is encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
+
+If `privacy` is `"trusting"`, both `value` is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers.
+
+#### `WritableCoList.delete(at)`
+
+```typescript
+delete(
+    at: number,
+    privacy: "private" | "trusting" = "private"
+): void
+```
+
+Deletes the item at index `at` from the list.
+
+If `privacy` is `"private"` **(default)**, the fact of this deletion is encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
+
+If `privacy` is `"trusting"`, the fact of this deletion is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers.
+
+---
+### `CoValue` ContentType: `CoStream` (not yet implemented)
+
+---
+### `CoValue` ContentType: `Static` (not yet implemented)
+---
+
+## `jazz-react`
+---
+### `<WithJazz>`
+
+Not yet documented, see [`examples/todo`](./examples/todo/) for now
+
+---
+### `useJazz()`
+
+Not yet documented, see [`examples/todo`](./examples/todo/) for now
+
+---
+### `useTelepathicData(coID)`
+
+Not yet documented, see [`examples/todo`](./examples/todo/) for now
+
+---
+### `useProfile(accountID)`
+
+Not yet documented, see [`examples/todo`](./examples/todo/) for now

examples/todo/README.md

@@ -1,27 +1,356 @@
-# React + TypeScript + Vite
+# Jazz Todo List Example
 
-This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+Live version: https://example-todo.jazz.tools
 
-Currently, two official plugins are available:
+More comprehensive guide coming soon, but these are the most important bits, with explanations:
 
-- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh
-- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+From `./src/main.tsx`
 
-## Expanding the ESLint configuration
+```typescript
+// ...
 
-If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:
+import { WithJazz } from "jazz-react";
+import { LocalAuth } from "jazz-react-auth-local";
 
-- Configure the top-level `parserOptions` property like this:
+// ...
+
+ReactDOM.createRoot(document.getElementById("root")!).render(
+    <React.StrictMode>
+        <ThemeProvider>
+            <div className="flex items-center gap-2 justify-center mt-5">
+                <img src="jazz-logo.png" className="h-5" /> Jazz Todo List
+                Example
+            </div>
+            <WithJazz
+                auth={LocalAuth({
+                    appName: "Jazz Todo List Example",
+                    Component: PrettyAuthComponent,
+                })}
+            >
+                <App />
+            </WithJazz>
+        </ThemeProvider>
+    </React.StrictMode>
+);
 
-```js
-   parserOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module',
-    project: ['./tsconfig.json', './tsconfig.node.json'],
-    tsconfigRootDir: __dirname,
-   },
 ```
 
-- Replace `plugin:@typescript-eslint/recommended` to `plugin:@typescript-eslint/recommended-type-checked` or `plugin:@typescript-eslint/strict-type-checked`
-- Optionally add `plugin:@typescript-eslint/stylistic-type-checked`
-- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and add `plugin:react/recommended` & `plugin:react/jsx-runtime` to the `extends` list
+This shows how to use the top-level component `<WithJazz/>`, which provides the rest of the app with a `LocalNode` (used through `useJazz` later), based on `LocalAuth` that uses Passkeys to store a user's account secret - no backend needed.
+
+Let's move on to the main app code.
+
+---
+
+From `./src/App.tsx`
+
+```typescript
+// ...
+
+import { CoMap, CoID, AccountID } from "cojson";
+import {
+   consumeInviteLinkFromWindowLocation,
+   useJazz,
+   useProfile,
+   useTelepathicState,
+   createInviteLink
+} from "jazz-react";
+
+// ...
+
+type Task = CoMap<{ done: boolean; text: string }>;
+
+type ListOfTasks = CoList<CoID<Task>>;
+
+type TodoList = CoMap<{
+    title: string;
+    tasks: CoID<ListOfTasks>;
+}>;
+
+// ...
+```
+
+First, we define our main data model of tasks and todo lists, using CoJSON's collaborative map and list types, `CoMap` & `CoList`.
+
+---
+
+```typescript
+// ...
+
+export default function App() {
+    const [listId, setListId] = useState<CoID<TodoList>>();
+
+    const { localNode, logOut } = useJazz();
+
+    useEffect(() => {
+        const listener = async () => {
+            const acceptedInvitation =
+                await consumeInviteLinkFromWindowLocation(localNode);
+
+            if (acceptedInvitation) {
+                setListId(acceptedInvitation.valueID as CoID<TodoList>);
+                window.location.hash = acceptedInvitation.valueID;
+                return;
+            }
+
+            setListId(window.location.hash.slice(1) as CoID<TodoList>);
+        };
+        window.addEventListener("hashchange", listener);
+        listener();
+
+        return () => {
+            window.removeEventListener("hashchange", listener);
+        };
+    }, [localNode]);
+
+    const createList = useCallback(
+        (title: string) => {
+            if (!title) return;
+            const listGroup = localNode.createGroup();
+            const list = listGroup.createMap<TodoList>();
+            const tasks = listGroup.createList<ListOfTasks>();
+
+            list.edit((list) => {
+                list.set("title", title);
+                list.set("tasks", tasks.id);
+            });
+
+            window.location.hash = list.id;
+        },
+        [localNode]
+    );
+
+    return (
+        <div className="flex flex-col h-full items-center justify-start gap-10 pt-10 pb-10 px-5">
+            {listId ? (
+                <TodoListComponent listId={listId} />
+            ) : (
+                <SubmittableInput
+                    onSubmit={createList}
+                    label="Create New List"
+                    placeholder="New list title"
+                />
+            )}
+            <Button
+                onClick={() => {
+                    window.location.hash = "";
+                    logOut();
+                }}
+                variant="outline"
+            >
+                Log Out
+            </Button>
+        </div>
+    );
+}
+```
+
+`<App>` is the main app component, handling client-side routing based on the CoValue ID (`CoID`) of our `TodoList`, stored in the URL hash - which can also contain invite links, which we intercept and use with `consumeInviteLinkFromWindowLocation`.
+
+`createList` is the first time we see CoJSON in action: using our `localNode` (which we got from `useJazz`), we first create a group for a new todo list (which allows us to set permissions later). Then, within that group, we create a new `CoMap<TodoListContent>` with `listGroup.createMap()`.
+
+We immediately start editing the created `list`. Within the edit callback, we can use the `set` function, to collaboratively set the key `title` to the initial title provided to `createList`.
+
+If we have a current `listId` set, we render `<TodoListComponent>` with it, which we'll see next.
+
+If we have no `listId` set, the user can use the displayed creation input to create (and open) their first list.
+
+---
+
+```typescript
+export function TodoListComponent({ listId }: { listId: CoID<TodoList> }) {
+    const list = useTelepathicState(listId);
+    const tasks = useTelepathicState(list?.get("tasks"));
+
+    const createTask = (text: string) => {
+        if (!tasks || !text) return;
+        const task = tasks.group.createMap<Task>();
+
+        task.edit((task) => {
+            task.set("text", text);
+            task.set("done", false);
+        });
+
+        tasks.edit((tasks) => {
+            tasks.push(task.id);
+        });
+    };
+
+    return (
+        <div className="max-w-full w-4xl">
+            <div className="flex justify-between items-center gap-4 mb-4">
+                <h1>
+                    {list?.get("title") ? (
+                        <>
+                            {list.get("title")}{" "}
+                            <span className="text-sm">({list.id})</span>
+                        </>
+                    ) : (
+                        <Skeleton className="mt-1 w-[200px] h-[1em] rounded-full" />
+                    )}
+                </h1>
+                {list && <InviteButton list={list} />}
+            </div>
+            <Table>
+                <TableHeader>
+                    <TableRow>
+                        <TableHead className="w-[40px]">Done</TableHead>
+                        <TableHead>Task</TableHead>
+                    </TableRow>
+                </TableHeader>
+                <TableBody>
+                    {tasks &&
+                        tasks
+                            .asArray()
+                            .map((taskId) => (
+                                <TaskRow key={taskId} taskId={taskId} />
+                            ))}
+                    <TableRow key="new">
+                        <TableCell>
+                            <Checkbox className="mt-1" disabled />
+                        </TableCell>
+                        <TableCell>
+                            <SubmittableInput
+                                onSubmit={(taskText) => createTask(taskText)}
+                                label="Add"
+                                placeholder="New task"
+                                disabled={!list}
+                            />
+                        </TableCell>
+                    </TableRow>
+                </TableBody>
+            </Table>
+        </div>
+    );
+}
+```
+
+Here in `<TodoListComponent>`, we use `useTelepathicData()` for the first time, in this case to load the CoValue for our `TodoList` as well as the `ListOfTasks` referenced in it. `useTelepathicData()` reactively subscribes to updates to a CoValue's content - whether we create edits locally, load persisted data, or receive sync updates from other devices or participants!
+
+`createTask` is similar to `createList` we saw earlier, creating a new CoMap for a new task, and then adding it as an item to our `TodoList`'s `ListOfTasks`.
+
+As you can see, we iterate over the items of our `ListOfTasks` and render a `<TaskRow>` for each.
+
+Below all tasks, we render a simple input for adding a task.
+
+---
+
+```typescript
+function TaskRow({ taskId }: { taskId: CoID<Task> }) {
+    const task = useTelepathicState(taskId);
+
+    return (
+        <TableRow>
+            <TableCell>
+                <Checkbox
+                    className="mt-1"
+                    checked={task?.get("done")}
+                    onCheckedChange={(checked) => {
+                        task?.edit((task) => {
+                            task.set("done", !!checked);
+                        });
+                    }}
+                />
+            </TableCell>
+            <TableCell>
+                <div className="flex flex-row justify-between items-center gap-2">
+                    <span className={task?.get("done") ? "line-through" : ""}>
+                        {task?.get("text") || (
+                            <Skeleton className="mt-1 w-[200px] h-[1em] rounded-full" />
+                        )}
+                    </span>
+                    <NameBadge accountID={task?.whoEdited("text")} />
+                </div>
+            </TableCell>
+        </TableRow>
+    );
+}
+```
+
+`<TaskRow>` uses `useTelepathicState()` as well, to granularly load and subscribe to changes for that particular task (the only thing we let the user change is the "done" status).
+
+We also use a `<NameBadge>` helper component to render the name of the author of the task, which we get by using the collaboration feature `whoEdited(key)` on our `Task` CoMap, which returns the accountID of the last account that changed a given key in the CoMap.
+
+---
+
+```typescript
+function NameBadge({ accountID }: { accountID?: AccountID }) {
+    const profile = useProfile(accountID);
+
+    const theme = window.matchMedia("(prefers-color-scheme: dark)").matches
+        ? "dark"
+        : "light";
+
+    const brightColor = uniqolor(accountID || "", { lightness: 80 }).color;
+    const darkColor = uniqolor(accountID || "", { lightness: 20 }).color;
+
+    return (
+        profile?.get("name") ? (
+            <span
+                className="rounded-full py-0.5 px-2 text-xs"
+                style={{
+                    color: theme == "light" ? darkColor : brightColor,
+                    background: theme == "light" ? brightColor : darkColor,
+                }}
+            >
+                {profile.get("name")}
+            </span>
+        ) : (
+            <Skeleton className="mt-1 w-[50px] h-[1em] rounded-full" />
+        )
+    );
+}
+```
+
+`<NameBadge>` uses `useProfile(accountID)`, which is a shorthand for loading an account's profile (which is always a `CoMap<{name: string}>`, but might have app-specific additional properties).
+
+In our case, we just display the profile name (which, by the way, is set by the `LocalAuth` provider when we first create an account).
+
+---
+
+```typescript
+function InviteButton({ list }: { list: TodoList }) {
+    const [existingInviteLink, setExistingInviteLink] = useState<string>();
+    const { toast } = useToast();
+
+    return (
+        list.group.myRole() === "admin" && (
+            <Button
+                size="sm"
+                className="py-0"
+                disabled={!list}
+                variant="outline"
+                onClick={async () => {
+                    let inviteLink = existingInviteLink;
+                    if (list && !inviteLink) {
+                        inviteLink = createInviteLink(list, "writer");
+                        setExistingInviteLink(inviteLink);
+                    }
+                    if (inviteLink) {
+                        const qr = await QRCode.toDataURL(inviteLink, {
+                            errorCorrectionLevel: "L",
+                        });
+                        navigator.clipboard.writeText(inviteLink).then(() =>
+                            toast({
+                                title: "Copied invite link to clipboard!",
+                                description: (
+                                    <img src={qr} className="w-20 h-20" />
+                                ),
+                            })
+                        );
+                    }
+                }}
+            >
+                Invite
+            </Button>
+        )
+    );
+}
+```
+
+Last, we have a look at the `<InviteButton>` component, which we use inside `<TodoListComponent>`. It only becomes visible when the current user is an admin in the `TodoList`'s group. You can see how we can create an invite link using `createInviteLink(coValue, role)` that allows anyone who has it to join the group as a specified role (here, as a writer).
+
+---
+
+This is the whole Todo List app!
+
+If you have feedback, let us know on [Discord](https://discord.gg/utDMjHYg42) or open an issue or PR to fix something that seems wrong.

examples/todo/job-template.nomad

@@ -1,9 +1,9 @@
 job "example-todo$BRANCH_SUFFIX" {
-  region     = "$REGION"
-  datacenters = ["$REGION"]
+  region     = "global"
+  datacenters = ["*"]
 
   group "static" {
-    // count = 3
+    count = 8
 
     network {
       port "http" {
@@ -14,13 +14,17 @@ job "example-todo$BRANCH_SUFFIX" {
     constraint {
       attribute = "${node.class}"
       operator  = "="
-      value     = "edge"
+      value     = "mesh"
     }
 
-    // spread {
-    //   attribute = "${node.datacenter}"
-    //   weight    = 100
-    // }
+    spread {
+      attribute = "${node.datacenter}"
+      weight    = 100
+    }
+
+    constraint {
+      distinct_hosts = true
+    }
 
     task "server" {
       driver = "docker"
@@ -37,9 +41,7 @@ job "example-todo$BRANCH_SUFFIX" {
 
       service {
         tags = ["public"]
-        meta {
-          public_name = "${BRANCH_SUBDOMAIN}example-todo"
-        }
+        name = "example-todo$BRANCH_SUFFIX"
         port = "http"
         provider = "consul"
       }

examples/todo/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jazz-example-todo",
   "private": true,
-  "version": "0.0.13",
+  "version": "0.0.22",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -13,11 +13,13 @@
     "@radix-ui/react-checkbox": "^1.0.4",
     "@radix-ui/react-slot": "^1.0.2",
     "@radix-ui/react-toast": "^1.1.4",
+    "@types/qrcode": "^1.5.1",
     "class-variance-authority": "^0.7.0",
     "clsx": "^2.0.0",
-    "jazz-react": "^0.1.1",
-    "jazz-react-auth-local": "^0.1.1",
+    "jazz-react": "^0.1.8",
+    "jazz-react-auth-local": "^0.1.8",
     "lucide-react": "^0.265.0",
+    "qrcode": "^1.5.3",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "tailwind-merge": "^1.14.0",

examples/todo/src/App.tsx

@@ -1,3 +1,17 @@
+import { useCallback, useEffect, useState } from "react";
+
+import { CoMap, CoID, AccountID } from "cojson";
+import {
+    consumeInviteLinkFromWindowLocation,
+    useJazz,
+    useProfile,
+    useTelepathicState,
+    createInviteLink,
+} from "jazz-react";
+
+import { SubmittableInput } from "./components/SubmittableInput";
+import { useToast } from "./components/ui/use-toast";
+import { Skeleton } from "./components/ui/skeleton";
 import {
     Table,
     TableBody,
@@ -8,56 +22,31 @@ import {
 } from "@/components/ui/table";
 import { Checkbox } from "@/components/ui/checkbox";
 import { Button } from "@/components/ui/button";
-import { useCallback, useEffect, useState } from "react";
-import { CoMap, CoID, AccountID } from "cojson";
-import {
-    consumeInviteLinkFromWindowLocation,
-    useJazz,
-    useProfile,
-    useTelepathicState,
-} from "jazz-react";
-import { SubmittableInput } from "./components/SubmittableInput";
-import { createInviteLink } from "jazz-react";
-import { useToast } from "./components/ui/use-toast";
-import { Skeleton } from "./components/ui/skeleton";
 import uniqolor from "uniqolor";
+import QRCode from "qrcode";
+import { CoList } from "cojson/dist/contentTypes/coList";
 
-type TaskContent = { done: boolean; text: string };
-type Task = CoMap<TaskContent>;
+type Task = CoMap<{ done: boolean; text: string }>;
 
-type TodoListContent = {
+type ListOfTasks = CoList<CoID<Task>>;
+
+type TodoList = CoMap<{
     title: string;
-    // other keys form a set of task IDs
-    [taskId: CoID<Task>]: true;
-};
-type TodoList = CoMap<TodoListContent>;
+    tasks: CoID<ListOfTasks>;
+}>;
 
-function App() {
+export default function App() {
     const [listId, setListId] = useState<CoID<TodoList>>();
 
     const { localNode, logOut } = useJazz();
 
-    const createList = useCallback(
-        (title: string) => {
-            const listGroup = localNode.createGroup();
-            const list = listGroup.createMap<TodoListContent>();
-
-            list.edit((list) => {
-                list.set("title", title);
-            });
-
-            window.location.hash = list.id;
-        },
-        [localNode]
-    );
-
     useEffect(() => {
         const listener = async () => {
             const acceptedInvitation =
-                await consumeInviteLinkFromWindowLocation(localNode);
+                await consumeInviteLinkFromWindowLocation<TodoList>(localNode);
 
             if (acceptedInvitation) {
-                setListId(acceptedInvitation.valueID as CoID<TodoList>);
+                setListId(acceptedInvitation.valueID);
                 window.location.hash = acceptedInvitation.valueID;
                 return;
             }
@@ -72,10 +61,27 @@ function App() {
         };
     }, [localNode]);
 
+    const createList = useCallback(
+        (title: string) => {
+            if (!title) return;
+            const listGroup = localNode.createGroup();
+            const list = listGroup.createMap<TodoList>();
+            const tasks = listGroup.createList<ListOfTasks>();
+
+            list.edit((list) => {
+                list.set("title", title);
+                list.set("tasks", tasks.id);
+            });
+
+            window.location.hash = list.id;
+        },
+        [localNode]
+    );
+
     return (
         <div className="flex flex-col h-full items-center justify-start gap-10 pt-10 pb-10 px-5">
             {listId ? (
-                <TodoList listId={listId} />
+                <TodoListComponent listId={listId} />
             ) : (
                 <SubmittableInput
                     onSubmit={createList}
@@ -96,20 +102,21 @@ function App() {
     );
 }
 
-export function TodoList({ listId }: { listId: CoID<TodoList> }) {
+export function TodoListComponent({ listId }: { listId: CoID<TodoList> }) {
     const list = useTelepathicState(listId);
+    const tasks = useTelepathicState(list?.get("tasks"));
 
     const createTask = (text: string) => {
-        if (!list) return;
-        const task = list.coValue.getGroup().createMap<TaskContent>();
+        if (!tasks || !text) return;
+        const task = tasks.group.createMap<Task>();
 
         task.edit((task) => {
             task.set("text", text);
             task.set("done", false);
         });
 
-        list.edit((list) => {
-            list.set(task.id, true);
+        tasks.edit((tasks) => {
+            tasks.push(task.id);
         });
     };
 
@@ -136,15 +143,9 @@ export function TodoList({ listId }: { listId: CoID<TodoList> }) {
                     </TableRow>
                 </TableHeader>
                 <TableBody>
-                    {list &&
-                        list
-                            .keys()
-                            .filter((key): key is CoID<Task> =>
-                                key.startsWith("co_")
-                            )
-                            .map((taskId) => (
-                                <TaskRow key={taskId} taskId={taskId} />
-                            ))}
+                    {tasks?.map((taskId) => (
+                        <TaskRow key={taskId} taskId={taskId} />
+                    ))}
                     <TableRow key="new">
                         <TableCell>
                             <Checkbox className="mt-1" disabled />
@@ -181,11 +182,13 @@ function TaskRow({ taskId }: { taskId: CoID<Task> }) {
                 />
             </TableCell>
             <TableCell>
-                <div className="flex flex-row justify-between">
+                <div className="flex flex-row justify-between items-center gap-2">
                     <span className={task?.get("done") ? "line-through" : ""}>
-                        {task?.get("text")}
+                        {task?.get("text") || (
+                            <Skeleton className="mt-1 w-[200px] h-[1em] rounded-full" />
+                        )}
                     </span>
-                    <NameBadge accountID={task?.getLastEditor("text")} />
+                    <NameBadge accountID={task?.whoEdited("text")} />
                 </div>
             </TableCell>
         </TableRow>
@@ -193,7 +196,7 @@ function TaskRow({ taskId }: { taskId: CoID<Task> }) {
 }
 
 function NameBadge({ accountID }: { accountID?: AccountID }) {
-    const profile = useProfile({ accountID });
+    const profile = useProfile(accountID);
 
     const theme = window.matchMedia("(prefers-color-scheme: dark)").matches
         ? "dark"
@@ -202,7 +205,7 @@ function NameBadge({ accountID }: { accountID?: AccountID }) {
     const brightColor = uniqolor(accountID || "", { lightness: 80 }).color;
     const darkColor = uniqolor(accountID || "", { lightness: 20 }).color;
 
-    return (
+    return profile?.get("name") ? (
         <span
             className="rounded-full py-0.5 px-2 text-xs"
             style={{
@@ -210,8 +213,10 @@ function NameBadge({ accountID }: { accountID?: AccountID }) {
                 background: theme == "light" ? brightColor : darkColor,
             }}
         >
-            {profile?.get("name") || "..."}
+            {profile.get("name")}
         </span>
+    ) : (
+        <Skeleton className="mt-1 w-[50px] h-[1em] rounded-full" />
     );
 }
 
@@ -220,22 +225,28 @@ function InviteButton({ list }: { list: TodoList }) {
     const { toast } = useToast();
 
     return (
-        list.coValue.getGroup().myRole() === "admin" && (
+        list.group.myRole() === "admin" && (
             <Button
                 size="sm"
                 className="py-0"
                 disabled={!list}
                 variant="outline"
-                onClick={() => {
+                onClick={async () => {
                     let inviteLink = existingInviteLink;
                     if (list && !inviteLink) {
                         inviteLink = createInviteLink(list, "writer");
                         setExistingInviteLink(inviteLink);
                     }
                     if (inviteLink) {
+                        const qr = await QRCode.toDataURL(inviteLink, {
+                            errorCorrectionLevel: "L",
+                        });
                         navigator.clipboard.writeText(inviteLink).then(() =>
                             toast({
-                                description: "Copied invite link to clipboard!",
+                                title: "Copied invite link to clipboard!",
+                                description: (
+                                    <img src={qr} className="w-20 h-20" />
+                                ),
                             })
                         );
                     }
@@ -246,5 +257,3 @@ function InviteButton({ list }: { list: TodoList }) {
         )
     );
 }
-
-export default App;

examples/todo/src/main.tsx

@@ -1,17 +1,22 @@
 import React from "react";
 import ReactDOM from "react-dom/client";
-import App from "./App.tsx";
-import "./index.css";
+
 import { WithJazz } from "jazz-react";
 import { LocalAuth } from "jazz-react-auth-local";
+
 import { PrettyAuthComponent } from "./components/prettyAuth.tsx";
 import { ThemeProvider } from "./components/themeProvider.tsx";
 import { Toaster } from "./components/ui/toaster.tsx";
+import App from "./App.tsx";
+import "./index.css";
 
 ReactDOM.createRoot(document.getElementById("root")!).render(
     <React.StrictMode>
         <ThemeProvider>
-            <div className="flex items-center gap-2 justify-center mt-5"><img src="jazz-logo.png" className="h-5"/> Jazz Todo List Example</div>
+            <div className="flex items-center gap-2 justify-center mt-5">
+                <img src="jazz-logo.png" className="h-5" /> Jazz Todo List
+                Example
+            </div>
             <WithJazz
                 auth={LocalAuth({
                     appName: "Jazz Todo List Example",

packages/cojson-simple-sync/.eslintrc.cjs

@@ -0,0 +1,18 @@
+module.exports = {
+    extends: [
+        'eslint:recommended',
+        'plugin:@typescript-eslint/recommended',
+    ],
+    parser: '@typescript-eslint/parser',
+    plugins: ['@typescript-eslint'],
+    parserOptions: {
+        project: './tsconfig.json',
+    },
+    root: true,
+    rules: {
+        "no-unused-vars": "off",
+        "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_", "varsIgnorePattern": "^_" }],
+        "@typescript-eslint/no-floating-promises": "error",
+    },
+
+  };

packages/cojson-simple-sync/.gitignore

@@ -0,0 +1,174 @@
+# Based on https://raw.githubusercontent.com/github/gitignore/main/Node.gitignore
+
+# Logs
+
+logs
+_.log
+npm-debug.log_
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+
+report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
+
+# Runtime data
+
+pids
+_.pid
+_.seed
+\*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+
+lib-cov
+
+# Coverage directory used by tools like istanbul
+
+coverage
+\*.lcov
+
+# nyc test coverage
+
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+
+bower_components
+
+# node-waf configuration
+
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+
+build/Release
+
+# Dependency directories
+
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+
+web_modules/
+
+# TypeScript cache
+
+\*.tsbuildinfo
+
+# Optional npm cache directory
+
+.npm
+
+# Optional eslint cache
+
+.eslintcache
+
+# Optional stylelint cache
+
+.stylelintcache
+
+# Microbundle cache
+
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+
+.node_repl_history
+
+# Output of 'npm pack'
+
+\*.tgz
+
+# Yarn Integrity file
+
+.yarn-integrity
+
+# dotenv environment variable files
+
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# parcel-bundler cache (https://parceljs.org/)
+
+.cache
+.parcel-cache
+
+# Next.js build output
+
+.next
+out
+
+# Nuxt.js build / generate output
+
+.nuxt
+dist
+
+# Gatsby files
+
+.cache/
+
+# Comment in the public line in if your project uses Gatsby and not Next.js
+
+# https://nextjs.org/blog/next-9-1#public-directory-support
+
+# public
+
+# vuepress build output
+
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+
+.temp
+.cache
+
+# Docusaurus cache and generated files
+
+.docusaurus
+
+# Serverless directories
+
+.serverless/
+
+# FuseBox cache
+
+.fusebox/
+
+# DynamoDB Local files
+
+.dynamodb/
+
+# TernJS port file
+
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+
+.vscode-test
+
+# yarn v2
+
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.\*
+
+.DS_Store
+
+out
+sync.db*

packages/cojson-simple-sync/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "cojson-simple-sync",
+    "module": "dist/index.js",
+    "types": "src/index.ts",
+    "type": "module",
+    "license": "MIT",
+    "version": "0.1.8",
+    "devDependencies": {
+        "@types/jest": "^29.5.3",
+        "@types/ws": "^8.5.5",
+        "@typescript-eslint/eslint-plugin": "^6.2.1",
+        "@typescript-eslint/parser": "^6.2.1",
+        "eslint": "^8.46.0",
+        "jest": "^29.6.2",
+        "ts-jest": "^29.1.1",
+        "typescript": "5.0.2"
+    },
+    "dependencies": {
+        "cojson": "^0.1.7",
+        "cojson-storage-sqlite": "^0.1.5",
+        "ws": "^8.13.0"
+    },
+    "scripts": {
+        "build": "rm -rf ./dist && tsc --sourceMap --outDir dist && npm run add-shebang && chmod +x ./dist/index.js",
+        "add-shebang": "echo \"#!/usr/bin/env node\" | cat - ./dist/index.js > /tmp/out && mv /tmp/out ./dist/index.js",
+        "start": "node dist/index.js",
+        "test": "jest",
+        "prepublishOnly": "npm run build"
+    },
+    "bin": "./dist/index.js",
+    "jest": {
+        "preset": "ts-jest",
+        "testEnvironment": "node"
+    }
+}

packages/cojson-simple-sync/src/index.ts

@@ -0,0 +1,54 @@
+import { AnonymousControlledAccount, LocalNode, cojsonInternals } from "cojson";
+import { WebSocketServer } from "ws";
+import { SQLiteStorage } from "cojson-storage-sqlite";
+import { websocketReadableStream, websocketWritableStream } from "./websocketStreams.js";
+
+const wss = new WebSocketServer({ port: 4200 });
+
+console.log("COJSON sync server listening on port " + wss.options.port);
+
+const agentSecret = cojsonInternals.newRandomAgentSecret();
+const agentID = cojsonInternals.getAgentID(agentSecret);
+
+const localNode = new LocalNode(
+    new AnonymousControlledAccount(agentSecret),
+    cojsonInternals.newRandomSessionID(agentID)
+);
+
+SQLiteStorage.asPeer({ filename: "./sync.db" })
+    .then((storage) => localNode.sync.addPeer(storage))
+    .catch((e) => console.error(e));
+
+wss.on("connection", function connection(ws, req) {
+    const pinging = setInterval(() => {
+        ws.send(
+            JSON.stringify({
+                type: "ping",
+                time: Date.now(),
+                dc: "cojson-simple-sync",
+            })
+        );
+    }, 2000);
+
+    ws.on("close", () => {
+        clearInterval(pinging);
+    });
+
+
+
+    const clientAddress =
+        (req.headers["x-forwarded-for"] as string | undefined)
+            ?.split(",")[0]
+            ?.trim() || req.socket.remoteAddress;
+
+    const clientId = clientAddress + "@" + new Date().toISOString();
+
+    localNode.sync.addPeer({
+        id: clientId,
+        role: "client",
+        incoming: websocketReadableStream(ws),
+        outgoing: websocketWritableStream(ws),
+    });
+
+    ws.on("error", (e) => console.error(`Error on connection ${clientId}:`, e));
+});

packages/cojson-simple-sync/src/websocketStreams.ts

@@ -0,0 +1,86 @@
+import { WebSocket } from "ws";
+import { WritableStream, ReadableStream } from "isomorphic-streams";
+
+export function websocketReadableStream<T>(ws: WebSocket) {
+    ws.binaryType = "arraybuffer";
+
+    return new ReadableStream<T>({
+        start(controller) {
+            ws.addEventListener("message", (event) => {
+                if (typeof event.data !== "string")
+                    return console.warn(
+                        "Got non-string message from client",
+                        event.data
+                    );
+                const msg = JSON.parse(event.data);
+                if (msg.type === "ping") {
+                    // console.debug(
+                    //     "Got ping from",
+                    //     msg.dc,
+                    //     "latency",
+                    //     Date.now() - msg.time,
+                    //     "ms"
+                    // );
+                    return;
+                }
+                controller.enqueue(msg);
+            });
+            ws.addEventListener("close", () => controller.close());
+            ws.addEventListener("error", () =>
+                controller.error(new Error("The WebSocket errored!"))
+            );
+        },
+
+        cancel() {
+            ws.close();
+        },
+    });
+}
+
+export function websocketWritableStream<T>(ws: WebSocket) {
+    return new WritableStream<T>({
+        start(controller) {
+            ws.addEventListener("close", () =>
+                controller.error(
+                    new Error("The WebSocket closed unexpectedly!")
+                )
+            );
+            ws.addEventListener("error", () =>
+                controller.error(new Error("The WebSocket errored!"))
+            );
+
+            if (ws.readyState === WebSocket.OPEN) {
+                return;
+            }
+
+            return new Promise((resolve) => ws.once("open", resolve));
+        },
+
+        write(chunk) {
+            ws.send(JSON.stringify(chunk));
+            // Return immediately, since the web socket gives us no easy way to tell
+            // when the write completes.
+        },
+
+        close() {
+            return closeWS(1000);
+        },
+
+        abort(reason) {
+            return closeWS(4000, reason && reason.message);
+        },
+    });
+
+    function closeWS(code: number, reasonString?: string) {
+        return new Promise<void>((resolve, reject) => {
+            ws.onclose = (e) => {
+                if (e.wasClean) {
+                    resolve();
+                } else {
+                    reject(new Error("The connection was not closed cleanly"));
+                }
+            };
+            ws.close(code, reasonString);
+        });
+    }
+}

packages/cojson-simple-sync/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "module": "esnext",
+    "target": "esnext",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "strict": true,
+    "downlevelIteration": true,
+    "skipLibCheck": true,
+    "jsx": "preserve",
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowJs": true,
+    "noUncheckedIndexedAccess": true,
+    "esModuleInterop": true,
+  },
+  "include": ["./src/**/*"],
+}

packages/cojson-storage-sqlite/.eslintrc.cjs

@@ -0,0 +1,17 @@
+module.exports = {
+    extends: [
+        'eslint:recommended',
+        'plugin:@typescript-eslint/recommended',
+    ],
+    parser: '@typescript-eslint/parser',
+    plugins: ['@typescript-eslint'],
+    parserOptions: {
+        project: "./tsconfig.json",
+    },
+    root: true,
+    rules: {
+        "no-unused-vars": "off",
+        "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_", "varsIgnorePattern": "^_" }],
+        // "@typescript-eslint/no-floating-promises": "error",
+    },
+};

packages/cojson-storage-sqlite/.gitignore

@@ -0,0 +1,171 @@
+# Based on https://raw.githubusercontent.com/github/gitignore/main/Node.gitignore
+
+# Logs
+
+logs
+_.log
+npm-debug.log_
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+
+report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
+
+# Runtime data
+
+pids
+_.pid
+_.seed
+\*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+
+lib-cov
+
+# Coverage directory used by tools like istanbul
+
+coverage
+\*.lcov
+
+# nyc test coverage
+
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+
+bower_components
+
+# node-waf configuration
+
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+
+build/Release
+
+# Dependency directories
+
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+
+web_modules/
+
+# TypeScript cache
+
+\*.tsbuildinfo
+
+# Optional npm cache directory
+
+.npm
+
+# Optional eslint cache
+
+.eslintcache
+
+# Optional stylelint cache
+
+.stylelintcache
+
+# Microbundle cache
+
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+
+.node_repl_history
+
+# Output of 'npm pack'
+
+\*.tgz
+
+# Yarn Integrity file
+
+.yarn-integrity
+
+# dotenv environment variable files
+
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# parcel-bundler cache (https://parceljs.org/)
+
+.cache
+.parcel-cache
+
+# Next.js build output
+
+.next
+out
+
+# Nuxt.js build / generate output
+
+.nuxt
+dist
+
+# Gatsby files
+
+.cache/
+
+# Comment in the public line in if your project uses Gatsby and not Next.js
+
+# https://nextjs.org/blog/next-9-1#public-directory-support
+
+# public
+
+# vuepress build output
+
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+
+.temp
+.cache
+
+# Docusaurus cache and generated files
+
+.docusaurus
+
+# Serverless directories
+
+.serverless/
+
+# FuseBox cache
+
+.fusebox/
+
+# DynamoDB Local files
+
+.dynamodb/
+
+# TernJS port file
+
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+
+.vscode-test
+
+# yarn v2
+
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.\*
+
+.DS_Store

packages/cojson-storage-sqlite/.npmignore

@@ -0,0 +1,2 @@
+coverage
+node_modules

packages/cojson-storage-sqlite/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "cojson-storage-sqlite",
+  "type": "module",
+  "version": "0.1.5",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "dependencies": {
+    "better-sqlite3": "^8.5.2",
+    "cojson": "^0.1.7",
+    "typescript": "^5.1.6"
+  },
+  "scripts": {
+    "lint": "eslint src/**/*.ts",
+    "build": "npm run lint && rm -rf ./dist && tsc --declaration --sourceMap --outDir dist",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.4"
+  }
+}

packages/cojson-storage-sqlite/src/index.ts

@@ -0,0 +1,386 @@
+import {
+    cojsonInternals,
+    SyncMessage,
+    Peer,
+    CojsonInternalTypes,
+    SessionID,
+    // CojsonInternalTypes,
+    // SessionID,
+} from "cojson";
+import {
+    ReadableStream,
+    WritableStream,
+    ReadableStreamDefaultReader,
+    WritableStreamDefaultWriter,
+} from "isomorphic-streams";
+
+import Database, { Database as DatabaseT } from "better-sqlite3";
+import { RawCoID } from "cojson/dist/ids";
+
+type CoValueRow = {
+    id: CojsonInternalTypes.RawCoID;
+    header: string;
+};
+
+type StoredCoValueRow = CoValueRow & { rowID: number };
+
+type SessionRow = {
+    coValue: number;
+    sessionID: SessionID;
+    lastIdx: number;
+    lastSignature: CojsonInternalTypes.Signature;
+};
+
+type StoredSessionRow = SessionRow & { rowID: number };
+
+type TransactionRow = {
+    ses: number;
+    idx: number;
+    tx: string;
+};
+
+export class SQLiteStorage {
+    fromLocalNode!: ReadableStreamDefaultReader<SyncMessage>;
+    toLocalNode: WritableStreamDefaultWriter<SyncMessage>;
+    db: DatabaseT;
+
+    constructor(
+        db: DatabaseT,
+        fromLocalNode: ReadableStream<SyncMessage>,
+        toLocalNode: WritableStream<SyncMessage>
+    ) {
+        this.db = db;
+        this.fromLocalNode = fromLocalNode.getReader();
+        this.toLocalNode = toLocalNode.getWriter();
+
+        (async () => {
+            let done = false;
+            while (!done) {
+                const result = await this.fromLocalNode.read();
+                done = result.done;
+
+                if (result.value) {
+                    this.handleSyncMessage(result.value);
+                }
+            }
+        })();
+    }
+
+    static async asPeer({
+        filename,
+        trace,
+        localNodeName = "local",
+    }: {
+        filename: string;
+        trace?: boolean;
+        localNodeName?: string;
+    }): Promise<Peer> {
+        const [localNodeAsPeer, storageAsPeer] = cojsonInternals.connectedPeers(
+            localNodeName,
+            "storage",
+            { peer1role: "client", peer2role: "server", trace }
+        );
+
+        await SQLiteStorage.open(
+            filename,
+            localNodeAsPeer.incoming,
+            localNodeAsPeer.outgoing
+        );
+
+        return storageAsPeer;
+    }
+
+    static async open(
+        filename: string,
+        fromLocalNode: ReadableStream<SyncMessage>,
+        toLocalNode: WritableStream<SyncMessage>
+    ) {
+        const db = Database(filename);
+        db.pragma("journal_mode = WAL");
+
+        db.prepare(
+            `CREATE TABLE IF NOT EXISTS transactions (
+                ses INTEGER,
+                idx INTEGER,
+                tx TEXT NOT NULL ,
+                PRIMARY KEY (ses, idx)
+            ) WITHOUT ROWID;`
+        ).run();
+
+        db.prepare(
+            `CREATE TABLE IF NOT EXISTS sessions (
+                rowID INTEGER PRIMARY KEY,
+                coValue INTEGER NOT NULL,
+                sessionID TEXT NOT NULL,
+                lastIdx INTEGER,
+                lastSignature TEXT,
+                UNIQUE (sessionID, coValue)
+            );`
+        ).run();
+
+        db.prepare(
+            `CREATE INDEX IF NOT EXISTS sessionsByCoValue ON sessions (coValue);`
+        ).run();
+
+        db.prepare(
+            `CREATE TABLE IF NOT EXISTS coValues (
+                rowID INTEGER PRIMARY KEY,
+                id TEXT NOT NULL UNIQUE,
+                header TEXT NOT NULL UNIQUE
+            );`
+        ).run();
+
+        db.prepare(
+            `CREATE INDEX IF NOT EXISTS coValuesByID ON coValues (id);`
+        ).run();
+
+        return new SQLiteStorage(db, fromLocalNode, toLocalNode);
+    }
+
+    async handleSyncMessage(msg: SyncMessage) {
+        switch (msg.action) {
+            case "load":
+                await this.handleLoad(msg);
+                break;
+            case "content":
+                await this.handleContent(msg);
+                break;
+            case "known":
+                await this.handleKnown(msg);
+                break;
+            case "done":
+                await this.handleDone(msg);
+                break;
+        }
+    }
+
+    async sendNewContentAfter(
+        theirKnown: CojsonInternalTypes.CoValueKnownState,
+        asDependencyOf?: CojsonInternalTypes.RawCoID
+    ) {
+        const coValueRow = (await this.db
+            .prepare(`SELECT * FROM coValues WHERE id = ?`)
+            .get(theirKnown.id)) as StoredCoValueRow | undefined;
+
+        const allOurSessions = coValueRow
+            ? (this.db
+                  .prepare<number>(`SELECT * FROM sessions WHERE coValue = ?`)
+                  .all(coValueRow.rowID) as StoredSessionRow[])
+            : [];
+
+        const ourKnown: CojsonInternalTypes.CoValueKnownState = {
+            id: theirKnown.id,
+            header: !!coValueRow,
+            sessions: {},
+        };
+
+        const parsedHeader = (coValueRow?.header &&
+            JSON.parse(coValueRow.header)) as
+            | CojsonInternalTypes.CoValueHeader
+            | undefined;
+
+        const newContent: CojsonInternalTypes.NewContentMessage = {
+            action: "content",
+            id: theirKnown.id,
+            header: theirKnown.header ? undefined : parsedHeader,
+            new: {},
+        };
+
+        for (const sessionRow of allOurSessions) {
+            ourKnown.sessions[sessionRow.sessionID] = sessionRow.lastIdx;
+
+            if (
+                sessionRow.lastIdx >
+                (theirKnown.sessions[sessionRow.sessionID] || 0)
+            ) {
+                const firstNewTxIdx =
+                    theirKnown.sessions[sessionRow.sessionID] || 0;
+
+                const newTxInSession = this.db
+                    .prepare<[number, number]>(
+                        `SELECT * FROM transactions WHERE ses = ? AND idx > ?`
+                    )
+                    .all(sessionRow.rowID, firstNewTxIdx) as TransactionRow[];
+
+                newContent.new[sessionRow.sessionID] = {
+                    after: firstNewTxIdx,
+                    lastSignature: sessionRow.lastSignature,
+                    newTransactions: newTxInSession.map((row) =>
+                        JSON.parse(row.tx)
+                    ),
+                };
+            }
+        }
+
+        const dependedOnCoValues =
+            parsedHeader?.ruleset.type === "group"
+                ? Object.values(newContent.new).flatMap((sessionEntry) =>
+                      sessionEntry.newTransactions.flatMap((tx) => {
+                          if (tx.privacy !== "trusting") return [];
+                          return tx.changes
+                              .map(
+                                  (change) =>
+                                      change &&
+                                      typeof change === "object" &&
+                                      "op" in change &&
+                                      change.op === "set" &&
+                                      "key" in change &&
+                                      change.key
+                              )
+                              .filter(
+                                  (key): key is CojsonInternalTypes.RawCoID =>
+                                      typeof key === "string" &&
+                                      key.startsWith("co_")
+                              );
+                      })
+                  )
+                : parsedHeader?.ruleset.type === "ownedByGroup"
+                ? [parsedHeader?.ruleset.group]
+                : [];
+
+        for (const dependedOnCoValue of dependedOnCoValues) {
+            await this.sendNewContentAfter(
+                { id: dependedOnCoValue, header: false, sessions: {} },
+                asDependencyOf || theirKnown.id
+            );
+        }
+
+        await this.toLocalNode.write({
+            action: "known",
+            ...ourKnown,
+            asDependencyOf,
+        });
+
+        if (newContent.header || Object.keys(newContent.new).length > 0) {
+            await this.toLocalNode.write(newContent);
+        }
+    }
+
+    handleLoad(msg: CojsonInternalTypes.LoadMessage) {
+        return this.sendNewContentAfter(msg);
+    }
+
+    async handleContent(msg: CojsonInternalTypes.NewContentMessage) {
+        let storedCoValueRowID = (
+            this.db
+                .prepare<RawCoID>(`SELECT rowID FROM coValues WHERE id = ?`)
+                .get(msg.id) as StoredCoValueRow | undefined
+        )?.rowID;
+
+        if (storedCoValueRowID === undefined) {
+            const header = msg.header;
+            if (!header) {
+                console.error("Expected to be sent header first");
+                await this.toLocalNode.write({
+                    action: "known",
+                    id: msg.id,
+                    header: false,
+                    sessions: {},
+                    isCorrection: true,
+                });
+                return;
+            }
+
+            storedCoValueRowID = this.db
+                .prepare<[RawCoID, string]>(
+                    `INSERT INTO coValues (id, header) VALUES (?, ?)`
+                )
+                .run(msg.id, JSON.stringify(header)).lastInsertRowid as number;
+        }
+
+        const ourKnown: CojsonInternalTypes.CoValueKnownState = {
+            id: msg.id,
+            header: true,
+            sessions: {},
+        };
+        let invalidAssumptions = false;
+
+        this.db.transaction(() => {
+            const allOurSessions = (
+                this.db
+                    .prepare<number>(`SELECT * FROM sessions WHERE coValue = ?`)
+                    .all(storedCoValueRowID!) as StoredSessionRow[]
+            ).reduce((acc, row) => {
+                acc[row.sessionID] = row;
+                return acc;
+            }, {} as { [sessionID: string]: StoredSessionRow });
+
+            for (const sessionID of Object.keys(msg.new) as SessionID[]) {
+                const sessionRow = allOurSessions[sessionID];
+                if (sessionRow) {
+                    ourKnown.sessions[sessionRow.sessionID] =
+                        sessionRow.lastIdx;
+                }
+
+                if (
+                    (sessionRow?.lastIdx || 0) <
+                    (msg.new[sessionID]?.after || 0)
+                ) {
+                    invalidAssumptions = true;
+                } else {
+                    const newTransactions =
+                        msg.new[sessionID]?.newTransactions || [];
+
+                    const actuallyNewOffset =
+                        (sessionRow?.lastIdx || 0) -
+                        (msg.new[sessionID]?.after || 0);
+                    const actuallyNewTransactions =
+                        newTransactions.slice(actuallyNewOffset);
+
+                    let nextIdx = sessionRow?.lastIdx || 0;
+
+                    const sessionUpdate = {
+                        coValue: storedCoValueRowID!,
+                        sessionID: sessionID,
+                        lastIdx:
+                            (sessionRow?.lastIdx || 0) +
+                            actuallyNewTransactions.length,
+                        lastSignature: msg.new[sessionID]!.lastSignature,
+                    };
+
+                    const upsertedSession = (this.db
+                        .prepare<[number, string, number, string]>(
+                            `INSERT INTO sessions (coValue, sessionID, lastIdx, lastSignature) VALUES (?, ?, ?, ?)
+                            ON CONFLICT(coValue, sessionID) DO UPDATE SET lastIdx=excluded.lastIdx, lastSignature=excluded.lastSignature
+                            RETURNING rowID`
+                        )
+                        .get(
+                            sessionUpdate.coValue,
+                            sessionUpdate.sessionID,
+                            sessionUpdate.lastIdx,
+                            sessionUpdate.lastSignature
+                        ) as {rowID: number});
+
+                    const sessionRowID = upsertedSession.rowID;
+
+                    for (const newTransaction of actuallyNewTransactions) {
+                        nextIdx++;
+                        this.db
+                            .prepare<[number, number, string]>(
+                                `INSERT INTO transactions (ses, idx, tx) VALUES (?, ?, ?)`
+                            )
+                            .run(
+                                sessionRowID,
+                                nextIdx,
+                                JSON.stringify(newTransaction)
+                            );
+                    }
+                }
+            }
+        })();
+
+        if (invalidAssumptions) {
+            await this.toLocalNode.write({
+                action: "known",
+                ...ourKnown,
+                isCorrection: invalidAssumptions,
+            });
+        }
+    }
+
+    handleKnown(msg: CojsonInternalTypes.KnownStateMessage) {
+        return this.sendNewContentAfter(msg);
+    }
+
+    handleDone(_msg: CojsonInternalTypes.DoneMessage) {}
+}

packages/cojson-storage-sqlite/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "module": "esnext",
+    "target": "ES2020",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUncheckedIndexedAccess": true,
+    "esModuleInterop": true,
+  },
+  "include": ["./src/**/*"],
+}

packages/cojson/README.md

@@ -1,53 +1,3 @@
 # CoJSON
 
-CoJSON ("Collaborative JSON") will be a minimal protocol and implementation for collaborative values (CRDTs + public-key cryptography).
-
-CoJSON is developed by [Garden Computing](https://gcmp.io) as the underpinnings of [Jazz](https://jazz.tools), a framework for building apps with telepathic data.
-
-The protocol and implementation will cover:
-
-- how to represent collaborative values internally
-- the APIs collaborative values expose
-- how to sync and query for collaborative values between peers
-- how to enforce access rights within collaborative values locally and at sync boundaries
-
-THIS IS WORK IN PROGRESS
-
-## Core Value Types
-
-### `Immutable` Values (JSON)
-- null
-- boolean
-- number
-- string
-  - stringly-encoded CoJSON identifiers & data (`CoID`, `AgentID`, `SessionID`, `SignerID`, `SignerSecret`, `Signature`, `SealerID`, `SealerSecret`, `Sealed`, `Hash`, `ShortHash`, `KeySecret`, `KeyID`, `Encrypted`, `Role`)
-
-- array
-- object
-
-### `Collaborative` Values
-- CoMap (`string` → `Immutable`, last-writer-wins per key)
-  - Group (`AgentID` → `Role`)
-- CoList (`Immutable[]`, addressable positions, insertAfter semantics)
-  - Agent (`{signerID, sealerID}[]`)
-- CoStream (independent per-session streams of `Immutable`s)
-- Static (single addressable `Immutable`)
-
-## Implementation Abstractions
-- CoValue
-  - Session Logs
-  - Transactions
-    - Private (encrypted) transactions
-    - Trusting (unencrypted) transactions
-  - Rulesets
-- CoValue Content Types
-- LocalNode
-  - Peers
-  - AgentCredentials
-- Peer
-
-## Extensions & higher-level protocols
-
-### More complex datastructures
-- CoText: a clean way to collaboratively mark up rich text with CoJSON
-- CoJSON Tree: a clean way to represent collaborative tree structures with CoJSON
+[See the top-level README](../../README.md#cojson)

packages/cojson/package.json

@@ -5,7 +5,7 @@
     "types": "dist/index.d.ts",
     "type": "module",
     "license": "MIT",
-    "version": "0.1.1",
+    "version": "0.1.7",
     "devDependencies": {
         "@types/jest": "^29.5.3",
         "@typescript-eslint/eslint-plugin": "^6.2.1",

packages/cojson/src/account.test.ts

@@ -34,7 +34,7 @@ test("A node with an account can create groups and and objects within them", asy
 
     expect(map.get("foo")).toEqual("bar");
 
-    expect(map.getLastEditor("foo")).toEqual(accountID);
+    expect(map.whoEdited("foo")).toEqual(accountID);
 });
 
 test("Can create account with one node, and then load it on another", async () => {

packages/cojson/src/account.ts

@@ -52,7 +52,7 @@ export class Account extends Group {
 }
 
 export interface GeneralizedControlledAccount {
-    id: AccountIDOrAgentID;
+    id: AccountID | AgentID;
     agentSecret: AgentSecret;
 
     currentAgentID: () => AgentID;
@@ -135,13 +135,10 @@ export class AnonymousControlledAccount
 
 export type AccountContent = GroupContent & { profile: CoID<Profile> };
 export type AccountMeta = { type: "account" };
-export type AccountID = CoID<CoMap<AccountContent, AccountMeta>>;
+export type AccountMap = CoMap<AccountContent, AccountMeta>;
+export type AccountID = CoID<AccountMap>;
 
-export type AccountIDOrAgentID = AgentID | AccountID;
-export type AccountOrAgentID = AgentID | Account;
-export type AccountOrAgentSecret = AgentSecret | Account;
-
-export function isAccountID(id: AccountIDOrAgentID): id is AccountID {
+export function isAccountID(id: AccountID | AgentID): id is AccountID {
     return id.startsWith("co_");
 }
 

packages/cojson/src/coValue.test.ts

@@ -28,13 +28,13 @@ test("Can create coValue with new agent credentials and add transaction to it",
     };
 
     const { expectedNewHash } = coValue.expectedNewHashAfter(
-        node.ownSessionID,
+        node.currentSessionID,
         [transaction]
     );
 
     expect(
         coValue.tryAddTransactions(
-            node.ownSessionID,
+            node.currentSessionID,
             [transaction],
             expectedNewHash,
             sign(account.currentSignerSecret(), expectedNewHash)
@@ -65,13 +65,13 @@ test("transactions with wrong signature are rejected", () => {
     };
 
     const { expectedNewHash } = coValue.expectedNewHashAfter(
-        node.ownSessionID,
+        node.currentSessionID,
         [transaction]
     );
 
     expect(
         coValue.tryAddTransactions(
-            node.ownSessionID,
+            node.currentSessionID,
             [transaction],
             expectedNewHash,
             sign(getAgentSignerSecret(wrongAgent), expectedNewHash)
@@ -101,7 +101,7 @@ test("transactions with correctly signed, but wrong hash are rejected", () => {
     };
 
     const { expectedNewHash } = coValue.expectedNewHashAfter(
-        node.ownSessionID,
+        node.currentSessionID,
         [
             {
                 privacy: "trusting",
@@ -117,7 +117,7 @@ test("transactions with correctly signed, but wrong hash are rejected", () => {
 
     expect(
         coValue.tryAddTransactions(
-            node.ownSessionID,
+            node.currentSessionID,
             [transaction],
             expectedNewHash,
             sign(account.currentSignerSecret(), expectedNewHash)
@@ -170,7 +170,7 @@ test("New transactions in a group correctly update owned values, including subsc
 
     expect(map.coValue.getValidSortedTransactions().length).toBe(1);
 
-    const manuallyAdddedTxSuccess = group.groupMap.coValue.tryAddTransactions(node.ownSessionID, [resignationThatWeJustLearnedAbout], expectedNewHash, signature);
+    const manuallyAdddedTxSuccess = group.groupMap.coValue.tryAddTransactions(node.currentSessionID, [resignationThatWeJustLearnedAbout], expectedNewHash, signature);
 
     expect(manuallyAdddedTxSuccess).toBe(true);
 

packages/cojson/src/coValue.ts

@@ -30,11 +30,10 @@ import {
 import { Group, expectGroupContent } from "./group.js";
 import { LocalNode } from "./node.js";
 import { CoValueKnownState, NewContentMessage } from "./sync.js";
-import { RawCoID, SessionID, TransactionID } from "./ids.js";
+import { AgentID, RawCoID, SessionID, TransactionID } from "./ids.js";
 import { CoList } from "./contentTypes/coList.js";
 import {
     AccountID,
-    AccountIDOrAgentID,
     GeneralizedControlledAccount,
 } from "./account.js";
 
@@ -53,11 +52,11 @@ export function idforHeader(header: CoValueHeader): RawCoID {
 
 export function accountOrAgentIDfromSessionID(
     sessionID: SessionID
-): AccountIDOrAgentID {
-    return sessionID.split("_session")[0] as AccountIDOrAgentID;
+): AccountID | AgentID {
+    return sessionID.split("_session")[0] as AccountID | AgentID;
 }
 
-export function newRandomSessionID(accountID: AccountIDOrAgentID): SessionID {
+export function newRandomSessionID(accountID: AccountID | AgentID): SessionID {
     return `${accountID}_session_z${base58.encode(randomBytes(8))}`;
 }
 
@@ -92,6 +91,8 @@ export type DecryptedTransaction = {
     madeAt: number;
 };
 
+const readKeyCache = new WeakMap<CoValue, { [id: KeyID]: KeySecret }>();
+
 export class CoValue {
     id: RawCoID;
     node: LocalNode;
@@ -100,7 +101,11 @@ export class CoValue {
     _cachedContent?: ContentType;
     listeners: Set<(content?: ContentType) => void> = new Set();
 
-    constructor(header: CoValueHeader, node: LocalNode, internalInitSessions: { [key: SessionID]: SessionLog } = {}) {
+    constructor(
+        header: CoValueHeader,
+        node: LocalNode,
+        internalInitSessions: { [key: SessionID]: SessionLog } = {}
+    ) {
         this.id = idforHeader(header);
         this.header = header;
         this._sessions = internalInitSessions;
@@ -125,11 +130,11 @@ export class CoValue {
 
     testWithDifferentAccount(
         account: GeneralizedControlledAccount,
-        ownSessionID: SessionID
+        currentSessionID: SessionID
     ): CoValue {
         const newNode = this.node.testWithDifferentAccount(
             account,
-            ownSessionID
+            currentSessionID
         );
 
         return newNode.expectCoValueLoaded(this.id);
@@ -153,7 +158,7 @@ export class CoValue {
     }
 
     nextTransactionID(): TransactionID {
-        const sessionID = this.node.ownSessionID;
+        const sessionID = this.node.currentSessionID;
         return {
             sessionID,
             txIndex: this.sessions[sessionID]?.transactions.length || 0,
@@ -288,7 +293,7 @@ export class CoValue {
             };
         }
 
-        const sessionID = this.node.ownSessionID;
+        const sessionID = this.node.currentSessionID;
 
         const { expectedNewHash } = this.expectedNewHashAfter(sessionID, [
             transaction,
@@ -412,6 +417,9 @@ export class CoValue {
     }
 
     getReadKey(keyID: KeyID): KeySecret | undefined {
+        if (readKeyCache.get(this)?.[keyID]) {
+            return readKeyCache.get(this)?.[keyID];
+        }
         if (this.header.ruleset.type === "group") {
             const content = expectGroupContent(this.getCurrentContent());
 
@@ -440,7 +448,16 @@ export class CoValue {
                     }
                 );
 
-                if (secret) return secret as KeySecret;
+                if (secret) {
+                    let cache = readKeyCache.get(this);
+                    if (!cache) {
+                        cache = {};
+                        readKeyCache.set(this, cache);
+                    }
+                    cache[keyID] = secret;
+
+                    return secret as KeySecret;
+                }
             }
 
             // Try to find indirect revelation through previousKeys
@@ -467,7 +484,14 @@ export class CoValue {
                     );
 
                     if (secret) {
-                        return secret;
+                        let cache = readKeyCache.get(this);
+                        if (!cache) {
+                            cache = {};
+                            readKeyCache.set(this, cache);
+                        }
+                        cache[keyID] = secret;
+
+                        return secret as KeySecret;
                     } else {
                         console.error(
                             `Encrypting ${encryptingKeyID} key didn't decrypt ${keyID}`

packages/cojson/src/contentType.test.ts

@@ -3,7 +3,7 @@ import { createdNowUnique } from "./crypto.js";
 import { LocalNode } from "./node.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
 
-test("Empty COJSON Map works", () => {
+test("Empty CoMap works", () => {
     const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
@@ -24,7 +24,7 @@ test("Empty COJSON Map works", () => {
     expect(content.toJSON()).toEqual({});
 });
 
-test("Can insert and delete Map entries in edit()", () => {
+test("Can insert and delete CoMap entries in edit()", () => {
     const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
@@ -53,7 +53,7 @@ test("Can insert and delete Map entries in edit()", () => {
     });
 });
 
-test("Can get map entry values at different points in time", () => {
+test("Can get CoMap entry values at different points in time", () => {
     const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
@@ -89,7 +89,7 @@ test("Can get map entry values at different points in time", () => {
     });
 });
 
-test("Can get all historic values of key", () => {
+test("Can get all historic values of key in CoMap", () => {
     const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
@@ -141,7 +141,7 @@ test("Can get all historic values of key", () => {
     });
 });
 
-test("Can get last tx ID for a key", () => {
+test("Can get last tx ID for a key in CoMap", () => {
     const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
@@ -173,3 +173,112 @@ test("Can get last tx ID for a key", () => {
         expect(editable.getLastTxID("hello")?.txIndex).toEqual(2);
     });
 });
+
+test("Empty CoList works", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+
+    const coValue = node.createCoValue({
+        type: "colist",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "colist") {
+        throw new Error("Expected list");
+    }
+
+    expect(content.type).toEqual("colist");
+    expect(content.toJSON()).toEqual([]);
+});
+
+test("Can append, prepend and delete items to CoList", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+
+    const coValue = node.createCoValue({
+        type: "colist",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "colist") {
+        throw new Error("Expected list");
+    }
+
+    expect(content.type).toEqual("colist");
+
+    content.edit((editable) => {
+        editable.append(0, "hello", "trusting");
+        expect(editable.toJSON()).toEqual(["hello"]);
+        editable.append(0, "world", "trusting");
+        expect(editable.toJSON()).toEqual(["hello", "world"]);
+        editable.prepend(1, "beautiful", "trusting");
+        expect(editable.toJSON()).toEqual(["hello", "beautiful", "world"]);
+        editable.prepend(3, "hooray", "trusting");
+        expect(editable.toJSON()).toEqual([
+            "hello",
+            "beautiful",
+            "world",
+            "hooray",
+        ]);
+        editable.delete(2, "trusting");
+        expect(editable.toJSON()).toEqual(["hello", "beautiful", "hooray"]);
+    });
+});
+
+test("Push is equivalent to append after last item", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+
+    const coValue = node.createCoValue({
+        type: "colist",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "colist") {
+        throw new Error("Expected list");
+    }
+
+    expect(content.type).toEqual("colist");
+
+    content.edit((editable) => {
+        editable.append(0, "hello", "trusting");
+        expect(editable.toJSON()).toEqual(["hello"]);
+        editable.push("world", "trusting");
+        expect(editable.toJSON()).toEqual(["hello", "world"]);
+        editable.push("hooray", "trusting");
+        expect(editable.toJSON()).toEqual(["hello", "world", "hooray"]);
+    });
+});
+
+test("Can push into empty list", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+
+    const coValue = node.createCoValue({
+        type: "colist",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "colist") {
+        throw new Error("Expected list");
+    }
+
+    expect(content.type).toEqual("colist");
+
+    content.edit((editable) => {
+        editable.push("hello", "trusting");
+        expect(editable.toJSON()).toEqual(["hello"]);
+    });
+})

packages/cojson/src/contentTypes/coList.ts

@@ -1,19 +1,288 @@
-import { JsonObject, JsonValue } from '../jsonValue.js';
-import { CoID } from '../contentType.js';
-import { CoValue } from '../coValue.js';
+import { JsonObject, JsonValue } from "../jsonValue.js";
+import { CoID } from "../contentType.js";
+import { CoValue, accountOrAgentIDfromSessionID } from "../coValue.js";
+import { SessionID, TransactionID } from "../ids.js";
+import { AccountID, Group } from "../index.js";
+import { isAccountID } from "../account.js";
 
-export class CoList<T extends JsonValue, Meta extends JsonObject | null = null> {
+type OpID = TransactionID & { changeIdx: number };
+
+type InsertionOpPayload<T extends JsonValue> =
+    | {
+          op: "pre";
+          value: T;
+          before: OpID | "end";
+      }
+    | {
+          op: "app";
+          value: T;
+          after: OpID | "start";
+      };
+
+type DeletionOpPayload = {
+    op: "del";
+    insertion: OpID;
+};
+
+export type ListOpPayload<T extends JsonValue> =
+    | InsertionOpPayload<T>
+    | DeletionOpPayload;
+
+type InsertionEntry<T extends JsonValue> = {
+    madeAt: number;
+    predecessors: OpID[];
+    successors: OpID[];
+} & InsertionOpPayload<T>;
+
+type DeletionEntry = {
+    madeAt: number;
+    deletionID: OpID;
+} & DeletionOpPayload;
+
+export class CoList<
+    T extends JsonValue,
+    Meta extends JsonObject | null = null
+> {
     id: CoID<CoList<T, Meta>>;
     type = "colist" as const;
     coValue: CoValue;
+    afterStart: OpID[];
+    beforeEnd: OpID[];
+    insertions: {
+        [sessionID: SessionID]: {
+            [txIdx: number]: {
+                [changeIdx: number]: InsertionEntry<T>;
+            };
+        };
+    };
+    deletionsByInsertion: {
+        [deletedSessionID: SessionID]: {
+            [deletedTxIdx: number]: {
+                [deletedChangeIdx: number]: DeletionEntry[];
+            };
+        };
+    };
 
     constructor(coValue: CoValue) {
         this.id = coValue.id as CoID<CoList<T, Meta>>;
         this.coValue = coValue;
+        this.afterStart = [];
+        this.beforeEnd = [];
+        this.insertions = {};
+        this.deletionsByInsertion = {};
+
+        this.fillOpsFromCoValue();
     }
 
-    toJSON(): JsonObject {
-        throw new Error("Method not implemented.");
+
+    get meta(): Meta {
+        return this.coValue.header.meta as Meta;
+    }
+
+    get group(): Group {
+        return this.coValue.getGroup();
+    }
+
+    protected fillOpsFromCoValue() {
+        this.insertions = {};
+        this.deletionsByInsertion = {};
+        this.afterStart = [];
+        this.beforeEnd = [];
+
+        for (const {
+            txID,
+            changes,
+            madeAt,
+        } of this.coValue.getValidSortedTransactions()) {
+            for (const [changeIdx, changeUntyped] of changes.entries()) {
+                const change = changeUntyped as ListOpPayload<T>;
+
+                if (change.op === "pre" || change.op === "app") {
+                    let sessionEntry = this.insertions[txID.sessionID];
+                    if (!sessionEntry) {
+                        sessionEntry = {};
+                        this.insertions[txID.sessionID] = sessionEntry;
+                    }
+                    let txEntry = sessionEntry[txID.txIndex];
+                    if (!txEntry) {
+                        txEntry = {};
+                        sessionEntry[txID.txIndex] = txEntry;
+                    }
+                    txEntry[changeIdx] = {
+                        madeAt,
+                        predecessors: [],
+                        successors: [],
+                        ...change,
+                    };
+                    if (change.op === "pre") {
+                        if (change.before === "end") {
+                            this.beforeEnd.push({
+                                ...txID,
+                                changeIdx,
+                            });
+                        } else {
+                            const beforeEntry =
+                                this.insertions[change.before.sessionID]?.[
+                                    change.before.txIndex
+                                ]?.[change.before.changeIdx];
+                            if (!beforeEntry) {
+                                throw new Error(
+                                    "Not yet implemented: insertion before missing op " +
+                                        change.before
+                                );
+                            }
+                            beforeEntry.predecessors.splice(0, 0, {
+                                ...txID,
+                                changeIdx,
+                            });
+                        }
+                    } else {
+                        if (change.after === "start") {
+                            this.afterStart.push({
+                                ...txID,
+                                changeIdx,
+                            });
+                        } else {
+                            const afterEntry =
+                                this.insertions[change.after.sessionID]?.[
+                                    change.after.txIndex
+                                ]?.[change.after.changeIdx];
+                            if (!afterEntry) {
+                                throw new Error(
+                                    "Not yet implemented: insertion after missing op " +
+                                        change.after
+                                );
+                            }
+                            afterEntry.successors.push({
+                                ...txID,
+                                changeIdx,
+                            });
+                        }
+                    }
+                } else if (change.op === "del") {
+                    let sessionEntry =
+                        this.deletionsByInsertion[change.insertion.sessionID];
+                    if (!sessionEntry) {
+                        sessionEntry = {};
+                        this.deletionsByInsertion[change.insertion.sessionID] =
+                            sessionEntry;
+                    }
+                    let txEntry = sessionEntry[change.insertion.txIndex];
+                    if (!txEntry) {
+                        txEntry = {};
+                        sessionEntry[change.insertion.txIndex] = txEntry;
+                    }
+                    let changeEntry = txEntry[change.insertion.changeIdx];
+                    if (!changeEntry) {
+                        changeEntry = [];
+                        txEntry[change.insertion.changeIdx] = changeEntry;
+                    }
+                    changeEntry.push({
+                        madeAt,
+                        deletionID: {
+                            ...txID,
+                            changeIdx,
+                        },
+                        ...change,
+                    });
+                } else {
+                    throw new Error(
+                        "Unknown list operation " +
+                            (change as { op: unknown }).op
+                    );
+                }
+            }
+        }
+    }
+
+    entries(): { value: T; madeAt: number; opID: OpID }[] {
+        const arr: { value: T; madeAt: number; opID: OpID }[] = [];
+        for (const opID of this.afterStart) {
+            this.fillArrayFromOpID(opID, arr);
+        }
+        for (const opID of this.beforeEnd) {
+            this.fillArrayFromOpID(opID, arr);
+        }
+        return arr;
+    }
+
+    private fillArrayFromOpID(
+        opID: OpID,
+        arr: { value: T; madeAt: number; opID: OpID }[]
+    ) {
+        const entry =
+            this.insertions[opID.sessionID]?.[opID.txIndex]?.[opID.changeIdx];
+        if (!entry) {
+            throw new Error("Missing op " + opID);
+        }
+        for (const predecessor of entry.predecessors) {
+            this.fillArrayFromOpID(predecessor, arr);
+        }
+        const deleted =
+            (this.deletionsByInsertion[opID.sessionID]?.[opID.txIndex]?.[
+                opID.changeIdx
+            ]?.length || 0) > 0;
+        if (!deleted) {
+            arr.push({
+                value: entry.value,
+                madeAt: entry.madeAt,
+                opID,
+            });
+        }
+        for (const successor of entry.successors) {
+            this.fillArrayFromOpID(successor, arr);
+        }
+    }
+
+    whoInserted(idx: number): AccountID | undefined {
+        const entry = this.entries()[idx];
+        if (!entry) {
+            return undefined;
+        }
+        const accountID = accountOrAgentIDfromSessionID(entry.opID.sessionID);
+        if (isAccountID(accountID)) {
+            return accountID;
+        } else {
+            return undefined;
+        }
+    }
+
+    toJSON(): T[] {
+        return this.asArray();
+    }
+
+    asArray(): T[] {
+        return this.entries().map((entry) => entry.value);
+    }
+
+    map<U>(mapper: (value: T, idx: number) => U): U[] {
+        return this.entries().map((entry, idx) => mapper(entry.value, idx));
+    }
+
+    filter<U extends T>(predicate: (value: T, idx: number) => value is U): U[]
+    filter(predicate: (value: T, idx: number) => boolean): T[] {
+        return this.entries()
+            .filter((entry, idx) => predicate(entry.value, idx))
+            .map((entry) => entry.value);
+    }
+
+    reduce<U>(
+        reducer: (accumulator: U, value: T, idx: number) => U,
+        initialValue: U
+    ): U {
+        return this.entries().reduce(
+            (accumulator, entry, idx) =>
+                reducer(accumulator, entry.value, idx),
+            initialValue
+        );
+    }
+
+    edit(
+        changer: (editable: WriteableCoList<T, Meta>) => void
+    ): CoList<T, Meta> {
+        const editable = new WriteableCoList<T, Meta>(this.coValue);
+        changer(editable);
+        return new CoList(this.coValue);
     }
 
     subscribe(listener: (coMap: CoList<T, Meta>) => void): () => void {
@@ -22,3 +291,106 @@ export class CoList<T extends JsonValue, Meta extends JsonObject | null = null>
         });
     }
 }
+
+export class WriteableCoList<
+    T extends JsonValue,
+    Meta extends JsonObject | null = null
+> extends CoList<T, Meta> {
+    append(
+        after: number,
+        value: T,
+        privacy: "private" | "trusting" = "private"
+    ): void {
+        const entries = this.entries();
+        let opIDBefore;
+        if (entries.length > 0) {
+            const entryBefore = entries[after];
+            if (!entryBefore) {
+                throw new Error("Invalid index " + after);
+            }
+            opIDBefore = entryBefore.opID;
+        } else {
+            if (after !== 0) {
+                throw new Error("Invalid index " + after);
+            }
+            opIDBefore = "start";
+        }
+        this.coValue.makeTransaction(
+            [
+                {
+                    op: "app",
+                    value,
+                    after: opIDBefore,
+                },
+            ],
+            privacy
+        );
+
+        this.fillOpsFromCoValue();
+    }
+
+    push(value: T, privacy: "private" | "trusting" = "private"): void {
+        // TODO: optimize
+        const entries = this.entries();
+        this.append(entries.length > 0 ? entries.length - 1 : 0, value, privacy);
+    }
+
+    prepend(
+        before: number,
+        value: T,
+        privacy: "private" | "trusting" = "private"
+    ): void {
+        const entries = this.entries();
+        let opIDAfter;
+        if (entries.length > 0) {
+            const entryAfter = entries[before];
+            if (entryAfter) {
+                opIDAfter = entryAfter.opID;
+            } else {
+                if (before !== entries.length) {
+                    throw new Error("Invalid index " + before);
+                }
+                opIDAfter = "end";
+            }
+        } else {
+            if (before !== 0) {
+                throw new Error("Invalid index " + before);
+            }
+            opIDAfter = "end";
+        }
+        this.coValue.makeTransaction(
+            [
+                {
+                    op: "pre",
+                    value,
+                    before: opIDAfter,
+                },
+            ],
+            privacy
+        );
+
+        this.fillOpsFromCoValue();
+    }
+
+    delete(
+        at: number,
+        privacy: "private" | "trusting" = "private"
+    ): void {
+        const entries = this.entries();
+        const entry = entries[at];
+        if (!entry) {
+            throw new Error("Invalid index " + at);
+        }
+        this.coValue.makeTransaction(
+            [
+                {
+                    op: "del",
+                    insertion: entry.opID,
+                },
+            ],
+            privacy
+        );
+
+        this.fillOpsFromCoValue();
+    }
+}

packages/cojson/src/contentTypes/coMap.ts

@@ -3,6 +3,7 @@ import { TransactionID } from '../ids.js';
 import { CoID } from '../contentType.js';
 import { CoValue, accountOrAgentIDfromSessionID } from '../coValue.js';
 import { AccountID, isAccountID } from '../account.js';
+import { Group } from '../group.js';
 
 type MapOp<K extends string, V extends JsonValue> = {
     txID: TransactionID;
@@ -46,6 +47,14 @@ export class CoMap<
         this.fillOpsFromCoValue();
     }
 
+    get meta(): Meta {
+        return this.coValue.header.meta as Meta;
+    }
+
+    get group(): Group {
+        return this.coValue.getGroup();
+    }
+
     protected fillOpsFromCoValue() {
         this.ops = {};
 
@@ -107,7 +116,7 @@ export class CoMap<
         }
     }
 
-    getLastEditor<K extends MapK<M>>(key: K): AccountID | undefined {
+    whoEdited<K extends MapK<M>>(key: K): AccountID | undefined {
         const tx  = this.getLastTxID(key);
         if (!tx) {
             return undefined;

packages/cojson/src/group.ts

@@ -16,20 +16,21 @@ import {
     getAgentID,
 } from "./crypto.js";
 import { LocalNode } from "./node.js";
-import { SessionID, isAgentID } from "./ids.js";
+import { AgentID, SessionID, isAgentID } from "./ids.js";
 import {
-    AccountIDOrAgentID,
+    AccountID,
     GeneralizedControlledAccount,
     Profile,
 } from "./account.js";
 import { Role } from "./permissions.js";
 import { base58 } from "@scure/base";
+import { CoList } from "./contentTypes/coList.js";
 
 export type GroupContent = {
     profile: CoID<Profile> | null;
-    [key: AccountIDOrAgentID]: Role;
+    [key: AccountID | AgentID]: Role;
     readKey: KeyID;
-    [revelationFor: `${KeyID}_for_${AccountIDOrAgentID}`]: Sealed<KeySecret>;
+    [revelationFor: `${KeyID}_for_${AccountID | AgentID}`]: Sealed<KeySecret>;
     [oldKeyForNewKey: `${KeyID}_for_${KeyID}`]: Encrypted<
         KeySecret,
         { encryptedID: KeyID; encryptingID: KeyID }
@@ -62,15 +63,25 @@ export class Group {
         return this.groupMap.id;
     }
 
-    roleOf(accountID: AccountIDOrAgentID): Role | undefined {
+    roleOf(accountID: AccountID): Role | undefined {
+        return this.roleOfInternal(accountID);
+    }
+
+    /** @internal */
+    roleOfInternal(accountID: AccountID | AgentID): Role | undefined {
         return this.groupMap.get(accountID);
     }
 
     myRole(): Role | undefined {
-        return this.roleOf(this.node.account.id);
+        return this.roleOfInternal(this.node.account.id);
     }
 
-    addMember(accountID: AccountIDOrAgentID, role: Role) {
+    addMember(accountID: AccountID, role: Role) {
+        this.addMemberInternal(accountID, role);
+    }
+
+    /** @internal */
+    addMemberInternal(accountID: AccountID | AgentID, role: Role) {
         this.groupMap = this.groupMap.edit((map) => {
             const currentReadKey = this.groupMap.coValue.getCurrentReadKey();
 
@@ -111,7 +122,7 @@ export class Group {
         const inviteSecret = agentSecretFromSecretSeed(secretSeed);
         const inviteID = getAgentID(inviteSecret);
 
-        this.addMember(inviteID, `${role}Invite` as Role);
+        this.addMemberInternal(inviteID, `${role}Invite` as Role);
 
         return inviteSecretFromSecretSeed(secretSeed);
     }
@@ -126,7 +137,7 @@ export class Group {
             } else {
                 return false;
             }
-        }) as AccountIDOrAgentID[];
+        }) as (AccountID | AgentID)[];
 
         const maybeCurrentReadKey = this.groupMap.coValue.getCurrentReadKey();
 
@@ -178,7 +189,12 @@ export class Group {
         });
     }
 
-    removeMember(accountID: AccountIDOrAgentID) {
+    removeMember(accountID: AccountID) {
+        this.removeMemberInternal(accountID);
+    }
+
+    /** @internal */
+    removeMemberInternal(accountID: AccountID | AgentID) {
         this.groupMap = this.groupMap.edit((map) => {
             map.set(accountID, "revoked", "trusting");
         });
@@ -186,10 +202,9 @@ export class Group {
         this.rotateReadKey();
     }
 
-    createMap<
-        M extends { [key: string]: JsonValue },
-        Meta extends JsonObject | null = null
-    >(meta?: Meta): CoMap<M, Meta> {
+    createMap<M extends CoMap<{ [key: string]: JsonValue }, JsonObject | null>>(
+        meta?: M["meta"]
+    ): M {
         return this.node
             .createCoValue({
                 type: "comap",
@@ -200,9 +215,26 @@ export class Group {
                 meta: meta || null,
                 ...createdNowUnique(),
             })
-            .getCurrentContent() as CoMap<M, Meta>;
+            .getCurrentContent() as M;
     }
 
+    createList<L extends CoList<JsonValue, JsonObject | null>>(
+        meta?: L["meta"]
+    ): L {
+        return this.node
+            .createCoValue({
+                type: "colist",
+                ruleset: {
+                    type: "ownedByGroup",
+                    group: this.groupMap.id,
+                },
+                meta: meta || null,
+                ...createdNowUnique(),
+            })
+            .getCurrentContent() as L;
+    }
+
+    /** @internal */
     testWithDifferentAccount(
         account: GeneralizedControlledAccount,
         sessionId: SessionID
@@ -230,4 +262,4 @@ export function secretSeedFromInviteSecret(inviteSecret: InviteSecret) {
     }
 
     return base58.decode(inviteSecret.slice("inviteSecret_z".length));
-}
+}

packages/cojson/src/ids.ts

@@ -1,4 +1,4 @@
-import { AccountIDOrAgentID } from './account.js';
+import { AccountID } from './account.js';
 import { base58 } from "@scure/base";
 import { shortHashLength } from './crypto.js';
 
@@ -23,4 +23,4 @@ export function isAgentID(id: string): id is AgentID {
     return typeof id === "string" && id.startsWith("sealer_") && id.includes("/signer_");
 }
 
-export type SessionID = `${AccountIDOrAgentID}_session_z${string}`;
+export type SessionID = `${AccountID | AgentID}_session_z${string}`;

packages/cojson/src/index.ts

@@ -25,6 +25,7 @@ import type {
     AccountID,
     AccountContent,
     ProfileContent,
+    ProfileMeta,
     Profile,
 } from "./account.js";
 import type { InviteSecret } from "./group.js";
@@ -70,6 +71,7 @@ export type {
     AccountContent,
     Profile,
     ProfileContent,
+    ProfileMeta,
     InviteSecret
 };
 
@@ -84,5 +86,4 @@ export namespace CojsonInternalTypes {
     export type Transaction = import("./coValue.js").Transaction;
     export type Signature = import("./crypto.js").Signature;
     export type RawCoID = import("./ids.js").RawCoID;
-    export type AccountIDOrAgentID = import("./account.js").AccountIDOrAgentID;
 }

packages/cojson/src/node.ts

@@ -23,7 +23,6 @@ import { CoID, ContentType } from "./contentType.js";
 import {
     Account,
     AccountMeta,
-    AccountIDOrAgentID,
     accountHeaderForInitialAgentSecret,
     GeneralizedControlledAccount,
     ControlledAccount,
@@ -31,23 +30,24 @@ import {
     AccountID,
     Profile,
     AccountContent,
-    ProfileContent,
-    ProfileMeta,
+    AccountMap,
 } from "./account.js";
 import { CoMap } from "./index.js";
 
 export class LocalNode {
+    /** @internal */
     coValues: { [key: RawCoID]: CoValueState } = {};
+    /** @internal */
     account: GeneralizedControlledAccount;
-    ownSessionID: SessionID;
+    currentSessionID: SessionID;
     sync = new SyncManager(this);
 
     constructor(
         account: GeneralizedControlledAccount,
-        ownSessionID: SessionID
+        currentSessionID: SessionID
     ) {
         this.account = account;
-        this.ownSessionID = ownSessionID;
+        this.currentSessionID = currentSessionID;
     }
 
     static withNewlyCreatedAccount(
@@ -76,7 +76,7 @@ export class LocalNode {
             node: nodeWithAccount,
             accountID: account.id,
             accountSecret: account.agentSecret,
-            sessionID: nodeWithAccount.ownSessionID,
+            sessionID: nodeWithAccount.currentSessionID,
         };
     }
 
@@ -110,6 +110,7 @@ export class LocalNode {
         return node;
     }
 
+    /** @internal */
     createCoValue(header: CoValueHeader): CoValue {
         const coValue = new CoValue(header, this);
         this.coValues[coValue.id] = { state: "loaded", coValue: coValue };
@@ -119,6 +120,7 @@ export class LocalNode {
         return coValue;
     }
 
+    /** @internal */
     loadCoValue(id: RawCoID): Promise<CoValue> {
         let entry = this.coValues[id];
         if (!entry) {
@@ -139,7 +141,7 @@ export class LocalNode {
     }
 
     async loadProfile(id: AccountID): Promise<Profile> {
-        const account = await this.load<CoMap<AccountContent>>(id);
+        const account = await this.load<AccountMap>(id);
         const profileID = account.get("profile");
 
         if (!profileID) {
@@ -211,7 +213,7 @@ export class LocalNode {
             newRandomSessionID(inviteAgentID)
         );
 
-        groupAsInvite.addMember(
+        groupAsInvite.addMemberInternal(
             this.account.id,
             inviteRole === "adminInvite"
                 ? "admin"
@@ -228,6 +230,7 @@ export class LocalNode {
         }
     }
 
+    /** @internal */
     expectCoValueLoaded(id: RawCoID, expectation?: string): CoValue {
         const entry = this.coValues[id];
         if (!entry) {
@@ -245,6 +248,7 @@ export class LocalNode {
         return entry.coValue;
     }
 
+    /** @internal */
     expectProfileLoaded(id: AccountID, expectation?: string): Profile {
         const account = this.expectCoValueLoaded(id, expectation);
         const profileID = expectGroupContent(account.getCurrentContent()).get(
@@ -263,6 +267,7 @@ export class LocalNode {
         ).getCurrentContent() as Profile;
     }
 
+    /** @internal */
     createAccount(
         name: string,
         agentSecret = newRandomAgentSecret()
@@ -307,7 +312,7 @@ export class LocalNode {
             account.node
         );
 
-        const profile = accountAsGroup.createMap<ProfileContent, ProfileMeta>({
+        const profile = accountAsGroup.createMap<Profile>({
             type: "profile",
         });
 
@@ -327,7 +332,8 @@ export class LocalNode {
         return controlledAccount;
     }
 
-    resolveAccountAgent(id: AccountIDOrAgentID, expectation?: string): AgentID {
+    /** @internal */
+    resolveAccountAgent(id: AccountID | AgentID, expectation?: string): AgentID {
         if (isAgentID(id)) {
             return id;
         }
@@ -389,11 +395,12 @@ export class LocalNode {
         return new Group(groupContent, this);
     }
 
+    /** @internal */
     testWithDifferentAccount(
         account: GeneralizedControlledAccount,
-        ownSessionID: SessionID
+        currentSessionID: SessionID
     ): LocalNode {
-        const newNode = new LocalNode(account, ownSessionID);
+        const newNode = new LocalNode(account, currentSessionID);
 
         const coValuesToCopy = Object.entries(this.coValues);
 
@@ -430,6 +437,7 @@ export class LocalNode {
     }
 }
 
+/** @internal */
 type CoValueState =
     | {
           state: "loading";
@@ -438,6 +446,7 @@ type CoValueState =
       }
     | { state: "loaded"; coValue: CoValue };
 
+/** @internal */
 export function newLoadingState(): CoValueState {
     let resolve: (coValue: CoValue) => void;
 

packages/cojson/src/permissions.test.ts

@@ -108,7 +108,7 @@ test("Admins can't demote other admins in a group (high level)", () => {
         newRandomSessionID(otherAdmin.id)
     );
 
-    expect(() => groupAsOtherAdmin.addMember(admin.id, "writer")).toThrow(
+    expect(() => groupAsOtherAdmin.addMemberInternal(admin.id, "writer")).toThrow(
         "Failed to set role"
     );
 
@@ -1378,7 +1378,7 @@ test("Admins can create an adminInvite, which can add an admin (high-level)", as
         groupAsInvitedAdmin.groupMap.coValue.getCurrentReadKey().secret
     ).toBeDefined();
 
-    groupAsInvitedAdmin.addMember(thirdAdminID, "admin");
+    groupAsInvitedAdmin.addMemberInternal(thirdAdminID, "admin");
 
     expect(groupAsInvitedAdmin.groupMap.get(thirdAdminID)).toEqual("admin");
 });

packages/cojson/src/permissions.ts

@@ -10,14 +10,14 @@ import {
     TrustingTransaction,
     accountOrAgentIDfromSessionID,
 } from "./coValue.js";
-import { RawCoID, SessionID, TransactionID } from "./ids.js";
+import { AgentID, RawCoID, SessionID, TransactionID } from "./ids.js";
 import {
-    AccountIDOrAgentID,
+    AccountID,
     Profile,
 } from "./account.js";
 
 export type PermissionsDef =
-    | { type: "group"; initialAdmin: AccountIDOrAgentID }
+    | { type: "group"; initialAdmin: AccountID | AgentID }
     | { type: "ownedByGroup"; group: RawCoID }
     | { type: "unsafeAllowAll" };
 
@@ -63,7 +63,7 @@ export function determineValidTransactions(
             throw new Error("Group must have initialAdmin");
         }
 
-        const memberState: { [agent: AccountIDOrAgentID]: Role } = {};
+        const memberState: { [agent: AccountID | AgentID]: Role } = {};
 
         const validTransactions: { txID: TransactionID; tx: Transaction }[] =
             [];
@@ -77,7 +77,7 @@ export function determineValidTransactions(
             const transactor = accountOrAgentIDfromSessionID(sessionID);
 
             const change = tx.changes[0] as
-                | MapOpPayload<AccountIDOrAgentID, Role>
+                | MapOpPayload<AccountID | AgentID, Role>
                 | MapOpPayload<"readKey", JsonValue>
                 | MapOpPayload<"profile", CoID<Profile>>;
             if (tx.changes.length !== 1) {
@@ -248,7 +248,7 @@ export function isKeyForKeyField(
 
 export function isKeyForAccountField(
     field: string
-): field is `${KeyID}_for_${AccountIDOrAgentID}` {
+): field is `${KeyID}_for_${AccountID | AgentID}` {
     return (
         field.startsWith("key_") &&
         (field.includes("_for_sealer") || field.includes("_for_co"))

packages/cojson/src/streamUtils.ts

@@ -1,12 +1,17 @@
-import { ReadableStream, TransformStream, WritableStream } from "isomorphic-streams";
+import {
+    ReadableStream,
+    TransformStream,
+    WritableStream,
+} from "isomorphic-streams";
 import { Peer, PeerID, SyncMessage } from "./sync.js";
 
-
 export function connectedPeers(
     peer1id: PeerID,
     peer2id: PeerID,
     {
-        trace = false, peer1role = "peer", peer2role = "peer",
+        trace = false,
+        peer1role = "peer",
+        peer2role = "peer",
     }: {
         trace?: boolean;
         peer1role?: Peer["role"];
@@ -24,9 +29,13 @@ export function connectedPeers(
             new TransformStream({
                 transform(
                     chunk: SyncMessage,
-                    controller: { enqueue: (msg: SyncMessage) => void; }
+                    controller: { enqueue: (msg: SyncMessage) => void }
                 ) {
-                    trace && console.debug(`${peer2id} -> ${peer1id}`, JSON.stringify(chunk, null, 2));
+                    trace &&
+                        console.debug(
+                            `${peer2id} -> ${peer1id}`,
+                            JSON.stringify(chunk, null, 2)
+                        );
                     controller.enqueue(chunk);
                 },
             })
@@ -38,9 +47,13 @@ export function connectedPeers(
             new TransformStream({
                 transform(
                     chunk: SyncMessage,
-                    controller: { enqueue: (msg: SyncMessage) => void; }
+                    controller: { enqueue: (msg: SyncMessage) => void }
                 ) {
-                    trace && console.debug(`${peer1id} -> ${peer2id}`, JSON.stringify(chunk, null, 2));
+                    trace &&
+                        console.debug(
+                            `${peer1id} -> ${peer2id}`,
+                            JSON.stringify(chunk, null, 2)
+                        );
                     controller.enqueue(chunk);
                 },
             })
@@ -65,39 +78,22 @@ export function connectedPeers(
 }
 
 export function newStreamPair<T>(): [ReadableStream<T>, WritableStream<T>] {
-    const queue: T[] = [];
-    let resolveNextItemReady: () => void = () => { };
-    let nextItemReady: Promise<void> = new Promise((resolve) => {
-        resolveNextItemReady = resolve;
-    });
-
-    let writerClosed = false;
     let readerClosed = false;
 
+    let resolveEnqueue: (enqueue: (item: T) => void) => void;
+    const enqueuePromise = new Promise<(item: T) => void>((resolve) => {
+        resolveEnqueue = resolve;
+    });
+
+    let resolveClose: (close: () => void) => void;
+    const closePromise = new Promise<() => void>((resolve) => {
+        resolveClose = resolve;
+    });
+
     const readable = new ReadableStream<T>({
-        async pull(controller) {
-            let retriesLeft = 3;
-            while (retriesLeft > 0) {
-                if (writerClosed) {
-                    controller.close();
-                    return;
-                }
-                retriesLeft--;
-                if (queue.length > 0) {
-                    controller.enqueue(queue.shift()!);
-                    if (queue.length === 0) {
-                        nextItemReady = new Promise((resolve) => {
-                            resolveNextItemReady = resolve;
-                        });
-                    }
-                    return;
-                } else {
-                    await nextItemReady;
-                }
-            }
-            throw new Error(
-                "Should only use one retry to get next item in queue."
-            );
+        async start(controller) {
+            resolveEnqueue(controller.enqueue.bind(controller));
+            resolveClose(controller.close.bind(controller));
         },
 
         cancel(_reason) {
@@ -107,22 +103,21 @@ export function newStreamPair<T>(): [ReadableStream<T>, WritableStream<T>] {
     });
 
     const writable = new WritableStream<T>({
-        write(chunk) {
+        async write(chunk) {
+            const enqueue = await enqueuePromise;
             if (readerClosed) {
-                console.log("Reader closed, not writing chunk", chunk);
-                throw new Error("Reader closed, not writing chunk");
-            }
-            queue.push(chunk);
-            if (queue.length === 1) {
-                // make sure that await write resolves before corresponding read
-                setTimeout(() => resolveNextItemReady());
+                throw new Error("Reader closed");
+            } else {
+                // make sure write resolves before corresponding read
+                setTimeout(() => {
+                    enqueue(chunk);
+                })
             }
         },
-        abort(_reason) {
-            console.log("Manually closing writer");
-            writerClosed = true;
-            resolveNextItemReady();
-            return Promise.resolve();
+        async abort(reason) {
+            console.debug("Manually closing writer", reason);
+            const close = await closePromise;
+            close();
         },
     });
 

packages/cojson/src/sync.test.ts

@@ -77,12 +77,12 @@ test("Node replies with initial tx and header to empty subscribe", async () => {
             uniqueness: map.coValue.header.uniqueness,
         },
         new: {
-            [node.ownSessionID]: {
+            [node.currentSessionID]: {
                 after: 0,
                 newTransactions: [
                     {
                         privacy: "trusting" as const,
-                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                        madeAt: map.coValue.sessions[node.currentSessionID]!
                             .transactions[0]!.madeAt,
                         changes: [
                             {
@@ -94,7 +94,7 @@ test("Node replies with initial tx and header to empty subscribe", async () => {
                     },
                 ],
                 lastSignature:
-                    map.coValue.sessions[node.ownSessionID]!.lastSignature!,
+                    map.coValue.sessions[node.currentSessionID]!.lastSignature!,
             },
         },
     } satisfies SyncMessage);
@@ -130,7 +130,7 @@ test("Node replies with only new tx to subscribe with some known state", async (
         id: map.coValue.id,
         header: true,
         sessions: {
-            [node.ownSessionID]: 1,
+            [node.currentSessionID]: 1,
         },
     });
 
@@ -155,12 +155,12 @@ test("Node replies with only new tx to subscribe with some known state", async (
         id: map.coValue.id,
         header: undefined,
         new: {
-            [node.ownSessionID]: {
+            [node.currentSessionID]: {
                 after: 1,
                 newTransactions: [
                     {
                         privacy: "trusting" as const,
-                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                        madeAt: map.coValue.sessions[node.currentSessionID]!
                             .transactions[1]!.madeAt,
                         changes: [
                             {
@@ -172,7 +172,7 @@ test("Node replies with only new tx to subscribe with some known state", async (
                     },
                 ],
                 lastSignature:
-                    map.coValue.sessions[node.ownSessionID]!.lastSignature!,
+                    map.coValue.sessions[node.currentSessionID]!.lastSignature!,
             },
         },
     } satisfies SyncMessage);
@@ -207,7 +207,7 @@ test("After subscribing, node sends own known state and new txs to peer", async
         id: map.coValue.id,
         header: false,
         sessions: {
-            [node.ownSessionID]: 0,
+            [node.currentSessionID]: 0,
         },
     });
 
@@ -244,12 +244,12 @@ test("After subscribing, node sends own known state and new txs to peer", async
         action: "content",
         id: map.coValue.id,
         new: {
-            [node.ownSessionID]: {
+            [node.currentSessionID]: {
                 after: 0,
                 newTransactions: [
                     {
                         privacy: "trusting" as const,
-                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                        madeAt: map.coValue.sessions[node.currentSessionID]!
                             .transactions[0]!.madeAt,
                         changes: [
                             {
@@ -261,7 +261,7 @@ test("After subscribing, node sends own known state and new txs to peer", async
                     },
                 ],
                 lastSignature:
-                    map.coValue.sessions[node.ownSessionID]!.lastSignature!,
+                    map.coValue.sessions[node.currentSessionID]!.lastSignature!,
             },
         },
     } satisfies SyncMessage);
@@ -276,12 +276,12 @@ test("After subscribing, node sends own known state and new txs to peer", async
         action: "content",
         id: map.coValue.id,
         new: {
-            [node.ownSessionID]: {
+            [node.currentSessionID]: {
                 after: 1,
                 newTransactions: [
                     {
                         privacy: "trusting" as const,
-                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                        madeAt: map.coValue.sessions[node.currentSessionID]!
                             .transactions[1]!.madeAt,
                         changes: [
                             {
@@ -293,7 +293,7 @@ test("After subscribing, node sends own known state and new txs to peer", async
                     },
                 ],
                 lastSignature:
-                    map.coValue.sessions[node.ownSessionID]!.lastSignature!,
+                    map.coValue.sessions[node.currentSessionID]!.lastSignature!,
             },
         },
     } satisfies SyncMessage);
@@ -332,7 +332,7 @@ test("Client replies with known new content to tellKnownState from server", asyn
         id: map.coValue.id,
         header: false,
         sessions: {
-            [node.ownSessionID]: 0,
+            [node.currentSessionID]: 0,
         },
     });
 
@@ -355,12 +355,12 @@ test("Client replies with known new content to tellKnownState from server", asyn
         id: map.coValue.id,
         header: map.coValue.header,
         new: {
-            [node.ownSessionID]: {
+            [node.currentSessionID]: {
                 after: 0,
                 newTransactions: [
                     {
                         privacy: "trusting" as const,
-                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                        madeAt: map.coValue.sessions[node.currentSessionID]!
                             .transactions[0]!.madeAt,
                         changes: [
                             {
@@ -372,7 +372,7 @@ test("Client replies with known new content to tellKnownState from server", asyn
                     },
                 ],
                 lastSignature:
-                    map.coValue.sessions[node.ownSessionID]!.lastSignature!,
+                    map.coValue.sessions[node.currentSessionID]!.lastSignature!,
             },
         },
     } satisfies SyncMessage);
@@ -403,7 +403,7 @@ test("No matter the optimistic known state, node respects invalid known state me
         id: map.coValue.id,
         header: false,
         sessions: {
-            [node.ownSessionID]: 0,
+            [node.currentSessionID]: 0,
         },
     });
 
@@ -447,7 +447,7 @@ test("No matter the optimistic known state, node respects invalid known state me
         id: map.coValue.id,
         header: true,
         sessions: {
-            [node.ownSessionID]: 1,
+            [node.currentSessionID]: 1,
         },
     } satisfies SyncMessage);
 
@@ -458,12 +458,12 @@ test("No matter the optimistic known state, node respects invalid known state me
         id: map.coValue.id,
         header: undefined,
         new: {
-            [node.ownSessionID]: {
+            [node.currentSessionID]: {
                 after: 1,
                 newTransactions: [
                     {
                         privacy: "trusting" as const,
-                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                        madeAt: map.coValue.sessions[node.currentSessionID]!
                             .transactions[1]!.madeAt,
                         changes: [
                             {
@@ -475,7 +475,7 @@ test("No matter the optimistic known state, node respects invalid known state me
                     },
                 ],
                 lastSignature:
-                    map.coValue.sessions[node.ownSessionID]!.lastSignature!,
+                    map.coValue.sessions[node.currentSessionID]!.lastSignature!,
             },
         },
     } satisfies SyncMessage);
@@ -561,12 +561,12 @@ test("If we add a server peer, all updates to all coValues are sent to it, even
         id: map.coValue.id,
         header: map.coValue.header,
         new: {
-            [node.ownSessionID]: {
+            [node.currentSessionID]: {
                 after: 0,
                 newTransactions: [
                     {
                         privacy: "trusting" as const,
-                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                        madeAt: map.coValue.sessions[node.currentSessionID]!
                             .transactions[0]!.madeAt,
                         changes: [
                             {
@@ -578,7 +578,7 @@ test("If we add a server peer, all updates to all coValues are sent to it, even
                     },
                 ],
                 lastSignature:
-                    map.coValue.sessions[node.ownSessionID]!.lastSignature!,
+                    map.coValue.sessions[node.currentSessionID]!.lastSignature!,
             },
         },
     } satisfies SyncMessage);
@@ -697,7 +697,7 @@ test("When receiving a subscribe with a known state that is ahead of our own, pe
         id: map.coValue.id,
         header: true,
         sessions: {
-            [node.ownSessionID]: 1,
+            [node.currentSessionID]: 1,
         },
     });
 

packages/cojson/src/sync.ts

@@ -149,16 +149,11 @@ export class SyncManager {
         }
     }
 
-    async subscribeToIncludingDependencies(
-        id: RawCoID,
-        peer: PeerState
-    ) {
+    async subscribeToIncludingDependencies(id: RawCoID, peer: PeerState) {
         const entry = this.local.coValues[id];
 
         if (!entry) {
-            throw new Error(
-                "Expected coValue entry on subscribe"
-            );
+            throw new Error("Expected coValue entry on subscribe");
         }
 
         if (entry.state === "loading") {
@@ -212,10 +207,7 @@ export class SyncManager {
         }
     }
 
-    async sendNewContentIncludingDependencies(
-        id: RawCoID,
-        peer: PeerState
-    ) {
+    async sendNewContentIncludingDependencies(id: RawCoID, peer: PeerState) {
         const coValue = this.local.expectCoValueLoaded(id);
 
         for (const id of coValue.getDependedOnCoValues()) {
@@ -229,8 +221,7 @@ export class SyncManager {
         if (newContent) {
             await this.trySendToPeer(peer, newContent);
             peer.optimisticKnownStates[id] = combinedKnownStates(
-                peer.optimisticKnownStates[id] ||
-                    emptyKnownState(id),
+                peer.optimisticKnownStates[id] || emptyKnownState(id),
                 coValue.knownState()
             );
         }
@@ -265,17 +256,23 @@ export class SyncManager {
         }
 
         const readIncoming = async () => {
-            for await (const msg of peerState.incoming) {
-                try {
-                    await this.handleSyncMessage(msg, peerState);
-                } catch (e) {
-                    console.error(
-                        `Error reading from peer ${peer.id}`,
-                        JSON.stringify(msg),
-                        e
-                    );
+            try {
+                for await (const msg of peerState.incoming) {
+                    try {
+                        await this.handleSyncMessage(msg, peerState);
+                    } catch (e) {
+                        console.error(
+                            `Error reading from peer ${peer.id}, handling msg`,
+                            JSON.stringify(msg),
+                            e
+                        );
+                    }
                 }
+                console.log("DONE!!!");
+            } catch (e) {
+                console.error(`Error reading from peer ${peer.id}`, e);
             }
+
             console.log("Peer disconnected:", peer.id);
             delete this.peers[peer.id];
         };
@@ -284,9 +281,32 @@ export class SyncManager {
     }
 
     trySendToPeer(peer: PeerState, msg: SyncMessage) {
-        return peer.outgoing.write(msg).catch((e) => {
-            console.error(new Error(`Error writing to peer ${peer.id}, disconnecting`, {cause: e}));
-            delete this.peers[peer.id];
+        return new Promise<void>((resolve) => {
+            const timeout = setTimeout(() => {
+                console.error(
+                    new Error(
+                        `Writing to peer ${peer.id} took >1s - this should never happen as write should resolve quickly or error`
+                    )
+                );
+                resolve();
+            }, 1000);
+            peer.outgoing
+                .write(msg)
+                .then(() => {
+                    clearTimeout(timeout);
+                    resolve();
+                })
+                .catch((e) => {
+                    console.error(
+                        new Error(
+                            `Error writing to peer ${peer.id}, disconnecting`,
+                            {
+                                cause: e,
+                            }
+                        )
+                    );
+                    delete this.peers[peer.id];
+                });
         });
     }
 
@@ -295,7 +315,19 @@ export class SyncManager {
 
         if (!entry || entry.state === "loading") {
             if (!entry) {
-                this.local.coValues[msg.id] = newLoadingState();
+                await new Promise<void>((resolve) => {
+                    this.local
+                        .loadCoValue(msg.id)
+                        .then(() => resolve())
+                        .catch((e) => {
+                            console.error(
+                                "Error loading coValue in handleLoad",
+                                e
+                            );
+                            resolve();
+                        });
+                    setTimeout(resolve, 1000);
+                });
             }
 
             peer.optimisticKnownStates[msg.id] = knownStateIn(msg);
@@ -313,10 +345,7 @@ export class SyncManager {
 
         peer.optimisticKnownStates[msg.id] = knownStateIn(msg);
 
-        await this.tellUntoldKnownStateIncludingDependencies(
-            msg.id,
-            peer
-        );
+        await this.tellUntoldKnownStateIncludingDependencies(msg.id, peer);
 
         await this.sendNewContentIncludingDependencies(msg.id, peer);
     }
@@ -325,8 +354,7 @@ export class SyncManager {
         let entry = this.local.coValues[msg.id];
 
         peer.optimisticKnownStates[msg.id] = combinedKnownStates(
-            peer.optimisticKnownStates[msg.id] ||
-                emptyKnownState(msg.id),
+            peer.optimisticKnownStates[msg.id] || emptyKnownState(msg.id),
             knownStateIn(msg)
         );
 
@@ -352,10 +380,7 @@ export class SyncManager {
             return [];
         }
 
-        await this.tellUntoldKnownStateIncludingDependencies(
-            msg.id,
-            peer
-        );
+        await this.tellUntoldKnownStateIncludingDependencies(msg.id, peer);
         await this.sendNewContentIncludingDependencies(msg.id, peer);
     }
 
@@ -370,8 +395,7 @@ export class SyncManager {
 
         let resolveAfterDone: ((coValue: CoValue) => void) | undefined;
 
-        const peerOptimisticKnownState =
-            peer.optimisticKnownStates[msg.id];
+        const peerOptimisticKnownState = peer.optimisticKnownStates[msg.id];
 
         if (!peerOptimisticKnownState) {
             throw new Error(
@@ -453,10 +477,7 @@ export class SyncManager {
         }
     }
 
-    async handleCorrection(
-        msg: KnownStateMessage,
-        peer: PeerState
-    ) {
+    async handleCorrection(msg: KnownStateMessage, peer: PeerState) {
         const coValue = this.local.expectCoValueLoaded(msg.id);
 
         peer.optimisticKnownStates[msg.id] = combinedKnownStates(
@@ -499,11 +520,7 @@ export class SyncManager {
     }
 }
 
-function knownStateIn(
-    msg:
-        | LoadMessage
-        | KnownStateMessage
-) {
+function knownStateIn(msg: LoadMessage | KnownStateMessage) {
     return {
         id: msg.id,
         header: msg.header,

packages/cojson/tsconfig.json

@@ -10,6 +10,7 @@
     "forceConsistentCasingInFileNames": true,
     "noUncheckedIndexedAccess": true,
     "esModuleInterop": true,
+    "stripInternal": true
   },
   "include": ["./src/**/*"],
   "exclude": ["./src/**/*.test.*"],

packages/jazz-browser-auth-local/package.json

@@ -1,11 +1,11 @@
 {
     "name": "jazz-browser-auth-local",
-    "version": "0.1.1",
+    "version": "0.1.7",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "license": "MIT",
     "dependencies": {
-        "jazz-browser": "^0.1.1",
+        "jazz-browser": "^0.1.7",
         "typescript": "^5.1.6"
     },
     "scripts": {

packages/jazz-browser-auth-local/src/index.ts

@@ -147,7 +147,7 @@ async function signUp(
         accountSecret,
     } satisfies SessionStorageData);
 
-    node.ownSessionID = await getSessionFor(accountID);
+    node.currentSessionID = await getSessionFor(accountID);
 
     return node;
 }

packages/jazz-browser/package.json

@@ -1,12 +1,12 @@
 {
   "name": "jazz-browser",
-  "version": "0.1.1",
+  "version": "0.1.7",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "cojson": "^0.1.1",
-    "jazz-storage-indexeddb": "^0.1.1",
+    "cojson": "^0.1.7",
+    "jazz-storage-indexeddb": "^0.1.7",
     "typescript": "^5.1.6"
   },
   "scripts": {

packages/jazz-browser/src/index.ts

@@ -2,7 +2,8 @@ import { InviteSecret } from "cojson";
 import {
     LocalNode,
     cojsonInternals,
-    CojsonInternalTypes,
+    AccountID,
+    AgentID,
     SessionID,
     SyncMessage,
     Peer,
@@ -39,10 +40,10 @@ export async function createBrowserNode({
             sessionDone = sessionHandle.done;
             return sessionHandle.session;
         },
-        [await IDBStorage.asPeer({ trace: true }), firstWsPeer]
+        [await IDBStorage.asPeer(), firstWsPeer]
     );
 
-    void async function websocketReconnectLoop() {
+    async function websocketReconnectLoop() {
         while (shouldTryToReconnect) {
             if (
                 Object.keys(node.sync.peers).some((peerId) =>
@@ -60,7 +61,9 @@ export async function createBrowserNode({
                 );
             }
         }
-    };
+    }
+
+    void websocketReconnectLoop();
 
     return {
         node,
@@ -79,7 +82,7 @@ export interface AuthProvider {
 }
 
 export type SessionProvider = (
-    accountID: CojsonInternalTypes.AccountIDOrAgentID
+    accountID: AccountID | AgentID
 ) => Promise<SessionID>;
 
 export type SessionHandle = {
@@ -88,7 +91,7 @@ export type SessionHandle = {
 };
 
 function getSessionHandleFor(
-    accountID: CojsonInternalTypes.AccountIDOrAgentID
+    accountID: AccountID | AgentID
 ): SessionHandle {
     let done!: () => void;
     const donePromise = new Promise<void>((resolve) => {
@@ -153,6 +156,8 @@ function websocketReadableStream<T>(ws: WebSocket) {
 
     return new ReadableStream<T>({
         start(controller) {
+            let pingTimeout: ReturnType<typeof setTimeout> | undefined;
+
             ws.onmessage = (event) => {
                 const msg = JSON.parse(event.data);
                 if (msg.type === "ping") {
@@ -163,13 +168,27 @@ function websocketReadableStream<T>(ws: WebSocket) {
                         Date.now() - msg.time,
                         "ms"
                     );
+
+                    if (pingTimeout) {
+                        clearTimeout(pingTimeout);
+                    }
+
+                    pingTimeout = setTimeout(() => {
+                        console.debug("Ping timeout");
+                        controller.close();
+                        ws.close();
+                    }, 2500);
+
                     return;
                 }
                 controller.enqueue(msg);
             };
-            ws.onclose = () => controller.close();
-            ws.onerror = () =>
+            const closeListener = () => controller.close();
+            ws.addEventListener("close", closeListener);
+            ws.addEventListener("error", () => {
                 controller.error(new Error("The WebSocket errored!"));
+                ws.removeEventListener("close", closeListener);
+            });
         },
 
         cancel() {
@@ -193,23 +212,37 @@ function createWebSocketPeer(syncAddress: string): Peer {
 }
 
 function websocketWritableStream<T>(ws: WebSocket) {
+    const initialQueue = [] as T[];
+    let isOpen = false;
+
     return new WritableStream<T>({
         start(controller) {
-            ws.onerror = () => {
-                controller.error(new Error("The WebSocket errored!"));
-                ws.onclose = null;
-            };
-            ws.onclose = () =>
+            ws.addEventListener("error", (event) => {
+                controller.error(
+                    new Error("The WebSocket errored!" + JSON.stringify(event))
+                );
+            });
+            ws.addEventListener("close", () => {
                 controller.error(
                     new Error("The server closed the connection unexpectedly!")
                 );
-            return new Promise((resolve) => (ws.onopen = resolve));
+            });
+            ws.addEventListener("open", () => {
+                for (const item of initialQueue) {
+                    ws.send(JSON.stringify(item));
+                }
+                isOpen = true;
+            });
         },
 
-        write(chunk) {
-            ws.send(JSON.stringify(chunk));
-            // Return immediately, since the web socket gives us no easy way to tell
-            // when the write completes.
+        async write(chunk) {
+            if (isOpen) {
+                ws.send(JSON.stringify(chunk));
+                // Return immediately, since the web socket gives us no easy way to tell
+                // when the write completes.
+            } else {
+                initialQueue.push(chunk);
+            }
         },
 
         close() {
@@ -223,13 +256,19 @@ function websocketWritableStream<T>(ws: WebSocket) {
 
     function closeWS(code: number, reasonString?: string) {
         return new Promise<void>((resolve, reject) => {
-            ws.onclose = (e) => {
-                if (e.wasClean) {
-                    resolve();
-                } else {
-                    reject(new Error("The connection was not closed cleanly"));
-                }
-            };
+            ws.addEventListener(
+                "close",
+                (e) => {
+                    if (e.wasClean) {
+                        resolve();
+                    } else {
+                        reject(
+                            new Error("The connection was not closed cleanly")
+                        );
+                    }
+                },
+                { once: true }
+            );
             ws.close(code, reasonString);
         });
     }
@@ -248,9 +287,7 @@ export function createInviteLink(
     let currentCoValue = coValue;
 
     while (currentCoValue.header.ruleset.type === "ownedByGroup") {
-        currentCoValue = node.expectCoValueLoaded(
-            currentCoValue.header.ruleset.group
-        );
+        currentCoValue = currentCoValue.getGroup().groupMap.coValue;
     }
 
     if (currentCoValue.header.ruleset.type !== "group") {
@@ -267,33 +304,32 @@ export function createInviteLink(
     return `${baseURL}#invitedTo=${value.id}&${inviteSecret}`;
 }
 
-export function parseInviteLink(inviteURL: string):
+export function parseInviteLink<C extends ContentType>(inviteURL: string):
     | {
-          valueID: CoID<ContentType>;
+          valueID: CoID<C>;
           inviteSecret: InviteSecret;
       }
     | undefined {
     const url = new URL(inviteURL);
     const valueID = url.hash
         .split("&")[0]
-        ?.replace(/^#invitedTo=/, "") as CoID<ContentType>;
-    const inviteSecret = url.hash
-        .split("&")[1] as InviteSecret;
+        ?.replace(/^#invitedTo=/, "") as CoID<C>;
+    const inviteSecret = url.hash.split("&")[1] as InviteSecret;
     if (!valueID || !inviteSecret) {
         return undefined;
     }
     return { valueID, inviteSecret };
 }
 
-export function consumeInviteLinkFromWindowLocation(node: LocalNode): Promise<
+export function consumeInviteLinkFromWindowLocation<C extends ContentType>(node: LocalNode): Promise<
     | {
-          valueID: string;
+          valueID: CoID<C>;
           inviteSecret: string;
       }
     | undefined
 > {
     return new Promise((resolve, reject) => {
-        const result = parseInviteLink(window.location.href);
+        const result = parseInviteLink<C>(window.location.href);
 
         if (result) {
             node.acceptInvite(result.valueID, result.inviteSecret)

packages/jazz-react-auth-local/package.json

@@ -1,12 +1,12 @@
 {
     "name": "jazz-react-auth-local",
-    "version": "0.1.1",
+    "version": "0.1.8",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "license": "MIT",
     "dependencies": {
-        "jazz-browser-auth-local": "^0.1.1",
-        "jazz-react": "^0.1.1",
+        "jazz-browser-auth-local": "^0.1.7",
+        "jazz-react": "^0.1.8",
         "typescript": "^5.1.6"
     },
     "devDependencies": {

packages/jazz-react/package.json

@@ -1,12 +1,12 @@
 {
   "name": "jazz-react",
-  "version": "0.1.1",
+  "version": "0.1.8",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "cojson": "^0.1.1",
-    "jazz-browser": "^0.1.1",
+    "cojson": "^0.1.7",
+    "jazz-browser": "^0.1.7",
     "typescript": "^5.1.6"
   },
   "devDependencies": {

packages/jazz-react/src/index.tsx

@@ -3,9 +3,10 @@ import {
     ContentType,
     CoID,
     ProfileContent,
+    ProfileMeta,
     CoMap,
     AccountID,
-    Profile,
+    JsonValue,
 } from "cojson";
 import React, { useEffect, useState } from "react";
 import { AuthProvider, createBrowserNode } from "jazz-browser";
@@ -123,12 +124,10 @@ export function useTelepathicState<T extends ContentType>(id?: CoID<T>) {
     return state;
 }
 
-export function useProfile<P extends ProfileContent = ProfileContent>({
-    accountID,
-}: {
-    accountID?: AccountID;
-}): (Profile & CoMap<P>) | undefined {
-    const [profileID, setProfileID] = useState<CoID<Profile & CoMap<P>>>();
+export function useProfile<
+    P extends ({ [key: string]: JsonValue } & ProfileContent) = ProfileContent
+>(accountID?: AccountID): CoMap<P, ProfileMeta> | undefined {
+    const [profileID, setProfileID] = useState<CoID<CoMap<P, ProfileMeta>>>();
 
     const { localNode } = useJazz();
 

packages/jazz-storage-indexeddb/package.json

@@ -1,11 +1,11 @@
 {
   "name": "jazz-storage-indexeddb",
-  "version": "0.1.1",
+  "version": "0.1.7",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "cojson": "^0.1.1",
+    "cojson": "^0.1.7",
     "typescript": "^5.1.6"
   },
   "devDependencies": {

yarn.lock

@@ -1513,6 +1513,13 @@
   dependencies:
     "@babel/types" "^7.20.7"
 
+"@types/better-sqlite3@^7.6.4":
+  version "7.6.4"
+  resolved "https://registry.yarnpkg.com/@types/better-sqlite3/-/better-sqlite3-7.6.4.tgz#102462611e67aadf950d3ccca10292de91e6f35b"
+  integrity sha512-dzrRZCYPXIXfSR1/surNbJ/grU3scTaygS0OMzjlGf71i9sc2fGyHPXXiXmEvNIoE0cGwsanEFMVJxPXmco9Eg==
+  dependencies:
+    "@types/node" "*"
+
 "@types/chai-subset@^1.3.3":
   version "1.3.3"
   resolved "https://registry.yarnpkg.com/@types/chai-subset/-/chai-subset-1.3.3.tgz#97893814e92abd2c534de422cb377e0e0bdaac94"
@@ -1604,6 +1611,13 @@
   resolved "https://registry.yarnpkg.com/@types/prop-types/-/prop-types-15.7.5.tgz#5f19d2b85a98e9558036f6a3cacc8819420f05cf"
   integrity sha512-JCB8C6SnDoQf0cNycqd/35A7MjcnK+ZTqE7judS6o7utxUCg6imJg3QK2qzHKszlTjcj2cn+NwMB2i96ubpj7w==
 
+"@types/qrcode@^1.5.1":
+  version "1.5.1"
+  resolved "https://registry.yarnpkg.com/@types/qrcode/-/qrcode-1.5.1.tgz#027c2dbfbc8505e1fe2f4033daba920dbd182b44"
+  integrity sha512-HpSN675K0PmxIDRpjMI3Mc2GiKo3dNu+X/F5SoItiaDS1lVfgC6Wac1c5lQDfKWbTJUSHWiHKzpJpBZG7k9gaA==
+  dependencies:
+    "@types/node" "*"
+
 "@types/react-dom@^18.2.7":
   version "18.2.7"
   resolved "https://registry.yarnpkg.com/@types/react-dom/-/react-dom-18.2.7.tgz#67222a08c0a6ae0a0da33c3532348277c70abb63"
@@ -1640,7 +1654,7 @@
   resolved "https://registry.yarnpkg.com/@types/which/-/which-2.0.2.tgz#54541d02d6b1daee5ec01ac0d1b37cecf37db1ae"
   integrity sha512-113D3mDkZDjo+EeUEHCFy0qniNc1ZpecGiAU7WSo7YDoSzolZIQKpYFHrPpjkB2nuyahcKfrmLXeQlh7gqJYdw==
 
-"@types/ws@^8.5.3":
+"@types/ws@^8.5.3", "@types/ws@^8.5.5":
   version "8.5.5"
   resolved "https://registry.yarnpkg.com/@types/ws/-/ws-8.5.5.tgz#af587964aa06682702ee6dcbc7be41a80e4b28eb"
   integrity sha512-lwhs8hktwxSjf9UaZ9tG5M03PGogvFaH8gUgLNbN9HKIg0dvv6q+gkSuJ8HN4/VbyxkuLzCjlN7GquQ0gUJfIg==
@@ -2243,6 +2257,14 @@ before-after-hook@^2.2.0:
   resolved "https://registry.yarnpkg.com/before-after-hook/-/before-after-hook-2.2.3.tgz#c51e809c81a4e354084422b9b26bad88249c517c"
   integrity sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ==
 
+better-sqlite3@^8.5.2:
+  version "8.5.2"
+  resolved "https://registry.yarnpkg.com/better-sqlite3/-/better-sqlite3-8.5.2.tgz#a1c13e4361125255e39302e8b569a6568c3291e3"
+  integrity sha512-w/EZ/jwuZF+/47mAVC2+rhR2X/gwkZ+fd1pbX7Y90D5NRaRzDQcxrHY10t6ijGiYIonCVsBSF5v1cay07bP5sg==
+  dependencies:
+    bindings "^1.5.0"
+    prebuild-install "^7.1.0"
+
 big-integer@^1.6.17:
   version "1.6.51"
   resolved "https://registry.yarnpkg.com/big-integer/-/big-integer-1.6.51.tgz#0df92a5d9880560d3ff2d5fd20245c889d130686"
@@ -2261,6 +2283,13 @@ binary@~0.3.0:
     buffers "~0.1.1"
     chainsaw "~0.1.0"
 
+bindings@^1.5.0:
+  version "1.5.0"
+  resolved "https://registry.yarnpkg.com/bindings/-/bindings-1.5.0.tgz#10353c9e945334bc0511a6d90b38fbc7c9c504df"
+  integrity sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==
+  dependencies:
+    file-uri-to-path "1.0.0"
+
 bl@^4.0.3, bl@^4.1.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/bl/-/bl-4.1.0.tgz#451535264182bec2fbbc83a62ab98cf11d9f7b3a"
@@ -2433,7 +2462,7 @@ camelcase-keys@^6.2.2:
     map-obj "^4.0.0"
     quick-lru "^4.0.1"
 
-camelcase@^5.3.1:
+camelcase@^5.0.0, camelcase@^5.3.1:
   version "5.3.1"
   resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320"
   integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==
@@ -2528,6 +2557,11 @@ chokidar@^3.5.3:
   optionalDependencies:
     fsevents "~2.3.2"
 
+chownr@^1.1.1:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/chownr/-/chownr-1.1.4.tgz#6fc9d7b42d32a583596337666e7d08084da2cc6b"
+  integrity sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==
+
 chownr@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/chownr/-/chownr-2.0.0.tgz#15bfbe53d2eab4cf70f18a8cd68ebe5b3cb1dece"
@@ -2594,6 +2628,15 @@ cli-width@^3.0.0:
   resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-3.0.0.tgz#a2f48437a2caa9a22436e794bf071ec9e61cedf6"
   integrity sha512-FxqpkPPwu1HjuN93Omfm4h8uIanXofW0RxVEW3k5RKx+mJJYSthzNhp32Kzxxy3YAEZ/Dc/EWN1vZRY0+kOhbw==
 
+cliui@^6.0.0:
+  version "6.0.0"
+  resolved "https://registry.yarnpkg.com/cliui/-/cliui-6.0.0.tgz#511d702c0c4e41ca156d7d0e96021f23e13225b1"
+  integrity sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==
+  dependencies:
+    string-width "^4.2.0"
+    strip-ansi "^6.0.0"
+    wrap-ansi "^6.2.0"
+
 cliui@^7.0.2:
   version "7.0.4"
   resolved "https://registry.yarnpkg.com/cliui/-/cliui-7.0.4.tgz#a0265ee655476fc807aea9df3df8df7783808b4f"
@@ -2927,7 +2970,7 @@ decamelize-keys@^1.1.0:
     decamelize "^1.1.0"
     map-obj "^1.0.0"
 
-decamelize@^1.1.0:
+decamelize@^1.1.0, decamelize@^1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290"
   integrity sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==
@@ -2961,6 +3004,11 @@ deep-eql@^4.1.2:
   dependencies:
     type-detect "^4.0.0"
 
+deep-extend@^0.6.0:
+  version "0.6.0"
+  resolved "https://registry.yarnpkg.com/deep-extend/-/deep-extend-0.6.0.tgz#c4fa7c95404a17a9c3e8ca7e1537312b736330ac"
+  integrity sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==
+
 deep-is@^0.1.3:
   version "0.1.4"
   resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.4.tgz#a6f2dce612fadd2ef1f519b73551f17e85199831"
@@ -3027,6 +3075,11 @@ detect-indent@^5.0.0:
   resolved "https://registry.yarnpkg.com/detect-indent/-/detect-indent-5.0.0.tgz#3871cc0a6a002e8c3e5b3cf7f336264675f06b9d"
   integrity sha512-rlpvsxUtM0PQvy9iZe640/IWwWYyBsTApREbA1pHOpmOUIl9MkP/U4z7vTtg4Oaojvqhxt7sdufnT0EzGaR31g==
 
+detect-libc@^2.0.0:
+  version "2.0.2"
+  resolved "https://registry.yarnpkg.com/detect-libc/-/detect-libc-2.0.2.tgz#8ccf2ba9315350e1241b88d0ac3b0e1fbd99605d"
+  integrity sha512-UX6sGumvvqSaXgdKGUsgZWqcUyIXZ/vZTrlRT/iobiKhGL0zL4d3osHj3uqllWJK+i+sixDS/3COVEOFbupFyw==
+
 detect-newline@^3.0.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/detect-newline/-/detect-newline-3.1.0.tgz#576f5dfc63ae1a192ff192d8ad3af6308991b651"
@@ -3052,6 +3105,11 @@ diff-sequences@^29.4.3:
   resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-29.4.3.tgz#9314bc1fabe09267ffeca9cbafc457d8499a13f2"
   integrity sha512-ofrBgwpPhCD85kMKtE9RYFFq6OC1A89oW2vvgWZNCwxrUpRUILopY7lsYyMDSjc8g6U6aiO0Qubg6r4Wgt5ZnA==
 
+dijkstrajs@^1.0.1:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/dijkstrajs/-/dijkstrajs-1.0.3.tgz#4c8dbdea1f0f6478bff94d9c49c784d623e4fc23"
+  integrity sha512-qiSlmBq9+BCdCA/L46dw8Uy93mloxsPSbwnm5yrKn2vMPiy8KyAskTF6zuV/j5BMsmOGZDPs7KjU+mjb670kfA==
+
 dir-glob@^3.0.1:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/dir-glob/-/dir-glob-3.0.1.tgz#56dbf73d992a4a93ba1584f4534063fd2e41717f"
@@ -3148,6 +3206,11 @@ emoji-regex@^9.2.2:
   resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72"
   integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
 
+encode-utf8@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/encode-utf8/-/encode-utf8-1.0.3.tgz#f30fdd31da07fb596f281beb2f6b027851994cda"
+  integrity sha512-ucAnuBEhUK4boH2HjVYG5Q2mQyPorvv0u/ocS+zhdw0S8AlHYY+GOFhP1Gio5z4icpP2ivFSvhtFjQi8+T9ppw==
+
 encoding@^0.1.13:
   version "0.1.13"
   resolved "https://registry.yarnpkg.com/encoding/-/encoding-0.1.13.tgz#56574afdd791f54a8e9b2785c0582a2d26210fa9"
@@ -3543,6 +3606,11 @@ exit@^0.1.2:
   resolved "https://registry.yarnpkg.com/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c"
   integrity sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==
 
+expand-template@^2.0.3:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/expand-template/-/expand-template-2.0.3.tgz#6e14b3fcee0f3a6340ecb57d2e8918692052a47c"
+  integrity sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==
+
 expect@^29.0.0, expect@^29.6.2:
   version "29.6.2"
   resolved "https://registry.yarnpkg.com/expect/-/expect-29.6.2.tgz#7b08e83eba18ddc4a2cf62b5f2d1918f5cd84521"
@@ -3674,6 +3742,11 @@ file-entry-cache@^6.0.1:
   dependencies:
     flat-cache "^3.0.4"
 
+file-uri-to-path@1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd"
+  integrity sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==
+
 filelist@^1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/filelist/-/filelist-1.0.4.tgz#f78978a1e944775ff9e62e744424f215e58352b5"
@@ -3871,7 +3944,7 @@ gensync@^1.0.0-beta.2:
   resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
   integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==
 
-get-caller-file@^2.0.5:
+get-caller-file@^2.0.1, get-caller-file@^2.0.5:
   version "2.0.5"
   resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e"
   integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
@@ -3980,6 +4053,11 @@ gitconfiglocal@^1.0.0:
   dependencies:
     ini "^1.3.2"
 
+github-from-package@0.0.0:
+  version "0.0.0"
+  resolved "https://registry.yarnpkg.com/github-from-package/-/github-from-package-0.0.0.tgz#97fb5d96bfde8973313f20e8288ef9a167fa64ce"
+  integrity sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==
+
 glob-parent@5.1.2, glob-parent@^5.1.2, glob-parent@~5.1.2:
   version "5.1.2"
   resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
@@ -4359,7 +4437,7 @@ inherits@2, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.0, inherits@~2.0.3:
   resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
 
-ini@^1.3.2, ini@^1.3.8:
+ini@^1.3.2, ini@^1.3.8, ini@~1.3.0:
   version "1.3.8"
   resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c"
   integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==
@@ -5614,7 +5692,7 @@ minimist-options@4.1.0:
     is-plain-obj "^1.1.0"
     kind-of "^6.0.3"
 
-minimist@^1.2.0, minimist@^1.2.5, minimist@^1.2.6:
+minimist@^1.2.0, minimist@^1.2.3, minimist@^1.2.5, minimist@^1.2.6:
   version "1.2.8"
   resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c"
   integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==
@@ -5701,7 +5779,7 @@ mitt@3.0.0:
   resolved "https://registry.yarnpkg.com/mitt/-/mitt-3.0.0.tgz#69ef9bd5c80ff6f57473e8d89326d01c414be0bd"
   integrity sha512-7dX2/10ITVyqh4aOSVI9gdape+t9l2/8QxHrFmUXu4EEUpdlxl6RudZUPZoc+zuY2hk1j7XxVroIVIan/pD/SQ==
 
-mkdirp-classic@^0.5.2:
+mkdirp-classic@^0.5.2, mkdirp-classic@^0.5.3:
   version "0.5.3"
   resolved "https://registry.yarnpkg.com/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz#fa10c9115cc6d8865be221ba47ee9bed78601113"
   integrity sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==
@@ -5798,6 +5876,11 @@ nanoid@^3.3.6:
   resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.6.tgz#443380c856d6e9f9824267d960b4236ad583ea4c"
   integrity sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==
 
+napi-build-utils@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/napi-build-utils/-/napi-build-utils-1.0.2.tgz#b1fddc0b2c46e380a0b7a76f984dd47c41a13806"
+  integrity sha512-ONmRUqK7zj7DWX0D9ADe03wbwOBZxNAfF20PlGfCWQcD3+/MakShIHrMqx9YwPTfxDdF1zLeL+RGZiR9kGMLdg==
+
 natural-compare@^1.4.0:
   version "1.4.0"
   resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
@@ -5826,6 +5909,13 @@ nice-napi@^1.0.2:
     node-addon-api "^3.0.0"
     node-gyp-build "^4.2.2"
 
+node-abi@^3.3.0:
+  version "3.47.0"
+  resolved "https://registry.yarnpkg.com/node-abi/-/node-abi-3.47.0.tgz#6cbfa2916805ae25c2b7156ca640131632eb05e8"
+  integrity sha512-2s6B2CWZM//kPgwnuI0KrYwNjfdByE25zvAaEpq9IH4zcNsarH8Ihu/UuX6XMPEogDAxkuUFeZn60pXNHAqn3A==
+  dependencies:
+    semver "^7.3.5"
+
 node-addon-api@^3.0.0, node-addon-api@^3.2.1:
   version "3.2.1"
   resolved "https://registry.yarnpkg.com/node-addon-api/-/node-addon-api-3.2.1.tgz#81325e0a2117789c0128dab65e7e38f07ceba161"
@@ -6521,6 +6611,11 @@ pkg-types@^1.0.3:
     mlly "^1.2.0"
     pathe "^1.1.0"
 
+pngjs@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/pngjs/-/pngjs-5.0.0.tgz#e79dd2b215767fd9c04561c01236df960bce7fbb"
+  integrity sha512-40QW5YalBNfQo5yRYmiw7Yz6TKKVr3h6970B2YE+3fQpsWcrbj1PzJgxeJ19DRQjhMbKPIuMY8rFaXc8moolVw==
+
 postcss-import@^15.1.0:
   version "15.1.0"
   resolved "https://registry.yarnpkg.com/postcss-import/-/postcss-import-15.1.0.tgz#41c64ed8cc0e23735a9698b3249ffdbf704adc70"
@@ -6574,6 +6669,24 @@ postcss@^8.4.23, postcss@^8.4.27:
     picocolors "^1.0.0"
     source-map-js "^1.0.2"
 
+prebuild-install@^7.1.0:
+  version "7.1.1"
+  resolved "https://registry.yarnpkg.com/prebuild-install/-/prebuild-install-7.1.1.tgz#de97d5b34a70a0c81334fd24641f2a1702352e45"
+  integrity sha512-jAXscXWMcCK8GgCoHOfIr0ODh5ai8mj63L2nWrjuAgXE6tDyYGnx4/8o/rCgU+B4JSyZBKbeZqzhtwtC3ovxjw==
+  dependencies:
+    detect-libc "^2.0.0"
+    expand-template "^2.0.3"
+    github-from-package "0.0.0"
+    minimist "^1.2.3"
+    mkdirp-classic "^0.5.3"
+    napi-build-utils "^1.0.1"
+    node-abi "^3.3.0"
+    pump "^3.0.0"
+    rc "^1.2.7"
+    simple-get "^4.0.0"
+    tar-fs "^2.0.0"
+    tunnel-agent "^0.6.0"
+
 prelude-ls@^1.2.1:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.2.1.tgz#debc6489d7a6e6b0e7611888cec880337d316396"
@@ -6685,6 +6798,16 @@ pure-rand@^6.0.0:
   resolved "https://registry.yarnpkg.com/pure-rand/-/pure-rand-6.0.2.tgz#a9c2ddcae9b68d736a8163036f088a2781c8b306"
   integrity sha512-6Yg0ekpKICSjPswYOuC5sku/TSWaRYlA0qsXqJgM/d/4pLPHPuTxK7Nbf7jFKzAeedUhR8C7K9Uv63FBsSo8xQ==
 
+qrcode@^1.5.3:
+  version "1.5.3"
+  resolved "https://registry.yarnpkg.com/qrcode/-/qrcode-1.5.3.tgz#03afa80912c0dccf12bc93f615a535aad1066170"
+  integrity sha512-puyri6ApkEHYiVl4CFzo1tDkAZ+ATcnbJrJ6RiBM1Fhctdn/ix9MTE3hRph33omisEbC/2fcfemsseiKgBPKZg==
+  dependencies:
+    dijkstrajs "^1.0.1"
+    encode-utf8 "^1.0.3"
+    pngjs "^5.0.0"
+    yargs "^15.3.1"
+
 query-selector-shadow-dom@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/query-selector-shadow-dom/-/query-selector-shadow-dom-1.0.1.tgz#1c7b0058eff4881ac44f45d8f84ede32e9a2f349"
@@ -6710,6 +6833,16 @@ quick-lru@^5.1.1:
   resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-5.1.1.tgz#366493e6b3e42a3a6885e2e99d18f80fb7a8c932"
   integrity sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==
 
+rc@^1.2.7:
+  version "1.2.8"
+  resolved "https://registry.yarnpkg.com/rc/-/rc-1.2.8.tgz#cd924bf5200a075b83c188cd6b9e211b7fc0d3ed"
+  integrity sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==
+  dependencies:
+    deep-extend "^0.6.0"
+    ini "~1.3.0"
+    minimist "^1.2.0"
+    strip-json-comments "~2.0.1"
+
 react-dom@^18.2.0:
   version "18.2.0"
   resolved "https://registry.yarnpkg.com/react-dom/-/react-dom-18.2.0.tgz#22aaf38708db2674ed9ada224ca4aa708d821e3d"
@@ -6876,6 +7009,11 @@ require-directory@^2.1.1:
   resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
   integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==
 
+require-main-filename@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/require-main-filename/-/require-main-filename-2.0.0.tgz#d0b329ecc7cc0f61649f62215be69af54aa8989b"
+  integrity sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==
+
 resolve-alpn@^1.2.0:
   version "1.2.1"
   resolved "https://registry.yarnpkg.com/resolve-alpn/-/resolve-alpn-1.2.1.tgz#b7adbdac3546aaaec20b45e7d8265927072726f9"
@@ -7001,16 +7139,16 @@ safaridriver@^0.1.0:
   resolved "https://registry.yarnpkg.com/safaridriver/-/safaridriver-0.1.0.tgz#8ff901e847b003c6a52b534028f57cddc82d6b14"
   integrity sha512-azzzIP3gR1TB9bVPv7QO4Zjw0rR1BWEU/s2aFdUMN48gxDjxEB13grAEuXDmkKPgE74cObymDxmAmZnL3clj4w==
 
+safe-buffer@^5.0.1, safe-buffer@~5.2.0:
+  version "5.2.1"
+  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
+  integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
+
 safe-buffer@~5.1.0, safe-buffer@~5.1.1:
   version "5.1.2"
   resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"
   integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
 
-safe-buffer@~5.2.0:
-  version "5.2.1"
-  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
-  integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
-
 "safer-buffer@>= 2.1.2 < 3", "safer-buffer@>= 2.1.2 < 3.0.0":
   version "2.1.2"
   resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
@@ -7109,6 +7247,20 @@ sigstore@^1.3.0, sigstore@^1.4.0:
     "@sigstore/tuf" "^1.0.3"
     make-fetch-happen "^11.0.1"
 
+simple-concat@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/simple-concat/-/simple-concat-1.0.1.tgz#f46976082ba35c2263f1c8ab5edfe26c41c9552f"
+  integrity sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==
+
+simple-get@^4.0.0:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/simple-get/-/simple-get-4.0.1.tgz#4a39db549287c979d352112fa03fd99fd6bc3543"
+  integrity sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==
+  dependencies:
+    decompress-response "^6.0.0"
+    once "^1.3.1"
+    simple-concat "^1.0.0"
+
 sirv@^2.0.3:
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/sirv/-/sirv-2.0.3.tgz#ca5868b87205a74bef62a469ed0296abceccd446"
@@ -7349,6 +7501,11 @@ strip-json-comments@^3.1.1:
   resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006"
   integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==
 
+strip-json-comments@~2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a"
+  integrity sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==
+
 strip-literal@^1.0.1:
   version "1.3.0"
   resolved "https://registry.yarnpkg.com/strip-literal/-/strip-literal-1.3.0.tgz#db3942c2ec1699e6836ad230090b84bb458e3a07"
@@ -7451,7 +7608,17 @@ tar-fs@3.0.4, tar-fs@^3.0.4:
     pump "^3.0.0"
     tar-stream "^3.1.5"
 
-tar-stream@^2.2.0, tar-stream@~2.2.0:
+tar-fs@^2.0.0:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/tar-fs/-/tar-fs-2.1.1.tgz#489a15ab85f1f0befabb370b7de4f9eb5cbe8784"
+  integrity sha512-V0r2Y9scmbDRLCNex/+hYzvp/zyYjvFbHPNgVTKfQvVrb6guiE/fxP+XblDNR011utopbkex2nM4dHNV6GDsng==
+  dependencies:
+    chownr "^1.1.1"
+    mkdirp-classic "^0.5.2"
+    pump "^3.0.0"
+    tar-stream "^2.1.4"
+
+tar-stream@^2.1.4, tar-stream@^2.2.0, tar-stream@~2.2.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/tar-stream/-/tar-stream-2.2.0.tgz#acad84c284136b060dc3faa64474aa9aebd77287"
   integrity sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==
@@ -7659,6 +7826,13 @@ tuf-js@^1.1.7:
     debug "^4.3.4"
     make-fetch-happen "^11.1.1"
 
+tunnel-agent@^0.6.0:
+  version "0.6.0"
+  resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd"
+  integrity sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==
+  dependencies:
+    safe-buffer "^5.0.1"
+
 type-check@^0.4.0, type-check@~0.4.0:
   version "0.4.0"
   resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.4.0.tgz#07b8203bfa7056c0657050e3ccd2c37730bab8f1"
@@ -8001,6 +8175,11 @@ whatwg-url@^5.0.0:
     tr46 "~0.0.3"
     webidl-conversions "^3.0.0"
 
+which-module@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/which-module/-/which-module-2.0.1.tgz#776b1fe35d90aebe99e8ac15eb24093389a4a409"
+  integrity sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==
+
 which@^2.0.1, which@^2.0.2:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1"
@@ -8045,7 +8224,7 @@ wordwrap@^1.0.0:
     string-width "^4.1.0"
     strip-ansi "^6.0.0"
 
-wrap-ansi@^6.0.1:
+wrap-ansi@^6.0.1, wrap-ansi@^6.2.0:
   version "6.2.0"
   resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz#e9393ba07102e6c91a3b221478f0257cd2856e53"
   integrity sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==
@@ -8114,7 +8293,7 @@ write-pkg@4.0.0:
     type-fest "^0.4.1"
     write-json-file "^3.2.0"
 
-ws@8.13.0, ws@^8.8.0:
+ws@8.13.0, ws@^8.13.0, ws@^8.8.0:
   version "8.13.0"
   resolved "https://registry.yarnpkg.com/ws/-/ws-8.13.0.tgz#9a9fb92f93cf41512a0735c8f4dd09b8a1211cd0"
   integrity sha512-x9vcZYTrFPC7aSIbj7sRCYo7L/Xb8Iy+pW0ng0wt2vCJv7M9HOMy0UoN3rr+IFC7hb7vXoqS+P9ktyLLLhO+LA==
@@ -8124,6 +8303,11 @@ xtend@~4.0.1:
   resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54"
   integrity sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==
 
+y18n@^4.0.0:
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/y18n/-/y18n-4.0.3.tgz#b5f259c82cd6e336921efd7bfd8bf560de9eeedf"
+  integrity sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==
+
 y18n@^5.0.5:
   version "5.0.8"
   resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55"
@@ -8154,6 +8338,14 @@ yargs-parser@21.1.1, yargs-parser@^21.0.1, yargs-parser@^21.1.1:
   resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.1.1.tgz#9096bceebf990d21bb31fa9516e0ede294a77d35"
   integrity sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==
 
+yargs-parser@^18.1.2:
+  version "18.1.3"
+  resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-18.1.3.tgz#be68c4975c6b2abf469236b0c870362fab09a7b0"
+  integrity sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==
+  dependencies:
+    camelcase "^5.0.0"
+    decamelize "^1.2.0"
+
 yargs-parser@^20.2.2, yargs-parser@^20.2.3:
   version "20.2.9"
   resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.9.tgz#2eb7dc3b0289718fc295f362753845c41a0c94ee"
@@ -8185,6 +8377,23 @@ yargs@17.7.1:
     y18n "^5.0.5"
     yargs-parser "^21.1.1"
 
+yargs@^15.3.1:
+  version "15.4.1"
+  resolved "https://registry.yarnpkg.com/yargs/-/yargs-15.4.1.tgz#0d87a16de01aee9d8bec2bfbf74f67851730f4f8"
+  integrity sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==
+  dependencies:
+    cliui "^6.0.0"
+    decamelize "^1.2.0"
+    find-up "^4.1.0"
+    get-caller-file "^2.0.1"
+    require-directory "^2.1.1"
+    require-main-filename "^2.0.0"
+    set-blocking "^2.0.0"
+    string-width "^4.2.0"
+    which-module "^2.0.0"
+    y18n "^4.0.0"
+    yargs-parser "^18.1.2"
+
 yargs@^17.3.1, yargs@^17.6.2:
   version "17.7.2"
   resolved "https://registry.yarnpkg.com/yargs/-/yargs-17.7.2.tgz#991df39aca675a192b816e1e0363f9d75d2aa269"