Publish

- jazz-example-todo@0.0.25
 - cojson@0.1.9
 - cojson-simple-sync@0.1.10
 - cojson-storage-sqlite@0.1.7
 - jazz-browser@0.1.9
 - jazz-browser-auth-local@0.1.9
 - jazz-react@0.1.11
 - jazz-react-auth-local@0.1.11
 - jazz-storage-indexeddb@0.1.9

.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

.gitignore

@@ -1,3 +1,4 @@
 node_modules
 yarn-error.log
-lerna-debug.log
+lerna-debug.log
+docsTmp

.vscode/settings.json

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

README.md

@@ -1,9 +1,82 @@
 # 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.
+
+# Documentation
+
+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`** → [DOCS](./DOCS.md#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`** → [DOCS](./DOCS.md#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`**  → [DOCS](./DOCS.md#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>

examples/todo/README.md

@@ -1,27 +1,65 @@
-# 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:
+## Installing & running the example locally
 
-- [@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
+Start by checking out just the example app to a folder:
 
-## Expanding the ESLint configuration
-
-If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:
-
-- Configure the top-level `parserOptions` property like this:
-
-```js
-   parserOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module',
-    project: ['./tsconfig.json', './tsconfig.node.json'],
-    tsconfigRootDir: __dirname,
-   },
+```bash
+npx degit gardencmp/jazz/examples/todo jazz-example-todo
+cd jazz-example-todo
 ```
 
-- 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 ensures that you have the example app without git history or our multi-package monorepo)
+
+Install dependencies:
+
+```bash
+npm install
+```
+
+Start the dev server:
+
+```bash
+npm run dev
+```
+
+## Structure
+
+- [`src/basicComponents`](./src/basicComponents) contains simple components to build the UI, unrelated to Jazz (powered by [shadcn/ui](https://ui.shadcn.com))
+- [`src/components`](./src/components/) contains helper components that do contain Jazz-specific logic, but are not super relevant to understand the basics of Jazz and CoJSON
+- [`src/0_main.tsx`](./src/0_main.tsx), [`src/1_types.ts`](./src/1_types.ts), [`src/2_App.tsx`](./src/2_App.tsx), [`src/3_TodoTable.tsx`](./src/3_TodoTable.tsx), [`src/router.ts`](./src/router.ts) - the main files for this example, see the walkthrough below
+
+## Walkthrough
+
+### Main parts
+
+- The top-level provider `<WithJazz/>`: [`src/0_main.tsx`](./src/0_main.tsx)
+
+- Defining the data model with CoJSON: [`src/1_types.ts`](./src/1_types.ts)
+
+- Creating todo projects & routing in `<App/>`: [`src/2_App.tsx`](./src/2_App.tsx)
+
+- Reactively rendering a todo project as a table, adding and editing tasks: [`src/3_TodoTable.tsx`](./src/3_TodoTable.tsx)
+
+### Helpers
+
+- Getting user profiles in `<NameBadge/>`: [`src/components/NameBadge.tsx`](./src/components/NameBadge.tsx)
+
+- (not yet commented) Creating invite links/QR codes with `<InviteButton/>`: [`src/components/InviteButton.tsx`](./src/components/InviteButton.tsx)
+
+- (not yet commented) `location.hash`-based routing and accepting invite links with `useSimpleHashRouterThatAcceptsInvites()` in [`src/router.ts`](./src/router.ts)
+
+This is the whole Todo List app!
+
+## Questions / problems / feedback
+
+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.
+
+
+## Configuration: sync server
+
+By default, the example app uses [Jazz Global Mesh](https://jazz.tools/mesh) (`wss://sync.jazz.tools`) - so cross-device use, invites and collaboration should just work.
+
+You can also run a local sync server by running `npx cojson-simple-sync` and adding the query param `?sync=ws://localhost:4200` to the URL of the example app (for example: `http://localhost:5173/?sync=ws://localhost:4200`), or by setting the `sync` parameter of the `<WithJazz>` provider component in [./src/0_main.tsx](./src/0_main.tsx).

examples/todo/components.json

@@ -10,7 +10,7 @@
     "cssVariables": true
   },
   "aliases": {
-    "components": "@/components",
-    "utils": "@/lib/utils"
+    "components": "@/basicComponents",
+    "utils": "@/basicComponents/lib/utils"
   }
 }

examples/todo/index.html

@@ -2,12 +2,12 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <link rel="icon" type="image/png" href="/jazz-logo.png" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Vite + React + TS</title>
+    <title>Jazz Todo List Example</title>
   </head>
   <body>
     <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
+    <script type="module" src="/src/0_main.tsx"></script>
   </body>
 </html>

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.10",
+  "version": "0.0.25",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -13,15 +13,18 @@
     "@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.0.16",
-    "jazz-react-auth-local": "^0.0.13",
-    "lucide-react": "^0.265.0",
+    "jazz-react": "^0.1.11",
+    "jazz-react-auth-local": "^0.1.11",
+    "lucide-react": "^0.274.0",
+    "qrcode": "^1.5.3",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "tailwind-merge": "^1.14.0",
-    "tailwindcss-animate": "^1.0.6"
+    "tailwindcss-animate": "^1.0.7",
+    "uniqolor": "^1.1.0"
   },
   "devDependencies": {
     "@types/react": "^18.2.15",

examples/todo/public/vite.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>

examples/todo/src/0_main.tsx

@@ -0,0 +1,38 @@
+import React from "react";
+import ReactDOM from "react-dom/client";
+import "./index.css";
+
+import { WithJazz } from "jazz-react";
+import { LocalAuth } from "jazz-react-auth-local";
+
+import { ThemeProvider, TitleAndLogo } from "./basicComponents/index.ts";
+import { PrettyAuthUI } from "./components/Auth.tsx";
+import App from "./2_App.tsx";
+
+/** Walkthrough: The top-level provider `<WithJazz/>`
+ *
+ *  This shows how to use the top-level provider `<WithJazz/>`,
+ *  which provides the rest of the app with a `LocalNode` (used through `useJazz` later),
+ *  based on `LocalAuth` that uses PassKeys (aka WebAuthn) to store a user's account secret
+ *  - no backend needed. */
+
+const appName = "Jazz Todo List Example";
+
+const auth = LocalAuth({
+    appName,
+    Component: PrettyAuthUI,
+});
+
+ReactDOM.createRoot(document.getElementById("root")!).render(
+    <React.StrictMode>
+        <ThemeProvider>
+            <TitleAndLogo name={appName} />
+
+            <WithJazz auth={auth}>
+                <App />
+            </WithJazz>
+        </ThemeProvider>
+    </React.StrictMode>
+);
+
+/** Walkthrough: Continue with ./1_types.ts */

examples/todo/src/1_types.ts

@@ -0,0 +1,28 @@
+import { CoMap, CoList, CoID } from "cojson";
+
+/** Walkthrough: Defining the data model with CoJSON
+ *
+ *  Here, we define our main data model of tasks, lists of tasks and projects
+ *  using CoJSON's collaborative map and list types, CoMap & CoList.
+ *
+ *  CoMap values and CoLists items can be:
+ *  - arbitrary immutable JSON
+ *  - references to other CoValues by their CoID
+ *    - CoIDs are strings that look like `co_zXPuWmH1D1cKdMpDW6CMzWb3LpY`
+ *    - In TypeScript, CoIDs take a generic parameter for the type of the
+ *      referenced CoValue, e.g. `CoID<Task>` - to make the references precise
+ **/
+
+/** An individual task which collaborators can tick or rename */
+export type Task = CoMap<{ done: boolean; text: string; }>;
+
+/** A collaborative, ordered list of task references */
+export type ListOfTasks = CoList<CoID<Task>>;
+
+/** Our top level object: a project with a title, referencing a list of tasks */
+export type TodoProject = CoMap<{
+    title: string;
+    tasks: CoID<ListOfTasks>;
+}>;
+
+/** Walkthrough: Continue with ./2_App.tsx */

examples/todo/src/2_App.tsx

@@ -0,0 +1,78 @@
+import { useCallback } from "react";
+
+import { useJazz } from "jazz-react";
+
+import { TodoProject, ListOfTasks } from "./1_types";
+
+import { SubmittableInput, Button } from "./basicComponents";
+
+import { useSimpleHashRouterThatAcceptsInvites } from "./router";
+import { TodoTable } from "./3_TodoTable";
+
+/** Walkthrough: Creating todo projects & routing in `<App/>`
+ *
+ *  <App> is the main app component, handling client-side routing based
+ *  on the CoValue ID (CoID) of our TodoProject, stored in the URL hash
+ *  - which can also contain invite links.
+ */
+
+export default function App() {
+    // A `LocalNode` represents a local view of loaded & created CoValues.
+    // It is associated with a current user account, which will determine
+    // access rights to CoValues. We get it from the top-level provider `<WithJazz/>`.
+    const { localNode, logOut } = useJazz();
+
+    // This sets up routing and accepting invites, skip for now
+    const [currentProjectId, navigateToProjectId] =
+        useSimpleHashRouterThatAcceptsInvites<TodoProject>(localNode);
+
+    const createProject = useCallback(
+        (title: string) => {
+            if (!title) return;
+
+            // To create a new todo project, we first create a `Group`,
+            // which is a scope for defining access rights (reader/writer/admin)
+            // of its members, which will apply to all CoValues owned by that group.
+            const projectGroup = localNode.createGroup();
+
+            // Then we create an empty todo project and list of tasks within that group.
+            const project = projectGroup.createMap<TodoProject>();
+            const tasks = projectGroup.createList<ListOfTasks>();
+
+            // We edit the todo project to initialise it.
+            // Inside the `.edit` callback we can mutate a CoValue
+            project.edit((project) => {
+                project.set("title", title);
+                project.set("tasks", tasks.id);
+            });
+
+            navigateToProjectId(project.id);
+        },
+        [localNode, navigateToProjectId]
+    );
+
+    return (
+        <div className="flex flex-col h-full items-center justify-start gap-10 pt-10 pb-10 px-5">
+            {currentProjectId ? (
+                <TodoTable projectId={currentProjectId} />
+            ) : (
+                <SubmittableInput
+                    onSubmit={createProject}
+                    label="Create New Project"
+                    placeholder="New project title"
+                />
+            )}
+            <Button
+                onClick={() => {
+                    navigateToProjectId(undefined);
+                    logOut();
+                }}
+                variant="outline"
+            >
+                Log Out
+            </Button>
+        </div>
+    );
+}
+
+/** Walkthrough: continue with ./3_TodoTable.tsx */

examples/todo/src/3_TodoTable.tsx

@@ -0,0 +1,162 @@
+import { useCallback } from "react";
+
+import { CoID } from "cojson";
+import { useTelepathicState } from "jazz-react";
+
+import { TodoProject, Task } from "./1_types";
+
+import {
+    Checkbox,
+    SubmittableInput,
+    Skeleton,
+    Table,
+    TableBody,
+    TableCell,
+    TableHead,
+    TableHeader,
+    TableRow,
+} from "./basicComponents";
+
+import { InviteButton } from "./components/InviteButton";
+import { NameBadge } from "./components/NameBadge";
+
+/** Walkthrough: Reactively rendering a todo project as a table,
+ *               adding and editing tasks
+ *
+ *  Here in `<TodoTable/>`, we use `useTelepathicData()` for the first time,
+ *  in this case to load the CoValue for our `TodoProject` as well as
+ *  the `ListOfTasks` referenced in it.
+ */
+
+export function TodoTable({ projectId }: { projectId: CoID<TodoProject> }) {
+    // `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!
+    const project = useTelepathicState(projectId);
+    const projectTasks = useTelepathicState(project?.get("tasks"));
+
+    // `createTask` is similar to `createProject` we saw earlier, creating a new CoMap
+    // for a new task (in the same group as the list of tasks/the project), and then
+    // adding it as an item to the project's list of tasks.
+    const createTask = useCallback(
+        (text: string) => {
+            if (!projectTasks || !text) return;
+            const task = projectTasks.group.createMap<Task>();
+
+            task.edit((task) => {
+                task.set("text", text);
+                task.set("done", false);
+            });
+
+            projectTasks.edit((projectTasks) => {
+                projectTasks.push(task.id);
+            });
+        },
+        [projectTasks]
+    );
+
+    return (
+        <div className="max-w-full w-4xl">
+            <div className="flex justify-between items-center gap-4 mb-4">
+                <h1>
+                    {
+                        // This is how we can access properties from the project,
+                        // accounting for the fact that it might not be loaded yet
+                        project?.get("title") ? (
+                            <>
+                                {project.get("title")}{" "}
+                                <span className="text-sm">({project.id})</span>
+                            </>
+                        ) : (
+                            <Skeleton className="mt-1 w-[200px] h-[1em] rounded-full" />
+                        )
+                    }
+                </h1>
+                <InviteButton list={project} />
+            </div>
+            <Table>
+                <TableHeader>
+                    <TableRow>
+                        <TableHead className="w-[40px]">Done</TableHead>
+                        <TableHead>Task</TableHead>
+                    </TableRow>
+                </TableHeader>
+                <TableBody>
+                    {
+                        // Here, we iterate over the items of our `ListOfTasks`
+                        // and render a `<TaskRow>` for each.
+
+                        projectTasks?.map((taskId: CoID<Task>) => (
+                            <TaskRow key={taskId} taskId={taskId} />
+                        ))
+                    }
+                    <NewTaskInputRow
+                        createTask={createTask}
+                        disabled={!project}
+                    />
+                </TableBody>
+            </Table>
+        </div>
+    );
+}
+
+export function TaskRow({ taskId }: { taskId: CoID<Task> }) {
+    // `<TaskRow/>` uses `useTelepathicState()` as well, to granularly load and
+    // subscribe to changes for that particular task.
+    const task = useTelepathicState(taskId);
+
+    return (
+        <TableRow>
+            <TableCell>
+                <Checkbox
+                    className="mt-1"
+                    checked={task?.get("done")}
+                    onCheckedChange={(checked) => {
+                        // (the only thing we let the user change is the "done" status)
+                        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>
+                    {/* We also use a `<NameBadge/>` helper component to render the name
+                        of the author of the task. We get the author 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. */}
+                    <NameBadge accountID={task?.whoEdited("text")} />
+                </div>
+            </TableCell>
+        </TableRow>
+    );
+}
+
+function NewTaskInputRow({
+    createTask,
+    disabled,
+}: {
+    createTask: (text: string) => void;
+    disabled: boolean;
+}) {
+    return (
+        <TableRow>
+            <TableCell>
+                <Checkbox className="mt-1" disabled />
+            </TableCell>
+            <TableCell>
+                <SubmittableInput
+                    onSubmit={(taskText) => createTask(taskText)}
+                    label="Add"
+                    placeholder="New task"
+                    disabled={disabled}
+                />
+            </TableCell>
+        </TableRow>
+    );
+}

examples/todo/src/App.tsx

@@ -1,228 +0,0 @@
-import {
-    Table,
-    TableBody,
-    TableCell,
-    TableHead,
-    TableHeader,
-    TableRow,
-} 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";
-
-type TaskContent = { done: boolean; text: string };
-type Task = CoMap<TaskContent>;
-
-type TodoListContent = {
-    title: string;
-    // other keys form a set of task IDs
-    [taskId: CoID<Task>]: true;
-};
-type TodoList = CoMap<TodoListContent>;
-
-function App() {
-    const [listId, setListId] = useState<CoID<TodoList>>();
-
-    const { localNode, logOut } = useJazz();
-
-    const createList = useCallback(
-        (title: string) => {
-            const listTeam = localNode.createTeam();
-            const list = listTeam.createMap<TodoListContent>();
-
-            list.edit((list) => {
-                list.set("title", title);
-            });
-
-            window.location.hash = list.id;
-        },
-        [localNode]
-    );
-
-    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]);
-
-    return (
-        <div className="flex flex-col h-full items-center justify-start gap-10 pt-10 md:pt-[30vh] pb-10 px-5">
-            {listId ? (
-                <TodoList 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>
-    );
-}
-
-export function TodoList({ listId }: { listId: CoID<TodoList> }) {
-    const list = useTelepathicState(listId);
-
-    const createTask = (text: string) => {
-        if (!list) return;
-        let task = list.coValue.getTeam().createMap<TaskContent>();
-
-        task = task.edit((task) => {
-            task.set("text", text);
-            task.set("done", false);
-        });
-
-        console.log("Created task", task.id, task.toJSON());
-
-        const listAfter = list.edit((list) => {
-            list.set(task.id, true);
-        });
-
-        console.log("Updated list", listAfter.toJSON());
-    };
-
-    const { toast } = useToast();
-
-    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 && list.coValue.getTeam().myRole() === "admin" && <Button
-                    size="sm"
-                    className="py-0"
-                    disabled={!list}
-                    variant="outline"
-                    onClick={() => {
-                        if (list) {
-                            const inviteLink = createInviteLink(list, "writer");
-                            navigator.clipboard.writeText(inviteLink).then(() =>
-                                toast({
-                                    description:
-                                        "Copied invite link to clipboard!",
-                                })
-                            );
-                        }
-                    }}
-                >
-                    Invite
-                </Button>}
-            </div>
-            <Table>
-                <TableHeader>
-                    <TableRow>
-                        <TableHead className="w-[40px]">Done</TableHead>
-                        <TableHead>Task</TableHead>
-                    </TableRow>
-                </TableHeader>
-                <TableBody>
-                    {list &&
-                        list
-                            .keys()
-                            .filter((key): key is CoID<Task> =>
-                                key.startsWith("co_")
-                            )
-                            .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>
-    );
-}
-
-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">
-                    <span className={task?.get("done") ? "line-through" : ""}>
-                        {task?.get("text")}
-                    </span>
-                    <NameBadge accountID={task?.getLastEditor("text")} />
-                </div>
-            </TableCell>
-        </TableRow>
-    );
-}
-
-function NameBadge({ accountID }: { accountID?: AccountID }) {
-    const profile = useProfile({ accountID });
-
-    return (
-        <span className="rounded-full bg-neutral-200 dark:bg-neutral-600 py-0.5 px-2 text-xs text-neutral-500 dark:text-neutral-300">
-            {profile?.get("name") || "..."}
-        </span>
-    );
-}
-
-export default App;

examples/todo/src/basicComponents/SubmittableInput.tsx

