turtb 0.5.0

package/lib/display/render.js

@@ -0,0 +1,177 @@
+function _constructValue (parts, node) {
+  if (parts == null) return null
+  if (typeof parts === 'function') {
+    parts = parts(node)
+  }
+  if (Array.isArray(parts)) {
+    const mappedParts = parts.map(part => {
+      if (typeof part === 'function') {
+        part = part(node)
+      }
+      if (part == null) return ''
+      if (part && part.type === 'part') {
+        return part.value
+      } else {
+        return part
+      }
+    })
+    if (mappedParts.length === 1) {
+      return mappedParts[0]
+    }
+    return mappedParts.join('')
+  }
+  return parts
+}
+
+function _renderAttributes (attributes, node) {
+  let obj = {}
+  attributes.forEach(attribute => {
+    if (typeof attribute === 'function') {
+      attribute = attribute(node)
+    }
+    if (attribute == null) return
+    if (attribute && attribute.type === 'attribute') {
+      const name = attribute.name
+      if (name in obj) return
+      const value = _constructValue(attribute.value, node)
+      if (value == null) {
+        obj[name] = name
+      } else {
+        obj[name] = value
+      }
+    } else if (Array.isArray(attribute)) {
+      obj = Object.assign(_renderAttributes(attribute, node), obj)
+    } else if (typeof attribute === 'object') {
+      Object.entries(attribute).forEach(([name, value]) => {
+        if (name in obj) return
+        obj[name] = value
+      })
+    } else {
+      const name = attribute.toString()
+      if (name in obj) return
+      obj[name] = name
+    }
+  })
+  return obj
+}
+
+function _setAttribute (element, name, value) {
+  if (element[name] !== value) {
+    try {
+      element[name] = value
+    } catch (e) {
+      // SVGs don't like getting their properties set and that's okay...
+    }
+  }
+  if (!(typeof value).match(/(?:boolean|number|string)/)) {
+    value = name
+  }
+  const str = value.toString()
+  if (element.getAttribute(name) !== str) {
+    element.setAttribute(name, str)
+  }
+  return element
+}
+
+function _setAttributes (element, attributes) {
+  Object.entries(attributes).forEach(([name, value]) => {
+    _setAttribute(element, name, value)
+  })
+  return element
+}
+
+function _pruneAttributes (element, newAttributes, oldAttributes) {
+  const orphans = new Set(Object.keys(oldAttributes))
+  Object.keys(newAttributes).forEach(attribute => orphans.delete(attribute))
+  orphans.forEach(attribute => {
+    element.removeAttribute(attribute)
+    delete element[attribute]
+  })
+}
+
+const _descriptionMap = new Map()
+function _descriptionsToNodes (descriptions, xmlns, recaller, debugString) {
+  if (!Array.isArray(descriptions)) {
+    descriptions = [descriptions]
+  }
+  const nodes = []
+  descriptions.forEach(description => {
+    if (typeof description === 'function') {
+      description = description()
+    }
+    if (description != null) {
+      if (Array.isArray(description)) {
+        nodes.push(..._descriptionsToNodes(description, xmlns, recaller, debugString))
+      } else {
+        if (description.tag === null || description.tag === '') {
+          nodes.push(..._descriptionsToNodes(description.children, xmlns, recaller, debugString))
+        } else if (typeof description.tag === 'function') {
+          const attributes = _renderAttributes(description.attributes)
+          nodes.push(..._descriptionsToNodes(description.tag(attributes, description.children, description), attributes.xmlns || xmlns, recaller, debugString))
+        } else if (description.type) {
+          if (!_descriptionMap.has(description)) {
+            let node
+            if (description.type === 'textnode') {
+              node = document.createTextNode(description.value)
+            } else {
+              let oldAttributes = {}
+              let newAttributes = _renderAttributes(description.attributes, node)
+              node = document.createElementNS(newAttributes.xmlns || xmlns, description.tag, { is: newAttributes.is })
+              _setAttributes(node, newAttributes)
+              render(node, description.children, recaller, debugString, newAttributes.xmlns || xmlns)
+              recaller.watch(debugString, () => {
+                newAttributes = _renderAttributes(description.attributes, node)
+                _setAttributes(node, newAttributes)
+                _pruneAttributes(node, newAttributes, oldAttributes)
+                oldAttributes = newAttributes
+              })
+            }
+            _descriptionMap.set(description, node)
+          }
+          nodes.push(_descriptionMap.get(description))
+        } else {
+          nodes.push(document.createTextNode(description.toString()))
+        }
+      }
+    }
+  })
+  return nodes
+}
+
+function _setChildren (element, descriptions, xmlns, recaller, debugString) {
+  const newNodes = _descriptionsToNodes(descriptions, xmlns, recaller, debugString)
+  newNodes.forEach((newNode, index) => {
+    while (element.childNodes[index] !== newNode) {
+      const oldNode = element.childNodes[index]
+      if (!oldNode) {
+        element.appendChild(newNode)
+      } else if (newNodes.indexOf(oldNode) > index) {
+        element.insertBefore(newNode, oldNode)
+      } else {
+        element.removeChild(oldNode)
+      }
+    }
+  })
+  while (element.childNodes.length > newNodes.length) {
+    element.removeChild(element.lastChild)
+  }
+  return element
+}
+
+/**
+ * @param {HTMLElement} element
+ * @param {array|object|function|null} descriptions
+ * @param {import('../utils/Recaller.js').Recaller} recaller
+ * @param {string} debugString
+ * @param {string} [xmlns='http://www.w3.org/1999/xhtml']
+ */
+export function render (element, descriptions, recaller, debugString, xmlns = 'http://www.w3.org/1999/xhtml') {
+  if (!descriptions) {
+    return _descriptionsToNodes(element, xmlns, recaller, debugString)
+  }
+  function f () {
+    return _setChildren(element, descriptions, xmlns, recaller, debugString)
+  }
+  recaller.watch(debugString, f)
+  return f
+}

