@automerge/automerge-repo 0.2.0 → 1.0.0-alpha.0

package/dist/types.d.ts

@@ -1,6 +1,12 @@
 export type DocumentId = string & {
     __documentId: true;
 };
+export type AutomergeUrl = string & {
+    __documentUrl: true;
+};
+export type BinaryDocumentId = Uint8Array & {
+    __binaryDocumentId: true;
+};
 export type PeerId = string & {
     __peerId: false;
 };

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG;IAAE,YAAY,EAAE,IAAI,CAAA;CAAE,CAAA;AACxD,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG;IAAE,QAAQ,EAAE,KAAK,CAAA;CAAE,CAAA;AACjD,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG;IAAE,WAAW,EAAE,KAAK,CAAA;CAAE,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG;IAAE,YAAY,EAAE,IAAI,CAAA;CAAE,CAAA;AACxD,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IAAE,aAAa,EAAE,IAAI,CAAA;CAAE,CAAA;AAC3D,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG;IAAE,kBAAkB,EAAE,IAAI,CAAA;CAAE,CAAA;AAExE,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG;IAAE,QAAQ,EAAE,KAAK,CAAA;CAAE,CAAA;AACjD,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG;IAAE,WAAW,EAAE,KAAK,CAAA;CAAE,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automerge/automerge-repo",
-  "version": "0.2.0",
+  "version": "1.0.0-alpha.0",
   "description": "A repository object to manage a collection of automerge documents",
   "repository": "https://github.com/automerge/automerge-repo",
   "author": "Peter van Hardenberg <pvh@pvh.ca>",
@@ -22,19 +22,22 @@
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",
+    "@types/node": "^20.4.8",
     "@types/uuid": "^8.3.4",
     "@types/ws": "^8.5.3",
     "@typescript-eslint/eslint-plugin": "^5.33.0",
     "@typescript-eslint/parser": "^5.33.0",
-    "http-server": "^14.1.0"
+    "http-server": "^14.1.0",
+    "typescript": "^5.1.6"
   },
   "peerDependencies": {
-    "@automerge/automerge": "^2.1.0-alpha.8"
+    "@automerge/automerge": "^2.1.0-alpha.9"
   },
   "dependencies": {
+    "bs58check": "^3.0.1",
     "cbor-x": "^1.3.0",
     "debug": "^4.3.4",
-    "eventemitter3": "^4.0.7",
+    "eventemitter3": "^5.0.1",
     "fast-sha256": "^1.3.0",
     "tiny-typed-emitter": "^2.1.0",
     "ts-node": "^10.9.1",
@@ -62,5 +65,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "b17ea68dce605c06e57e4fcd6e6295ef968a8b6d"
+  "gitHead": "38c0c32796ddca5f86a2e55ab0f1202a2ce107c8"
 }

package/src/DocCollection.ts

@@ -1,8 +1,14 @@
 import EventEmitter from "eventemitter3"
-import { v4 as uuid } from "uuid"
 import { DocHandle } from "./DocHandle.js"
-import { type DocumentId } from "./types.js"
+import { DocumentId, type BinaryDocumentId, AutomergeUrl } from "./types.js"
 import { type SharePolicy } from "./Repo.js"