@@ -1,5 +1,5 @@
-import { Input } from "@/components/ui/input";
-import { Button } from "@/components/ui/button";
+import { Input } from "@/basicComponents/ui/input";
+import { Button } from "@/basicComponents/ui/button";
 
 export function SubmittableInput({
     onSubmit,

examples/todo/src/basicComponents/TitleAndLogo.tsx

@@ -0,0 +1,10 @@
+import { Toaster } from ".";
+
+export function TitleAndLogo({name}: {name: string}) {
+    return <>
+        <div className="flex items-center gap-2 justify-center mt-5">
+                <img src="jazz-logo.png" className="h-5" /> {name}
+            </div>
+            <Toaster />
+    </>
+}

examples/todo/src/basicComponents/index.ts

@@ -0,0 +1,17 @@
+export { Button } from "./ui/button";
+export { Checkbox } from "./ui/checkbox";
+export { Input } from "./ui/input";
+export { Skeleton } from "./ui/skeleton";
+export { Toaster } from "./ui/toaster";
+export { useToast } from "./ui/use-toast";
+export { SubmittableInput } from "./SubmittableInput";
+export { TitleAndLogo } from "./TitleAndLogo";
+export { ThemeProvider } from "./themeProvider";
+export {
+    Table,
+    TableBody,
+    TableCell,
+    TableHead,
+    TableHeader,
+    TableRow,
+} from "./ui/table";

examples/todo/src/basicComponents/ui/button.tsx

@@ -2,7 +2,7 @@ import * as React from "react"
 import { Slot } from "@radix-ui/react-slot"
 import { cva, type VariantProps } from "class-variance-authority"
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/basicComponents/lib/utils"
 
 const buttonVariants = cva(
   "inline-flex items-center justify-center rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50",

examples/todo/src/basicComponents/ui/checkbox.tsx

@@ -2,7 +2,7 @@ import * as React from "react"
 import * as CheckboxPrimitive from "@radix-ui/react-checkbox"
 import { Check } from "lucide-react"
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/basicComponents/lib/utils"
 
 const Checkbox = React.forwardRef<
   React.ElementRef<typeof CheckboxPrimitive.Root>,

examples/todo/src/basicComponents/ui/input.tsx

@@ -1,6 +1,6 @@
 import * as React from "react"
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/basicComponents/lib/utils"
 
 export interface InputProps
   extends React.InputHTMLAttributes<HTMLInputElement> {}

examples/todo/src/basicComponents/ui/skeleton.tsx

@@ -1,4 +1,4 @@
-import { cn } from "@/lib/utils"
+import { cn } from "@/basicComponents/lib/utils"
 
 function Skeleton({
   className,

examples/todo/src/basicComponents/ui/table.tsx

@@ -1,6 +1,6 @@
 import * as React from "react"
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/basicComponents/lib/utils"
 
 const Table = React.forwardRef<
   HTMLTableElement,

examples/todo/src/basicComponents/ui/toast.tsx

@@ -3,7 +3,7 @@ import * as ToastPrimitives from "@radix-ui/react-toast"
 import { cva, type VariantProps } from "class-variance-authority"
 import { X } from "lucide-react"
 
-import { cn } from "@/lib/utils"
+import { cn } from "@/basicComponents/lib/utils"
 
 const ToastProvider = ToastPrimitives.Provider
 

examples/todo/src/basicComponents/ui/toaster.tsx

@@ -5,8 +5,8 @@ import {
   ToastProvider,
   ToastTitle,
   ToastViewport,
-} from "@/components/ui/toast"
-import { useToast } from "@/components/ui/use-toast"
+} from "@/basicComponents/ui/toast"
+import { useToast } from "@/basicComponents/ui/use-toast"
 
 export function Toaster() {
   const { toasts } = useToast()

examples/todo/src/basicComponents/ui/use-toast.ts

@@ -4,7 +4,7 @@ import * as React from "react"
 import type {
   ToastActionElement,
   ToastProps,
-} from "@/components/ui/toast"
+} from "@/basicComponents/ui/toast"
 
 const TOAST_LIMIT = 1
 const TOAST_REMOVE_DELAY = 1000000

examples/todo/src/components/Auth.tsx

@@ -1,9 +1,10 @@
-import { LocalAuthComponent } from "jazz-react-auth-local";
 import { useState } from "react";
-import { Input } from "./ui/input";
-import { Button } from "./ui/button";
 
-export const PrettyAuthComponent: LocalAuthComponent = ({
+import { LocalAuthComponent } from "jazz-react-auth-local";
+
+import { Input, Button } from "../basicComponents";
+
+export const PrettyAuthUI: LocalAuthComponent = ({
     loading,
     logIn,
     signUp,

examples/todo/src/components/InviteButton.tsx

@@ -0,0 +1,46 @@
+import { useState } from "react";
+
+import { TodoProject } from "../1_types";
+
+import { createInviteLink } from "jazz-react";
+import QRCode from "qrcode";
+
+import { useToast, Button } from "../basicComponents";
+
+export function InviteButton({ list }: { list?: TodoProject }) {
+    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>
+        )
+    );
+}

examples/todo/src/components/NameBadge.tsx

@@ -0,0 +1,46 @@
+import { AccountID } from "cojson";
+import { useProfile } from "jazz-react";
+
+import { Skeleton } from "@/basicComponents";
+import uniqolor from "uniqolor";
+
+/** Walkthrough: Getting user profiles in `<NameBadge/>`
+ *
+ *  `<NameBadge/>` uses `useProfile(accountID)`, which is a shorthand for
+ *  useTelepathicState on an account's profile.
+ *
+ *  Profiles are always a `CoMap<{name: string}>`, but they might have app-specific
+ *  additional properties).
+ *
+ *  In our case, we just display the profile name (which is set by the LocalAuth
+ *  provider when we first create an account).
+ */
+
+export function NameBadge({ accountID }: { accountID?: AccountID }) {
+    const profile = useProfile(accountID);
+
+    return accountID && profile?.get("name") ? (
+        <span
+            className="rounded-full py-0.5 px-2 text-xs"
+            style={randomUserColor(accountID)}
+        >
+            {profile.get("name")}
+        </span>
+    ) : (
+        <Skeleton className="mt-1 w-[50px] h-[1em] rounded-full" />
+    );
+}
+
+function randomUserColor(accountID: 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 {
+        color: theme == "light" ? darkColor : brightColor,
+        background: theme == "light" ? brightColor : darkColor,
+    };
+}

examples/todo/src/index.css

@@ -1,12 +1,7 @@
 @tailwind base;
 @tailwind components;
 @tailwind utilities;
-
-:root, body, #root {
-  width: 100%;
-  height: 100%;
-}
-
+ 
 @layer base {
   :root {
     --background: 0 0% 100%;
@@ -14,63 +9,63 @@
 
     --card: 0 0% 100%;
     --card-foreground: 20 14.3% 4.1%;
-
+ 
     --popover: 0 0% 100%;
     --popover-foreground: 20 14.3% 4.1%;
-
+ 
     --primary: 24 9.8% 10%;
     --primary-foreground: 60 9.1% 97.8%;
-
+ 
     --secondary: 60 4.8% 95.9%;
     --secondary-foreground: 24 9.8% 10%;
-
+ 
     --muted: 60 4.8% 95.9%;
     --muted-foreground: 25 5.3% 44.7%;
-
+ 
     --accent: 60 4.8% 95.9%;
     --accent-foreground: 24 9.8% 10%;
-
+ 
     --destructive: 0 84.2% 60.2%;
     --destructive-foreground: 60 9.1% 97.8%;
 
     --border: 20 5.9% 90%;
     --input: 20 5.9% 90%;
     --ring: 20 14.3% 4.1%;
-
+ 
     --radius: 0.5rem;
   }
-
+ 
   .dark {
     --background: 20 14.3% 4.1%;
     --foreground: 60 9.1% 97.8%;
-
+ 
     --card: 20 14.3% 4.1%;
     --card-foreground: 60 9.1% 97.8%;
-
+ 
     --popover: 20 14.3% 4.1%;
     --popover-foreground: 60 9.1% 97.8%;
-
+ 
     --primary: 60 9.1% 97.8%;
     --primary-foreground: 24 9.8% 10%;
-
+ 
     --secondary: 12 6.5% 15.1%;
     --secondary-foreground: 60 9.1% 97.8%;
-
+ 
     --muted: 12 6.5% 15.1%;
     --muted-foreground: 24 5.4% 63.9%;
-
+ 
     --accent: 12 6.5% 15.1%;
     --accent-foreground: 60 9.1% 97.8%;
-
+ 
     --destructive: 0 62.8% 30.6%;
     --destructive-foreground: 60 9.1% 97.8%;
-
+ 
     --border: 12 6.5% 15.1%;
     --input: 12 6.5% 15.1%;
     --ring: 24 5.7% 82.9%;
   }
 }
-
+ 
 @layer base {
   * {
     @apply border-border;

examples/todo/src/main.tsx

@@ -1,29 +0,0 @@
-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";
-
-ReactDOM.createRoot(document.getElementById("root")!).render(
-    <React.StrictMode>
-        <ThemeProvider>
-            <WithJazz
-                auth={LocalAuth({
-                    appName: "Todo List Example",
-                    Component: PrettyAuthComponent,
-                })}
-                syncAddress={
-                    new URLSearchParams(window.location.search).get("sync") ||
-                    undefined
-                }
-            >
-                <App />
-                <Toaster />
-            </WithJazz>
-        </ThemeProvider>
-    </React.StrictMode>
-);

examples/todo/src/router.ts

@@ -0,0 +1,37 @@
+import { useCallback, useEffect, useState } from "react";
+import { CoID, LocalNode, ContentType } from "cojson";
+import { consumeInviteLinkFromWindowLocation } from "jazz-react";
+
+export function useSimpleHashRouterThatAcceptsInvites<C extends ContentType>(
+    localNode: LocalNode
+) {
+    const [currentValueId, setCurrentValueId] = useState<CoID<C>>();
+
+    useEffect(() => {
+        const listener = async () => {
+            const acceptedInvitation = await consumeInviteLinkFromWindowLocation<C>(localNode);
+
+            if (acceptedInvitation) {
+                setCurrentValueId(acceptedInvitation.valueID);
+                window.location.hash = acceptedInvitation.valueID;
+                return;
+            }
+
+            setCurrentValueId(
+                (window.location.hash.slice(1) as CoID<C>) || undefined
+            );
+        };
+        window.addEventListener("hashchange", listener);
+        listener();
+
+        return () => {
+            window.removeEventListener("hashchange", listener);
+        };
+    }, [localNode]);
+
+    const navigateToValue = useCallback((id: CoID<C> | undefined) => {
+        window.location.hash = id || "";
+    }, []);
+
+    return [currentValueId, navigateToValue] as const;
+}

generateDocs.ts

@@ -0,0 +1,433 @@
+import { readFile, writeFile } from "fs/promises";
+import { Application, JSONOutput } from "typedoc";
+
+const manuallyIgnore = new Set(["CojsonInternalTypes"]);
+
+async function main() {
+    // Application.bootstrap also exists, which will not load plugins
+    // Also accepts an array of option readers if you want to disable
+    // TypeDoc's tsconfig.json/package.json/typedoc.json option readers
+    const packageDocs = Object.entries({
+        cojson: "index.ts",
+        "jazz-react": "index.tsx",
+        "jazz-browser": "index.ts",
+    }).map(async ([packageName, entryPoint]) => {
+        const app = await Application.bootstrapWithPlugins({
+            entryPoints: [`packages/${packageName}/src/${entryPoint}`],
+            tsconfig: `packages/${packageName}/tsconfig.json`,
+            sort: ["required-first"],
+        });
+
+        const project = await app.convert();
+
+        if (!project) {
+            throw new Error("Failed to convert project" + packageName);
+        }
+        // Alternatively generate JSON output
+        await app.generateJson(project, `docsTmp/${packageName}.json`);
+
+        const docs = JSON.parse(
+            await readFile(`docsTmp/${packageName}.json`, "utf8")
+        ) as JSONOutput.ProjectReflection;
+
+        return (
+            `# ${packageName}\n\n` +
+            docs
+                .groups!.map((group) => {
+                    return group.children
+                        ?.map((childId) => {
+                            const child = docs.children!.find(
+                                (child) => child.id === childId
+                            )!;
+
+                            if (manuallyIgnore.has(child.name)) {
+                                return "";
+                            }
+
+                            return (
+                                `## \`${renderChildName(child)}\` (${group.title
+                                    .toLowerCase()
+                                    .replace("ces", "ce")
+                                    .replace(/es$/, "")
+                                    .replace(
+                                        "ns",
+                                        "n"
+                                    )} in \`${packageName}\`)\n\n` +
+                                renderChildType(child) +
+                                renderComment(child.comment) +
+                                (child.kind === 128 || child.kind === 256
+                                    ? child.groups
+                                          ?.map((group) =>
+                                              renderChildGroup(child, group)
+                                          )
+                                          .join("\n\n")
+                                    : "TODO: doc generator not implemented yet")
+                            );
+                        })
+                        .join("\n\n----\n\n");
+                })
+                .join("\n\n----\n\n")
+        );
+
+        function renderComment(comment?: JSONOutput.Comment): string {
+            if (comment) {
+                return (
+                    comment.summary
+                        .map((token) =>
+                            token.kind === "text" || token.kind === "code"
+                                ? token.text
+                                : ""
+                        )
+                        .join("") +
+                    "\n\n" +
+                    (comment.blockTags || [])
+                        .map((blockTag) =>
+                            blockTag.tag === "@example"
+                                ? "##### Example:\n\n" +
+                                  blockTag.content
+                                      .map((token) =>
+                                          token.kind === "text" ||
+                                          token.kind === "code"
+                                              ? token.text
+                                              : ""
+                                      )
+                                      .join("")
+                                : ""
+                        )
+                        .join("\n\n") +
+                    "\n\n"
+                );
+            } else {
+                return "TODO: document\n\n";
+            }
+        }
+
+        function renderChildName(child: JSONOutput.DeclarationReflection) {
+            if (child.signatures) {
+                if (
+                    child.signatures[0].type?.type === "reference" &&
+                    child.signatures[0].type.qualifiedName ===
+                        "React.JSX.Element"
+                ) {
+                    return `<${child.name}/>`;
+                } else {
+                    return (
+                        child.name +
+                        `(${(child.signatures[0].parameters || [])
+                            .map(renderParamSimple)
+                            .join(", ")})`
+                    );
+                }
+            } else {
+                return child.name;
+            }
+        }
+
+        function renderChildType(
+            child: JSONOutput.DeclarationReflection
+        ): string {
+            const isClass = child.kind === 128;
+            const isTypeDef = child.kind === 2097152;
+            const isInterface = child.kind === 256;
+            const isFunction = !!child.signatures;
+            return (
+                "```typescript\n" +
+                `export ${
+                    isClass
+                        ? "class"
+                        : isTypeDef
+                        ? "type"
+                        : isFunction
+                        ? "function"
+                        : isInterface
+                        ? "interface"
+                        : ""
+                } ${child.name}` +
+                (child.typeParameters
+                    ? "<" +
+                      child.typeParameters.map(renderTypeParam).join(", ") +
+                      ">"
+                    : "") +
+                (child.extendedTypes
+                    ? " extends " +
+                      child.extendedTypes.map(renderType).join(", ")
+                    : "") +
+                (child.implementedTypes
+                    ? " implements " +
+                      child.implementedTypes.map(renderType).join(", ")
+                    : "") +
+                (isClass || isInterface
+                    ? " {...}"
+                    : isTypeDef
+                    ? ` = ${renderType(child.type)}`
+                    : child.signatures
+                    ? `(${(child.signatures[0].parameters || [])
+                          .map(renderParam)
+                          .join(", ")}): ${renderType(
+                          child.signatures[0].type
+                      )}`
+                    : "") +
+                "\n```\n"
+            );
+        }
+
+        function renderChildGroup(
+            child: JSONOutput.DeclarationReflection,
+            group: JSONOutput.ReflectionGroup
+        ): string {
+            return (
+                `### ${group.title}\n\n` +
+                group.children
+                    ?.map((memberId) => {
+                        const member = child.children!.find(
+                            (child) => child.id === memberId
+                        )!;
+
+                        if (member.kind === 2048 || member.kind === 512) {
+                            return documentConstructorOrMethod(member, child);
+                        } else if (
+                            member.kind === 1024 ||
+                            member.kind === 262144
+                        ) {
+                            return documentProperty(member, child);
+                        } else {
+                            return "Unknown member kind " + member.kind;
+                        }
+                    })
+                    .join("\n\n")
+            );
+        }
+
+        function renderType(t?: JSONOutput.SomeType): string {
+            if (!t) return "";
+            if (t.type === "reference") {
+                return (
+                    t.name +
+                    (t.typeArguments
+                        ? "<" + t.typeArguments.map(renderType).join(", ") + ">"
+                        : "")
+                );
+            } else if (t.type === "intrinsic") {
+                return t.name;
+            } else if (t.type === "literal") {
+                return JSON.stringify(t.value);
+            } else if (t.type === "union") {
+                return [...new Set(t.types.map(renderType))].join(" | ");
+            } else if (t.type === "intersection") {
+                return [...new Set(t.types.map(renderType))].join(" & ");
+            } else if (t.type === "indexedAccess") {
+                return (
+                    renderType(t.objectType) +
+                    "[" +
+                    renderType(t.indexType) +
+                    "]"
+                );
+            } else if (t.type === "reflection") {
+                if (t.declaration.indexSignature) {
+                    return (
+                        "{ [" +
+                        t.declaration.indexSignature?.parameters?.[0].name +
+                        ": " +
+                        renderType(
+                            t.declaration.indexSignature?.parameters?.[0].type
+                        ) +
+                        "]: " +
+                        renderType(t.declaration.indexSignature?.type) +
+                        " }"
+                    );
+                } else if (t.declaration.children) {
+                    return `{${t.declaration.children
+                        .map(
+                            (child) =>
+                                `${child.name}${
+                                    child.flags.isOptional ? "?" : ""
+                                }: ${renderType(child.type)}`
+                        )
+                        .join(", ")}}`;
+                } else if (t.declaration.signatures) {
+                    if (t.declaration.signatures.length > 1) {
+                        return "COMPLEX_TYPE_MULTIPLE_INLINE_SIGNATURES";
+                    } else {
+                        return `(${(
+                            t.declaration.signatures[0].parameters || []
+                        ).map(renderParam)}) => ${renderType(
+                            t.declaration.signatures[0].type
+                        )}`;
+                    }
+                } else {
+                    return "COMPLEX_TYPE_REFLECTION";
+                }
+            } else if (t.type === "array") {
+                return renderType(t.elementType) + "[]";
+            } else if (t.type === "templateLiteral") {
+                const matchingNamedType = docs.children?.find(
+                    (child) =>
+                        child.variant === "declaration" &&
+                        child.type?.type === "templateLiteral" &&
+                        child.type.head === t.head &&
+                        child.type.tail.every(
+                            (piece, i) => piece[1] === t.tail[i][1]
+                        )
+                );
+
+                if (matchingNamedType) {
+                    return matchingNamedType.name;
+                } else {
+                    if (
+                        t.head === "sealerSecret_z" &&
+                        t.tail[0][1] === "/signerSecret_z"
+                    ) {
+                        return "AgentSecret";
+                    } else if (
+                        t.head === "sealer_z" &&
+                        t.tail[0][1] === "/signer_z"
+                    ) {
+                        if (t.tail[1] && t.tail[1][1] === "_session_z") {
+                            return "SessionID";
+                        } else {
+                            return "AgentID";
+                        }
+                    } else {
+                        return "TEMPLATE_LITERAL";
+                    }
+                }
+            } else {
+                return "COMPLEX_TYPE_" + t.type;
+            }
+        }
+
+        // function renderTemplateLiteral(tempLit: JSONOutput.TemplateLiteralType) {
+        //     return tempLit.head + tempLit.tail.map((piece) => piece[0] + piece[1]).join("");
+        // }
+
+        // function resolveTemplateLiteralPieceType(t: SomeType): string {
+        //     if (t.type === "string") {
+        //         return "${string}"
+        //     }
+        //     if (t.type === "reference") {
+        //         const referencedType = docs.children?.find(
+        //             (child) => child.name === t.name
+        //         );
+
+        //     }
+        // }
+
+        function renderTypeParam(
+            t?: JSONOutput.TypeParameterReflection
+        ): string {
+            if (!t) return "";
+            return t.name + (t.type ? " extends " + renderType(t.type) : "");
+        }
+
+        function renderParam(param: JSONOutput.ParameterReflection) {
+            return param.name === "__namedParameters"
+                ? renderType(param.type)
+                : `${param.name}: ${renderType(param.type)}`;
+        }
+
+        function renderParamSimple(param: JSONOutput.ParameterReflection) {
+            return param.name === "__namedParameters" &&
+                param.type?.type === "reflection"
+                ? `{${param.type?.declaration.children
+                      ?.map(
+                          (child) =>
+                              child.name + (child.flags.isOptional ? "?" : "")
+                      )
+                      .join(", ")}}${param.defaultValue ? "?" : ""}`
+                : param.name + (param.defaultValue ? "?" : "");
+        }
+
+        function documentConstructorOrMethod(
+            member: JSONOutput.DeclarationReflection,
+            child: JSONOutput.DeclarationReflection
+        ) {
+            const stem =
+                member.name === "constructor"
+                    ? "new " + child.name
+                    : (member.flags.isStatic
+                          ? child.name
+                          : child.name[0].toLowerCase() + child.name.slice(1)) +
+                      "." +
+                      member.name;
+
+            return (
+                `<details>\n<summary><code>${stem}(${(
+                    member.signatures?.[0]?.parameters?.map(
+                        renderParamSimple
+                    ) || []
+                ).join(", ")})</code> ${
+                    member.inheritedFrom
+                        ? "(from <code>" +
+                          member.inheritedFrom.name.split(".")[0] +
+                          "</code>) "
+                        : ""
+                } ${
+                    member.signatures?.[0]?.comment ? "" : "(undocumented)"
+                }</summary>\n\n` +
+                member.signatures?.map((signature) => {
+                    return (
+                        "```typescript\n" +
+                        `${stem}${
+                            signature.typeParameter
+                                ? `<${signature.typeParameter
+                                      .map(renderTypeParam)
+                                      .join(", ")}>`
+                                : ""
+                        }(${
+                            (
+                                signature.parameters?.map(
+                                    (param) =>
+                                        `\n  ${param.name}${
+                                            param.defaultValue ? "?" : ""
+                                        }: ${renderType(param.type)}${
+                                            param.defaultValue
+                                                ? ` = ${param.defaultValue}`
+                                                : ""
+                                        }`
+                                ) || []
+                            ).join(",") +
+                            (signature.parameters?.length ? "\n" : "")
+                        }): ${renderType(signature.type)}\n` +
+                        "```\n" +
+                        renderComment(signature.comment)
+                    );
+                }) +
+                "</details>\n\n"
+            );
+        }
+
+        function documentProperty(
+            member: JSONOutput.DeclarationReflection,
+            child: JSONOutput.DeclarationReflection
+        ) {
+            const stem = member.flags.isStatic
+                ? child.name
+                : child.name[0].toLowerCase() + child.name.slice(1);
+            return (
+                `<details>\n<summary><code>${stem}.${member.name}</code> ${
+                    member.inheritedFrom
+                        ? "(from <code>" +
+                          member.inheritedFrom.name.split(".")[0] +
+                          "</code>) "
+                        : ""
+                } ${
+                    member.comment ? "" : "(undocumented)"
+                }</summary>\n\n` +
+                "```typescript\n" +
+                `${member.getSignature ? "get " : ""}${stem}.${member.name}${
+                    member.getSignature ? "()" : ""
+                }: ${renderType(member.type || member.getSignature?.type)}\n` +
+                "```\n" +
+                renderComment(member.comment) +
+                "</details>\n\n"
+            );
+        }
+    });
+
+    await writeFile(
+        "./DOCS.md",
+        (await Promise.all(packageDocs)).join("\n\n\n")
+    );
+}
+
+main().catch(console.error);

package.json

@@ -7,6 +7,14 @@
   ],
   "dependencies": {},
   "devDependencies": {
-    "lerna": "^7.1.5"
+    "lerna": "^7.1.5",
+    "ts-node": "^10.9.1",
+    "typedoc": "^0.25.1"
+  },
+  "scripts": {
+    "build-all": "lerna run build",
+    "updated": "lerna updated --include-merged-tags",
+    "publish-all": "yarn run gen-docs && lerna publish --include-merged-tags",
+    "gen-docs": "ts-node generateDocs.ts"
   }
 }

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.10",
+    "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.9",
+        "cojson-storage-sqlite": "^0.1.7",
+        "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.7",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "MIT",
+  "dependencies": {
+    "better-sqlite3": "^8.5.2",
+    "cojson": "^0.1.9",
+    "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)
-  - Team (`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.0.23",
+    "version": "0.1.9",
     "devDependencies": {
         "@types/jest": "^29.5.3",
         "@typescript-eslint/eslint-plugin": "^6.2.1",

packages/cojson/src/account.test.ts

@@ -1,4 +1,4 @@
-import { newRandomSessionID } from "./coValue.js";
+import { newRandomSessionID } from "./coValueCore.js";
 import { LocalNode } from "./node.js";
 import { connectedPeers } from "./streamUtils.js";
 
@@ -19,14 +19,14 @@ test("Can create a node while creating a new account with profile", async () =>
     );
 });
 
-test("A node with an account can create teams and and objects within them", async () => {
+test("A node with an account can create groups and and objects within them", async () => {
     const { node, accountID } =
         LocalNode.withNewlyCreatedAccount("Hermes Puggington");
 
-    const team = await node.createTeam();
-    expect(team).not.toBeNull();
+    const group = await node.createGroup();
+    expect(group).not.toBeNull();
 
-    let map = team.createMap();
+    let map = group.createMap();
     map = map.edit((edit) => {
         edit.set("foo", "bar", "private");
         expect(edit.get("foo")).toEqual("bar");
@@ -34,17 +34,17 @@ test("A node with an account can create teams and and objects within them", asyn
 
     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 () => {
     const { node, accountID, accountSecret } =
         LocalNode.withNewlyCreatedAccount("Hermes Puggington");
 
-    const team = await node.createTeam();
-    expect(team).not.toBeNull();
+    const group = await node.createGroup();
+    expect(group).not.toBeNull();
 
-    let map = team.createMap();
+    let map = group.createMap();
     map = map.edit((edit) => {
         edit.set("foo", "bar", "private");
         expect(edit.get("foo")).toEqual("bar");

packages/cojson/src/account.ts

@@ -1,5 +1,5 @@
-import { CoValueHeader } from "./coValue.js";
-import { CoID } from "./contentType.js";
+import { CoValueHeader } from "./coValueCore.js";
+import { CoID } from "./coValue.js";
 import {
     AgentSecret,
     SealerID,
@@ -14,7 +14,7 @@ import {
 } from "./crypto.js";
 import { AgentID } from "./ids.js";
 import { CoMap, LocalNode } from "./index.js";
-import { Team, TeamContent } from "./team.js";
+import { Group, GroupContent } from "./group.js";
 
 export function accountHeaderForInitialAgentSecret(
     agentSecret: AgentSecret
@@ -22,7 +22,7 @@ export function accountHeaderForInitialAgentSecret(
     const agent = getAgentID(agentSecret);
     return {
         type: "comap",
-        ruleset: { type: "team", initialAdmin: agent },
+        ruleset: { type: "group", initialAdmin: agent },
         meta: {
             type: "account",
         },
@@ -31,13 +31,13 @@ export function accountHeaderForInitialAgentSecret(
     };
 }
 
-export class Account extends Team {
+export class Account extends Group {
     get id(): AccountID {
-        return this.teamMap.id as AccountID;
+        return this.underlyingMap.id as AccountID;
     }
 
     getCurrentAgentID(): AgentID {
-        const agents = this.teamMap
+        const agents = this.underlyingMap
             .keys()
             .filter((k): k is AgentID => k.startsWith("sealer_"));
 
@@ -52,7 +52,7 @@ export class Account extends Team {
 }
 
 export interface GeneralizedControlledAccount {
-    id: AccountIDOrAgentID;
+    id: AccountID | AgentID;
     agentSecret: AgentSecret;
 
     currentAgentID: () => AgentID;
@@ -62,6 +62,7 @@ export interface GeneralizedControlledAccount {
     currentSealerSecret: () => SealerSecret;
 }
 
+/** @hidden */
 export class ControlledAccount
     extends Account
     implements GeneralizedControlledAccount
@@ -70,10 +71,10 @@ export class ControlledAccount
 
     constructor(
         agentSecret: AgentSecret,
-        teamMap: CoMap<AccountContent, AccountMeta>,
+        groupMap: CoMap<AccountContent, AccountMeta>,
         node: LocalNode
     ) {
-        super(teamMap, node);
+        super(groupMap, node);
 
         this.agentSecret = agentSecret;
     }
@@ -99,6 +100,7 @@ export class ControlledAccount
     }
 }
 
+/** @hidden */
 export class AnonymousControlledAccount
     implements GeneralizedControlledAccount
 {
@@ -133,15 +135,12 @@ export class AnonymousControlledAccount
     }
 }
 
-export type AccountContent = TeamContent & { profile: CoID<Profile> };
+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

@@ -1,181 +1,284 @@
-import { Transaction } from "./coValue.js";
+import { accountOrAgentIDfromSessionID } from "./coValueCore.js";
+import { createdNowUnique } from "./crypto.js";
 import { LocalNode } from "./node.js";
-import { createdNowUnique, getAgentSignerSecret, newRandomAgentSecret, sign } from "./crypto.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
-import { CoMap, MapOpPayload } from "./contentTypes/coMap.js";
-import { AccountID } from "./index.js";
-import { Role } from "./permissions.js";
 
-test("Can create coValue with new agent credentials and add transaction to it", () => {
-    const [account, sessionID] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(account, sessionID);
+test("Empty CoMap works", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
-        type: "costream",
+        type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
         ...createdNowUnique(),
     });
 
-    const transaction: Transaction = {
-        privacy: "trusting",
-        madeAt: Date.now(),
-        changes: [
-            {
-                hello: "world",
-            },
-        ],
-    };
+    const content = coValue.getCurrentContent();
 
-    const { expectedNewHash } = coValue.expectedNewHashAfter(
-        node.ownSessionID,
-        [transaction]
-    );
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
 
-    expect(
-        coValue.tryAddTransactions(
-            node.ownSessionID,
-            [transaction],
-            expectedNewHash,
-            sign(account.currentSignerSecret(), expectedNewHash)
-        )
-    ).toBe(true);
+    expect(content.type).toEqual("comap");
+    expect([...content.keys()]).toEqual([]);
+    expect(content.toJSON()).toEqual({});
 });
 
-test("transactions with wrong signature are rejected", () => {
-    const wrongAgent = newRandomAgentSecret();
-    const [agentSecret, sessionID] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(agentSecret, sessionID);
+test("Can insert and delete CoMap entries in edit()", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
-        type: "costream",
+        type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
         ...createdNowUnique(),
     });
 
-    const transaction: Transaction = {
-        privacy: "trusting",
-        madeAt: Date.now(),
-        changes: [
-            {
-                hello: "world",
-            },
-        ],
-    };
+    const content = coValue.getCurrentContent();
 
-    const { expectedNewHash } = coValue.expectedNewHashAfter(
-        node.ownSessionID,
-        [transaction]
-    );
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
 
-    expect(
-        coValue.tryAddTransactions(
-            node.ownSessionID,
-            [transaction],
-            expectedNewHash,
-            sign(getAgentSignerSecret(wrongAgent), expectedNewHash)
-        )
-    ).toBe(false);
+    expect(content.type).toEqual("comap");
+
+    content.edit((editable) => {
+        editable.set("hello", "world", "trusting");
+        expect(editable.get("hello")).toEqual("world");
+        editable.set("foo", "bar", "trusting");
+        expect(editable.get("foo")).toEqual("bar");
+        expect([...editable.keys()]).toEqual(["hello", "foo"]);
+        editable.delete("foo", "trusting");
+        expect(editable.get("foo")).toEqual(undefined);
+    });
 });
 
-test("transactions with correctly signed, but wrong hash are rejected", () => {
-    const [account, sessionID] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(account, sessionID);
+test("Can get CoMap entry values at different points in time", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
-        type: "costream",
+        type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
         ...createdNowUnique(),
     });
 
-    const transaction: Transaction = {
-        privacy: "trusting",
-        madeAt: Date.now(),
-        changes: [
-            {
-                hello: "world",
-            },
-        ],
-    };
+    const content = coValue.getCurrentContent();
 
-    const { expectedNewHash } = coValue.expectedNewHashAfter(
-        node.ownSessionID,
-        [
-            {
-                privacy: "trusting",
-                madeAt: Date.now(),
-                changes: [
-                    {
-                        hello: "wrong",
-                    },
-                ],
-            },
-        ]
-    );
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
 
-    expect(
-        coValue.tryAddTransactions(
-            node.ownSessionID,
-            [transaction],
-            expectedNewHash,
-            sign(account.currentSignerSecret(), expectedNewHash)
-        )
-    ).toBe(false);
+    expect(content.type).toEqual("comap");
+
+    content.edit((editable) => {
+        const beforeA = Date.now();
+        while (Date.now() < beforeA + 10) {}
+        editable.set("hello", "A", "trusting");
+        const beforeB = Date.now();
+        while (Date.now() < beforeB + 10) {}
+        editable.set("hello", "B", "trusting");
+        const beforeC = Date.now();
+        while (Date.now() < beforeC + 10) {}
+        editable.set("hello", "C", "trusting");
+        expect(editable.get("hello")).toEqual("C");
+        expect(editable.getAtTime("hello", Date.now())).toEqual("C");
+        expect(editable.getAtTime("hello", beforeA)).toEqual(undefined);
+        expect(editable.getAtTime("hello", beforeB)).toEqual("A");
+        expect(editable.getAtTime("hello", beforeC)).toEqual("B");
+    });
 });
 
-test("New transactions in a team correctly update owned values, including subscriptions", async () => {
-    const [account, sessionID] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(account, sessionID);
+test("Can get all historic values of key in CoMap", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
-    const team = node.createTeam();
-
-    const timeBeforeEdit = Date.now();
-
-    await new Promise((resolve) => setTimeout(resolve, 10));
-
-    let map = team.createMap();
-
-    let mapAfterEdit = map.edit((map) => {
-        map.set("hello", "world");
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
     });
 
-    const listener = jest.fn().mockImplementation();
+    const content = coValue.getCurrentContent();
 
-    map.subscribe(listener);
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
 
-    expect(listener.mock.calls[0][0].get("hello")).toBe("world");
+    expect(content.type).toEqual("comap");
 
-    const resignationThatWeJustLearnedAbout = {
-        privacy: "trusting",
-        madeAt: timeBeforeEdit,
-        changes: [
+    content.edit((editable) => {
+        editable.set("hello", "A", "trusting");
+        const txA = editable.getLastTxID("hello");
+        editable.set("hello", "B", "trusting");
+        const txB = editable.getLastTxID("hello");
+        editable.delete("hello", "trusting");
+        const txDel = editable.getLastTxID("hello");
+        editable.set("hello", "C", "trusting");
+        const txC = editable.getLastTxID("hello");
+        expect(editable.getHistory("hello")).toEqual([
             {
-                op: "set",
-                key: account.id,
-                value: "revoked"
-            } satisfies MapOpPayload<typeof account.id, Role>
-        ]
-    } satisfies Transaction;
-
-    const { expectedNewHash } = team.teamMap.coValue.expectedNewHashAfter(sessionID, [
-        resignationThatWeJustLearnedAbout,
-    ]);
-
-    const signature = sign(
-        node.account.currentSignerSecret(),
-        expectedNewHash
-    );
-
-    expect(map.coValue.getValidSortedTransactions().length).toBe(1);
-
-    const manuallyAdddedTxSuccess = team.teamMap.coValue.tryAddTransactions(node.ownSessionID, [resignationThatWeJustLearnedAbout], expectedNewHash, signature);
-
-    expect(manuallyAdddedTxSuccess).toBe(true);
-
-    expect(listener.mock.calls.length).toBe(2);
-    expect(listener.mock.calls[1][0].get("hello")).toBe(undefined);
-
-    expect(map.coValue.getValidSortedTransactions().length).toBe(0);
+                txID: txA,
+                value: "A",
+                at: txA && coValue.getTx(txA)?.madeAt,
+            },
+            {
+                txID: txB,
+                value: "B",
+                at: txB && coValue.getTx(txB)?.madeAt,
+            },
+            {
+                txID: txDel,
+                value: undefined,
+                at: txDel && coValue.getTx(txDel)?.madeAt,
+            },
+            {
+                txID: txC,
+                value: "C",
+                at: txC && coValue.getTx(txC)?.madeAt,
+            },
+        ]);
+    });
 });
+
+test("Can get last tx ID for a key in CoMap", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    expect(content.type).toEqual("comap");
+
+    content.edit((editable) => {
+        expect(editable.getLastTxID("hello")).toEqual(undefined);
+        editable.set("hello", "A", "trusting");
+        const sessionID = editable.getLastTxID("hello")?.sessionID;
+        expect(sessionID && accountOrAgentIDfromSessionID(sessionID)).toEqual(
+            node.account.id
+        );
+        expect(editable.getLastTxID("hello")?.txIndex).toEqual(0);
+        editable.set("hello", "B", "trusting");
+        expect(editable.getLastTxID("hello")?.txIndex).toEqual(1);
+        editable.set("hello", "C", "trusting");
+        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/coValue.ts

@@ -1,564 +1,62 @@
-import { randomBytes } from "@noble/hashes/utils";
-import { ContentType } from "./contentType.js";
-import { Static } from "./contentTypes/static.js";
-import { CoStream } from "./contentTypes/coStream.js";
-import { CoMap } from "./contentTypes/coMap.js";
-import {
-    Encrypted,
-    Hash,
-    KeySecret,
-    Signature,
-    StreamingHash,
-    unseal,
-    shortHash,
-    sign,
-    verify,
-    encryptForTransaction,
-    decryptForTransaction,
-    KeyID,
-    decryptKeySecret,
-    getAgentSignerID,
-    getAgentSealerID,
-} from "./crypto.js";
 import { JsonObject, JsonValue } from "./jsonValue.js";
-import { base58 } from "@scure/base";
-import {
-    PermissionsDef as RulesetDef,
-    determineValidTransactions,
-    isKeyForKeyField,
-} from "./permissions.js";
-import { Team, expectTeamContent } from "./team.js";
-import { LocalNode } from "./node.js";
-import { CoValueKnownState, NewContentMessage } from "./sync.js";
-import { RawCoID, SessionID, TransactionID } from "./ids.js";
-import { CoList } from "./contentTypes/coList.js";
-import {
-    AccountID,
-    AccountIDOrAgentID,
-    GeneralizedControlledAccount,
-} from "./account.js";
+import { RawCoID } from "./ids.js";
+import { CoMap } from "./coValues/coMap.js";
+import { CoStream } from "./coValues/coStream.js";
+import { Static } from "./coValues/static.js";
+import { CoList } from "./coValues/coList.js";
+import { CoValueCore, Group } from "./index.js";
 
-export type CoValueHeader = {
-    type: ContentType["type"];
-    ruleset: RulesetDef;
+export type CoID<T extends CoValueImpl> = RawCoID & {
+    readonly __type: T;
+};
+
+export interface ReadableCoValue extends CoValue {
+    /** Lets you subscribe to future updates to this CoValue (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 `CoValue`. */
+    subscribe(listener: (coValue: CoValueImpl) => void): () => void;
+    /** Lets you apply edits to a `CoValue`, inside the changer callback, which receives a `WriteableCoValue`.
+     *
+     *  A `WritableCoValue` has all the same methods as a `CoValue`, but all edits made to it (with its additional mutator methods)
+     *  are reflected in it immediately - so it behaves mutably, whereas a `CoValue` is always immutable
+     *  (you need to use `subscribe` to receive new versions of it). */
+    edit?:
+        | ((changer: (editable: WriteableCoValue) => void) => CoValueImpl)
+        | undefined;
+}
+
+export interface CoValue {
+    /** The `CoValue`'s (precisely typed) `CoID` */
+    id: CoID<CoValueImpl>;
+    core: CoValueCore;
+    /** Specifies which kind of `CoValue` this is */
+    type: CoValueImpl["type"];
+    /** The `CoValue`'s (precisely typed) static metadata */
     meta: JsonObject | null;
-    createdAt: `2${string}` | null;
-    uniqueness: `z${string}` | null;
-};
-
-export function idforHeader(header: CoValueHeader): RawCoID {
-    const hash = shortHash(header);
-    return `co_z${hash.slice("shortHash_z".length)}`;
+    /** The `Group` this `CoValue` belongs to (determining permissions) */
+    group: Group;
+    /** Returns an immutable JSON presentation of this `CoValue` */
+    toJSON(): JsonValue;
 }
 
-export function accountOrAgentIDfromSessionID(
-    sessionID: SessionID
-): AccountIDOrAgentID {
-    return sessionID.split("_session")[0] as AccountIDOrAgentID;
-}
-
-export function newRandomSessionID(accountID: AccountIDOrAgentID): SessionID {
-    return `${accountID}_session_z${base58.encode(randomBytes(8))}`;
-}
-
-type SessionLog = {
-    transactions: Transaction[];
-    lastHash?: Hash;
-    streamingHash: StreamingHash;
-    lastSignature: Signature;
-};
-
-export type PrivateTransaction = {
-    privacy: "private";
-    madeAt: number;
-    keyUsed: KeyID;
-    encryptedChanges: Encrypted<
-        JsonValue[],
-        { in: RawCoID; tx: TransactionID }
-    >;
-};
-
-export type TrustingTransaction = {
-    privacy: "trusting";
-    madeAt: number;
-    changes: JsonValue[];
-};
-
-export type Transaction = PrivateTransaction | TrustingTransaction;
-
-export type DecryptedTransaction = {
-    txID: TransactionID;
-    changes: JsonValue[];
-    madeAt: number;
-};
-
-export class CoValue {
-    id: RawCoID;
-    node: LocalNode;
-    header: CoValueHeader;
-    _sessions: { [key: SessionID]: SessionLog };
-    _cachedContent?: ContentType;
-    listeners: Set<(content?: ContentType) => void> = new Set();
-
-    constructor(header: CoValueHeader, node: LocalNode, internalInitSessions: { [key: SessionID]: SessionLog } = {}) {
-        this.id = idforHeader(header);
-        this.header = header;
-        this._sessions = internalInitSessions;
-        this.node = node;
-
-        if (header.ruleset.type == "ownedByTeam") {
-            this.node
-                .expectCoValueLoaded(header.ruleset.team)
-                .subscribe((_teamUpdate) => {
-                    this._cachedContent = undefined;
-                    const newContent = this.getCurrentContent();
-                    for (const listener of this.listeners) {
-                        listener(newContent);
-                    }
-                });
-        }
-    }
-
-    get sessions(): Readonly<{ [key: SessionID]: SessionLog }> {
-        return this._sessions;
-    }
-
-    testWithDifferentAccount(
-        account: GeneralizedControlledAccount,
-        ownSessionID: SessionID
-    ): CoValue {
-        const newNode = this.node.testWithDifferentAccount(
-            account,
-            ownSessionID
-        );
-
-        return newNode.expectCoValueLoaded(this.id);
-    }
-
-    knownState(): CoValueKnownState {
-        return {
-            id: this.id,
-            header: true,
-            sessions: Object.fromEntries(
-                Object.entries(this.sessions).map(([k, v]) => [
-                    k,
-                    v.transactions.length,
-                ])
-            ),
-        };
-    }
-
-    get meta(): JsonValue {
-        return this.header?.meta ?? null;
-    }
-
-    nextTransactionID(): TransactionID {
-        const sessionID = this.node.ownSessionID;
-        return {
-            sessionID,
-            txIndex: this.sessions[sessionID]?.transactions.length || 0,
-        };
-    }
-
-    tryAddTransactions(
-        sessionID: SessionID,
-        newTransactions: Transaction[],
-        givenExpectedNewHash: Hash | undefined,
-        newSignature: Signature
-    ): boolean {
-        const signerID = getAgentSignerID(
-            this.node.resolveAccountAgent(
-                accountOrAgentIDfromSessionID(sessionID),
-                "Expected to know signer of transaction"
-            )
-        );
-
-        if (!signerID) {
-            console.warn(
-                "Unknown agent",
-                accountOrAgentIDfromSessionID(sessionID)
-            );
-            return false;
-        }
-
-        const { expectedNewHash, newStreamingHash } = this.expectedNewHashAfter(
-            sessionID,
-            newTransactions
-        );
-
-        if (givenExpectedNewHash && givenExpectedNewHash !== expectedNewHash) {
-            console.warn("Invalid hash", {
-                expectedNewHash,
-                givenExpectedNewHash,
-            });
-            return false;
-        }
-
-        if (!verify(newSignature, expectedNewHash, signerID)) {
-            console.warn(
-                "Invalid signature",
-                newSignature,
-                expectedNewHash,
-                signerID
-            );
-            return false;
-        }
-
-        const transactions = this.sessions[sessionID]?.transactions ?? [];
-
-        transactions.push(...newTransactions);
-
-        this._sessions[sessionID] = {
-            transactions,
-            lastHash: expectedNewHash,
-            streamingHash: newStreamingHash,
-            lastSignature: newSignature,
-        };
-
-        this._cachedContent = undefined;
-
-        const content = this.getCurrentContent();
-
-        for (const listener of this.listeners) {
-            listener(content);
-        }
-
-        return true;
-    }
-
-    subscribe(listener: (content?: ContentType) => void): () => void {
-        this.listeners.add(listener);
-        listener(this.getCurrentContent());
-
-        return () => {
-            this.listeners.delete(listener);
-        };
-    }
-
-    expectedNewHashAfter(
-        sessionID: SessionID,
-        newTransactions: Transaction[]
-    ): { expectedNewHash: Hash; newStreamingHash: StreamingHash } {
-        const streamingHash =
-            this.sessions[sessionID]?.streamingHash.clone() ??
-            new StreamingHash();
-        for (const transaction of newTransactions) {
-            streamingHash.update(transaction);
-        }
-
-        const newStreamingHash = streamingHash.clone();
-
-        return {
-            expectedNewHash: streamingHash.digest(),
-            newStreamingHash,
-        };
-    }
-
-    makeTransaction(
-        changes: JsonValue[],
-        privacy: "private" | "trusting"
-    ): boolean {
-        const madeAt = Date.now();
-
-        let transaction: Transaction;
-
-        if (privacy === "private") {
-            const { secret: keySecret, id: keyID } = this.getCurrentReadKey();
-
-            if (!keySecret) {
-                throw new Error(
-                    "Can't make transaction without read key secret"
-                );
-            }
-
-            transaction = {
-                privacy: "private",
-                madeAt,
-                keyUsed: keyID,
-                encryptedChanges: encryptForTransaction(changes, keySecret, {
-                    in: this.id,
-                    tx: this.nextTransactionID(),
-                }),
-            };
-        } else {
-            transaction = {
-                privacy: "trusting",
-                madeAt,
-                changes,
-            };
-        }
-
-        const sessionID = this.node.ownSessionID;
-
-        const { expectedNewHash } = this.expectedNewHashAfter(sessionID, [
-            transaction,
-        ]);
-
-        const signature = sign(
-            this.node.account.currentSignerSecret(),
-            expectedNewHash
-        );
-
-        const success = this.tryAddTransactions(
-            sessionID,
-            [transaction],
-            expectedNewHash,
-            signature
-        );
-
-        if (success) {
-            void this.node.sync.syncCoValue(this);
-        }
-
-        return success;
-    }
-
-    getCurrentContent(): ContentType {
-        if (this._cachedContent) {
-            return this._cachedContent;
-        }
-
-        if (this.header.type === "comap") {
-            this._cachedContent = new CoMap(this);
-        } else if (this.header.type === "colist") {
-            this._cachedContent = new CoList(this);
-        } else if (this.header.type === "costream") {
-            this._cachedContent = new CoStream(this);
-        } else if (this.header.type === "static") {
-            this._cachedContent = new Static(this);
-        } else {
-            throw new Error(`Unknown coValue type ${this.header.type}`);
-        }
-
-        return this._cachedContent;
-    }
-
-    getValidSortedTransactions(): DecryptedTransaction[] {
-        const validTransactions = determineValidTransactions(this);
-
-        const allTransactions: DecryptedTransaction[] = validTransactions
-            .map(({ txID, tx }) => {
-                if (tx.privacy === "trusting") {
-                    return {
-                        txID,
-                        madeAt: tx.madeAt,
-                        changes: tx.changes,
-                    };
-                } else {
-                    const readKey = this.getReadKey(tx.keyUsed);
-
-                    if (!readKey) {
-                        return undefined;
-                    } else {
-                        const decrytedChanges = decryptForTransaction(
-                            tx.encryptedChanges,
-                            readKey,
-                            {
-                                in: this.id,
-                                tx: txID,
-                            }
-                        );
-
-                        if (!decrytedChanges) {
-                            console.error(
-                                "Failed to decrypt transaction despite having key"
-                            );
-                            return undefined;
-                        }
-                        return {
-                            txID,
-                            madeAt: tx.madeAt,
-                            changes: decrytedChanges,
-                        };
-                    }
-                }
-            })
-            .filter((x): x is Exclude<typeof x, undefined> => !!x);
-        allTransactions.sort(
-            (a, b) =>
-                a.madeAt - b.madeAt ||
-                (a.txID.sessionID < b.txID.sessionID ? -1 : 1) ||
-                a.txID.txIndex - b.txID.txIndex
-        );
-
-        return allTransactions;
-    }
-
-    getCurrentReadKey(): { secret: KeySecret | undefined; id: KeyID } {
-        if (this.header.ruleset.type === "team") {
-            const content = expectTeamContent(this.getCurrentContent());
-
-            const currentKeyId = content.get("readKey");
-
-            if (!currentKeyId) {
-                throw new Error("No readKey set");
-            }
-
-            const secret = this.getReadKey(currentKeyId);
-
-            return {
-                secret: secret,
-                id: currentKeyId,
-            };
-        } else if (this.header.ruleset.type === "ownedByTeam") {
-            return this.node
-                .expectCoValueLoaded(this.header.ruleset.team)
-                .getCurrentReadKey();
-        } else {
-            throw new Error(
-                "Only teams or values owned by teams have read secrets"
-            );
-        }
-    }
-
-    getReadKey(keyID: KeyID): KeySecret | undefined {
-        if (this.header.ruleset.type === "team") {
-            const content = expectTeamContent(this.getCurrentContent());
-
-            // Try to find key revelation for us
-
-            const readKeyEntry = content.getLastEntry(
-                `${keyID}_for_${this.node.account.id}`
-            );
-
-            if (readKeyEntry) {
-                const revealer = accountOrAgentIDfromSessionID(
-                    readKeyEntry.txID.sessionID
-                );
-                const revealerAgent = this.node.resolveAccountAgent(
-                    revealer,
-                    "Expected to know revealer"
-                );
-
-                const secret = unseal(
-                    readKeyEntry.value,
-                    this.node.account.currentSealerSecret(),
-                    getAgentSealerID(revealerAgent),
-                    {
-                        in: this.id,
-                        tx: readKeyEntry.txID,
-                    }
-                );
-
-                if (secret) return secret as KeySecret;
-            }
-
-            // Try to find indirect revelation through previousKeys
-
-            for (const field of content.keys()) {
-                if (isKeyForKeyField(field) && field.startsWith(keyID)) {
-                    const encryptingKeyID = field.split("_for_")[1] as KeyID;
-                    const encryptingKeySecret =
-                        this.getReadKey(encryptingKeyID);
-
-                    if (!encryptingKeySecret) {
-                        continue;
-                    }
-
-                    const encryptedPreviousKey = content.get(field)!;
-
-                    const secret = decryptKeySecret(
-                        {
-                            encryptedID: keyID,
-                            encryptingID: encryptingKeyID,
-                            encrypted: encryptedPreviousKey,
-                        },
-                        encryptingKeySecret
-                    );
-
-                    if (secret) {
-                        return secret;
-                    } else {
-                        console.error(
-                            `Encrypting ${encryptingKeyID} key didn't decrypt ${keyID}`
-                        );
-                    }
-                }
-            }
-
-            return undefined;
-        } else if (this.header.ruleset.type === "ownedByTeam") {
-            return this.node
-                .expectCoValueLoaded(this.header.ruleset.team)
-                .getReadKey(keyID);
-        } else {
-            throw new Error(
-                "Only teams or values owned by teams have read secrets"
-            );
-        }
-    }
-
-    getTeam(): Team {
-        if (this.header.ruleset.type !== "ownedByTeam") {
-            throw new Error("Only values owned by teams have teams");
-        }
-
-        return new Team(
-            expectTeamContent(
-                this.node
-                    .expectCoValueLoaded(this.header.ruleset.team)
-                    .getCurrentContent()
-            ),
-            this.node
-        );
-    }
-
-    getTx(txID: TransactionID): Transaction | undefined {
-        return this.sessions[txID.sessionID]?.transactions[txID.txIndex];
-    }
-
-    newContentSince(
-        knownState: CoValueKnownState | undefined
-    ): NewContentMessage | undefined {
-        const newContent: NewContentMessage = {
-            action: "content",
-            id: this.id,
-            header: knownState?.header ? undefined : this.header,
-            new: Object.fromEntries(
-                Object.entries(this.sessions)
-                    .map(([sessionID, log]) => {
-                        const newTransactions = log.transactions.slice(
-                            knownState?.sessions[sessionID as SessionID] || 0
-                        );
-
-                        if (
-                            newTransactions.length === 0 ||
-                            !log.lastHash ||
-                            !log.lastSignature
-                        ) {
-                            return undefined;
-                        }
-
-                        return [
-                            sessionID,
-                            {
-                                after:
-                                    knownState?.sessions[
-                                        sessionID as SessionID
-                                    ] || 0,
-                                newTransactions,
-                                lastSignature: log.lastSignature,
-                            },
-                        ];
-                    })
-                    .filter((x): x is Exclude<typeof x, undefined> => !!x)
-            ),
-        };
-
-        if (!newContent.header && Object.keys(newContent.new).length === 0) {
-            return undefined;
-        }
-
-        return newContent;
-    }
-
-    getDependedOnCoValues(): RawCoID[] {
-        return this.header.ruleset.type === "team"
-            ? expectTeamContent(this.getCurrentContent())
-                  .keys()
-                  .filter((k): k is AccountID => k.startsWith("co_"))
-            : this.header.ruleset.type === "ownedByTeam"
-            ? [this.header.ruleset.team]
-            : [];
-    }
+export interface WriteableCoValue extends CoValue {}
+
+export type CoValueImpl =
+    | CoMap<{ [key: string]: JsonValue }, JsonObject | null>
+    | CoList<JsonValue, JsonObject | null>
+    | CoStream<JsonValue, JsonObject | null>
+    | Static<JsonObject>;
+
+export function expectMap(
+    content: CoValueImpl
+): CoMap<{ [key: string]: string }, JsonObject | null> {
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    return content as CoMap<{ [key: string]: string }, JsonObject | null>;
 }

packages/cojson/src/coValueCore.test.ts

@@ -0,0 +1,181 @@
+import { Transaction } from "./coValueCore.js";
+import { LocalNode } from "./node.js";
+import { createdNowUnique, getAgentSignerSecret, newRandomAgentSecret, sign } from "./crypto.js";
+import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import { CoMap, MapOpPayload } from "./coValues/coMap.js";
+import { AccountID } from "./index.js";
+import { Role } from "./permissions.js";
+
+test("Can create coValue with new agent credentials and add transaction to it", () => {
+    const [account, sessionID] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(account, sessionID);
+
+    const coValue = node.createCoValue({
+        type: "costream",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const transaction: Transaction = {
+        privacy: "trusting",
+        madeAt: Date.now(),
+        changes: [
+            {
+                hello: "world",
+            },
+        ],
+    };
+
+    const { expectedNewHash } = coValue.expectedNewHashAfter(
+        node.currentSessionID,
+        [transaction]
+    );
+
+    expect(
+        coValue.tryAddTransactions(
+            node.currentSessionID,
+            [transaction],
+            expectedNewHash,
+            sign(account.currentSignerSecret(), expectedNewHash)
+        )
+    ).toBe(true);
+});
+
+test("transactions with wrong signature are rejected", () => {
+    const wrongAgent = newRandomAgentSecret();
+    const [agentSecret, sessionID] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(agentSecret, sessionID);
+
+    const coValue = node.createCoValue({
+        type: "costream",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const transaction: Transaction = {
+        privacy: "trusting",
+        madeAt: Date.now(),
+        changes: [
+            {
+                hello: "world",
+            },
+        ],
+    };
+
+    const { expectedNewHash } = coValue.expectedNewHashAfter(
+        node.currentSessionID,
+        [transaction]
+    );
+
+    expect(
+        coValue.tryAddTransactions(
+            node.currentSessionID,
+            [transaction],
+            expectedNewHash,
+            sign(getAgentSignerSecret(wrongAgent), expectedNewHash)
+        )
+    ).toBe(false);
+});
+
+test("transactions with correctly signed, but wrong hash are rejected", () => {
+    const [account, sessionID] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(account, sessionID);
+
+    const coValue = node.createCoValue({
+        type: "costream",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const transaction: Transaction = {
+        privacy: "trusting",
+        madeAt: Date.now(),
+        changes: [
+            {
+                hello: "world",
+            },
+        ],
+    };
+
+    const { expectedNewHash } = coValue.expectedNewHashAfter(
+        node.currentSessionID,
+        [
+            {
+                privacy: "trusting",
+                madeAt: Date.now(),
+                changes: [
+                    {
+                        hello: "wrong",
+                    },
+                ],
+            },
+        ]
+    );
+
+    expect(
+        coValue.tryAddTransactions(
+            node.currentSessionID,
+            [transaction],
+            expectedNewHash,
+            sign(account.currentSignerSecret(), expectedNewHash)
+        )
+    ).toBe(false);
+});
+
+test("New transactions in a group correctly update owned values, including subscriptions", async () => {
+    const [account, sessionID] = randomAnonymousAccountAndSessionID();
+    const node = new LocalNode(account, sessionID);
+
+    const group = node.createGroup();
+
+    const timeBeforeEdit = Date.now();
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    let map = group.createMap();
+
+    let mapAfterEdit = map.edit((map) => {
+        map.set("hello", "world");
+    });
+
+    const listener = jest.fn().mockImplementation();
+
+    map.subscribe(listener);
+
+    expect(listener.mock.calls[0][0].get("hello")).toBe("world");
+
+    const resignationThatWeJustLearnedAbout = {
+        privacy: "trusting",
+        madeAt: timeBeforeEdit,
+        changes: [
+            {
+                op: "set",
+                key: account.id,
+                value: "revoked"
+            } satisfies MapOpPayload<typeof account.id, Role>
+        ]
+    } satisfies Transaction;
+
+    const { expectedNewHash } = group.underlyingMap.core.expectedNewHashAfter(sessionID, [
+        resignationThatWeJustLearnedAbout,
+    ]);
+
+    const signature = sign(
+        node.account.currentSignerSecret(),
+        expectedNewHash
+    );
+
+    expect(map.core.getValidSortedTransactions().length).toBe(1);
+
+    const manuallyAdddedTxSuccess = group.underlyingMap.core.tryAddTransactions(node.currentSessionID, [resignationThatWeJustLearnedAbout], expectedNewHash, signature);
+
+    expect(manuallyAdddedTxSuccess).toBe(true);
+
+    expect(listener.mock.calls.length).toBe(2);
+    expect(listener.mock.calls[1][0].get("hello")).toBe(undefined);
+
+    expect(map.core.getValidSortedTransactions().length).toBe(0);
+});

packages/cojson/src/coValueCore.ts

@@ -0,0 +1,588 @@
+import { randomBytes } from "@noble/hashes/utils";
+import { CoValueImpl } from "./coValue.js";
+import { Static } from "./coValues/static.js";
+import { CoStream } from "./coValues/coStream.js";
+import { CoMap } from "./coValues/coMap.js";
+import {
+    Encrypted,
+    Hash,
+    KeySecret,
+    Signature,
+    StreamingHash,
+    unseal,
+    shortHash,
+    sign,
+    verify,
+    encryptForTransaction,
+    decryptForTransaction,
+    KeyID,
+    decryptKeySecret,
+    getAgentSignerID,
+    getAgentSealerID,
+} from "./crypto.js";
+import { JsonObject, JsonValue } from "./jsonValue.js";
+import { base58 } from "@scure/base";
+import {
+    PermissionsDef as RulesetDef,
+    determineValidTransactions,
+    isKeyForKeyField,
+} from "./permissions.js";
+import { Group, expectGroupContent } from "./group.js";
+import { LocalNode } from "./node.js";
+import { CoValueKnownState, NewContentMessage } from "./sync.js";
+import { AgentID, RawCoID, SessionID, TransactionID } from "./ids.js";
+import { CoList } from "./coValues/coList.js";
+import {
+    AccountID,
+    GeneralizedControlledAccount,
+} from "./account.js";
+
+export type CoValueHeader = {
+    type: CoValueImpl["type"];
+    ruleset: RulesetDef;
+    meta: JsonObject | null;
+    createdAt: `2${string}` | null;
+    uniqueness: `z${string}` | null;
+};
+
+export function idforHeader(header: CoValueHeader): RawCoID {
+    const hash = shortHash(header);
+    return `co_z${hash.slice("shortHash_z".length)}`;
+}
+
+export function accountOrAgentIDfromSessionID(
+    sessionID: SessionID
+): AccountID | AgentID {
+    return sessionID.split("_session")[0] as AccountID | AgentID;
+}
+
+export function newRandomSessionID(accountID: AccountID | AgentID): SessionID {
+    return `${accountID}_session_z${base58.encode(randomBytes(8))}`;
+}
+
+type SessionLog = {
+    transactions: Transaction[];
+    lastHash?: Hash;
+    streamingHash: StreamingHash;
+    lastSignature: Signature;
+};
+
+export type PrivateTransaction = {
+    privacy: "private";
+    madeAt: number;
+    keyUsed: KeyID;
+    encryptedChanges: Encrypted<
+        JsonValue[],
+        { in: RawCoID; tx: TransactionID }
+    >;
+};
+
+export type TrustingTransaction = {
+    privacy: "trusting";
+    madeAt: number;
+    changes: JsonValue[];
+};
+
+export type Transaction = PrivateTransaction | TrustingTransaction;
+
+export type DecryptedTransaction = {
+    txID: TransactionID;
+    changes: JsonValue[];
+    madeAt: number;
+};
+
+const readKeyCache = new WeakMap<CoValueCore, { [id: KeyID]: KeySecret }>();
+
+export class CoValueCore {
+    id: RawCoID;
+    node: LocalNode;
+    header: CoValueHeader;
+    _sessions: { [key: SessionID]: SessionLog };
+    _cachedContent?: CoValueImpl;
+    listeners: Set<(content?: CoValueImpl) => void> = new Set();
+
+    constructor(
+        header: CoValueHeader,
+        node: LocalNode,
+        internalInitSessions: { [key: SessionID]: SessionLog } = {}
+    ) {
+        this.id = idforHeader(header);
+        this.header = header;
+        this._sessions = internalInitSessions;
+        this.node = node;
+
+        if (header.ruleset.type == "ownedByGroup") {
+            this.node
+                .expectCoValueLoaded(header.ruleset.group)
+                .subscribe((_groupUpdate) => {
+                    this._cachedContent = undefined;
+                    const newContent = this.getCurrentContent();
+                    for (const listener of this.listeners) {
+                        listener(newContent);
+                    }
+                });
+        }
+    }
+
+    get sessions(): Readonly<{ [key: SessionID]: SessionLog }> {
+        return this._sessions;
+    }
+
+    testWithDifferentAccount(
+        account: GeneralizedControlledAccount,
+        currentSessionID: SessionID
+    ): CoValueCore {
+        const newNode = this.node.testWithDifferentAccount(
+            account,
+            currentSessionID
+        );
+
+        return newNode.expectCoValueLoaded(this.id);
+    }
+
+    knownState(): CoValueKnownState {
+        return {
+            id: this.id,
+            header: true,
+            sessions: Object.fromEntries(
+                Object.entries(this.sessions).map(([k, v]) => [
+                    k,
+                    v.transactions.length,
+                ])
+            ),
+        };
+    }
+
+    get meta(): JsonValue {
+        return this.header?.meta ?? null;
+    }
+
+    nextTransactionID(): TransactionID {
+        const sessionID = this.node.currentSessionID;
+        return {
+            sessionID,
+            txIndex: this.sessions[sessionID]?.transactions.length || 0,
+        };
+    }
+
+    tryAddTransactions(
+        sessionID: SessionID,
+        newTransactions: Transaction[],
+        givenExpectedNewHash: Hash | undefined,
+        newSignature: Signature
+    ): boolean {
+        const signerID = getAgentSignerID(
+            this.node.resolveAccountAgent(
+                accountOrAgentIDfromSessionID(sessionID),
+                "Expected to know signer of transaction"
+            )
+        );
+
+        if (!signerID) {
+            console.warn(
+                "Unknown agent",
+                accountOrAgentIDfromSessionID(sessionID)
+            );
+            return false;
+        }
+
+        const { expectedNewHash, newStreamingHash } = this.expectedNewHashAfter(
+            sessionID,
+            newTransactions
+        );
+
+        if (givenExpectedNewHash && givenExpectedNewHash !== expectedNewHash) {
+            console.warn("Invalid hash", {
+                expectedNewHash,
+                givenExpectedNewHash,
+            });
+            return false;
+        }
+
+        if (!verify(newSignature, expectedNewHash, signerID)) {
+            console.warn(
+                "Invalid signature",
+                newSignature,
+                expectedNewHash,
+                signerID
+            );
+            return false;
+        }
+
+        const transactions = this.sessions[sessionID]?.transactions ?? [];
+
+        transactions.push(...newTransactions);
+
+        this._sessions[sessionID] = {
+            transactions,
+            lastHash: expectedNewHash,
+            streamingHash: newStreamingHash,
+            lastSignature: newSignature,
+        };
+
+        this._cachedContent = undefined;
+
+        const content = this.getCurrentContent();
+
+        for (const listener of this.listeners) {
+            listener(content);
+        }
+
+        return true;
+    }
+
+    subscribe(listener: (content?: CoValueImpl) => void): () => void {
+        this.listeners.add(listener);
+        listener(this.getCurrentContent());
+
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+
+    expectedNewHashAfter(
+        sessionID: SessionID,
+        newTransactions: Transaction[]
+    ): { expectedNewHash: Hash; newStreamingHash: StreamingHash } {
+        const streamingHash =
+            this.sessions[sessionID]?.streamingHash.clone() ??
+            new StreamingHash();
+        for (const transaction of newTransactions) {
+            streamingHash.update(transaction);
+        }
+
+        const newStreamingHash = streamingHash.clone();
+
+        return {
+            expectedNewHash: streamingHash.digest(),
+            newStreamingHash,
+        };
+    }
+
+    makeTransaction(
+        changes: JsonValue[],
+        privacy: "private" | "trusting"
+    ): boolean {
+        const madeAt = Date.now();
+
+        let transaction: Transaction;
+
+        if (privacy === "private") {
+            const { secret: keySecret, id: keyID } = this.getCurrentReadKey();
+
+            if (!keySecret) {
+                throw new Error(
+                    "Can't make transaction without read key secret"
+                );
+            }
+
+            transaction = {
+                privacy: "private",
+                madeAt,
+                keyUsed: keyID,
+                encryptedChanges: encryptForTransaction(changes, keySecret, {
+                    in: this.id,
+                    tx: this.nextTransactionID(),
+                }),
+            };
+        } else {
+            transaction = {
+                privacy: "trusting",
+                madeAt,
+                changes,
+            };
+        }
+
+        const sessionID = this.node.currentSessionID;
+
+        const { expectedNewHash } = this.expectedNewHashAfter(sessionID, [
+            transaction,
+        ]);
+
+        const signature = sign(
+            this.node.account.currentSignerSecret(),
+            expectedNewHash
+        );
+
+        const success = this.tryAddTransactions(
+            sessionID,
+            [transaction],
+            expectedNewHash,
+            signature
+        );
+
+        if (success) {
+            void this.node.sync.syncCoValue(this);
+        }
+
+        return success;
+    }
+
+    getCurrentContent(): CoValueImpl {
+        if (this._cachedContent) {
+            return this._cachedContent;
+        }
+
+        if (this.header.type === "comap") {
+            this._cachedContent = new CoMap(this);
+        } else if (this.header.type === "colist") {
+            this._cachedContent = new CoList(this);
+        } else if (this.header.type === "costream") {
+            this._cachedContent = new CoStream(this);
+        } else if (this.header.type === "static") {
+            this._cachedContent = new Static(this);
+        } else {
+            throw new Error(`Unknown coValue type ${this.header.type}`);
+        }
+
+        return this._cachedContent;
+    }
+
+    getValidSortedTransactions(): DecryptedTransaction[] {
+        const validTransactions = determineValidTransactions(this);
+
+        const allTransactions: DecryptedTransaction[] = validTransactions
+            .map(({ txID, tx }) => {
+                if (tx.privacy === "trusting") {
+                    return {
+                        txID,
+                        madeAt: tx.madeAt,
+                        changes: tx.changes,
+                    };
+                } else {
+                    const readKey = this.getReadKey(tx.keyUsed);
+
+                    if (!readKey) {
+                        return undefined;
+                    } else {
+                        const decrytedChanges = decryptForTransaction(
+                            tx.encryptedChanges,
+                            readKey,
+                            {
+                                in: this.id,
+                                tx: txID,
+                            }
+                        );
+
+                        if (!decrytedChanges) {
+                            console.error(
+                                "Failed to decrypt transaction despite having key"
+                            );
+                            return undefined;
+                        }
+                        return {
+                            txID,
+                            madeAt: tx.madeAt,
+                            changes: decrytedChanges,
+                        };
+                    }
+                }
+            })
+            .filter((x): x is Exclude<typeof x, undefined> => !!x);
+        allTransactions.sort(
+            (a, b) =>
+                a.madeAt - b.madeAt ||
+                (a.txID.sessionID < b.txID.sessionID ? -1 : 1) ||
+                a.txID.txIndex - b.txID.txIndex
+        );
+
+        return allTransactions;
+    }
+
+    getCurrentReadKey(): { secret: KeySecret | undefined; id: KeyID } {
+        if (this.header.ruleset.type === "group") {
+            const content = expectGroupContent(this.getCurrentContent());
+
+            const currentKeyId = content.get("readKey");
+
+            if (!currentKeyId) {
+                throw new Error("No readKey set");
+            }
+
+            const secret = this.getReadKey(currentKeyId);
+
+            return {
+                secret: secret,
+                id: currentKeyId,
+            };
+        } else if (this.header.ruleset.type === "ownedByGroup") {
+            return this.node
+                .expectCoValueLoaded(this.header.ruleset.group)
+                .getCurrentReadKey();
+        } else {
+            throw new Error(
+                "Only groups or values owned by groups have read secrets"
+            );
+        }
+    }
+
+    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());
+
+            // Try to find key revelation for us
+
+            const readKeyEntry = content.getLastEntry(
+                `${keyID}_for_${this.node.account.id}`
+            );
+
+            if (readKeyEntry) {
+                const revealer = accountOrAgentIDfromSessionID(
+                    readKeyEntry.txID.sessionID
+                );
+                const revealerAgent = this.node.resolveAccountAgent(
+                    revealer,
+                    "Expected to know revealer"
+                );
+
+                const secret = unseal(
+                    readKeyEntry.value,
+                    this.node.account.currentSealerSecret(),
+                    getAgentSealerID(revealerAgent),
+                    {
+                        in: this.id,
+                        tx: readKeyEntry.txID,
+                    }
+                );
+
+                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
+
+            for (const field of content.keys()) {
+                if (isKeyForKeyField(field) && field.startsWith(keyID)) {
+                    const encryptingKeyID = field.split("_for_")[1] as KeyID;
+                    const encryptingKeySecret =
+                        this.getReadKey(encryptingKeyID);
+
+                    if (!encryptingKeySecret) {
+                        continue;
+                    }
+
+                    const encryptedPreviousKey = content.get(field)!;
+
+                    const secret = decryptKeySecret(
+                        {
+                            encryptedID: keyID,
+                            encryptingID: encryptingKeyID,
+                            encrypted: encryptedPreviousKey,
+                        },
+                        encryptingKeySecret
+                    );
+
+                    if (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}`
+                        );
+                    }
+                }
+            }
+
+            return undefined;
+        } else if (this.header.ruleset.type === "ownedByGroup") {
+            return this.node
+                .expectCoValueLoaded(this.header.ruleset.group)
+                .getReadKey(keyID);
+        } else {
+            throw new Error(
+                "Only groups or values owned by groups have read secrets"
+            );
+        }
+    }
+
+    getGroup(): Group {
+        if (this.header.ruleset.type !== "ownedByGroup") {
+            throw new Error("Only values owned by groups have groups");
+        }
+
+        return new Group(
+            expectGroupContent(
+                this.node
+                    .expectCoValueLoaded(this.header.ruleset.group)
+                    .getCurrentContent()
+            ),
+            this.node
+        );
+    }
+
+    getTx(txID: TransactionID): Transaction | undefined {
+        return this.sessions[txID.sessionID]?.transactions[txID.txIndex];
+    }
+
+    newContentSince(
+        knownState: CoValueKnownState | undefined
+    ): NewContentMessage | undefined {
+        const newContent: NewContentMessage = {
+            action: "content",
+            id: this.id,
+            header: knownState?.header ? undefined : this.header,
+            new: Object.fromEntries(
+                Object.entries(this.sessions)
+                    .map(([sessionID, log]) => {
+                        const newTransactions = log.transactions.slice(
+                            knownState?.sessions[sessionID as SessionID] || 0
+                        );
+
+                        if (
+                            newTransactions.length === 0 ||
+                            !log.lastHash ||
+                            !log.lastSignature
+                        ) {
+                            return undefined;
+                        }
+
+                        return [
+                            sessionID,
+                            {
+                                after:
+                                    knownState?.sessions[
+                                        sessionID as SessionID
+                                    ] || 0,
+                                newTransactions,
+                                lastSignature: log.lastSignature,
+                            },
+                        ];
+                    })
+                    .filter((x): x is Exclude<typeof x, undefined> => !!x)
+            ),
+        };
+
+        if (!newContent.header && Object.keys(newContent.new).length === 0) {
+            return undefined;
+        }
+
+        return newContent;
+    }
+
+    getDependedOnCoValues(): RawCoID[] {
+        return this.header.ruleset.type === "group"
+            ? expectGroupContent(this.getCurrentContent())
+                  .keys()
+                  .filter((k): k is AccountID => k.startsWith("co_"))
+            : this.header.ruleset.type === "ownedByGroup"
+            ? [this.header.ruleset.group]
+            : [];
+    }
+}

packages/cojson/src/coValues/coList.ts

@@ -0,0 +1,445 @@
+import { JsonObject, JsonValue } from "../jsonValue.js";
+import { CoID, ReadableCoValue, WriteableCoValue } from "../coValue.js";
+import { CoValueCore, accountOrAgentIDfromSessionID } from "../coValueCore.js";
+import { SessionID, TransactionID } from "../ids.js";
+import { AccountID, Group } from "../index.js";
+import { isAccountID } from "../account.js";
+
+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>
+    implements ReadableCoValue
+{
+    id: CoID<CoList<T, Meta>>;
+    type = "colist" as const;
+    core: CoValueCore;
+    /** @internal */
+    afterStart: OpID[];
+    /** @internal */
+    beforeEnd: OpID[];
+    /** @internal */
+    insertions: {
+        [sessionID: SessionID]: {
+            [txIdx: number]: {
+                [changeIdx: number]: InsertionEntry<T>;
+            };
+        };
+    };
+    /** @internal */
+    deletionsByInsertion: {
+        [deletedSessionID: SessionID]: {
+            [deletedTxIdx: number]: {
+                [deletedChangeIdx: number]: DeletionEntry[];
+            };
+        };
+    };
+
+    /** @internal */
+    constructor(core: CoValueCore) {
+        this.id = core.id as CoID<CoList<T, Meta>>;
+        this.core = core;
+        this.afterStart = [];
+        this.beforeEnd = [];
+        this.insertions = {};
+        this.deletionsByInsertion = {};
+
+        this.fillOpsFromCoValue();
+    }
+
+    get meta(): Meta {
+        return this.core.header.meta as Meta;
+    }
+
+    get group(): Group {
+        return this.core.getGroup();
+    }
+
+    /** @internal */
+    protected fillOpsFromCoValue() {
+        this.insertions = {};
+        this.deletionsByInsertion = {};
+        this.afterStart = [];
+        this.beforeEnd = [];
+
+        for (const {
+            txID,
+            changes,
+            madeAt,
+        } of this.core.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
+                    );
+                }
+            }
+        }
+    }
+
+    /** Get the item currently at `idx`. */
+    get(idx: number): T | undefined {
+        const entry = this.entries()[idx];
+        if (!entry) {
+            return undefined;
+        }
+        return entry.value;
+    }
+
+    /** Returns the current items in the CoList as an array. */
+    asArray(): T[] {
+        return this.entries().map((entry) => entry.value);
+    }
+
+    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;
+    }
+
+    /** @internal */
+    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);
+        }
+    }
+
+    /** Returns the accountID of the account that inserted value at the given index. */
+    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;
+        }
+    }
+
+    /** Returns the current items in the CoList as an array. (alias of `asArray`) */
+    toJSON(): T[] {
+        return this.asArray();
+    }
+
+    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
+        );
+    }
+
+    subscribe(listener: (coMap: CoList<T, Meta>) => void): () => void {
+        return this.core.subscribe((content) => {
+            listener(content as CoList<T, Meta>);
+        });
+    }
+
+    edit(
+        changer: (editable: WriteableCoList<T, Meta>) => void
+    ): CoList<T, Meta> {
+        const editable = new WriteableCoList<T, Meta>(this.core);
+        changer(editable);
+        return new CoList(this.core);
+    }
+}
+
+export class WriteableCoList<
+        T extends JsonValue,
+        Meta extends JsonObject | null = null
+    >
+    extends CoList<T, Meta>
+    implements WriteableCoValue
+{
+    /** @internal */
+    edit(
+        _changer: (editable: WriteableCoList<T, Meta>) => void
+    ): CoList<T, Meta> {
+        throw new Error("Already editing.");
+    }
+
+    /** 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. */
+    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.core.makeTransaction(
+            [
+                {
+                    op: "app",
+                    value,
+                    after: opIDBefore,
+                },
+            ],
+            privacy
+        );
+
+        this.fillOpsFromCoValue();
+    }
+
+    /** 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. */
+    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
+        );
+    }
+
+    /**
+     * 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.
+     */
+    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.core.makeTransaction(
+            [
+                {
+                    op: "pre",
+                    value,
+                    before: opIDAfter,
+                },
+            ],
+            privacy
+        );
+
+        this.fillOpsFromCoValue();
+    }
+
+    /** 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. */
+    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.core.makeTransaction(
+            [
+                {
+                    op: "del",
+                    insertion: entry.opID,
+                },
+            ],
+            privacy
+        );
+
+        this.fillOpsFromCoValue();
+    }
+}

packages/cojson/src/coValues/coMap.ts

@@ -1,8 +1,9 @@
 import { JsonObject, JsonValue } from '../jsonValue.js';
 import { TransactionID } from '../ids.js';
-import { CoID } from '../contentType.js';
-import { CoValue, accountOrAgentIDfromSessionID } from '../coValue.js';
+import { CoID, ReadableCoValue, WriteableCoValue } from '../coValue.js';
+import { CoValueCore, accountOrAgentIDfromSessionID } from '../coValueCore.js';
 import { AccountID, isAccountID } from '../account.js';
+import { Group } from '../group.js';
 
 type MapOp<K extends string, V extends JsonValue> = {
     txID: TransactionID;
@@ -27,29 +28,41 @@ export type MapM<M extends { [key: string]: JsonValue; }> = {
     [KK in MapK<M>]: M[KK];
 }
 
+/** A collaborative map with precise shape `M` and optional static metadata `Meta` */
 export class CoMap<
     M extends { [key: string]: JsonValue; },
     Meta extends JsonObject | null = null,
-> {
+> implements ReadableCoValue {
     id: CoID<CoMap<MapM<M>, Meta>>;
-    coValue: CoValue;
     type = "comap" as const;
+    core: CoValueCore;
+    /** @internal */
     ops: {
         [KK in MapK<M>]?: MapOp<KK, M[KK]>[];
     };
 
-    constructor(coValue: CoValue) {
-        this.id = coValue.id as CoID<CoMap<MapM<M>, Meta>>;
-        this.coValue = coValue;
+    /** @internal */
+    constructor(core: CoValueCore) {
+        this.id = core.id as CoID<CoMap<MapM<M>, Meta>>;
+        this.core = core;
         this.ops = {};
 
         this.fillOpsFromCoValue();
     }
 
+    get meta(): Meta {
+        return this.core.header.meta as Meta;
+    }
+
+    get group(): Group {
+        return this.core.getGroup();
+    }
+
+    /** @internal */
     protected fillOpsFromCoValue() {
         this.ops = {};
 
-        for (const { txID, changes, madeAt } of this.coValue.getValidSortedTransactions()) {
+        for (const { txID, changes, madeAt } of this.core.getValidSortedTransactions()) {
             for (const [changeIdx, changeUntyped] of (
                 changes
             ).entries()) {
@@ -73,6 +86,7 @@ export class CoMap<
         return Object.keys(this.ops) as MapK<M>[];
     }
 
+    /** Returns the current value for the given key. */
     get<K extends MapK<M>>(key: K): M[K] | undefined {
         const ops = this.ops[key];
         if (!ops) {
@@ -107,7 +121,8 @@ export class CoMap<
         }
     }
 
-    getLastEditor<K extends MapK<M>>(key: K): AccountID | undefined {
+    /** Returns the accountID of the last account to modify the value for the given key. */
+    whoEdited<K extends MapK<M>>(key: K): AccountID | undefined {
         const tx  = this.getLastTxID(key);
         if (!tx) {
             return undefined;
@@ -178,26 +193,35 @@ export class CoMap<
         return json;
     }
 
-    edit(changer: (editable: WriteableCoMap<M, Meta>) => void): CoMap<M, Meta> {
-        const editable = new WriteableCoMap<M, Meta>(this.coValue);
-        changer(editable);
-        return new CoMap(this.coValue);
-    }
-
     subscribe(listener: (coMap: CoMap<M, Meta>) => void): () => void {
-        return this.coValue.subscribe((content) => {
+        return this.core.subscribe((content) => {
             listener(content as CoMap<M, Meta>);
         });
     }
+
+    edit(changer: (editable: WriteableCoMap<M, Meta>) => void): CoMap<M, Meta> {
+        const editable = new WriteableCoMap<M, Meta>(this.core);
+        changer(editable);
+        return new CoMap(this.core);
+    }
 }
 
 export class WriteableCoMap<
     M extends { [key: string]: JsonValue; },
     Meta extends JsonObject | null = null,
+> extends CoMap<M, Meta> implements WriteableCoValue {
+    /** @internal */
+    edit(_changer: (editable: WriteableCoMap<M, Meta>) => void): CoMap<M, Meta> {
+        throw new Error("Already editing.");
+    }
 
-> extends CoMap<M, Meta> {
+    /** 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. */
     set<K extends MapK<M>>(key: K, value: M[K], privacy: "private" | "trusting" = "private"): void {
-        this.coValue.makeTransaction([
+        this.core.makeTransaction([
             {
                 op: "set",
                 key,
@@ -208,8 +232,13 @@ export class WriteableCoMap<
         this.fillOpsFromCoValue();
     }
 
+    /** 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. */
     delete(key: MapK<M>, privacy: "private" | "trusting" = "private"): void {
-        this.coValue.makeTransaction([
+        this.core.makeTransaction([
             {
                 op: "del",
                 key,

packages/cojson/src/coValues/coStream.ts

@@ -0,0 +1,33 @@
+import { JsonObject, JsonValue } from '../jsonValue.js';
+import { CoID, ReadableCoValue } from '../coValue.js';
+import { CoValueCore } from '../coValueCore.js';
+import { Group } from '../index.js';
+
+export class CoStream<T extends JsonValue, Meta extends JsonObject | null = null> implements ReadableCoValue {
+    id: CoID<CoStream<T, Meta>>;
+    type = "costream" as const;
+    core: CoValueCore;
+
+    constructor(core: CoValueCore) {
+        this.id = core.id as CoID<CoStream<T, Meta>>;
+        this.core = core;
+    }
+
+    get meta(): Meta {
+        return this.core.header.meta as Meta;
+    }
+
+    get group(): Group {
+        return this.core.getGroup();
+    }
+
+    toJSON(): JsonObject {
+        throw new Error("Method not implemented.");
+    }
+
+    subscribe(listener: (coMap: CoStream<T, Meta>) => void): () => void {
+        return this.core.subscribe((content) => {
+            listener(content as CoStream<T, Meta>);
+        });
+    }
+}

packages/cojson/src/coValues/static.ts

@@ -0,0 +1,31 @@
+import { JsonObject } from '../jsonValue.js';
+import { CoID, ReadableCoValue } from '../coValue.js';
+import { CoValueCore } from '../coValueCore.js';
+import { Group } from '../index.js';
+
+export class Static<T extends JsonObject> implements ReadableCoValue{
+    id: CoID<Static<T>>;
+    type = "static" as const;
+    core: CoValueCore;
+
+    constructor(core: CoValueCore) {
+        this.id = core.id as CoID<Static<T>>;
+        this.core = core;
+    }
+
+    get meta(): T {
+        return this.core.header.meta as T;
+    }
+
+    get group(): Group {
+        return this.core.getGroup();
+    }
+
+    toJSON(): JsonObject {
+        throw new Error("Method not implemented.");
+    }
+
+    subscribe(_listener: (coMap: Static<T>) => void): () => void {
+        throw new Error("Method not implemented.");
+    }
+}

packages/cojson/src/contentType.test.ts

@@ -1,175 +0,0 @@
-import { accountOrAgentIDfromSessionID } from "./coValue.js";
-import { createdNowUnique } from "./crypto.js";
-import { LocalNode } from "./node.js";
-import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
-
-test("Empty COJSON Map works", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
-
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...createdNowUnique(),
-    });
-
-    const content = coValue.getCurrentContent();
-
-    if (content.type !== "comap") {
-        throw new Error("Expected map");
-    }
-
-    expect(content.type).toEqual("comap");
-    expect([...content.keys()]).toEqual([]);
-    expect(content.toJSON()).toEqual({});
-});
-
-test("Can insert and delete Map entries in edit()", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
-
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...createdNowUnique(),
-    });
-
-    const content = coValue.getCurrentContent();
-
-    if (content.type !== "comap") {
-        throw new Error("Expected map");
-    }
-
-    expect(content.type).toEqual("comap");
-
-    content.edit((editable) => {
-        editable.set("hello", "world", "trusting");
-        expect(editable.get("hello")).toEqual("world");
-        editable.set("foo", "bar", "trusting");
-        expect(editable.get("foo")).toEqual("bar");
-        expect([...editable.keys()]).toEqual(["hello", "foo"]);
-        editable.delete("foo", "trusting");
-        expect(editable.get("foo")).toEqual(undefined);
-    });
-});
-
-test("Can get map entry values at different points in time", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
-
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...createdNowUnique(),
-    });
-
-    const content = coValue.getCurrentContent();
-
-    if (content.type !== "comap") {
-        throw new Error("Expected map");
-    }
-
-    expect(content.type).toEqual("comap");
-
-    content.edit((editable) => {
-        const beforeA = Date.now();
-        while (Date.now() < beforeA + 10) {}
-        editable.set("hello", "A", "trusting");
-        const beforeB = Date.now();
-        while (Date.now() < beforeB + 10) {}
-        editable.set("hello", "B", "trusting");
-        const beforeC = Date.now();
-        while (Date.now() < beforeC + 10) {}
-        editable.set("hello", "C", "trusting");
-        expect(editable.get("hello")).toEqual("C");
-        expect(editable.getAtTime("hello", Date.now())).toEqual("C");
-        expect(editable.getAtTime("hello", beforeA)).toEqual(undefined);
-        expect(editable.getAtTime("hello", beforeB)).toEqual("A");
-        expect(editable.getAtTime("hello", beforeC)).toEqual("B");
-    });
-});
-
-test("Can get all historic values of key", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
-
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...createdNowUnique(),
-    });
-
-    const content = coValue.getCurrentContent();
-
-    if (content.type !== "comap") {
-        throw new Error("Expected map");
-    }
-
-    expect(content.type).toEqual("comap");
-
-    content.edit((editable) => {
-        editable.set("hello", "A", "trusting");
-        const txA = editable.getLastTxID("hello");
-        editable.set("hello", "B", "trusting");
-        const txB = editable.getLastTxID("hello");
-        editable.delete("hello", "trusting");
-        const txDel = editable.getLastTxID("hello");
-        editable.set("hello", "C", "trusting");
-        const txC = editable.getLastTxID("hello");
-        expect(editable.getHistory("hello")).toEqual([
-            {
-                txID: txA,
-                value: "A",
-                at: txA && coValue.getTx(txA)?.madeAt,
-            },
-            {
-                txID: txB,
-                value: "B",
-                at: txB && coValue.getTx(txB)?.madeAt,
-            },
-            {
-                txID: txDel,
-                value: undefined,
-                at: txDel && coValue.getTx(txDel)?.madeAt,
-            },
-            {
-                txID: txC,
-                value: "C",
-                at: txC && coValue.getTx(txC)?.madeAt,
-            },
-        ]);
-    });
-});
-
-test("Can get last tx ID for a key", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
-
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...createdNowUnique(),
-    });
-
-    const content = coValue.getCurrentContent();
-
-    if (content.type !== "comap") {
-        throw new Error("Expected map");
-    }
-
-    expect(content.type).toEqual("comap");
-
-    content.edit((editable) => {
-        expect(editable.getLastTxID("hello")).toEqual(undefined);
-        editable.set("hello", "A", "trusting");
-        const sessionID = editable.getLastTxID("hello")?.sessionID;
-        expect(sessionID && accountOrAgentIDfromSessionID(sessionID)).toEqual(
-            node.account.id
-        );
-        expect(editable.getLastTxID("hello")?.txIndex).toEqual(0);
-        editable.set("hello", "B", "trusting");
-        expect(editable.getLastTxID("hello")?.txIndex).toEqual(1);
-        editable.set("hello", "C", "trusting");
-        expect(editable.getLastTxID("hello")?.txIndex).toEqual(2);
-    });
-});

packages/cojson/src/contentType.ts

@@ -1,26 +0,0 @@
-import { JsonObject, JsonValue } from "./jsonValue.js";
-import { RawCoID } from "./ids.js";
-import { CoMap } from "./contentTypes/coMap.js";
-import { CoStream } from "./contentTypes/coStream.js";
-import { Static } from "./contentTypes/static.js";
-import { CoList } from "./contentTypes/coList.js";
-
-export type CoID<T extends ContentType> = RawCoID & {
-    readonly __type: T;
-};
-
-export type ContentType =
-    | CoMap<{ [key: string]: JsonValue }, JsonObject | null>
-    | CoList<JsonValue, JsonObject | null>
-    | CoStream<JsonValue, JsonObject | null>
-    | Static<JsonObject>;
-
-export function expectMap(
-    content: ContentType
-): CoMap<{ [key: string]: string }, JsonObject | null> {
-    if (content.type !== "comap") {
-        throw new Error("Expected map");
-    }
-
-    return content as CoMap<{ [key: string]: string }, JsonObject | null>;
-}

packages/cojson/src/contentTypes/coList.ts

@@ -1,24 +0,0 @@
-import { JsonObject, JsonValue } from '../jsonValue.js';
-import { CoID } from '../contentType.js';
-import { CoValue } from '../coValue.js';
-
-export class CoList<T extends JsonValue, Meta extends JsonObject | null = null> {
-    id: CoID<CoList<T, Meta>>;
-    type = "colist" as const;
-    coValue: CoValue;
-
-    constructor(coValue: CoValue) {
-        this.id = coValue.id as CoID<CoList<T, Meta>>;
-        this.coValue = coValue;
-    }
-
-    toJSON(): JsonObject {
-        throw new Error("Method not implemented.");
-    }
-
-    subscribe(listener: (coMap: CoList<T, Meta>) => void): () => void {
-        return this.coValue.subscribe((content) => {
-            listener(content as CoList<T, Meta>);
-        });
-    }
-}

packages/cojson/src/contentTypes/coStream.ts

@@ -1,24 +0,0 @@
-import { JsonObject, JsonValue } from '../jsonValue.js';
-import { CoID } from '../contentType.js';
-import { CoValue } from '../coValue.js';
-
-export class CoStream<T extends JsonValue, Meta extends JsonObject | null = null> {
-    id: CoID<CoStream<T, Meta>>;
-    type = "costream" as const;
-    coValue: CoValue;
-
-    constructor(coValue: CoValue) {
-        this.id = coValue.id as CoID<CoStream<T, Meta>>;
-        this.coValue = coValue;
-    }
-
-    toJSON(): JsonObject {
-        throw new Error("Method not implemented.");
-    }
-
-    subscribe(listener: (coMap: CoStream<T, Meta>) => void): () => void {
-        return this.coValue.subscribe((content) => {
-            listener(content as CoStream<T, Meta>);
-        });
-    }
-}

packages/cojson/src/contentTypes/static.ts

@@ -1,22 +0,0 @@
-import { JsonObject } from '../jsonValue.js';
-import { CoID } from '../contentType.js';
-import { CoValue } from '../coValue.js';
-
-export class Static<T extends JsonObject> {
-    id: CoID<Static<T>>;
-    type = "static" as const;
-    coValue: CoValue;
-
-    constructor(coValue: CoValue) {
-        this.id = coValue.id as CoID<Static<T>>;
-        this.coValue = coValue;
-    }
-
-    toJSON(): JsonObject {
-        throw new Error("Method not implemented.");
-    }
-
-    subscribe(_listener: (coMap: Static<T>) => void): () => void {
-        throw new Error("Method not implemented.");
-    }
-}

packages/cojson/src/group.ts

@@ -0,0 +1,302 @@
+import { CoID, CoValueImpl } from "./coValue.js";
+import { CoMap } from "./coValues/coMap.js";
+import { JsonObject, JsonValue } from "./jsonValue.js";
+import {
+    Encrypted,
+    KeyID,
+    KeySecret,
+    createdNowUnique,
+    newRandomKeySecret,
+    seal,
+    encryptKeySecret,
+    getAgentSealerID,
+    Sealed,
+    newRandomSecretSeed,
+    agentSecretFromSecretSeed,
+    getAgentID,
+} from "./crypto.js";
+import { LocalNode } from "./node.js";
+import { AgentID, SessionID, isAgentID } from "./ids.js";
+import { AccountID, GeneralizedControlledAccount, Profile } from "./account.js";
+import { Role } from "./permissions.js";
+import { base58 } from "@scure/base";
+import { CoList } from "./coValues/coList.js";
+
+export type GroupContent = {
+    profile: CoID<Profile> | null;
+    [key: AccountID | AgentID]: Role;
+    readKey: KeyID;
+    [revelationFor: `${KeyID}_for_${AccountID | AgentID}`]: Sealed<KeySecret>;
+    [oldKeyForNewKey: `${KeyID}_for_${KeyID}`]: Encrypted<
+        KeySecret,
+        { encryptedID: KeyID; encryptingID: KeyID }
+    >;
+};
+
+export function expectGroupContent(
+    content: CoValueImpl
+): CoMap<GroupContent, JsonObject | null> {
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    return content as CoMap<GroupContent, JsonObject | null>;
+}
+
+/** A `Group` is a scope for permissions of its members (`"reader" | "writer" | "admin"`), applying to objects owned by that group.
+ *
+ *  A `Group` object exposes methods for permission management 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)
+ *
+ *  @example
+ *  You typically get a group from a CoValue that you already have loaded:
+ *
+ *  ```typescript
+ *  const group = coMap.group;
+ *  ```
+ *
+ *  @example
+ *  Or, you can create a new group with a `LocalNode`:
+ *
+ *  ```typescript
+ *  const localNode.createGroup();
+ *  ```
+ * */
+export class Group {
+    underlyingMap: CoMap<GroupContent, JsonObject | null>;
+    /** @internal */
+    node: LocalNode;
+
+    /** @internal */
+    constructor(
+        underlyingMap: CoMap<GroupContent, JsonObject | null>,
+        node: LocalNode
+    ) {
+        this.underlyingMap = underlyingMap;
+        this.node = node;
+    }
+
+    /** Returns the `CoID` of the `Group`. */
+    get id(): CoID<CoMap<GroupContent, JsonObject | null>> {
+        return this.underlyingMap.id;
+    }
+
+    /** Returns the current role of a given account. */
+    roleOf(accountID: AccountID): Role | undefined {
+        return this.roleOfInternal(accountID);
+    }
+
+    /** @internal */
+    roleOfInternal(accountID: AccountID | AgentID): Role | undefined {
+        return this.underlyingMap.get(accountID);
+    }
+
+    /** Returns the role of the current account in the group. */
+    myRole(): Role | undefined {
+        return this.roleOfInternal(this.node.account.id);
+    }
+
+    /** 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. */
+    addMember(accountID: AccountID, role: Role) {
+        this.addMemberInternal(accountID, role);
+    }
+
+    /** @internal */
+    addMemberInternal(accountID: AccountID | AgentID, role: Role) {
+        this.underlyingMap = this.underlyingMap.edit((map) => {
+            const currentReadKey = this.underlyingMap.core.getCurrentReadKey();
+
+            if (!currentReadKey.secret) {
+                throw new Error("Can't add member without read key secret");
+            }
+
+            const agent = this.node.resolveAccountAgent(
+                accountID,
+                "Expected to know agent to add them to group"
+            );
+
+            map.set(accountID, role, "trusting");
+
+            if (map.get(accountID) !== role) {
+                throw new Error("Failed to set role");
+            }
+
+            map.set(
+                `${currentReadKey.id}_for_${accountID}`,
+                seal(
+                    currentReadKey.secret,
+                    this.underlyingMap.core.node.account.currentSealerSecret(),
+                    getAgentSealerID(agent),
+                    {
+                        in: this.underlyingMap.core.id,
+                        tx: this.underlyingMap.core.nextTransactionID(),
+                    }
+                ),
+                "trusting"
+            );
+        });
+    }
+
+    /** @internal */
+    rotateReadKey() {
+        const currentlyPermittedReaders = this.underlyingMap
+            .keys()
+            .filter((key) => {
+                if (key.startsWith("co_") || isAgentID(key)) {
+                    const role = this.underlyingMap.get(key);
+                    return (
+                        role === "admin" ||
+                        role === "writer" ||
+                        role === "reader"
+                    );
+                } else {
+                    return false;
+                }
+            }) as (AccountID | AgentID)[];
+
+        const maybeCurrentReadKey = this.underlyingMap.core.getCurrentReadKey();
+
+        if (!maybeCurrentReadKey.secret) {
+            throw new Error(
+                "Can't rotate read key secret we don't have access to"
+            );
+        }
+
+        const currentReadKey = {
+            id: maybeCurrentReadKey.id,
+            secret: maybeCurrentReadKey.secret,
+        };
+
+        const newReadKey = newRandomKeySecret();
+
+        this.underlyingMap = this.underlyingMap.edit((map) => {
+            for (const readerID of currentlyPermittedReaders) {
+                const reader = this.node.resolveAccountAgent(
+                    readerID,
+                    "Expected to know currently permitted reader"
+                );
+
+                map.set(
+                    `${newReadKey.id}_for_${readerID}`,
+                    seal(
+                        newReadKey.secret,
+                        this.underlyingMap.core.node.account.currentSealerSecret(),
+                        getAgentSealerID(reader),
+                        {
+                            in: this.underlyingMap.core.id,
+                            tx: this.underlyingMap.core.nextTransactionID(),
+                        }
+                    ),
+                    "trusting"
+                );
+            }
+
+            map.set(
+                `${currentReadKey.id}_for_${newReadKey.id}`,
+                encryptKeySecret({
+                    encrypting: newReadKey,
+                    toEncrypt: currentReadKey,
+                }).encrypted,
+                "trusting"
+            );
+
+            map.set("readKey", newReadKey.id, "trusting");
+        });
+    }
+
+    /** Strips the specified member of all roles (preventing future writes in
+     *  the group and owned values) and rotates the read encryption key for that group
+     * (preventing reads of new content in the group and owned values) */
+    removeMember(accountID: AccountID) {
+        this.removeMemberInternal(accountID);
+    }
+
+    /** @internal */
+    removeMemberInternal(accountID: AccountID | AgentID) {
+        this.underlyingMap = this.underlyingMap.edit((map) => {
+            map.set(accountID, "revoked", "trusting");
+        });
+
+        this.rotateReadKey();
+    }
+
+    /** 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. */
+    createInvite(role: "reader" | "writer" | "admin"): InviteSecret {
+        const secretSeed = newRandomSecretSeed();
+
+        const inviteSecret = agentSecretFromSecretSeed(secretSeed);
+        const inviteID = getAgentID(inviteSecret);
+
+        this.addMemberInternal(inviteID, `${role}Invite` as Role);
+
+        return inviteSecretFromSecretSeed(secretSeed);
+    }
+
+    /** Creates a new `CoMap` within this group, with the specified specialized
+     *  `CoMap` type `M` and optional static metadata. */
+    createMap<M extends CoMap<{ [key: string]: JsonValue }, JsonObject | null>>(
+        meta?: M["meta"]
+    ): M {
+        return this.node
+            .createCoValue({
+                type: "comap",
+                ruleset: {
+                    type: "ownedByGroup",
+                    group: this.underlyingMap.id,
+                },
+                meta: meta || null,
+                ...createdNowUnique(),
+            })
+            .getCurrentContent() as M;
+    }
+
+    /** Creates a new `CoList` within this group, with the specified specialized
+     * `CoList` type `L` and optional static metadata. */
+    createList<L extends CoList<JsonValue, JsonObject | null>>(
+        meta?: L["meta"]
+    ): L {
+        return this.node
+            .createCoValue({
+                type: "colist",
+                ruleset: {
+                    type: "ownedByGroup",
+                    group: this.underlyingMap.id,
+                },
+                meta: meta || null,
+                ...createdNowUnique(),
+            })
+            .getCurrentContent() as L;
+    }
+
+    /** @internal */
+    testWithDifferentAccount(
+        account: GeneralizedControlledAccount,
+        sessionId: SessionID
+    ): Group {
+        return new Group(
+            expectGroupContent(
+                this.underlyingMap.core
+                    .testWithDifferentAccount(account, sessionId)
+                    .getCurrentContent()
+            ),
+            this.node
+        );
+    }
+}
+
+export type InviteSecret = `inviteSecret_z${string}`;
+
+function inviteSecretFromSecretSeed(secretSeed: Uint8Array): InviteSecret {
+    return `inviteSecret_z${base58.encode(secretSeed)}`;
+}
+
+export function secretSeedFromInviteSecret(inviteSecret: InviteSecret) {
+    if (!inviteSecret.startsWith("inviteSecret_z")) {
+        throw new Error("Invalid invite secret");
+    }
+
+    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

@@ -1,6 +1,8 @@
-import { CoValue, newRandomSessionID } from "./coValue.js";
+import { CoValueCore, newRandomSessionID } from "./coValueCore.js";
 import { LocalNode } from "./node.js";
-import { CoMap } from "./contentTypes/coMap.js";
+import type { CoValue, ReadableCoValue } from "./coValue.js";
+import { CoMap, WriteableCoMap } from "./coValues/coMap.js";
+import { CoList, WriteableCoList } from "./coValues/coList.js";
 import {
     agentSecretFromBytes,
     agentSecretToBytes,
@@ -14,23 +16,19 @@ import {
 import { connectedPeers } from "./streamUtils.js";
 import { AnonymousControlledAccount, ControlledAccount } from "./account.js";
 import { rawCoIDtoBytes, rawCoIDfromBytes } from "./ids.js";
-import { Team, expectTeamContent } from "./team.js"
+import { Group, expectGroupContent } from "./group.js";
 
 import type { SessionID, AgentID } from "./ids.js";
-import type { CoID, ContentType } from "./contentType.js";
+import type { CoID, CoValueImpl } from "./coValue.js";
 import type { JsonValue } from "./jsonValue.js";
 import type { SyncMessage, Peer } from "./sync.js";
 import type { AgentSecret } from "./crypto.js";
-import type {
-    AccountID,
-    AccountContent,
-    ProfileContent,
-    Profile,
-} from "./account.js";
-import type { InviteSecret } from "./team.js";
+import type { AccountID, Profile } from "./account.js";
+import type { InviteSecret } from "./group.js";
 
-type Value = JsonValue | ContentType;
+type Value = JsonValue | CoValueImpl;
 
+/** @hidden */
 export const cojsonInternals = {
     agentSecretFromBytes,
     agentSecretToBytes,
@@ -44,33 +42,36 @@ export const cojsonInternals = {
     agentSecretFromSecretSeed,
     secretSeedLength,
     shortHashLength,
-    expectTeamContent
+    expectGroupContent,
 };
 
 export {
     LocalNode,
-    CoValue,
+    Group,
     CoMap,
+    WriteableCoMap,
+    CoList,
+    WriteableCoList,
+    CoValueCore,
     AnonymousControlledAccount,
     ControlledAccount,
-    Team
 };
 
 export type {
     Value,
     JsonValue,
-    ContentType,
+    CoValue,
+    ReadableCoValue,
+    CoValueImpl,
     CoID,
-    AgentSecret,
-    SessionID,
-    SyncMessage,
-    AgentID,
     AccountID,
-    Peer,
-    AccountContent,
     Profile,
-    ProfileContent,
-    InviteSecret
+    SessionID,
+    Peer,
+    AgentID,
+    AgentSecret,
+    InviteSecret,
+    SyncMessage,
 };
 
 // eslint-disable-next-line @typescript-eslint/no-namespace
@@ -80,9 +81,13 @@ export namespace CojsonInternalTypes {
     export type KnownStateMessage = import("./sync.js").KnownStateMessage;
     export type LoadMessage = import("./sync.js").LoadMessage;
     export type NewContentMessage = import("./sync.js").NewContentMessage;
-    export type CoValueHeader = import("./coValue.js").CoValueHeader;
-    export type Transaction = import("./coValue.js").Transaction;
+    export type CoValueHeader = import("./coValueCore.js").CoValueHeader;
+    export type Transaction = import("./coValueCore.js").Transaction;
     export type Signature = import("./crypto.js").Signature;
     export type RawCoID = import("./ids.js").RawCoID;
-    export type AccountIDOrAgentID = import("./account.js").AccountIDOrAgentID;
+    export type AccountContent = import("./account.js").AccountContent;
+    export type ProfileContent = import("./account.js").ProfileContent;
+    export type ProfileMeta = import("./account.js").ProfileMeta;
+    export type SealerSecret = import("./crypto.js").SealerSecret;
+    export type SignerSecret = import("./crypto.js").SignerSecret;
 }

packages/cojson/src/node.ts

@@ -9,21 +9,20 @@ import {
     newRandomKeySecret,
     seal,
 } from "./crypto.js";
-import { CoValue, CoValueHeader, newRandomSessionID } from "./coValue.js";
+import { CoValueCore, CoValueHeader, newRandomSessionID } from "./coValueCore.js";
 import {
     InviteSecret,
-    Team,
-    TeamContent,
-    expectTeamContent,
+    Group,
+    GroupContent,
+    expectGroupContent,
     secretSeedFromInviteSecret,
-} from "./team.js";
+} from "./group.js";
 import { Peer, SyncManager } from "./sync.js";
 import { AgentID, RawCoID, SessionID, isAgentID } from "./ids.js";
-import { CoID, ContentType } from "./contentType.js";
+import { CoID, CoValueImpl } from "./coValue.js";
 import {
     Account,
     AccountMeta,
-    AccountIDOrAgentID,
     accountHeaderForInitialAgentSecret,
     GeneralizedControlledAccount,
     ControlledAccount,
@@ -31,23 +30,35 @@ import {
     AccountID,
     Profile,
     AccountContent,
-    ProfileContent,
-    ProfileMeta,
+    AccountMap,
 } from "./account.js";
 import { CoMap } from "./index.js";
 
+/** 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).
+
+@example
+You typically get hold of a `LocalNode` using `jazz-react`'s `useJazz()`:
+
+```typescript
+const { localNode } = useJazz();
+```
+*/
 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 +87,7 @@ export class LocalNode {
             node: nodeWithAccount,
             accountID: account.id,
             accountSecret: account.agentSecret,
-            sessionID: nodeWithAccount.ownSessionID,
+            sessionID: nodeWithAccount.currentSessionID,
         };
     }
 
@@ -110,8 +121,9 @@ export class LocalNode {
         return node;
     }
 
-    createCoValue(header: CoValueHeader): CoValue {
-        const coValue = new CoValue(header, this);
+    /** @internal */
+    createCoValue(header: CoValueHeader): CoValueCore {
+        const coValue = new CoValueCore(header, this);
         this.coValues[coValue.id] = { state: "loaded", coValue: coValue };
 
         void this.sync.syncCoValue(coValue);
@@ -119,7 +131,8 @@ export class LocalNode {
         return coValue;
     }
 
-    loadCoValue(id: RawCoID): Promise<CoValue> {
+    /** @internal */
+    loadCoValue(id: RawCoID): Promise<CoValueCore> {
         let entry = this.coValues[id];
         if (!entry) {
             entry = newLoadingState();
@@ -134,12 +147,21 @@ export class LocalNode {
         return entry.done;
     }
 
-    async 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 `coValue.subscribe()` and `node.useTelepathicData()`
+     * for listening to subsequent updates to the CoValue.
+     */
+    async load<T extends CoValueImpl>(id: CoID<T>): Promise<T> {
         return (await this.loadCoValue(id)).getCurrentContent() as T;
     }
 
+    /**
+     * Loads a profile associated with an account. `Profile` is at least a `CoMap<{string: name}>`,
+     * but might contain other, app-specific properties.
+     */
     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) {
@@ -150,33 +172,33 @@ export class LocalNode {
         ).getCurrentContent() as Profile;
     }
 
-    async acceptInvite<T extends ContentType>(
-        teamOrOwnedValueID: CoID<T>,
+    async acceptInvite<T extends CoValueImpl>(
+        groupOrOwnedValueID: CoID<T>,
         inviteSecret: InviteSecret
     ): Promise<void> {
-        const teamOrOwnedValue = await this.load(teamOrOwnedValueID);
+        const groupOrOwnedValue = await this.load(groupOrOwnedValueID);
 
-        if (teamOrOwnedValue.coValue.header.ruleset.type === "ownedByTeam") {
+        if (groupOrOwnedValue.core.header.ruleset.type === "ownedByGroup") {
             return this.acceptInvite(
-                teamOrOwnedValue.coValue.header.ruleset.team as CoID<
-                    CoMap<TeamContent>
+                groupOrOwnedValue.core.header.ruleset.group as CoID<
+                    CoMap<GroupContent>
                 >,
                 inviteSecret
             );
-        } else if (teamOrOwnedValue.coValue.header.ruleset.type !== "team") {
-            throw new Error("Can only accept invites to teams");
+        } else if (groupOrOwnedValue.core.header.ruleset.type !== "group") {
+            throw new Error("Can only accept invites to groups");
         }
 
-        const team = new Team(expectTeamContent(teamOrOwnedValue), this);
+        const group = new Group(expectGroupContent(groupOrOwnedValue), this);
 
         const inviteAgentSecret = agentSecretFromSecretSeed(
             secretSeedFromInviteSecret(inviteSecret)
         );
         const inviteAgentID = getAgentID(inviteAgentSecret);
 
-        const invitationRole = await new Promise((resolve, reject) => {
-            team.teamMap.subscribe((teamMap) => {
-                const role = teamMap.get(inviteAgentID);
+        const inviteRole = await new Promise((resolve, reject) => {
+            group.underlyingMap.subscribe((groupMap) => {
+                const role = groupMap.get(inviteAgentID);
                 if (role) {
                     resolve(role);
                 }
@@ -184,45 +206,52 @@ export class LocalNode {
             setTimeout(
                 () =>
                     reject(
-                        new Error("Couldn't find invitation before timeout")
+                        new Error("Couldn't find invite before timeout")
                     ),
                 1000
             );
         });
 
-        if (!invitationRole) {
-            throw new Error("No invitation found");
+        if (!inviteRole) {
+            throw new Error("No invite found");
         }
 
-        const existingRole = team.teamMap.get(this.account.id);
+        const existingRole = group.underlyingMap.get(this.account.id);
 
         if (
             existingRole === "admin" ||
-            (existingRole === "writer" && invitationRole === "reader")
+            (existingRole === "writer" && inviteRole === "writerInvite") ||
+            (existingRole === "writer" && inviteRole === "reader") ||
+            (existingRole === "reader" && inviteRole === "readerInvite")
         ) {
-            console.debug("Not accepting invite that would downgrade role");
+            console.debug("Not accepting invite that would replace or downgrade role");
             return;
         }
 
-        const teamAsInvite = team.testWithDifferentAccount(
+        const groupAsInvite = group.testWithDifferentAccount(
             new AnonymousControlledAccount(inviteAgentSecret),
             newRandomSessionID(inviteAgentID)
         );
 
-        teamAsInvite.addMember(
+        groupAsInvite.addMemberInternal(
             this.account.id,
-            invitationRole === "adminInvite"
+            inviteRole === "adminInvite"
                 ? "admin"
-                : invitationRole === "writerInvite"
+                : inviteRole === "writerInvite"
                 ? "writer"
                 : "reader"
         );
 
-        team.teamMap.coValue._sessions = teamAsInvite.teamMap.coValue.sessions;
-        team.teamMap.coValue._cachedContent = undefined;
+        group.underlyingMap.core._sessions = groupAsInvite.underlyingMap.core.sessions;
+        group.underlyingMap.core._cachedContent = undefined;
+
+        for (const groupListener of group.underlyingMap.core.listeners) {
+            groupListener(group.underlyingMap.core.getCurrentContent());
+        }
     }
 
-    expectCoValueLoaded(id: RawCoID, expectation?: string): CoValue {
+    /** @internal */
+    expectCoValueLoaded(id: RawCoID, expectation?: string): CoValueCore {
         const entry = this.coValues[id];
         if (!entry) {
             throw new Error(
@@ -239,9 +268,10 @@ export class LocalNode {
         return entry.coValue;
     }
 
+    /** @internal */
     expectProfileLoaded(id: AccountID, expectation?: string): Profile {
         const account = this.expectCoValueLoaded(id, expectation);
-        const profileID = expectTeamContent(account.getCurrentContent()).get(
+        const profileID = expectGroupContent(account.getCurrentContent()).get(
             "profile"
         );
         if (!profileID) {
@@ -257,6 +287,7 @@ export class LocalNode {
         ).getCurrentContent() as Profile;
     }
 
+    /** @internal */
     createAccount(
         name: string,
         agentSecret = newRandomAgentSecret()
@@ -268,12 +299,12 @@ export class LocalNode {
             newRandomSessionID(getAgentID(agentSecret))
         );
 
-        const accountAsTeam = new Team(
-            expectTeamContent(account.getCurrentContent()),
+        const accountAsGroup = new Group(
+            expectGroupContent(account.getCurrentContent()),
             account.node
         );
 
-        accountAsTeam.teamMap.edit((editable) => {
+        accountAsGroup.underlyingMap.edit((editable) => {
             editable.set(getAgentID(agentSecret), "admin", "trusting");
 
             const readKey = newRandomKeySecret();
@@ -301,7 +332,7 @@ export class LocalNode {
             account.node
         );
 
-        const profile = accountAsTeam.createMap<ProfileContent, ProfileMeta>({
+        const profile = accountAsGroup.createMap<Profile>({
             type: "profile",
         });
 
@@ -309,19 +340,20 @@ export class LocalNode {
             editable.set("name", name, "trusting");
         });
 
-        accountAsTeam.teamMap.edit((editable) => {
+        accountAsGroup.underlyingMap.edit((editable) => {
             editable.set("profile", profile.id, "trusting");
         });
 
         const accountOnThisNode = this.expectCoValueLoaded(account.id);
 
-        accountOnThisNode._sessions = {...accountAsTeam.teamMap.coValue.sessions};
+        accountOnThisNode._sessions = {...accountAsGroup.underlyingMap.core.sessions};
         accountOnThisNode._cachedContent = undefined;
 
         return controlledAccount;
     }
 
-    resolveAccountAgent(id: AccountIDOrAgentID, expectation?: string): AgentID {
+    /** @internal */
+    resolveAccountAgent(id: AccountID | AgentID, expectation?: string): AgentID {
         if (isAgentID(id)) {
             return id;
         }
@@ -330,7 +362,7 @@ export class LocalNode {
 
         if (
             coValue.header.type !== "comap" ||
-            coValue.header.ruleset.type !== "team" ||
+            coValue.header.ruleset.type !== "group" ||
             !coValue.header.meta ||
             !("type" in coValue.header.meta) ||
             coValue.header.meta.type !== "account"
@@ -343,22 +375,23 @@ export class LocalNode {
         }
 
         return new Account(
-            coValue.getCurrentContent() as CoMap<TeamContent, AccountMeta>,
+            coValue.getCurrentContent() as CoMap<GroupContent, AccountMeta>,
             this
         ).getCurrentAgentID();
     }
 
-    createTeam(): Team {
-        const teamCoValue = this.createCoValue({
+    /** Creates a new group (with the current account as the group's first admin). */
+    createGroup(): Group {
+        const groupCoValue = this.createCoValue({
             type: "comap",
-            ruleset: { type: "team", initialAdmin: this.account.id },
+            ruleset: { type: "group", initialAdmin: this.account.id },
             meta: null,
             ...createdNowUnique(),
         });
 
-        let teamContent = expectTeamContent(teamCoValue.getCurrentContent());
+        let groupContent = expectGroupContent(groupCoValue.getCurrentContent());
 
-        teamContent = teamContent.edit((editable) => {
+        groupContent = groupContent.edit((editable) => {
             editable.set(this.account.id, "admin", "trusting");
 
             const readKey = newRandomKeySecret();
@@ -370,8 +403,8 @@ export class LocalNode {
                     this.account.currentSealerSecret(),
                     this.account.currentSealerID(),
                     {
-                        in: teamCoValue.id,
-                        tx: teamCoValue.nextTransactionID(),
+                        in: groupCoValue.id,
+                        tx: groupCoValue.nextTransactionID(),
                     }
                 ),
                 "trusting"
@@ -380,14 +413,15 @@ export class LocalNode {
             editable.set("readKey", readKey.id, "trusting");
         });
 
-        return new Team(teamContent, this);
+        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);
 
@@ -409,7 +443,7 @@ export class LocalNode {
                     continue;
                 }
 
-                const newCoValue = new CoValue(entry.coValue.header, newNode, {...entry.coValue.sessions});
+                const newCoValue = new CoValueCore(entry.coValue.header, newNode, {...entry.coValue.sessions});
 
                 newNode.coValues[coValueID as RawCoID] = {
                     state: "loaded",
@@ -424,18 +458,20 @@ export class LocalNode {
     }
 }
 
+/** @internal */
 type CoValueState =
     | {
           state: "loading";
-          done: Promise<CoValue>;
-          resolve: (coValue: CoValue) => void;
+          done: Promise<CoValueCore>;
+          resolve: (coValue: CoValueCore) => void;
       }
-    | { state: "loaded"; coValue: CoValue };
+    | { state: "loaded"; coValue: CoValueCore };
 
+/** @internal */
 export function newLoadingState(): CoValueState {
-    let resolve: (coValue: CoValue) => void;
+    let resolve: (coValue: CoValueCore) => void;
 
-    const promise = new Promise<CoValue>((r) => {
+    const promise = new Promise<CoValueCore>((r) => {
         resolve = r;
     });
 

packages/cojson/src/permissions.ts

@@ -1,24 +1,24 @@
-import { CoID } from "./contentType.js";
-import { MapOpPayload } from "./contentTypes/coMap.js";
+import { CoID } from "./coValue.js";
+import { MapOpPayload } from "./coValues/coMap.js";
 import { JsonValue } from "./jsonValue.js";
 import {
     KeyID,
 } from "./crypto.js";
 import {
-    CoValue,
+    CoValueCore,
     Transaction,
     TrustingTransaction,
     accountOrAgentIDfromSessionID,
-} from "./coValue.js";
-import { RawCoID, SessionID, TransactionID } from "./ids.js";
+} from "./coValueCore.js";
+import { AgentID, RawCoID, SessionID, TransactionID } from "./ids.js";
 import {
-    AccountIDOrAgentID,
+    AccountID,
     Profile,
 } from "./account.js";
 
 export type PermissionsDef =
-    | { type: "team"; initialAdmin: AccountIDOrAgentID }
-    | { type: "ownedByTeam"; team: RawCoID }
+    | { type: "group"; initialAdmin: AccountID | AgentID }
+    | { type: "ownedByGroup"; group: RawCoID }
     | { type: "unsafeAllowAll" };
 
 export type Role =
@@ -31,9 +31,9 @@ export type Role =
     | "readerInvite";
 
 export function determineValidTransactions(
-    coValue: CoValue
+    coValue: CoValueCore
 ): { txID: TransactionID; tx: Transaction }[] {
-    if (coValue.header.ruleset.type === "team") {
+    if (coValue.header.ruleset.type === "group") {
         const allTrustingTransactionsSorted = Object.entries(
             coValue.sessions
         ).flatMap(([sessionID, sessionLog]) => {
@@ -43,7 +43,7 @@ export function determineValidTransactions(
                     if (tx.privacy === "trusting") {
                         return true;
                     } else {
-                        console.warn("Unexpected private transaction in Team");
+                        console.warn("Unexpected private transaction in Group");
                         return false;
                     }
                 }) as {
@@ -60,10 +60,10 @@ export function determineValidTransactions(
         const initialAdmin = coValue.header.ruleset.initialAdmin;
 
         if (!initialAdmin) {
-            throw new Error("Team must have initialAdmin");
+            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,16 +77,16 @@ 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) {
-                console.warn("Team transaction must have exactly one change");
+                console.warn("Group transaction must have exactly one change");
                 continue;
             }
 
             if (change.op !== "set") {
-                console.warn("Team transaction must set a role or readKey");
+                console.warn("Group transaction must set a role or readKey");
                 continue;
             }
 
@@ -138,7 +138,7 @@ export function determineValidTransactions(
                 change.value !== "writerInvite" &&
                 change.value !== "readerInvite"
             ) {
-                console.warn("Team transaction must set a valid role");
+                console.warn("Group transaction must set a valid role");
                 continue;
             }
 
@@ -176,7 +176,7 @@ export function determineValidTransactions(
                     }
                 } else {
                     console.warn(
-                        "Team transaction must be made by current admin or invite"
+                        "Group transaction must be made by current admin or invite"
                     );
                     continue;
                 }
@@ -189,16 +189,16 @@ export function determineValidTransactions(
         }
 
         return validTransactions;
-    } else if (coValue.header.ruleset.type === "ownedByTeam") {
-        const teamContent = coValue.node
+    } else if (coValue.header.ruleset.type === "ownedByGroup") {
+        const groupContent = coValue.node
             .expectCoValueLoaded(
-                coValue.header.ruleset.team,
-                "Determining valid transaction in owned object but its team wasn't loaded"
+                coValue.header.ruleset.group,
+                "Determining valid transaction in owned object but its group wasn't loaded"
             )
             .getCurrentContent();
 
-        if (teamContent.type !== "comap") {
-            throw new Error("Team must be a map");
+        if (groupContent.type !== "comap") {
+            throw new Error("Group must be a map");
         }
 
         return Object.entries(coValue.sessions).flatMap(
@@ -208,7 +208,7 @@ export function determineValidTransactions(
                 );
                 return sessionLog.transactions
                     .filter((tx) => {
-                        const transactorRoleAtTxTime = teamContent.getAtTime(
+                        const transactorRoleAtTxTime = groupContent.getAtTime(
                             transactor,
                             tx.madeAt
                         );
@@ -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

@@ -1,9 +1,9 @@
-import { newRandomSessionID } from "./coValue.js";
+import { newRandomSessionID } from "./coValueCore.js";
 import { LocalNode } from "./node.js";
 import { Peer, PeerID, SyncMessage } from "./sync.js";
-import { expectMap } from "./contentType.js";
-import { MapOpPayload } from "./contentTypes/coMap.js";
-import { Team } from "./team.js";
+import { expectMap } from "./coValue.js";
+import { MapOpPayload } from "./coValues/coMap.js";
+import { Group } from "./group.js";
 import {
     ReadableStream,
     WritableStream,
@@ -23,9 +23,9 @@ test("Node replies with initial tx and header to empty subscribe", async () => {
     const [admin, session] = randomAnonymousAccountAndSessionID();
     const node = new LocalNode(admin, session);
 
-    const team = node.createTeam();
+    const group = node.createGroup();
 
-    const map = team.createMap();
+    const map = group.createMap();
 
     map.edit((editable) => {
         editable.set("hello", "world", "trusting");
@@ -45,7 +45,7 @@ test("Node replies with initial tx and header to empty subscribe", async () => {
 
     await writer.write({
         action: "load",
-        id: map.coValue.id,
+        id: map.core.id,
         header: false,
         sessions: {},
     });
@@ -53,36 +53,36 @@ test("Node replies with initial tx and header to empty subscribe", async () => {
     const reader = outRx.getReader();
 
     // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(teamStateEx(team));
+    expect((await reader.read()).value).toMatchObject(groupStateEx(group));
 
     const mapTellKnownStateMsg = await reader.read();
     expect(mapTellKnownStateMsg.value).toEqual({
         action: "known",
-        ...map.coValue.knownState(),
+        ...map.core.knownState(),
     } satisfies SyncMessage);
 
     // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(teamContentEx(team));
+    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
 
     const newContentMsg = await reader.read();
 
     expect(newContentMsg.value).toEqual({
         action: "content",
-        id: map.coValue.id,
+        id: map.core.id,
         header: {
             type: "comap",
-            ruleset: { type: "ownedByTeam", team: team.id },
+            ruleset: { type: "ownedByGroup", group: group.id },
             meta: null,
-            createdAt: map.coValue.header.createdAt,
-            uniqueness: map.coValue.header.uniqueness,
+            createdAt: map.core.header.createdAt,
+            uniqueness: map.core.header.uniqueness,
         },
         new: {
-            [node.ownSessionID]: {
+            [node.currentSessionID]: {
                 after: 0,
                 newTransactions: [
                     {
                         privacy: "trusting" as const,
-                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                        madeAt: map.core.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.core.sessions[node.currentSessionID]!.lastSignature!,
             },
         },
     } satisfies SyncMessage);
@@ -104,9 +104,9 @@ test("Node replies with only new tx to subscribe with some known state", async (
     const [admin, session] = randomAnonymousAccountAndSessionID();
     const node = new LocalNode(admin, session);
 
-    const team = node.createTeam();
+    const group = node.createGroup();
 
-    const map = team.createMap();
+    const map = group.createMap();
 
     map.edit((editable) => {
         editable.set("hello", "world", "trusting");
@@ -127,40 +127,40 @@ test("Node replies with only new tx to subscribe with some known state", async (
 
     await writer.write({
         action: "load",
-        id: map.coValue.id,
+        id: map.core.id,
         header: true,
         sessions: {
-            [node.ownSessionID]: 1,
+            [node.currentSessionID]: 1,
         },
     });
 
     const reader = outRx.getReader();
 
     // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(teamStateEx(team));
+    expect((await reader.read()).value).toMatchObject(groupStateEx(group));
 
     const mapTellKnownStateMsg = await reader.read();
     expect(mapTellKnownStateMsg.value).toEqual({
         action: "known",
-        ...map.coValue.knownState(),
+        ...map.core.knownState(),
     } satisfies SyncMessage);
 
     // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(teamContentEx(team));
+    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
 
     const mapNewContentMsg = await reader.read();
 
     expect(mapNewContentMsg.value).toEqual({
         action: "content",
-        id: map.coValue.id,
+        id: map.core.id,
         header: undefined,
         new: {
-            [node.ownSessionID]: {
+            [node.currentSessionID]: {
                 after: 1,
                 newTransactions: [
                     {
                         privacy: "trusting" as const,
-                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                        madeAt: map.core.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.core.sessions[node.currentSessionID]!.lastSignature!,
             },
         },
     } satisfies SyncMessage);
@@ -186,9 +186,9 @@ test("After subscribing, node sends own known state and new txs to peer", async
     const [admin, session] = randomAnonymousAccountAndSessionID();
     const node = new LocalNode(admin, session);
 
-    const team = node.createTeam();
+    const group = node.createGroup();
 
-    const map = team.createMap();
+    const map = group.createMap();
 
     const [inRx, inTx] = newStreamPair<SyncMessage>();
     const [outRx, outTx] = newStreamPair<SyncMessage>();
@@ -204,33 +204,33 @@ test("After subscribing, node sends own known state and new txs to peer", async
 
     await writer.write({
         action: "load",
-        id: map.coValue.id,
+        id: map.core.id,
         header: false,
         sessions: {
-            [node.ownSessionID]: 0,
+            [node.currentSessionID]: 0,
         },
     });
 
     const reader = outRx.getReader();
 
     // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(teamStateEx(team));
+    expect((await reader.read()).value).toMatchObject(groupStateEx(group));
 
     const mapTellKnownStateMsg = await reader.read();
     expect(mapTellKnownStateMsg.value).toEqual({
         action: "known",
-        ...map.coValue.knownState(),
+        ...map.core.knownState(),
     } satisfies SyncMessage);
 
     // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(teamContentEx(team));
+    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
 
     const mapNewContentHeaderOnlyMsg = await reader.read();
 
     expect(mapNewContentHeaderOnlyMsg.value).toEqual({
         action: "content",
-        id: map.coValue.id,
-        header: map.coValue.header,
+        id: map.core.id,
+        header: map.core.header,
         new: {},
     } satisfies SyncMessage);
 
@@ -242,14 +242,14 @@ test("After subscribing, node sends own known state and new txs to peer", async
 
     expect(mapEditMsg1.value).toEqual({
         action: "content",
-        id: map.coValue.id,
+        id: map.core.id,
         new: {
-            [node.ownSessionID]: {
+            [node.currentSessionID]: {
                 after: 0,
                 newTransactions: [
                     {
                         privacy: "trusting" as const,
-                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                        madeAt: map.core.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.core.sessions[node.currentSessionID]!.lastSignature!,
             },
         },
     } satisfies SyncMessage);
@@ -274,14 +274,14 @@ test("After subscribing, node sends own known state and new txs to peer", async
 
     expect(mapEditMsg2.value).toEqual({
         action: "content",
-        id: map.coValue.id,
+        id: map.core.id,
         new: {
-            [node.ownSessionID]: {
+            [node.currentSessionID]: {
                 after: 1,
                 newTransactions: [
                     {
                         privacy: "trusting" as const,
-                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                        madeAt: map.core.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.core.sessions[node.currentSessionID]!.lastSignature!,
             },
         },
     } satisfies SyncMessage);
@@ -303,9 +303,9 @@ test("Client replies with known new content to tellKnownState from server", asyn
     const [admin, session] = randomAnonymousAccountAndSessionID();
     const node = new LocalNode(admin, session);
 
-    const team = node.createTeam();
+    const group = node.createGroup();
 
-    const map = team.createMap();
+    const map = group.createMap();
 
     map.edit((editable) => {
         editable.set("hello", "world", "trusting");
@@ -323,44 +323,44 @@ test("Client replies with known new content to tellKnownState from server", asyn
 
     const reader = outRx.getReader();
 
-    // expect((await reader.read()).value).toMatchObject(teamStateEx(team));
+    // expect((await reader.read()).value).toMatchObject(groupStateEx(group));
 
     const writer = inTx.getWriter();
 
     await writer.write({
         action: "known",
-        id: map.coValue.id,
+        id: map.core.id,
         header: false,
         sessions: {
-            [node.ownSessionID]: 0,
+            [node.currentSessionID]: 0,
         },
     });
 
     // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(teamStateEx(team));
+    expect((await reader.read()).value).toMatchObject(groupStateEx(group));
 
     const mapTellKnownStateMsg = await reader.read();
     expect(mapTellKnownStateMsg.value).toEqual({
         action: "known",
-        ...map.coValue.knownState(),
+        ...map.core.knownState(),
     } satisfies SyncMessage);
 
     // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(teamContentEx(team));
+    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
 
     const mapNewContentMsg = await reader.read();
 
     expect(mapNewContentMsg.value).toEqual({
         action: "content",
-        id: map.coValue.id,
-        header: map.coValue.header,
+        id: map.core.id,
+        header: map.core.header,
         new: {
-            [node.ownSessionID]: {
+            [node.currentSessionID]: {
                 after: 0,
                 newTransactions: [
                     {
                         privacy: "trusting" as const,
-                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                        madeAt: map.core.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.core.sessions[node.currentSessionID]!.lastSignature!,
             },
         },
     } satisfies SyncMessage);
@@ -382,9 +382,9 @@ test("No matter the optimistic known state, node respects invalid known state me
     const [admin, session] = randomAnonymousAccountAndSessionID();
     const node = new LocalNode(admin, session);
 
-    const team = node.createTeam();
+    const group = node.createGroup();
 
-    const map = team.createMap();
+    const map = group.createMap();
 
     const [inRx, inTx] = newStreamPair<SyncMessage>();
     const [outRx, outTx] = newStreamPair<SyncMessage>();
@@ -400,33 +400,33 @@ test("No matter the optimistic known state, node respects invalid known state me
 
     await writer.write({
         action: "load",
-        id: map.coValue.id,
+        id: map.core.id,
         header: false,
         sessions: {
-            [node.ownSessionID]: 0,
+            [node.currentSessionID]: 0,
         },
     });
 
     const reader = outRx.getReader();
 
     // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(teamStateEx(team));
+    expect((await reader.read()).value).toMatchObject(groupStateEx(group));
 
     const mapTellKnownStateMsg = await reader.read();
     expect(mapTellKnownStateMsg.value).toEqual({
         action: "known",
-        ...map.coValue.knownState(),
+        ...map.core.knownState(),
     } satisfies SyncMessage);
 
     // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(teamContentEx(team));
+    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
 
     const mapNewContentHeaderOnlyMsg = await reader.read();
 
     expect(mapNewContentHeaderOnlyMsg.value).toEqual({
         action: "content",
-        id: map.coValue.id,
-        header: map.coValue.header,
+        id: map.core.id,
+        header: map.core.header,
         new: {},
     } satisfies SyncMessage);
 
@@ -444,10 +444,10 @@ test("No matter the optimistic known state, node respects invalid known state me
     await writer.write({
         action: "known",
         isCorrection: true,
-        id: map.coValue.id,
+        id: map.core.id,
         header: true,
         sessions: {
-            [node.ownSessionID]: 1,
+            [node.currentSessionID]: 1,
         },
     } satisfies SyncMessage);
 
@@ -455,15 +455,15 @@ test("No matter the optimistic known state, node respects invalid known state me
 
     expect(newContentAfterWrongAssumedState.value).toEqual({
         action: "content",
-        id: map.coValue.id,
+        id: map.core.id,
         header: undefined,
         new: {
-            [node.ownSessionID]: {
+            [node.currentSessionID]: {
                 after: 1,
                 newTransactions: [
                     {
                         privacy: "trusting" as const,
-                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                        madeAt: map.core.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.core.sessions[node.currentSessionID]!.lastSignature!,
             },
         },
     } satisfies SyncMessage);
@@ -485,9 +485,9 @@ test("If we add a peer, but it never subscribes to a coValue, it won't get any m
     const [admin, session] = randomAnonymousAccountAndSessionID();
     const node = new LocalNode(admin, session);
 
-    const team = node.createTeam();
+    const group = node.createGroup();
 
-    const map = team.createMap();
+    const map = group.createMap();
 
     const [inRx, _inTx] = newStreamPair<SyncMessage>();
     const [outRx, outTx] = newStreamPair<SyncMessage>();
@@ -514,9 +514,9 @@ test("If we add a server peer, all updates to all coValues are sent to it, even
     const [admin, session] = randomAnonymousAccountAndSessionID();
     const node = new LocalNode(admin, session);
 
-    const team = node.createTeam();
+    const group = node.createGroup();
 
-    const map = team.createMap();
+    const map = group.createMap();
 
     const [inRx, _inTx] = newStreamPair<SyncMessage>();
     const [outRx, outTx] = newStreamPair<SyncMessage>();
@@ -535,14 +535,14 @@ test("If we add a server peer, all updates to all coValues are sent to it, even
     // });
     expect((await reader.read()).value).toMatchObject({
         action: "load",
-        id: team.teamMap.coValue.id,
+        id: group.underlyingMap.core.id,
     });
 
     const mapSubscribeMsg = await reader.read();
 
     expect(mapSubscribeMsg.value).toEqual({
         action: "load",
-        id: map.coValue.id,
+        id: map.core.id,
         header: true,
         sessions: {},
     } satisfies SyncMessage);
@@ -552,21 +552,21 @@ test("If we add a server peer, all updates to all coValues are sent to it, even
     });
 
     // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(teamContentEx(team));
+    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
 
     const mapNewContentMsg = await reader.read();
 
     expect(mapNewContentMsg.value).toEqual({
         action: "content",
-        id: map.coValue.id,
-        header: map.coValue.header,
+        id: map.core.id,
+        header: map.core.header,
         new: {
-            [node.ownSessionID]: {
+            [node.currentSessionID]: {
                 after: 0,
                 newTransactions: [
                     {
                         privacy: "trusting" as const,
-                        madeAt: map.coValue.sessions[node.ownSessionID]!
+                        madeAt: map.core.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.core.sessions[node.currentSessionID]!.lastSignature!,
             },
         },
     } satisfies SyncMessage);
@@ -588,7 +588,7 @@ test("If we add a server peer, newly created coValues are auto-subscribed to", a
     const [admin, session] = randomAnonymousAccountAndSessionID();
     const node = new LocalNode(admin, session);
 
-    const team = node.createTeam();
+    const group = node.createGroup();
 
     const [inRx, _inTx] = newStreamPair<SyncMessage>();
     const [outRx, outTx] = newStreamPair<SyncMessage>();
@@ -607,27 +607,27 @@ test("If we add a server peer, newly created coValues are auto-subscribed to", a
     // });
     expect((await reader.read()).value).toMatchObject({
         action: "load",
-        id: team.teamMap.coValue.id,
+        id: group.underlyingMap.core.id,
     });
 
-    const map = team.createMap();
+    const map = group.createMap();
 
     const mapSubscribeMsg = await reader.read();
 
     expect(mapSubscribeMsg.value).toEqual({
         action: "load",
-        ...map.coValue.knownState(),
+        ...map.core.knownState(),
     } satisfies SyncMessage);
 
     // expect((await reader.read()).value).toMatchObject(admContEx(adminID));
-    expect((await reader.read()).value).toMatchObject(teamContentEx(team));
+    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
 
     const mapContentMsg = await reader.read();
 
     expect(mapContentMsg.value).toEqual({
         action: "content",
-        id: map.coValue.id,
-        header: map.coValue.header,
+        id: map.core.id,
+        header: map.core.header,
         new: {},
     } satisfies SyncMessage);
 });
@@ -640,9 +640,9 @@ test("When we connect a new server peer, we try to sync all existing coValues to
     const [admin, session] = randomAnonymousAccountAndSessionID();
     const node = new LocalNode(admin, session);
 
-    const team = node.createTeam();
+    const group = node.createGroup();
 
-    const map = team.createMap();
+    const map = group.createMap();
 
     const [inRx, _inTx] = newStreamPair<SyncMessage>();
     const [outRx, outTx] = newStreamPair<SyncMessage>();
@@ -657,18 +657,18 @@ test("When we connect a new server peer, we try to sync all existing coValues to
     const reader = outRx.getReader();
 
     // const _adminSubscribeMessage = await reader.read();
-    const teamSubscribeMessage = await reader.read();
+    const groupSubscribeMessage = await reader.read();
 
-    expect(teamSubscribeMessage.value).toEqual({
+    expect(groupSubscribeMessage.value).toEqual({
         action: "load",
-        ...team.teamMap.coValue.knownState(),
+        ...group.underlyingMap.core.knownState(),
     } satisfies SyncMessage);
 
     const secondMessage = await reader.read();
 
     expect(secondMessage.value).toEqual({
         action: "load",
-        ...map.coValue.knownState(),
+        ...map.core.knownState(),
     } satisfies SyncMessage);
 });
 
@@ -676,9 +676,9 @@ test("When receiving a subscribe with a known state that is ahead of our own, pe
     const [admin, session] = randomAnonymousAccountAndSessionID();
     const node = new LocalNode(admin, session);
 
-    const team = node.createTeam();
+    const group = node.createGroup();
 
-    const map = team.createMap();
+    const map = group.createMap();
 
     const [inRx, inTx] = newStreamPair<SyncMessage>();
     const [outRx, outTx] = newStreamPair<SyncMessage>();
@@ -694,22 +694,22 @@ test("When receiving a subscribe with a known state that is ahead of our own, pe
 
     await writer.write({
         action: "load",
-        id: map.coValue.id,
+        id: map.core.id,
         header: true,
         sessions: {
-            [node.ownSessionID]: 1,
+            [node.currentSessionID]: 1,
         },
     });
 
     const reader = outRx.getReader();
 
     // expect((await reader.read()).value).toMatchObject(admStateEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(teamStateEx(team));
+    expect((await reader.read()).value).toMatchObject(groupStateEx(group));
     const mapTellKnownState = await reader.read();
 
     expect(mapTellKnownState.value).toEqual({
         action: "known",
-        ...map.coValue.knownState(),
+        ...map.core.knownState(),
     } satisfies SyncMessage);
 });
 
@@ -719,7 +719,7 @@ test.skip("When replaying creation and transactions of a coValue as new content,
 
     const node1 = new LocalNode(admin, session);
 
-    const team = node1.createTeam();
+    const group = node1.createGroup();
 
     const [inRx1, inTx1] = newStreamPair<SyncMessage>();
     const [outRx1, outTx1] = newStreamPair<SyncMessage>();
@@ -754,52 +754,52 @@ test.skip("When replaying creation and transactions of a coValue as new content,
         action: "load",
         id: admin.id,
     });
-    const teamSubscribeMsg = await from1.read();
-    expect(teamSubscribeMsg.value).toMatchObject({
+    const groupSubscribeMsg = await from1.read();
+    expect(groupSubscribeMsg.value).toMatchObject({
         action: "load",
-        id: team.teamMap.coValue.id,
+        id: group.underlyingMap.core.id,
     });
 
     await to2.write(adminSubscribeMessage.value!);
-    await to2.write(teamSubscribeMsg.value!);
+    await to2.write(groupSubscribeMsg.value!);
 
     // const adminTellKnownStateMsg = await from2.read();
     // expect(adminTellKnownStateMsg.value).toMatchObject(admStateEx(admin.id));
 
-    const teamTellKnownStateMsg = await from2.read();
-    expect(teamTellKnownStateMsg.value).toMatchObject(teamStateEx(team));
+    const groupTellKnownStateMsg = await from2.read();
+    expect(groupTellKnownStateMsg.value).toMatchObject(groupStateEx(group));
 
     expect(
         node2.sync.peers["test1"]!.optimisticKnownStates[
-            team.teamMap.coValue.id
+            group.underlyingMap.core.id
         ]
     ).toBeDefined();
 
     // await to1.write(adminTellKnownStateMsg.value!);
-    await to1.write(teamTellKnownStateMsg.value!);
+    await to1.write(groupTellKnownStateMsg.value!);
 
     // const adminContentMsg = await from1.read();
     // expect(adminContentMsg.value).toMatchObject(admContEx(admin.id));
 
-    const teamContentMsg = await from1.read();
-    expect(teamContentMsg.value).toMatchObject(teamContentEx(team));
+    const groupContentMsg = await from1.read();
+    expect(groupContentMsg.value).toMatchObject(groupContentEx(group));
 
     // await to2.write(adminContentMsg.value!);
-    await to2.write(teamContentMsg.value!);
+    await to2.write(groupContentMsg.value!);
 
-    const map = team.createMap();
+    const map = group.createMap();
 
     const mapSubscriptionMsg = await from1.read();
     expect(mapSubscriptionMsg.value).toMatchObject({
         action: "load",
-        id: map.coValue.id,
+        id: map.core.id,
     });
 
     const mapNewContentMsg = await from1.read();
     expect(mapNewContentMsg.value).toEqual({
         action: "content",
-        id: map.coValue.id,
-        header: map.coValue.header,
+        id: map.core.id,
+        header: map.core.header,
         new: {},
     } satisfies SyncMessage);
 
@@ -808,12 +808,12 @@ test.skip("When replaying creation and transactions of a coValue as new content,
     const mapTellKnownStateMsg = await from2.read();
     expect(mapTellKnownStateMsg.value).toEqual({
         action: "known",
-        id: map.coValue.id,
+        id: map.core.id,
         header: false,
         sessions: {},
     } satisfies SyncMessage);
 
-    expect(node2.coValues[map.coValue.id]?.state).toEqual("loading");
+    expect(node2.coValues[map.core.id]?.state).toEqual("loading");
 
     await to2.write(mapNewContentMsg.value!);
 
@@ -829,7 +829,7 @@ test.skip("When replaying creation and transactions of a coValue as new content,
 
     expect(
         expectMap(
-            node2.expectCoValueLoaded(map.coValue.id).getCurrentContent()
+            node2.expectCoValueLoaded(map.core.id).getCurrentContent()
         ).get("hello")
     ).toEqual("world");
 });
@@ -840,9 +840,9 @@ test.skip("When loading a coValue on one node, the server node it is requested f
 
     const node1 = new LocalNode(admin, session);
 
-    const team = node1.createTeam();
+    const group = node1.createGroup();
 
-    const map = team.createMap();
+    const map = group.createMap();
     map.edit((editable) => {
         editable.set("hello", "world", "trusting");
     });
@@ -854,11 +854,11 @@ test.skip("When loading a coValue on one node, the server node it is requested f
     node1.sync.addPeer(node2asPeer);
     node2.sync.addPeer(node1asPeer);
 
-    await node2.loadCoValue(map.coValue.id);
+    await node2.loadCoValue(map.core.id);
 
     expect(
         expectMap(
-            node2.expectCoValueLoaded(map.coValue.id).getCurrentContent()
+            node2.expectCoValueLoaded(map.core.id).getCurrentContent()
         ).get("hello")
     ).toEqual("world");
 });
@@ -868,9 +868,9 @@ test("Can sync a coValue through a server to another client", async () => {
 
     const client1 = new LocalNode(admin, session);
 
-    const team = client1.createTeam();
+    const group = client1.createGroup();
 
-    const map = team.createMap();
+    const map = group.createMap();
     map.edit((editable) => {
         editable.set("hello", "world", "trusting");
     });
@@ -898,7 +898,7 @@ test("Can sync a coValue through a server to another client", async () => {
     client2.sync.addPeer(serverAsOtherPeer);
     server.sync.addPeer(client2AsPeer);
 
-    const mapOnClient2 = await client2.loadCoValue(map.coValue.id);
+    const mapOnClient2 = await client2.loadCoValue(map.core.id);
 
     expect(expectMap(mapOnClient2.getCurrentContent()).get("hello")).toEqual(
         "world"
@@ -910,9 +910,9 @@ test("Can sync a coValue with private transactions through a server to another c
 
     const client1 = new LocalNode(admin, session);
 
-    const team = client1.createTeam();
+    const group = client1.createGroup();
 
-    const map = team.createMap();
+    const map = group.createMap();
     map.edit((editable) => {
         editable.set("hello", "world", "private");
     });
@@ -941,7 +941,7 @@ test("Can sync a coValue with private transactions through a server to another c
     client2.sync.addPeer(serverAsOtherPeer);
     server.sync.addPeer(client2AsPeer);
 
-    const mapOnClient2 = await client2.loadCoValue(map.coValue.id);
+    const mapOnClient2 = await client2.loadCoValue(map.core.id);
 
     expect(expectMap(mapOnClient2.getCurrentContent()).get("hello")).toEqual(
         "world"
@@ -952,7 +952,7 @@ test("When a peer's incoming/readable stream closes, we remove the peer", async
     const [admin, session] = randomAnonymousAccountAndSessionID();
     const node = new LocalNode(admin, session);
 
-    const team = node.createTeam();
+    const group = node.createGroup();
 
     const [inRx, inTx] = newStreamPair<SyncMessage>();
     const [outRx, outTx] = newStreamPair<SyncMessage>();
@@ -971,27 +971,27 @@ test("When a peer's incoming/readable stream closes, we remove the peer", async
     // });
     expect((await reader.read()).value).toMatchObject({
         action: "load",
-        id: team.teamMap.coValue.id,
+        id: group.underlyingMap.core.id,
     });
 
-    const map = team.createMap();
+    const map = group.createMap();
 
     const mapSubscribeMsg = await reader.read();
 
     expect(mapSubscribeMsg.value).toEqual({
         action: "load",
-        ...map.coValue.knownState(),
+        ...map.core.knownState(),
     } satisfies SyncMessage);
 
     // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(teamContentEx(team));
+    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
 
     const mapContentMsg = await reader.read();
 
     expect(mapContentMsg.value).toEqual({
         action: "content",
-        id: map.coValue.id,
-        header: map.coValue.header,
+        id: map.core.id,
+        header: map.core.header,
         new: {},
     } satisfies SyncMessage);
 
@@ -1006,7 +1006,7 @@ test("When a peer's outgoing/writable stream closes, we remove the peer", async
     const [admin, session] = randomAnonymousAccountAndSessionID();
     const node = new LocalNode(admin, session);
 
-    const team = node.createTeam();
+    const group = node.createGroup();
 
     const [inRx, inTx] = newStreamPair<SyncMessage>();
     const [outRx, outTx] = newStreamPair<SyncMessage>();
@@ -1025,27 +1025,27 @@ test("When a peer's outgoing/writable stream closes, we remove the peer", async
     // });
     expect((await reader.read()).value).toMatchObject({
         action: "load",
-        id: team.teamMap.coValue.id,
+        id: group.underlyingMap.core.id,
     });
 
-    const map = team.createMap();
+    const map = group.createMap();
 
     const mapSubscribeMsg = await reader.read();
 
     expect(mapSubscribeMsg.value).toEqual({
         action: "load",
-        ...map.coValue.knownState(),
+        ...map.core.knownState(),
     } satisfies SyncMessage);
 
     // expect((await reader.read()).value).toMatchObject(admContEx(admin.id));
-    expect((await reader.read()).value).toMatchObject(teamContentEx(team));
+    expect((await reader.read()).value).toMatchObject(groupContentEx(group));
 
     const mapContentMsg = await reader.read();
 
     expect(mapContentMsg.value).toEqual({
         action: "content",
-        id: map.coValue.id,
-        header: map.coValue.header,
+        id: map.core.id,
+        header: map.core.header,
         new: {},
     } satisfies SyncMessage);
 
@@ -1066,9 +1066,9 @@ test("If we start loading a coValue before connecting to a peer that has it, it
 
     const node1 = new LocalNode(admin, session);
 
-    const team = node1.createTeam();
+    const group = node1.createGroup();
 
-    const map = team.createMap();
+    const map = group.createMap();
     map.edit((editable) => {
         editable.set("hello", "world", "trusting");
     });
@@ -1083,9 +1083,9 @@ test("If we start loading a coValue before connecting to a peer that has it, it
 
     node1.sync.addPeer(node2asPeer);
 
-    const mapOnNode2Promise = node2.loadCoValue(map.coValue.id);
+    const mapOnNode2Promise = node2.loadCoValue(map.core.id);
 
-    expect(node2.coValues[map.coValue.id]?.state).toEqual("loading");
+    expect(node2.coValues[map.core.id]?.state).toEqual("loading");
 
     node2.sync.addPeer(node1asPeer);
 
@@ -1096,10 +1096,10 @@ test("If we start loading a coValue before connecting to a peer that has it, it
     );
 });
 
-function teamContentEx(team: Team) {
+function groupContentEx(group: Group) {
     return {
         action: "content",
-        id: team.teamMap.coValue.id,
+        id: group.underlyingMap.core.id,
     };
 }
 
@@ -1110,10 +1110,10 @@ function admContEx(adminID: AccountID) {
     };
 }
 
-function teamStateEx(team: Team) {
+function groupStateEx(group: Group) {
     return {
         action: "known",
-        id: team.teamMap.coValue.id,
+        id: group.underlyingMap.core.id,
     };
 }
 

packages/cojson/src/sync.ts

@@ -1,6 +1,6 @@
 import { Signature } from "./crypto.js";
-import { CoValueHeader, Transaction } from "./coValue.js";
-import { CoValue } from "./coValue.js";
+import { CoValueHeader, Transaction } from "./coValueCore.js";
+import { CoValueCore } from "./coValueCore.js";
 import { LocalNode } from "./node.js";
 import { newLoadingState } from "./node.js";
 import {
@@ -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);
     }
 
@@ -368,10 +393,9 @@ export class SyncManager {
             );
         }
 
-        let resolveAfterDone: ((coValue: CoValue) => void) | undefined;
+        let resolveAfterDone: ((coValue: CoValueCore) => void) | undefined;
 
-        const peerOptimisticKnownState =
-            peer.optimisticKnownStates[msg.id];
+        const peerOptimisticKnownState = peer.optimisticKnownStates[msg.id];
 
         if (!peerOptimisticKnownState) {
             throw new Error(
@@ -386,7 +410,7 @@ export class SyncManager {
 
             peerOptimisticKnownState.header = true;
 
-            const coValue = new CoValue(msg.header, this.local);
+            const coValue = new CoValueCore(msg.header, this.local);
 
             resolveAfterDone = entry.resolve;
 
@@ -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(
@@ -475,7 +496,7 @@ export class SyncManager {
         throw new Error("Method not implemented.");
     }
 
-    async syncCoValue(coValue: CoValue) {
+    async syncCoValue(coValue: CoValueCore) {
         for (const peer of Object.values(this.peers)) {
             const optimisticKnownState = peer.optimisticKnownStates[coValue.id];
 
@@ -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/src/team.ts

@@ -1,233 +0,0 @@
-import { CoID, ContentType } from "./contentType.js";
-import { CoMap } from "./contentTypes/coMap.js";
-import { JsonObject, JsonValue } from "./jsonValue.js";
-import {
-    Encrypted,
-    KeyID,
-    KeySecret,
-    createdNowUnique,
-    newRandomKeySecret,
-    seal,
-    encryptKeySecret,
-    getAgentSealerID,
-    Sealed,
-    newRandomSecretSeed,
-    agentSecretFromSecretSeed,
-    getAgentID,
-} from "./crypto.js";
-import { LocalNode } from "./node.js";
-import { SessionID, isAgentID } from "./ids.js";
-import {
-    AccountIDOrAgentID,
-    GeneralizedControlledAccount,
-    Profile,
-} from "./account.js";
-import { Role } from "./permissions.js";
-import { base58 } from "@scure/base";
-
-export type TeamContent = {
-    profile: CoID<Profile> | null;
-    [key: AccountIDOrAgentID]: Role;
-    readKey: KeyID;
-    [revelationFor: `${KeyID}_for_${AccountIDOrAgentID}`]: Sealed<KeySecret>;
-    [oldKeyForNewKey: `${KeyID}_for_${KeyID}`]: Encrypted<
-        KeySecret,
-        { encryptedID: KeyID; encryptingID: KeyID }
-    >;
-};
-
-export function expectTeamContent(
-    content: ContentType
-): CoMap<TeamContent, JsonObject | null> {
-    if (content.type !== "comap") {
-        throw new Error("Expected map");
-    }
-
-    return content as CoMap<TeamContent, JsonObject | null>;
-}
-
-export class Team {
-    teamMap: CoMap<TeamContent, JsonObject | null>;
-    node: LocalNode;
-
-    constructor(
-        teamMap: CoMap<TeamContent, JsonObject | null>,
-        node: LocalNode
-    ) {
-        this.teamMap = teamMap;
-        this.node = node;
-    }
-
-    get id(): CoID<CoMap<TeamContent, JsonObject | null>> {
-        return this.teamMap.id;
-    }
-
-    roleOf(accountID: AccountIDOrAgentID): Role | undefined {
-        return this.teamMap.get(accountID);
-    }
-
-    myRole(): Role | undefined {
-        return this.roleOf(this.node.account.id);
-    }
-
-    addMember(accountID: AccountIDOrAgentID, role: Role) {
-        this.teamMap = this.teamMap.edit((map) => {
-            const currentReadKey = this.teamMap.coValue.getCurrentReadKey();
-
-            if (!currentReadKey.secret) {
-                throw new Error("Can't add member without read key secret");
-            }
-
-            const agent = this.node.resolveAccountAgent(
-                accountID,
-                "Expected to know agent to add them to team"
-            );
-
-            map.set(accountID, role, "trusting");
-
-            if (map.get(accountID) !== role) {
-                throw new Error("Failed to set role");
-            }
-
-            map.set(
-                `${currentReadKey.id}_for_${accountID}`,
-                seal(
-                    currentReadKey.secret,
-                    this.teamMap.coValue.node.account.currentSealerSecret(),
-                    getAgentSealerID(agent),
-                    {
-                        in: this.teamMap.coValue.id,
-                        tx: this.teamMap.coValue.nextTransactionID(),
-                    }
-                ),
-                "trusting"
-            );
-        });
-    }
-
-    createInvite(role: "reader" | "writer" | "admin"): InviteSecret {
-        const secretSeed = newRandomSecretSeed();
-
-        const inviteSecret = agentSecretFromSecretSeed(secretSeed);
-        const inviteID = getAgentID(inviteSecret);
-
-        this.addMember(inviteID, `${role}Invite` as Role);
-
-        return inviteSecretFromSecretSeed(secretSeed);
-    }
-
-    rotateReadKey() {
-        const currentlyPermittedReaders = this.teamMap.keys().filter((key) => {
-            if (key.startsWith("co_") || isAgentID(key)) {
-                const role = this.teamMap.get(key);
-                return (
-                    role === "admin" || role === "writer" || role === "reader"
-                );
-            } else {
-                return false;
-            }
-        }) as AccountIDOrAgentID[];
-
-        const maybeCurrentReadKey = this.teamMap.coValue.getCurrentReadKey();
-
-        if (!maybeCurrentReadKey.secret) {
-            throw new Error(
-                "Can't rotate read key secret we don't have access to"
-            );
-        }
-
-        const currentReadKey = {
-            id: maybeCurrentReadKey.id,
-            secret: maybeCurrentReadKey.secret,
-        };
-
-        const newReadKey = newRandomKeySecret();
-
-        this.teamMap = this.teamMap.edit((map) => {
-            for (const readerID of currentlyPermittedReaders) {
-                const reader = this.node.resolveAccountAgent(
-                    readerID,
-                    "Expected to know currently permitted reader"
-                );
-
-                map.set(
-                    `${newReadKey.id}_for_${readerID}`,
-                    seal(
-                        newReadKey.secret,
-                        this.teamMap.coValue.node.account.currentSealerSecret(),
-                        getAgentSealerID(reader),
-                        {
-                            in: this.teamMap.coValue.id,
-                            tx: this.teamMap.coValue.nextTransactionID(),
-                        }
-                    ),
-                    "trusting"
-                );
-            }
-
-            map.set(
-                `${currentReadKey.id}_for_${newReadKey.id}`,
-                encryptKeySecret({
-                    encrypting: newReadKey,
-                    toEncrypt: currentReadKey,
-                }).encrypted,
-                "trusting"
-            );
-
-            map.set("readKey", newReadKey.id, "trusting");
-        });
-    }
-
-    removeMember(accountID: AccountIDOrAgentID) {
-        this.teamMap = this.teamMap.edit((map) => {
-            map.set(accountID, "revoked", "trusting");
-        });
-
-        this.rotateReadKey();
-    }
-
-    createMap<
-        M extends { [key: string]: JsonValue },
-        Meta extends JsonObject | null = null
-    >(meta?: Meta): CoMap<M, Meta> {
-        return this.node
-            .createCoValue({
-                type: "comap",
-                ruleset: {
-                    type: "ownedByTeam",
-                    team: this.teamMap.id,
-                },
-                meta: meta || null,
-                ...createdNowUnique(),
-            })
-            .getCurrentContent() as CoMap<M, Meta>;
-    }
-
-    testWithDifferentAccount(
-        account: GeneralizedControlledAccount,
-        sessionId: SessionID
-    ): Team {
-        return new Team(
-            expectTeamContent(
-                this.teamMap.coValue
-                    .testWithDifferentAccount(account, sessionId)
-                    .getCurrentContent()
-            ),
-            this.node
-        );
-    }
-}
-
-export type InviteSecret = `inviteSecret_z${string}`;
-
-function inviteSecretFromSecretSeed(secretSeed: Uint8Array): InviteSecret {
-    return `inviteSecret_z${base58.encode(secretSeed)}`;
-}
-
-export function secretSeedFromInviteSecret(inviteSecret: InviteSecret) {
-    if (!inviteSecret.startsWith("inviteSecret_z")) {
-        throw new Error("Invalid invite secret");
-    }
-
-    return base58.decode(inviteSecret.slice("inviteSecret_z".length));
-}

packages/cojson/src/testUtils.ts

@@ -1,7 +1,7 @@
 import { AgentSecret, createdNowUnique, getAgentID, newRandomAgentSecret  } from "./crypto.js";
-import { newRandomSessionID } from "./coValue.js";
+import { newRandomSessionID } from "./coValueCore.js";
 import { LocalNode } from "./node.js";
-import { expectTeamContent } from "./team.js";
+import { expectGroupContent } from "./group.js";
 import { AnonymousControlledAccount } from "./account.js";
 import { SessionID } from "./ids.js";
 
@@ -13,69 +13,69 @@ export function randomAnonymousAccountAndSessionID(): [AnonymousControlledAccoun
     return [new AnonymousControlledAccount(agentSecret), sessionID];
 }
 
-export function newTeam() {
+export function newGroup() {
     const [admin, sessionID] = randomAnonymousAccountAndSessionID();
 
     const node = new LocalNode(admin, sessionID);
 
-    const team = node.createCoValue({
+    const group = node.createCoValue({
         type: "comap",
-        ruleset: { type: "team", initialAdmin: admin.id },
+        ruleset: { type: "group", initialAdmin: admin.id },
         meta: null,
         ...createdNowUnique(),
     });
 
-    const teamContent = expectTeamContent(team.getCurrentContent());
+    const groupContent = expectGroupContent(group.getCurrentContent());
 
-    teamContent.edit((editable) => {
+    groupContent.edit((editable) => {
         editable.set(admin.id, "admin", "trusting");
         expect(editable.get(admin.id)).toEqual("admin");
     });
 
-    return { node, team, admin };
+    return { node, group, admin };
 }
 
-export function teamWithTwoAdmins() {
-    const { team, admin, node } = newTeam();
+export function groupWithTwoAdmins() {
+    const { group, admin, node } = newGroup();
 
     const otherAdmin = node.createAccount("otherAdmin");
 
-    let content = expectTeamContent(team.getCurrentContent());
+    let content = expectGroupContent(group.getCurrentContent());
 
     content.edit((editable) => {
         editable.set(otherAdmin.id, "admin", "trusting");
         expect(editable.get(otherAdmin.id)).toEqual("admin");
     });
 
-    content = expectTeamContent(team.getCurrentContent());
+    content = expectGroupContent(group.getCurrentContent());
 
     if (content.type !== "comap") {
         throw new Error("Expected map");
     }
 
     expect(content.get(otherAdmin.id)).toEqual("admin");
-    return { team, admin, otherAdmin, node };
+    return { group, admin, otherAdmin, node };
 }
 
-export function newTeamHighLevel() {
+export function newGroupHighLevel() {
     const [admin, sessionID] = randomAnonymousAccountAndSessionID();
 
 
     const node = new LocalNode(admin, sessionID);
 
-    const team = node.createTeam();
+    const group = node.createGroup();
 
-    return { admin, node, team };
+    return { admin, node, group };
 }
 
-export function teamWithTwoAdminsHighLevel() {
-    const { admin, node, team } = newTeamHighLevel();
+export function groupWithTwoAdminsHighLevel() {
+    const { admin, node, group } = newGroupHighLevel();
 
     const otherAdmin = node.createAccount("otherAdmin");
 
-    team.addMember(otherAdmin.id, "admin");
+    group.addMember(otherAdmin.id, "admin");
 
-    return { admin, node, team, otherAdmin };
+    return { admin, node, group, otherAdmin };
 }
 
 export function shouldNotResolve<T>(

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.0.6",
+    "version": "0.1.9",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "license": "MIT",
     "dependencies": {
-        "jazz-browser": "^0.0.6",
+        "jazz-browser": "^0.1.9",
         "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.0.6",
+  "version": "0.1.9",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "cojson": "^0.0.23",
-    "jazz-storage-indexeddb": "^0.0.10",
+    "cojson": "^0.1.9",
+    "jazz-storage-indexeddb": "^0.1.9",
     "typescript": "^5.1.6"
   },
   "scripts": {

packages/jazz-browser/src/index.ts

@@ -2,12 +2,13 @@ import { InviteSecret } from "cojson";
 import {
     LocalNode,
     cojsonInternals,
-    CojsonInternalTypes,
+    AccountID,
+    AgentID,
     SessionID,
     SyncMessage,
     Peer,
     ContentType,
-    Team,
+    Group,
     CoID,
 } from "cojson";
 import { ReadableStream, WritableStream } from "isomorphic-streams";
@@ -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);
         });
     }
@@ -247,54 +286,50 @@ export function createInviteLink(
     const node = coValue.node;
     let currentCoValue = coValue;
 
-    while (currentCoValue.header.ruleset.type === "ownedByTeam") {
-        currentCoValue = node.expectCoValueLoaded(
-            currentCoValue.header.ruleset.team
-        );
+    while (currentCoValue.header.ruleset.type === "ownedByGroup") {
+        currentCoValue = currentCoValue.getGroup().groupMap.coValue;
     }
 
-    if (currentCoValue.header.ruleset.type !== "team") {
-        throw new Error("Can't create invite link for object without team");
+    if (currentCoValue.header.ruleset.type !== "group") {
+        throw new Error("Can't create invite link for object without group");
     }
 
-    const team = new Team(
-        cojsonInternals.expectTeamContent(currentCoValue.getCurrentContent()),
+    const group = new Group(
+        cojsonInternals.expectGroupContent(currentCoValue.getCurrentContent()),
         node
     );
 
-    const inviteSecret = team.createInvite(role);
+    const inviteSecret = group.createInvite(role);
 
-    return `${baseURL}#invitedTo=${value.id}&inviteSecret=${inviteSecret}`;
+    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]
-        ?.replace(/^inviteSecret=/, "") 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,19 +1,19 @@
 {
     "name": "jazz-react-auth-local",
-    "version": "0.0.13",
+    "version": "0.1.11",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "license": "MIT",
     "dependencies": {
-        "jazz-browser-auth-local": "^0.0.6",
-        "jazz-react": "^0.0.16",
+        "jazz-browser-auth-local": "^0.1.9",
+        "jazz-react": "^0.1.11",
         "typescript": "^5.1.6"
     },
     "devDependencies": {
         "@types/react": "^18.2.19"
     },
     "peerDependencies": {
-        "react": "^17.0.2"
+        "react": "17 - 18"
     },
     "scripts": {
         "lint": "eslint src/**/*.tsx",

packages/jazz-react/package.json

@@ -1,19 +1,19 @@
 {
   "name": "jazz-react",
-  "version": "0.0.16",
+  "version": "0.1.11",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "cojson": "^0.0.23",
-    "jazz-browser": "^0.0.6",
+    "cojson": "^0.1.9",
+    "jazz-browser": "^0.1.9",
     "typescript": "^5.1.6"
   },
   "devDependencies": {
     "@types/react": "^18.2.19"
   },
   "peerDependencies": {
-    "react": "^17.0.2"
+    "react": "17 - 18"
   },
   "scripts": {
     "lint": "eslint src/**/*.tsx",

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";
@@ -48,7 +49,10 @@ export function WithJazz({
         (async () => {
             const nodeHandle = await createBrowserNode({
                 auth: auth,
-                syncAddress,
+                syncAddress:
+                    syncAddress ||
+                    new URLSearchParams(window.location.search).get("sync") ||
+                    undefined,
             });
 
             setNode(nodeHandle.node);
@@ -106,7 +110,6 @@ export function useTelepathicState<T extends ContentType>(id?: CoID<T>) {
                     //     "Got update",
                     //     id,
                     //     newState.toJSON(),
-                    //     newState.coValue.sessions
                     // );
                     setState(newState as T);
                 });
@@ -124,12 +127,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.0.10",
+  "version": "0.1.9",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "cojson": "^0.0.23",
+    "cojson": "^0.1.9",
     "typescript": "^5.1.6"
   },
   "devDependencies": {

packages/jazz-storage-indexeddb/src/index.test.ts

@@ -16,7 +16,7 @@ test.skip("Should be able to initialize and load from empty DB", async () => {
 
     console.log("yay!");
 
-    const _team = node.createTeam();
+    const _group = node.createGroup();
 
     await new Promise((resolve) => setTimeout(resolve, 200));
 
@@ -39,9 +39,9 @@ test("Should be able to sync data to database and then load that from a new node
 
     console.log("yay!");
 
-    const team = node1.createTeam();
+    const group = node1.createGroup();
 
-    const map = team.createMap();
+    const map = group.createMap();
 
     map.edit((m) => {
         m.set("hello", "world");

packages/jazz-storage-indexeddb/src/index.ts

@@ -205,7 +205,7 @@ export class IDBStorage {
         }
 
         const dependedOnCoValues =
-            coValueRow?.header.ruleset.type === "team"
+            coValueRow?.header.ruleset.type === "group"
                 ? Object.values(newContent.new).flatMap((sessionEntry) =>
                       sessionEntry.newTransactions.flatMap((tx) => {
                           if (tx.privacy !== "trusting") return [];
@@ -226,8 +226,8 @@ export class IDBStorage {
                               );
                       })
                   )
-                : coValueRow?.header.ruleset.type === "ownedByTeam"
-                ? [coValueRow?.header.ruleset.team]
+                : coValueRow?.header.ruleset.type === "ownedByGroup"
+                ? [coValueRow?.header.ruleset.group]
                 : [];
 
         for (const dependedOnCoValue of dependedOnCoValues) {

yarn.lock

@@ -319,6 +319,13 @@
   resolved "https://registry.yarnpkg.com/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz#75a2e8b51cb758a7553d6804a5932d7aace75c39"
   integrity sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==
 
+"@cspotcode/source-map-support@^0.8.0":
+  version "0.8.1"
+  resolved "https://registry.yarnpkg.com/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz#00629c35a688e05a88b1cda684fb9d5e73f000a1"
+  integrity sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==
+  dependencies:
+    "@jridgewell/trace-mapping" "0.3.9"
+
 "@esbuild/android-arm64@0.18.20":
   version "0.18.20"
   resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.18.20.tgz#984b4f9c8d0377443cc2dfcef266d02244593622"
@@ -719,7 +726,7 @@
     "@jridgewell/sourcemap-codec" "^1.4.10"
     "@jridgewell/trace-mapping" "^0.3.9"
 
-"@jridgewell/resolve-uri@^3.1.0":
+"@jridgewell/resolve-uri@^3.0.3", "@jridgewell/resolve-uri@^3.1.0":
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz#c08679063f279615a3326583ba3a90d1d82cc721"
   integrity sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==
@@ -734,6 +741,14 @@
   resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz#d7c6e6755c78567a951e04ab52ef0fd26de59f32"
   integrity sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==
 
+"@jridgewell/trace-mapping@0.3.9":
+  version "0.3.9"
+  resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz#6534fd5933a53ba7cbf3a17615e273a0d1273ff9"
+  integrity sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==
+  dependencies:
+    "@jridgewell/resolve-uri" "^3.0.3"
+    "@jridgewell/sourcemap-codec" "^1.4.10"
+
 "@jridgewell/trace-mapping@^0.3.12", "@jridgewell/trace-mapping@^0.3.17", "@jridgewell/trace-mapping@^0.3.18", "@jridgewell/trace-mapping@^0.3.9":
   version "0.3.19"
   resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.19.tgz#f8a3249862f91be48d3127c3cfe992f79b4b8811"
@@ -1467,6 +1482,26 @@
   resolved "https://registry.yarnpkg.com/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz#db4ecfd499a9765ab24002c3b696d02e6d32a12c"
   integrity sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==
 
+"@tsconfig/node10@^1.0.7":
+  version "1.0.9"
+  resolved "https://registry.yarnpkg.com/@tsconfig/node10/-/node10-1.0.9.tgz#df4907fc07a886922637b15e02d4cebc4c0021b2"
+  integrity sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==
+
+"@tsconfig/node12@^1.0.7":
+  version "1.0.11"
+  resolved "https://registry.yarnpkg.com/@tsconfig/node12/-/node12-1.0.11.tgz#ee3def1f27d9ed66dac6e46a295cffb0152e058d"
+  integrity sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==
+
+"@tsconfig/node14@^1.0.0":
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/@tsconfig/node14/-/node14-1.0.3.tgz#e4386316284f00b98435bf40f72f75a09dabf6c1"
+  integrity sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==
+
+"@tsconfig/node16@^1.0.2":
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.4.tgz#0b92dcc0cc1c81f6f306a381f28e31b1a56536e9"
+  integrity sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==
+
 "@tufjs/canonical-json@1.0.0":
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/@tufjs/canonical-json/-/canonical-json-1.0.0.tgz#eade9fd1f537993bc1f0949f3aea276ecc4fab31"
@@ -1513,6 +1548,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 +1646,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 +1689,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==
@@ -1911,12 +1960,12 @@ acorn-jsx@^5.3.2:
   resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937"
   integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==
 
-acorn-walk@^8.2.0:
+acorn-walk@^8.1.1, acorn-walk@^8.2.0:
   version "8.2.0"
   resolved "https://registry.yarnpkg.com/acorn-walk/-/acorn-walk-8.2.0.tgz#741210f2e2426454508853a2f44d0ab83b7f69c1"
   integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==
 
-acorn@^8.10.0, acorn@^8.9.0:
+acorn@^8.10.0, acorn@^8.4.1, acorn@^8.9.0:
   version "8.10.0"
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-8.10.0.tgz#8be5b3907a67221a81ab23c7889c4c5526b62ec5"
   integrity sha512-F0SAmZ8iUtS//m8DmCTA0jlh6TDKkHQyK6xc6V4KDTyZKA9dnvX9/3sRTVQrWm79glUAZbnmmNcdYwUIHWVybw==
@@ -1987,6 +2036,11 @@ ansi-regex@^6.0.1:
   resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-6.0.1.tgz#3183e38fae9a65d7cb5e53945cd5897d0260a06a"
   integrity sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==
 
+ansi-sequence-parser@^1.1.0:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/ansi-sequence-parser/-/ansi-sequence-parser-1.1.1.tgz#e0aa1cdcbc8f8bb0b5bca625aac41f5f056973cf"
+  integrity sha512-vJXt3yiaUL4UU546s3rPXlsry/RnM730G1+HkpKE012AN0sx1eOrxSu95oKDIonskeLTijMgqWZ3uDEe3NFvyg==
+
 ansi-styles@^3.2.1:
   version "3.2.1"
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
@@ -2066,6 +2120,11 @@ are-we-there-yet@^3.0.0:
     delegates "^1.0.0"
     readable-stream "^3.6.0"
 
+arg@^4.1.0:
+  version "4.1.3"
+  resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089"
+  integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==
+
 arg@^5.0.2:
   version "5.0.2"
   resolved "https://registry.yarnpkg.com/arg/-/arg-5.0.2.tgz#c81433cc427c92c4dcf4865142dbca6f15acd59c"
@@ -2243,6 +2302,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 +2328,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 +2507,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 +2602,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 +2673,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"
@@ -2849,6 +2937,11 @@ crc32-stream@^4.0.2:
     crc-32 "^1.2.0"
     readable-stream "^3.4.0"
 
+create-require@^1.1.0:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/create-require/-/create-require-1.1.1.tgz#c1d7e8f1e5f6cfc9ff65f9cd352d37348756c333"
+  integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==
+
 cross-fetch@4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/cross-fetch/-/cross-fetch-4.0.0.tgz#f037aef1580bb3a1a35164ea2a848ba81b445983"
@@ -2927,7 +3020,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 +3054,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 +3125,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 +3155,16 @@ diff-sequences@^29.4.3:
   resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-29.4.3.tgz#9314bc1fabe09267ffeca9cbafc457d8499a13f2"
   integrity sha512-ofrBgwpPhCD85kMKtE9RYFFq6OC1A89oW2vvgWZNCwxrUpRUILopY7lsYyMDSjc8g6U6aiO0Qubg6r4Wgt5ZnA==
 
+diff@^4.0.1:
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
+  integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
+
+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 +3261,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 +3661,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 +3797,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 +3999,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 +4108,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 +4492,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==
@@ -5421,10 +5554,15 @@ lru-cache@^7.14.1, lru-cache@^7.4.4, lru-cache@^7.5.1, lru-cache@^7.7.1:
   resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-10.0.1.tgz#0a3be479df549cca0e5d693ac402ff19537a6b7a"
   integrity sha512-IJ4uwUTi2qCccrioU6g9g/5rvvVl13bsdczUUcqbciD9iLr095yj8DQKdObriEvuNSx325N1rV1O0sJFszx75g==
 
-lucide-react@^0.265.0:
-  version "0.265.0"
-  resolved "https://registry.yarnpkg.com/lucide-react/-/lucide-react-0.265.0.tgz#251558b65aa24d069171b4e2b4846af37f5cc105"
-  integrity sha512-znyvziBEUQ7CKR31GiU4viomQbJrpDLG5ac+FajwiZIavC3YbPFLkzQx3dCXT4JWJx/pB34EwmtiZ0ElGZX0PA==
+lucide-react@^0.274.0:
+  version "0.274.0"
+  resolved "https://registry.yarnpkg.com/lucide-react/-/lucide-react-0.274.0.tgz#d3b54dcb972b12f1292061448d61d422ef2e269d"
+  integrity sha512-qiWcojRXEwDiSimMX1+arnxha+ROJzZjJaVvCC0rsG6a9pUPjZePXSq7em4ZKMp0NDm1hyzPNkM7UaWC3LU2AA==
+
+lunr@^2.3.9:
+  version "2.3.9"
+  resolved "https://registry.yarnpkg.com/lunr/-/lunr-2.3.9.tgz#18b123142832337dd6e964df1a5a7707b25d35e1"
+  integrity sha512-zTU3DaZaF3Rt9rhN3uBMGQD3dD2/vFQqnvZCDv4dl5iOzq2IZQqTxu90r4E5J+nP70J3ilqVCrbho2eWaeW8Ow==
 
 magic-string@^0.30.1:
   version "0.30.2"
@@ -5455,7 +5593,7 @@ make-dir@^4.0.0:
   dependencies:
     semver "^7.5.3"
 
-make-error@1.x:
+make-error@1.x, make-error@^1.1.1:
   version "1.3.6"
   resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2"
   integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==
@@ -5498,6 +5636,11 @@ map-obj@^4.0.0:
   resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-4.3.0.tgz#9304f906e93faae70880da102a9f1df0ea8bb05a"
   integrity sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==
 
+marked@^4.3.0:
+  version "4.3.0"
+  resolved "https://registry.yarnpkg.com/marked/-/marked-4.3.0.tgz#796362821b019f734054582038b116481b456cf3"
+  integrity sha512-PRsaiG84bK+AMvxziE/lCFss8juXjNaWzVbN5tXAm4XjeaS9NAHhop+PjQxz2A9h8Q4M/xGmzP8vqNwy6JeK0A==
+
 marky@^1.2.2:
   version "1.2.5"
   resolved "https://registry.yarnpkg.com/marky/-/marky-1.2.5.tgz#55796b688cbd72390d2d399eaaf1832c9413e3c0"
@@ -5598,7 +5741,7 @@ minimatch@^8.0.2:
   dependencies:
     brace-expansion "^2.0.1"
 
-minimatch@^9.0.0, minimatch@^9.0.1:
+minimatch@^9.0.0, minimatch@^9.0.1, minimatch@^9.0.3:
   version "9.0.3"
   resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-9.0.3.tgz#a6e00c3de44c3a542bfaae70abfc22420a6da825"
   integrity sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==
@@ -5614,7 +5757,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 +5844,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 +5941,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 +5974,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 +6676,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 +6734,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 +6863,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 +6898,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 +7074,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 +7204,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"
@@ -7083,6 +7286,16 @@ shebang-regex@^3.0.0:
   resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172"
   integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==
 
+shiki@^0.14.1:
+  version "0.14.4"
+  resolved "https://registry.yarnpkg.com/shiki/-/shiki-0.14.4.tgz#2454969b466a5f75067d0f2fa0d7426d32881b20"
+  integrity sha512-IXCRip2IQzKwxArNNq1S+On4KPML3Yyn8Zzs/xRgcgOWIr8ntIK3IKzjFPfjy/7kt9ZMjc+FItfqHRBg8b6tNQ==
+  dependencies:
+    ansi-sequence-parser "^1.1.0"
+    jsonc-parser "^3.2.0"
+    vscode-oniguruma "^1.7.0"
+    vscode-textmate "^8.0.0"
+
 siginfo@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/siginfo/-/siginfo-2.0.0.tgz#32e76c70b79724e3bb567cb9d543eb858ccfaf30"
@@ -7109,6 +7322,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 +7576,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"
@@ -7409,10 +7641,10 @@ tailwind-merge@^1.14.0:
   resolved "https://registry.yarnpkg.com/tailwind-merge/-/tailwind-merge-1.14.0.tgz#e677f55d864edc6794562c63f5001f45093cdb8b"
   integrity sha512-3mFKyCo/MBcgyOTlrY8T7odzZFx+w+qKSMAmdFzRvqBfLlSigU6TZnlFHK0lkMwj9Bj8OYU+9yW9lmGuS0QEnQ==
 
-tailwindcss-animate@^1.0.6:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/tailwindcss-animate/-/tailwindcss-animate-1.0.6.tgz#c7195037481552cc47962ea50113830360fd0c28"
-  integrity sha512-4WigSGMvbl3gCCact62ZvOngA+PRqhAn7si3TQ3/ZuPuQZcIEtVap+ENSXbzWhpojKB8CpvnIsrwBu8/RnHtuw==
+tailwindcss-animate@^1.0.7:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/tailwindcss-animate/-/tailwindcss-animate-1.0.7.tgz#318b692c4c42676cc9e67b19b78775742388bef4"
+  integrity sha512-bl6mpH3T7I3UFxuvDEXLxy/VuFxBk5bbzplh7tXI68mwMokNYd1t9qPBHlnyTwfa4JGC4zP516I1hYYtQ/vspA==
 
 tailwindcss@^3.3.3:
   version "3.3.3"
@@ -7451,7 +7683,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==
@@ -7636,6 +7878,25 @@ ts-jest@^29.1.1:
     semver "^7.5.3"
     yargs-parser "^21.0.1"
 
+ts-node@^10.9.1:
+  version "10.9.1"
+  resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-10.9.1.tgz#e73de9102958af9e1f0b168a6ff320e25adcff4b"
+  integrity sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==
+  dependencies:
+    "@cspotcode/source-map-support" "^0.8.0"
+    "@tsconfig/node10" "^1.0.7"
+    "@tsconfig/node12" "^1.0.7"
+    "@tsconfig/node14" "^1.0.0"
+    "@tsconfig/node16" "^1.0.2"
+    acorn "^8.4.1"
+    acorn-walk "^8.1.1"
+    arg "^4.1.0"
+    create-require "^1.1.0"
+    diff "^4.0.1"
+    make-error "^1.1.1"
+    v8-compile-cache-lib "^3.0.1"
+    yn "3.1.1"
+
 tsconfig-paths@^4.1.2:
   version "4.2.0"
   resolved "https://registry.yarnpkg.com/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz#ef78e19039133446d244beac0fd6a1632e2d107c"
@@ -7659,6 +7920,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"
@@ -7716,6 +7984,16 @@ typedarray@^0.0.6:
   resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
   integrity sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==
 
+typedoc@^0.25.1:
+  version "0.25.1"
+  resolved "https://registry.yarnpkg.com/typedoc/-/typedoc-0.25.1.tgz#50de2d8fb93623fbfb59e2fa6407ff40e3d3f438"
+  integrity sha512-c2ye3YUtGIadxN2O6YwPEXgrZcvhlZ6HlhWZ8jQRNzwLPn2ylhdGqdR8HbyDRyALP8J6lmSANILCkkIdNPFxqA==
+  dependencies:
+    lunr "^2.3.9"
+    marked "^4.3.0"
+    minimatch "^9.0.3"
+    shiki "^0.14.1"
+
 typescript@5.0.2:
   version "5.0.2"
   resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.0.2.tgz#891e1a90c5189d8506af64b9ef929fca99ba1ee5"
@@ -7744,6 +8022,11 @@ unbzip2-stream@1.4.3:
     buffer "^5.2.1"
     through "^2.3.8"
 
+uniqolor@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/uniqolor/-/uniqolor-1.1.0.tgz#7519f81133cd54a1f4a59c33c81dbe04a3ad155d"
+  integrity sha512-j2XyokF24fsj+L5u6fbu4rM3RQc6VWJuAngYM2k0ZdG3yiVxt0smLkps2GmQIYqK8VkELGdM9vFU/HfOkK/zoQ==
+
 unique-filename@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/unique-filename/-/unique-filename-3.0.0.tgz#48ba7a5a16849f5080d26c760c86cf5cf05770ea"
@@ -7819,6 +8102,11 @@ uuid@^9.0.0:
   resolved "https://registry.yarnpkg.com/uuid/-/uuid-9.0.0.tgz#592f550650024a38ceb0c562f2f6aa435761efb5"
   integrity sha512-MXcSTerfPa4uqyzStbRoTgt5XIe3x5+42+q1sDuy3R5MDk66URdLMOZe5aPX/SQd+kuYAh0FdP/pO28IkQyTeg==
 
+v8-compile-cache-lib@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz#6336e8d71965cb3d35a1bbb7868445a7c05264bf"
+  integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==
+
 v8-compile-cache@2.3.0:
   version "2.3.0"
   resolved "https://registry.yarnpkg.com/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz#2de19618c66dc247dcfb6f99338035d8245a2cee"
@@ -7908,6 +8196,16 @@ vitest@^0.34.1:
     vite-node "0.34.1"
     why-is-node-running "^2.2.2"
 
+vscode-oniguruma@^1.7.0:
+  version "1.7.0"
+  resolved "https://registry.yarnpkg.com/vscode-oniguruma/-/vscode-oniguruma-1.7.0.tgz#439bfad8fe71abd7798338d1cd3dc53a8beea94b"
+  integrity sha512-L9WMGRfrjOhgHSdOYgCt/yRMsXzLDJSL7BPrOZt73gU0iWO4mpqzqQzOz5srxqTvMBaR0XZTSrVWo4j55Rc6cA==
+
+vscode-textmate@^8.0.0:
+  version "8.0.0"
+  resolved "https://registry.yarnpkg.com/vscode-textmate/-/vscode-textmate-8.0.0.tgz#2c7a3b1163ef0441097e0b5d6389cd5504b59e5d"
+  integrity sha512-AFbieoL7a5LMqcnOF04ji+rpXadgOXnZsxQr//r83kLPr7biP7am3g9zbaZIaBGwBRWeSvoMD4mgPdX3e4NWBg==
+
 wait-port@^1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/wait-port/-/wait-port-1.0.4.tgz#6f9474645ddbf7701ac100ab6762438edf6e5689"
@@ -7996,6 +8294,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"
@@ -8040,7 +8343,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==
@@ -8109,7 +8412,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==
@@ -8119,6 +8422,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"
@@ -8149,6 +8457,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"
@@ -8180,6 +8496,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"
@@ -8201,6 +8534,11 @@ yauzl@^2.10.0:
     buffer-crc32 "~0.2.3"
     fd-slicer "~1.1.0"
 
+yn@3.1.1:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"
+  integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==
+
 yocto-queue@^0.1.0:
   version "0.1.0"
   resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"