package/lib/display/shapes.js

@@ -0,0 +1,91 @@
+import { h } from './h.js'
+
+export const cog = (attributes = {}, children = []) => {
+  attributes.viewBox ??= '-1 -1 2 2'
+  attributes.width ??= attributes.height ?? '1em'
+  attributes.height ??= attributes.width ?? '1em'
+  attributes.xmlns = 'http://www.w3.org/2000/svg'
+  const teeth = +attributes.teeth || 6
+  const holeR = +attributes.holeR || 0.25
+  const innerR = +attributes.innerR || 0.60
+  const outerR = +attributes.outerR || 0.90
+  const outerWeight = +attributes.outerWeight || 6
+  const innerWeight = +attributes.innerWeight || outerWeight * outerR / innerR
+  const transWeight = +attributes.transWeight || 3
+  const totalWeight = outerWeight + innerWeight + transWeight * 2
+  const toXY = (outerness, aroundness) => {
+    const r = outerR * outerness + innerR * (1 - outerness)
+    const theta = (aroundness - 0.25 - outerWeight / totalWeight / (2 * teeth)) * 2 * Math.PI
+    return `${Math.cos(theta) * r} ${Math.sin(theta) * r}`
+  }
+  return h`<svg ${attributes}>
+    <path d="
+      M ${toXY(1, 0)}
+      ${[...Array(teeth).keys().map(tooth =>
+        `
+          A ${outerR} ${outerR} 0 0 1 ${toXY(1, (tooth + outerWeight / totalWeight) / teeth)}
+          L ${toXY(0, (tooth + (outerWeight + transWeight) / totalWeight) / teeth)}
+          A ${innerR} ${innerR} 0 0 1 ${toXY(0, (tooth + (outerWeight + transWeight + innerWeight) / totalWeight) / teeth)}
+          L ${toXY(1, (tooth + 1) / teeth)}
+        `
+      )].join('')}
+      Z
+      M 0 -${holeR}
+      A ${holeR} ${holeR} 0 1 0 0 ${holeR}
+      A ${holeR} ${holeR} 0 1 0 0 -${holeR}
+      Z
+    "/>
+    ${children}
+  </svg>`
+}
+
+export const star = (attributes = {}, children = []) => {
+  attributes.viewBox ??= '-1 -1 2 2'
+  attributes.width ??= attributes.height ?? '1em'
+  attributes.height ??= attributes.width ?? '1em'
+  attributes.xmlns = 'http://www.w3.org/2000/svg'
+  const points = +attributes.points || 5
+  const innerR = +attributes.innerR || 0.60
+  const outerR = +attributes.outerR || 0.90
+  const toXY = (outerness, aroundness) => {
+    const r = outerR * outerness + innerR * (1 - outerness)
+    const theta = (aroundness - 0.25) * 2 * Math.PI
+    return `${Math.cos(theta) * r} ${Math.sin(theta) * r}`
+  }
+  return h`<svg ${attributes}>
+    <path d="
+      M ${toXY(1, 0)}
+      ${[...Array(points).keys().map(point =>
+        `
+          L ${toXY(0, (point + 0.5) / points)}
+          L ${toXY(1, (point + 1) / points)}
+        `
+      )].join('')}
+      Z
+    "/>
+    ${children}
+  </svg>`
+}
+
+export const equilateral = (attributes = {}, children = []) => {
+  attributes.viewBox ??= '-1 -1 2 2'
+  attributes.width ??= attributes.height ?? '1em'
+  attributes.height ??= attributes.width ?? '1em'
+  attributes.xmlns = 'http://www.w3.org/2000/svg'
+  const corners = +attributes.corners || 3
+  const r = +attributes.r || 0.90
+  const toXY = (aroundness) => {
+    const theta = (aroundness - 0.25) * 2 * Math.PI
+    return `${Math.cos(theta) * r} ${Math.sin(theta) * r}`
+  }
+  return h`<svg ${attributes}>
+    <path d="
+      M ${toXY(0)}
+      ${[...Array(corners).keys().map(corner =>
+        `L ${toXY((corner + 1) / corners)}`
+      )].join('')}
+      Z
+    "/>
+    ${children}
+  </svg>`
+}