+import {
+  documentIdToBinary,
+  binaryToDocumentId,
+  generateAutomergeUrl,
+  isValidAutomergeUrl,
+  parseAutomergeUrl,
+} from "./DocUrl.js"
 
 /**
  * A DocCollection is a collection of DocHandles. It supports creating new documents and finding
@@ -30,6 +36,7 @@ export class DocCollection extends EventEmitter<DocCollectionEvents> {
     if (this.#handleCache[documentId]) return this.#handleCache[documentId]
 
     // If not, create a new handle, cache it, and return it
+    if (!documentId) throw new Error(`Invalid documentId ${documentId}`)
     const handle = new DocHandle<T>(documentId, { isNew })
     this.#handleCache[documentId] = handle
     return handle
@@ -64,8 +71,9 @@ export class DocCollection extends EventEmitter<DocCollectionEvents> {
     // or
     // - pass a "reify" function that takes a `<any>` and returns `<T>`
 
-    const documentId = uuid() as DocumentId
-    const handle = this.#getHandle<T>(documentId, true) as DocHandle<T>
+    // Generate a new UUID and store it in the buffer
+    const { encodedDocumentId } = parseAutomergeUrl(generateAutomergeUrl())
+    const handle = this.#getHandle<T>(encodedDocumentId, true) as DocHandle<T>
     this.emit("document", { handle })
     return handle
   }
@@ -76,35 +84,37 @@ export class DocCollection extends EventEmitter<DocCollectionEvents> {
    */
   find<T>(
     /** The documentId of the handle to retrieve */
-    documentId: DocumentId
+    automergeUrl: AutomergeUrl
   ): DocHandle<T> {
-    // TODO: we want a way to make sure we don't yield intermediate document states during initial synchronization
+    if (!isValidAutomergeUrl(automergeUrl)) {
+      throw new Error(`Invalid AutomergeUrl: '${automergeUrl}'`)
+    }
 
-    // If we already have a handle, return it
-    if (this.#handleCache[documentId])
-      return this.#handleCache[documentId] as DocHandle<T>
-
-    // Otherwise, create a new handle
-    const handle = this.#getHandle<T>(documentId, false) as DocHandle<T>
-
-    // we don't directly initialize a value here because the StorageSubsystem and Synchronizers go
-    // and get the data asynchronously and block on read instead of on create
+    const { encodedDocumentId } = parseAutomergeUrl(automergeUrl)
+    // If we have the handle cached, return it
+    if (this.#handleCache[encodedDocumentId])
+      return this.#handleCache[encodedDocumentId]
 
-    // emit a document event to advertise interest in this document
+    const handle = this.#getHandle<T>(encodedDocumentId, false) as DocHandle<T>
     this.emit("document", { handle })
-
     return handle
   }
 
   delete(
     /** The documentId of the handle to delete */
-    documentId: DocumentId
+    id: DocumentId | AutomergeUrl
   ) {
-    const handle = this.#getHandle(documentId, false)
+    if (isValidAutomergeUrl(id)) {
+      ;({ encodedDocumentId: id } = parseAutomergeUrl(id))
+    }
+
+    const handle = this.#getHandle(id, false)
     handle.delete()
 
-    delete this.#handleCache[documentId]
-    this.emit("delete-document", { documentId })
+    delete this.#handleCache[id]
+    this.emit("delete-document", {
+      encodedDocumentId: id,
+    })
   }
 }
 
@@ -119,5 +129,5 @@ interface DocumentPayload {
 }
 
 interface DeleteDocumentPayload {
-  documentId: DocumentId
+  encodedDocumentId: DocumentId
 }

package/src/DocHandle.ts

@@ -17,7 +17,14 @@ import { waitFor } from "xstate/lib/waitFor.js"
 import { headsAreSame } from "./helpers/headsAreSame.js"
 import { pause } from "./helpers/pause.js"
 import { TimeoutError, withTimeout } from "./helpers/withTimeout.js"
-import type { ChannelId, DocumentId, PeerId } from "./types.js"
+import type {
+  BinaryDocumentId,
+  ChannelId,
+  DocumentId,
+  PeerId,
+  AutomergeUrl,
+} from "./types.js"
+import { binaryToDocumentId, stringifyAutomergeUrl } from "./DocUrl.js"
 
 /** DocHandle is a wrapper around a single Automerge document that lets us listen for changes. */
 export class DocHandle<T> //
@@ -28,30 +35,32 @@ export class DocHandle<T> //
   #machine: DocHandleXstateMachine<T>
   #timeoutDelay: number
 
+  get url(): AutomergeUrl {
+    return stringifyAutomergeUrl({ documentId: this.documentId })
+  }
+
   constructor(
     public documentId: DocumentId,
-    { isNew = false, timeoutDelay = 700000 }: DocHandleOptions = {}
+    { isNew = false, timeoutDelay = 60_000 }: DocHandleOptions = {}
   ) {
     super()
     this.#timeoutDelay = timeoutDelay
-    this.#log = debug(`automerge-repo:dochandle:${documentId.slice(0, 5)}`)
+    this.#log = debug(`automerge-repo:dochandle:${this.documentId.slice(0, 5)}`)
 
     // initial doc
-    const doc = A.init<T>({
-      patchCallback: (patches, patchInfo) =>
-        this.emit("patch", { handle: this, patches, patchInfo }),
-    })
+    const doc = A.init<T>()
 
     /**
      * Internally we use a state machine to orchestrate document loading and/or syncing, in order to
      * avoid requesting data we already have, or surfacing intermediate values to the consumer.
      *
-     *                      ┌─────────┐           ┌────────────┐
-     *  ┌───────┐  ┌──FIND──┤ loading ├─REQUEST──►│ requesting ├─UPDATE──┐
+     *                          ┌─────────────────────┬─────────TIMEOUT────►┌────────┐
+     *                      ┌───┴─────┐           ┌───┴────────┐            │ failed │
+     *  ┌───────┐  ┌──FIND──┤ loading ├─REQUEST──►│ requesting ├─UPDATE──┐  └────────┘
      *  │ idle  ├──┤        └───┬─────┘           └────────────┘         │
-     *  └───────┘  │            │                                        └─►┌─────────┐
-     *             │            └───────LOAD───────────────────────────────►│  ready  │
-     *             └──CREATE───────────────────────────────────────────────►└─────────┘
+     *  └───────┘  │            │                                        └─►┌────────┐
+     *             │            └───────LOAD───────────────────────────────►│ ready  │
+     *             └──CREATE───────────────────────────────────────────────►└────────┘
      */
     this.#machine = interpret(
       createMachine<DocHandleContext<T>, DocHandleEvent<T>>(
@@ -60,7 +69,7 @@ export class DocHandle<T> //
 
           id: "docHandle",
           initial: IDLE,
-          context: { documentId, doc },
+          context: { documentId: this.documentId, doc },
           states: {
             idle: {
               on: {
@@ -80,6 +89,12 @@ export class DocHandle<T> //
                 REQUEST: { target: REQUESTING },
                 DELETE: { actions: "onDelete", target: DELETED },
               },
+              after: [
+                {
+                  delay: this.#timeoutDelay,
+                  target: FAILED,
+                },
+              ],
             },
             requesting: {
               on: {
@@ -89,6 +104,12 @@ export class DocHandle<T> //
                 REQUEST_COMPLETE: { target: READY },
                 DELETE: { actions: "onDelete", target: DELETED },
               },
+              after: [
+                {
+                  delay: this.#timeoutDelay,
+                  target: FAILED,
+                },
+              ],
             },
             ready: {
               on: {
@@ -97,8 +118,12 @@ export class DocHandle<T> //
                 DELETE: { actions: "onDelete", target: DELETED },
               },
             },
-            error: {},
-            deleted: {},
+            failed: {
+              type: "final",
+            },
+            deleted: {
+              type: "final",
+            },
           },
         },
 
@@ -133,33 +158,36 @@ export class DocHandle<T> //
         const oldDoc = history?.context?.doc
         const newDoc = context.doc
 
+        this.#log(`${event} → ${state}`, newDoc)
+
         const docChanged = newDoc && oldDoc && !headsAreSame(newDoc, oldDoc)
         if (docChanged) {
-          this.emit("change", { handle: this, doc: newDoc })
+          this.emit("heads-changed", { handle: this, doc: newDoc })
+
+          const patches = A.diff(newDoc, A.getHeads(oldDoc), A.getHeads(newDoc))
+          if (patches.length > 0) {
+            const source = "change" // TODO: pass along the source (load/change/network)
+            this.emit("change", {
+              handle: this,
+              doc: newDoc,
+              patches,
+              patchInfo: { before: oldDoc, after: newDoc, source },
+            })
+          }
+
           if (!this.isReady()) {
             this.#machine.send(REQUEST_COMPLETE)
           }
         }
-        this.#log(`${event} → ${state}`, this.#doc)
       })
       .start()
 
     this.#machine.send(isNew ? CREATE : FIND)
   }
 