package/lib/turtle/Signer.js

@@ -0,0 +1,120 @@
+import { cryptoPromise, hashNameAndPassword } from '../utils/crypto.js'
+import { getPublicKey, signAsync, verify } from '../utils/noble-secp256k1.js'
+import { codec, COMMIT, splitEncodedCommit } from './codecs/codec.js'
+import { AS_REFS } from './codecs/CodecType.js'
+import { Commit } from './codecs/Commit.js'
+import { b36ToUint8Array, uint8ArrayToB36 } from './utils.js'
+import { combineUint8Arrays } from '../utils/combineUint8Arrays.js'
+import { U8aTurtle } from './U8aTurtle.js'
+import { logError } from '../utils/logger.js'
+
+/**
+ * @typedef {import('./U8aTurtle.js').U8aTurtle} U8aTurtle
+ * @typedef {import('./codecs/Commit.js').Commit} Commit
+ */
+
+/**
+ * @typedef KeyPair
+ * @property {string} privateKey
+ * @property {string} publicKey
+ */
+
+export class Signer {
+  /** @type {Object.<string, KeyPair>} */
+  keysByName = {}
+
+  constructor (username, password) {
+    this.username = username
+    this.hashwordPromise = hashNameAndPassword(username, password)
+  }
+
+  /**
+   * @param {string} turtlename
+   * @returns {KeyPair}
+   */
+  async makeKeysFor (turtlename) {
+    if (!(this.keysByName[turtlename])) {
+      const hashword = await this.hashwordPromise
+      const privateKey = await hashNameAndPassword(turtlename, hashword)
+      const publicKey = uint8ArrayToB36(getPublicKey(privateKey))
+      this.keysByName[turtlename] = { privateKey, publicKey }
+    }
+    return this.keysByName[turtlename]
+  }
+
+  /**
+   * @param {string} turtleName
+   * @param {Uint8Array} uint8Array
+   * @returns {Uint8Array}
+   */
+  async sign (turtleName, uint8Array) {
+    const { privateKey } = await this.makeKeysFor(turtleName)
+    const hash = await digestData(uint8Array)
+    const signature = await signAsync(hash, privateKey)
+    return signature.toCompactRawBytes()
+  }
+
+  /**
+   * @param {string} turtlename
+   * @param {number} commitAddress
+   * @param {U8aTurtle} u8aTurtle
+   * @param {U8aTurtle} committedTurtle
+   * @return {Uint8Array}
+   */
+  async signCommit (turtlename, commitAddress, u8aTurtle, committedTurtle) {
+    const uint8Arrays = u8aTurtle.exportUint8Arrays((committedTurtle?.index ?? -1) + 1)
+    if (committedTurtle) {
+      const previousEncodedCommit = splitEncodedCommit(committedTurtle)[1]
+      uint8Arrays.unshift(previousEncodedCommit)
+    }
+    const signature = await this.sign(turtlename, combineUint8Arrays(uint8Arrays))
+    const commit = new Commit(commitAddress, signature)
+    return COMMIT.encode(commit, undefined, AS_REFS)
+  }
+}
+
+/**
+ * @param {U8aTurtle} u8aTurtle
+ * @param {string} publicKey
+ */
+export async function verifyTurtleCommit (u8aTurtle, publicKey) {
+  try {
+    const footer = u8aTurtle.getByte()
+    const codecVersion = codec.getCodecTypeVersion(footer)
+    if (codecVersion.codecType !== COMMIT) {
+      throw new Error('last value must be Commit')
+    }
+    /** @type {Commit} */
+    const commit = codecVersion.decode(u8aTurtle, undefined, AS_REFS)
+    let uint8Array = u8aTurtle.slice(undefined, -codecVersion.getWidth(u8aTurtle) - 1)
+    if (u8aTurtle.parent) {
+      const previousEncodedCommit = splitEncodedCommit(u8aTurtle.parent)[1]
+      uint8Array = combineUint8Arrays([previousEncodedCommit, uint8Array])
+    }
+    const hash = await digestData(uint8Array)
+    return verify(commit.signature, hash, b36ToUint8Array(publicKey))
+  } catch (error) {
+    logError(() => console.error(error))
+    return false
+  }
+}
+
+/**
+ *
+ * @param {string} publicKey
+ * @param {Uint8Array} uint8Array
+ * @param {Uint8Array} [previousUint8Array]
+ */
+export function verifyCommitU8a (publicKey, uint8Array, previousUint8Array) {
+  const u8aTurtle = new U8aTurtle(
+    uint8Array,
+    previousUint8Array && new U8aTurtle(previousUint8Array)
+  )
+  return verifyTurtleCommit(u8aTurtle, publicKey)
+}
+
+const digestData = async uint8Array => {
+  const { subtle } = await cryptoPromise
+  const digested = await subtle.digest('SHA-256', uint8Array)
+  return new Uint8Array(digested)
+}

package/lib/turtle/Signer.test.js

@@ -0,0 +1,38 @@
+import { globalTestRunner, urlToName } from '../utils/TestRunner.js'
+import { Signer, verifyCommitU8a, verifyTurtleCommit } from './Signer.js'
+import { squashTurtle, U8aTurtle } from './U8aTurtle.js'
+import { OPAQUE_UINT8ARRAY } from './codecs/codec.js'
+
+globalTestRunner.describe(urlToName(import.meta.url), suite => {
+  suite.it('signs and verifies commits', async ({ assert }) => {
+    const signer = new Signer('signer1', 'password1')
+    const name = 'branch1'
+    const u8Array = new Uint8Array([1, 2, 3])
+    let u8aTurtle = new U8aTurtle(OPAQUE_UINT8ARRAY.encode(u8Array))
+    const u8aAddress = u8aTurtle.length - 1
+    const signedCommit = await signer.signCommit(name, u8aAddress, u8aTurtle)
+
+    u8aTurtle = new U8aTurtle(signedCommit, u8aTurtle)
+    u8aTurtle = squashTurtle(u8aTurtle, 0)
+    const committedTurtle = u8aTurtle
+    assert.equal(committedTurtle.lookup().document, u8Array)
+    const keys = await signer.makeKeysFor(name)
+    const verification0 = await verifyCommitU8a(keys.publicKey, u8aTurtle.getAncestorByIndex(0).uint8Array)
+    assert.assert(verification0)
+    const verification = await verifyTurtleCommit(committedTurtle, keys.publicKey)
+    assert.assert(verification)
+
+    const u8Array2 = new Uint8Array([4, 5, 6, 7])
+    u8aTurtle = new U8aTurtle(OPAQUE_UINT8ARRAY.encode(u8Array2), u8aTurtle)
+    const u8aAddress2 = u8aTurtle.length - 1
+    const signedCommit2 = await signer.signCommit(name, u8aAddress2, u8aTurtle, committedTurtle)
+    u8aTurtle = new U8aTurtle(signedCommit2, u8aTurtle)
+    u8aTurtle = squashTurtle(u8aTurtle, committedTurtle.index + 1)
+    assert.equal(u8aTurtle.lookup().document, u8Array2)
+    const verification2 = await verifyTurtleCommit(u8aTurtle, keys.publicKey)
+    assert.assert(verification2)
+
+    const verification3 = await verifyCommitU8a(keys.publicKey, u8aTurtle.uint8Array, u8aTurtle.parent.uint8Array)
+    assert.assert(verification3)
+  })
+})