-  get doc() {
-    if (!this.isReady()) {
-      throw new Error(
-        `DocHandle#${this.documentId} is not ready. Check \`handle.isReady()\` before accessing the document.`
-      )
-    }
-
-    return this.#doc
-  }
-
   // PRIVATE
 
-  /** Returns the current document */
+  /** Returns the current document, regardless of state */
   get #doc() {
     return this.#machine?.getSnapshot().context.doc
   }
@@ -175,7 +203,7 @@ export class DocHandle<T> //
     return Promise.any(
       awaitStates.map(state =>
         waitFor(this.#machine, s => s.matches(state), {
-          timeout: this.#timeoutDelay, // match the delay above
+          timeout: this.#timeoutDelay * 2000, // longer than the delay above for testing
         })
       )
     )
@@ -183,19 +211,48 @@ export class DocHandle<T> //
 
   // PUBLIC
 
-  isReady = () => this.#state === READY
-  isReadyOrRequesting = () =>
-    this.#state === READY || this.#state === REQUESTING
-  isDeleted = () => this.#state === DELETED
+  /**
+   * Checks if the document is ready for accessing or changes.
+   * Note that for documents already stored locally this occurs before synchronization
+   * with any peers. We do not currently have an equivalent `whenSynced()`.
+   */
+  isReady = () => this.inState([HandleState.READY])
+  /**
+   * Checks if this document has been marked as deleted.
+   * Deleted documents are removed from local storage and the sync process.
+   * It's not currently possible at runtime to undelete a document.
+   * @returns true if the document has been marked as deleted
+   */
+  isDeleted = () => this.inState([HandleState.DELETED])
+  inState = (states: HandleState[]) =>
+    states.some(this.#machine?.getSnapshot().matches)
+
+  get state() {
+    return this.#machine?.getSnapshot().value
+  }
+
+  /**
+   * Use this to block until the document handle has finished loading.
+   * The async equivalent to checking `inState()`.
+   * @param awaitStates = [READY]
+   * @returns
+   */
+  async whenReady(awaitStates: HandleState[] = [READY]): Promise<void> {
+    await withTimeout(this.#statePromise(awaitStates), this.#timeoutDelay)
+  }
 
   /**
-   * Returns the current document, waiting for the handle to be ready if necessary.
+   * Returns the current state of the Automerge document this handle manages.
+   * Note that this waits for the handle to be ready if necessary, and currently, if
+   * loading (or synchronization) fails, will never resolve.
+   *
+   * @param {awaitStates=[READY]} optional states to wait for, such as "LOADING". mostly for internal use.
    */
-  async value(awaitStates: HandleState[] = [READY]) {
+  async doc(awaitStates: HandleState[] = [READY]): Promise<A.Doc<T>> {
     await pause() // yield one tick because reasons
     try {
       // wait for the document to enter one of the desired states
-      await withTimeout(this.#statePromise(awaitStates), this.#timeoutDelay)
+      await this.#statePromise(awaitStates)
     } catch (error) {
       if (error instanceof TimeoutError)
         throw new Error(`DocHandle: timed out loading ${this.documentId}`)
@@ -205,20 +262,36 @@ export class DocHandle<T> //
     return this.#doc
   }
 
-  async loadAttemptedValue() {
-    return this.value([READY, REQUESTING])
+  /**
+   * Returns the current state of the Automerge document this handle manages, or undefined.
+   * Useful in a synchronous context. Consider using `await handle.doc()` instead, check `isReady()`,
+   * or use `whenReady()` if you want to make sure loading is complete first.
+   *
+   * Do not confuse this with the SyncState of the document, which describes the state of the synchronization process.
+   *
+   * Note that `undefined` is not a valid Automerge document so the return from this function is unambigous.
+   * @returns the current document, or undefined if the document is not ready
+   */
+  docSync(): A.Doc<T> | undefined {
+    if (!this.isReady()) {
+      return undefined
+    }
+
+    return this.#doc
   }
 
   /** `load` is called by the repo when the document is found in storage */
   load(binary: Uint8Array) {
-    if (binary.length) {
+    if (binary.length && binary.length > 0) {
       this.#machine.send(LOAD, { payload: { binary } })
     }
   }
 
   /** `update` is called by the repo when we receive changes from the network */
   update(callback: (doc: A.Doc<T>) => A.Doc<T>) {
-    this.#machine.send(UPDATE, { payload: { callback } })
+    this.#machine.send(UPDATE, {
+      payload: { callback },
+    })
   }
 
   /** `change` is called by the repo when the document is changed locally  */
@@ -250,7 +323,7 @@ export class DocHandle<T> //
     this.#machine.send(UPDATE, {
       payload: {
         callback: (doc: A.Doc<T>) => {
-          return A.changeAt(doc, heads, options, callback)
+          return A.changeAt(doc, heads, options, callback).newDoc
         },
       },
     })
@@ -280,7 +353,7 @@ export interface DocHandleMessagePayload {
   data: Uint8Array
 }
 
-export interface DocHandleChangePayload<T> {
+export interface DocHandleEncodedChangePayload<T> {
   handle: DocHandle<T>
   doc: A.Doc<T>
 }
@@ -289,15 +362,16 @@ export interface DocHandleDeletePayload<T> {
   handle: DocHandle<T>
 }
 
-export interface DocHandlePatchPayload<T> {
+export interface DocHandleChangePayload<T> {
   handle: DocHandle<T>
+  doc: A.Doc<T>
   patches: A.Patch[]
   patchInfo: A.PatchInfo<T>
 }
 
 export interface DocHandleEvents<T> {
+  "heads-changed": (payload: DocHandleEncodedChangePayload<T>) => void
   change: (payload: DocHandleChangePayload<T>) => void
-  patch: (payload: DocHandlePatchPayload<T>) => void
   delete: (payload: DocHandleDeletePayload<T>) => void
 }
 
@@ -310,7 +384,7 @@ export const HandleState = {
   LOADING: "loading",
   REQUESTING: "requesting",
   READY: "ready",
-  ERROR: "error",
+  FAILED: "failed",
   DELETED: "deleted",
 } as const
 export type HandleState = (typeof HandleState)[keyof typeof HandleState]
@@ -325,7 +399,7 @@ type DocHandleMachineState = {
 // context
 
 interface DocHandleContext<T> {
-  documentId: string
+  documentId: DocumentId
   doc: A.Doc<T>
 }
 
@@ -383,7 +457,7 @@ type DocHandleXstateMachine<T> = Interpreter<
 
 // CONSTANTS
 
-const { IDLE, LOADING, REQUESTING, READY, ERROR, DELETED } = HandleState
+export const { IDLE, LOADING, REQUESTING, READY, FAILED, DELETED } = HandleState
 const {
   CREATE,
   LOAD,

package/src/DocUrl.ts

@@ -0,0 +1,90 @@
+import {
+  type AutomergeUrl,
+  type BinaryDocumentId,
+  type DocumentId,
+} from "./types"
+import { v4 as uuid } from "uuid"
+import bs58check from "bs58check"
+
+export const urlPrefix = "automerge:"
+
+/**
+ * given an Automerge URL, return a decoded DocumentId (and the encoded DocumentId)
+ *
+ * @param url
+ * @returns { documentId: Uint8Array(16), encodedDocumentId: bs58check.encode(documentId) }
+ */
+export const parseAutomergeUrl = (url: AutomergeUrl) => {
+  const { binaryDocumentId: binaryDocumentId, encodedDocumentId } = parts(url)
+  if (!binaryDocumentId) throw new Error("Invalid document URL: " + url)
+  return { binaryDocumentId, encodedDocumentId }
+}
+
+interface StringifyAutomergeUrlOptions {
+  documentId: DocumentId | BinaryDocumentId
+}
+
+/**
+ * Given a documentId in either canonical form, return an Automerge URL
+ * Throws on invalid input.
+ * Note: this is an object because we anticipate adding fields in the future.
+ * @param { documentId: EncodedDocumentId | DocumentId }
+ * @returns AutomergeUrl
+ */
+export const stringifyAutomergeUrl = ({
+  documentId,
+}: StringifyAutomergeUrlOptions): AutomergeUrl => {
+  if (documentId instanceof Uint8Array)
+    return (urlPrefix +
+      binaryToDocumentId(documentId as BinaryDocumentId)) as AutomergeUrl
+  else if (typeof documentId === "string") {
+    return (urlPrefix + documentId) as AutomergeUrl
+  }
+  throw new Error("Invalid documentId: " + documentId)
+}
+
+/**
+ * Given a string, return true if it is a valid Automerge URL
+ * also acts as a type discriminator in Typescript.
+ * @param str: URL candidate
+ * @returns boolean
+ */
+export const isValidAutomergeUrl = (str: string): str is AutomergeUrl => {
+  if (!str.startsWith(urlPrefix)) return false
+
+  const { binaryDocumentId: documentId } = parts(str)
+  return documentId ? true : false
+}
+
+/**
+ * generateAutomergeUrl produces a new AutomergeUrl.
+ * generally only called by create(), but used in tests as well.
+ * @returns a new Automerge URL with a random UUID documentId
+ */
+export const generateAutomergeUrl = (): AutomergeUrl =>
+  stringifyAutomergeUrl({
+    documentId: uuid(null, new Uint8Array(16)) as BinaryDocumentId,
+  })
+
+export const documentIdToBinary = (
+  docId: DocumentId
+): BinaryDocumentId | undefined =>
+  bs58check.decodeUnsafe(docId) as BinaryDocumentId | undefined
+
+export const binaryToDocumentId = (docId: BinaryDocumentId): DocumentId =>
+  bs58check.encode(docId) as DocumentId
+
+/**
+ * parts breaks up the URL into constituent pieces,
+ * eventually this could include things like heads, so we use this structure
+ * we return both a binary & string-encoded version of the document ID
+ * @param str
+ * @returns { binaryDocumentId, encodedDocumentId }
+ */
+const parts = (str: string) => {
+  const regex = new RegExp(`^${urlPrefix}(\\w+)$`)
+  const [m, docMatch] = str.match(regex) || []
+  const encodedDocumentId = docMatch as DocumentId
+  const binaryDocumentId = documentIdToBinary(encodedDocumentId)
+  return { binaryDocumentId, encodedDocumentId }
+}

package/src/Repo.ts

@@ -5,12 +5,10 @@ import { NetworkSubsystem } from "./network/NetworkSubsystem.js"
 import { StorageAdapter } from "./storage/StorageAdapter.js"
 import { StorageSubsystem } from "./storage/StorageSubsystem.js"
 import { CollectionSynchronizer } from "./synchronizer/CollectionSynchronizer.js"
-import { ChannelId, DocumentId, PeerId } from "./types.js"
+import { DocumentId, PeerId } from "./types.js"
 
 import debug from "debug"
 
-const SYNC_CHANNEL = "sync_channel" as ChannelId
-
 /** A Repo is a DocCollection with networking, syncing, and storage capabilities. */
 export class Repo extends DocCollection {
   #log: debug.Debugger
@@ -31,8 +29,7 @@ export class Repo extends DocCollection {
     this.on("document", async ({ handle }) => {
       if (storageSubsystem) {
         // Save when the document changes
-        handle.on("change", async ({ handle }) => {
-          const doc = await handle.value()
+        handle.on("heads-changed", async ({ handle, doc }) => {
           await storageSubsystem.save(handle.documentId, doc)
         })
 
@@ -47,12 +44,12 @@ export class Repo extends DocCollection {
       synchronizer.addDocument(handle.documentId)
     })
 
-    this.on("delete-document", ({ documentId }) => {
+    this.on("delete-document", ({ encodedDocumentId }) => {
       // TODO Pass the delete on to the network
       // synchronizer.removeDocument(documentId)
 
       if (storageSubsystem) {
-        storageSubsystem.remove(documentId)
+        storageSubsystem.remove(encodedDocumentId)
       }
     })
 
@@ -112,7 +109,7 @@ export class Repo extends DocCollection {
     })
 
     // We establish a special channel for sync messages
-    networkSubsystem.join(SYNC_CHANNEL)
+    networkSubsystem.join()
 
     // EPHEMERAL DATA
     // The ephemeral data subsystem uses the network to send and receive messages that are not