package/lib/turtle/TurtleBranch.js

@@ -0,0 +1,147 @@
+import { Recaller } from '../utils/Recaller.js'
+import { squashTurtle, U8aTurtle } from './U8aTurtle.js'
+import { combineUint8Arrays } from '../utils/combineUint8Arrays.js'
+import { combineUint8ArrayLikes } from '../utils/combineUint8ArrayLikes.js'
+import { logInfo, logWarn } from '../utils/logger.js'
+import { JSON_FILE, pathToType, TEXT_FILE } from '../utils/fileTransformer.js'
+
+/**
+ * @typedef {import('./codecs/CodecType.js').CodecOptions} CodecOptions
+ */
+
+const _encodeUint8Array = uint8Array => {
+  const encodedLength = new Uint32Array([uint8Array.length])
+  return combineUint8ArrayLikes([encodedLength, uint8Array])
+}
+
+export class TurtleBranch {
+  /** @type {U8aTurtle} */
+  #u8aTurtle
+  #resolveNextUint8Array
+  #setNextUint8Array = uint8Array => {
+    const prevResolve = this.#resolveNextUint8Array
+    this.nextUint8Array = new Promise(resolve => { this.#resolveNextUint8Array = resolve })
+    prevResolve?.(uint8Array)
+  }
+
+  /**
+   * @param {string} name
+   * @param {Recaller} recaller
+   * @param {U8aTurtle} u8aTurtle
+   */
+  constructor (name, recaller = new Recaller(name), u8aTurtle) {
+    if (!name) throw new Error('please name your branches')
+    this.name = name
+    this.recaller = recaller
+    this.#u8aTurtle = u8aTurtle
+    this.nextUint8Array = new Promise(resolve => { this.#resolveNextUint8Array = resolve })
+  }
+
+  /** @type {U8aTurtle} */
+  get u8aTurtle () {
+    this.recaller.reportKeyAccess(this, 'u8aTurtle', 'get', this.name)
+    return this.#u8aTurtle
+  }
+
+  set u8aTurtle (u8aTurtle) {
+    if (u8aTurtle === this.#u8aTurtle) return
+    if (u8aTurtle !== undefined) {
+      if (u8aTurtle.hasAncestor(this.#u8aTurtle)) {
+        const uint8Arrays = u8aTurtle.exportUint8Arrays((this.index ?? -1) + 1)
+        uint8Arrays.forEach(uint8Array => {
+          this.#setNextUint8Array(uint8Array)
+        })
+      } else {
+        logWarn(() => console.warn(`TurtleBranch, ${this.name}.u8aTurtle set to non-descendant (generators are broken now)`))
+      }
+    }
+    this.recaller.reportKeyMutation(this, 'u8aTurtle', 'set', this.name)
+    this.#u8aTurtle = u8aTurtle
+  }
+
+  append (uint8Array) {
+    if (!uint8Array?.length) {
+      throw new Error('bad Uint8Array')
+    }
+    this.u8aTurtle = new U8aTurtle(uint8Array, this.u8aTurtle)
+    return this.length - 1
+  }
+
+  async * u8aTurtleGenerator () {
+    let lastIndex = -1
+    while (true) {
+      while (lastIndex < this.index) {
+        ++lastIndex
+        yield this.u8aTurtle.getAncestorByIndex(lastIndex)
+      }
+      await this.nextUint8Array
+    }
+  }
+
+  /**
+   * @returns {ReadableStream}
+   */
+  makeReadableStream () {
+    let _controller
+    const turtleBranch = this
+    return new ReadableStream({
+      async start (controller) {
+        _controller = controller
+        for await (const u8aTurtle of turtleBranch.u8aTurtleGenerator()) {
+          _controller.enqueue(_encodeUint8Array(u8aTurtle.uint8Array))
+        }
+      },
+      cancel (reason) {
+        logInfo(() => console.log('stream cancelled', { reason }))
+      },
+      type: 'bytes'
+    })
+  }
+
+  /**
+   * @returns {WritableStream}
+   */
+  makeWritableStream () {
+    let u8aProgress = new Uint8Array()
+    let u8aLength
+    const turtleBranch = this
+    return new WritableStream({
+      write (chunk) {
+        u8aProgress = combineUint8Arrays([u8aProgress, chunk])
+        while (u8aProgress.length > 4 && u8aProgress.length > (u8aLength = new Uint32Array(u8aProgress.slice(0, 4).buffer)[0])) {
+          const uint8Array = u8aProgress.slice(4, u8aLength + 4)
+          turtleBranch.append(uint8Array)
+          u8aProgress = u8aProgress.slice(u8aLength + 4)
+        }
+      }
+    })
+  }
+
+  get length () { return this.u8aTurtle?.length ?? 0 }
+  get index () { return this.u8aTurtle?.index ?? -1 }
+  getByte (address) { return this.u8aTurtle?.getAncestorByAddress?.(address)?.getByte?.(address) }
+  slice (start, end) { return this.u8aTurtle?.getAncestorByAddress?.(start)?.slice?.(start, end) }
+  squash (downToIndex) {
+    if (this.index === downToIndex) return
+    this.#u8aTurtle = squashTurtle(this.u8aTurtle, downToIndex)
+    this.recaller.reportKeyMutation(this, 'u8aTurtle', 'squash', this.name)
+  }
+
+  /**
+   * @param  {[optional_address:number, ...path:Array.<string>, optional_options:CodecOptions]} path
+   * @returns {any}
+   */
+  lookup (...path) { return this.u8aTurtle?.lookup?.(...path) }
+
+  lookupFile (filename, asStored = false, address) {
+    const type = pathToType(filename)
+    const storedContent = address ? this.lookup(address) : this.lookup('document', 'value', filename)
+    if (asStored || !storedContent) return storedContent
+    if (storedContent?.symlink) return storedContent
+    if (storedContent instanceof Uint8Array) return storedContent
+    if (typeof storedContent === 'string') return storedContent
+    if (type === JSON_FILE) return JSON.stringify(storedContent, null, 2)
+    if (type === TEXT_FILE) return storedContent.join('\n')
+    return undefined
+  }
+}

package/lib/turtle/TurtleBranch.test.js

@@ -0,0 +1,89 @@
+import { handleNextTick, tics } from '../utils/nextTick.js'
+import { globalTestRunner, urlToName } from '../utils/TestRunner.js'
+import { TurtleBranch } from './TurtleBranch.js'
+
+globalTestRunner.describe(urlToName(import.meta.url), suite => {
+  suite.it('passes through U8aTurtle changes', ({ assert }) => {
+    const branch = new TurtleBranch('branch')
+    const indices = []
+    branch.recaller.watch('indices', () => {
+      indices.push(branch.index)
+    })
+    assert.equal(indices, [-1])
+    branch.append(new Uint8Array([0, 1, 2]))
+    handleNextTick()
+    assert.equal(indices, [-1, 0])
+    branch.append(new Uint8Array([3, 4, 5]))
+    handleNextTick()
+    assert.equal(indices, [-1, 0, 1])
+    branch.append(new Uint8Array([6, 7, 8]))
+    handleNextTick()
+    assert.equal(indices, [-1, 0, 1, 2])
+    branch.squash(1)
+    handleNextTick()
+    assert.equal(indices, [-1, 0, 1, 2, 1])
+    assert.equal(branch.u8aTurtle.uint8Array, new Uint8Array([3, 4, 5, 6, 7, 8]))
+  })
+  suite.it('streams append', async ({ assert }) => {
+    const primary = new TurtleBranch('primary')
+    const secondary = new TurtleBranch('secondary')
+    const readableStream = primary.makeReadableStream()
+    const writableStream = secondary.makeWritableStream()
+    readableStream.pipeTo(writableStream)
+    primary.append(new Uint8Array([1, 2, 3]))
+    await new Promise(resolve => setTimeout(resolve))
+    assert.equal(secondary.u8aTurtle.exportUint8Arrays(), [new Uint8Array([1, 2, 3])])
+  })
+  suite.it('streams set u8aTurtle', async ({ assert }) => {
+    const primary = new TurtleBranch('primary')
+    const secondary = new TurtleBranch('secondary')
+    const readableStream = primary.makeReadableStream()
+    const writableStream = secondary.makeWritableStream()
+    readableStream.pipeTo(writableStream)
+    primary.append(new Uint8Array([1, 2, 3]))
+    await new Promise(resolve => setTimeout(resolve))
+    assert.equal(secondary.u8aTurtle.exportUint8Arrays(), [new Uint8Array([1, 2, 3])])
+
+    const primaryBranched = new TurtleBranch('branched', undefined, primary.u8aTurtle)
+    primaryBranched.append(new Uint8Array([4, 5, 6]))
+    primaryBranched.append(new Uint8Array([7, 8, 9]))
+    primary.u8aTurtle = primaryBranched.u8aTurtle
+    await new Promise(resolve => setTimeout(resolve))
+    assert.equal(secondary.u8aTurtle.exportUint8Arrays(), [
+      new Uint8Array([1, 2, 3]),
+      new Uint8Array([4, 5, 6]),
+      new Uint8Array([7, 8, 9])
+    ])
+  })
+  suite.it('streams established U8aTurtles', async ({ assert }) => {
+    const primary = new TurtleBranch('primary')
+    primary.append(new Uint8Array([1, 2, 3]))
+    primary.append(new Uint8Array([4, 5, 6]))
+    primary.append(new Uint8Array([7, 8, 9]))
+    const secondary = new TurtleBranch('secondary')
+    primary.makeReadableStream().pipeTo(secondary.makeWritableStream())
+    await tics(1)
+    assert.equal(secondary.u8aTurtle.exportUint8Arrays(), [
+      new Uint8Array([1, 2, 3]),
+      new Uint8Array([4, 5, 6]),
+      new Uint8Array([7, 8, 9])
+    ])
+  })
+  suite.it('async generators', async ({ assert }) => {
+    const branch = new TurtleBranch('branch')
+    branch.append(new Uint8Array([1]))
+    branch.append(new Uint8Array([2]))
+    const uint8Arrays = []
+    ;(async () => {
+      for await (const u8aTurtle of branch.u8aTurtleGenerator()) {
+        uint8Arrays.push(u8aTurtle.uint8Array)
+      }
+    })()
+    await tics(1)
+    assert.equal(uint8Arrays, [new Uint8Array([1]), new Uint8Array([2])])
+    branch.append(new Uint8Array([3]))
+    branch.append(new Uint8Array([4]))
+    await tics(1)
+    assert.equal(uint8Arrays, [new Uint8Array([1]), new Uint8Array([2]), new Uint8Array([3]), new Uint8Array([4])])
+  })
+})