@dxos/hypercore 0.1.53 → 0.1.54-main.1661511

package/dist/lib/node/index.cjs

@@ -2535,15 +2535,15 @@ var require_safe_buffer_equals = __commonJS({
 // node_modules/.pnpm/nanoassert@2.0.0/node_modules/nanoassert/index.js
 var require_nanoassert = __commonJS({
   "node_modules/.pnpm/nanoassert@2.0.0/node_modules/nanoassert/index.js"(exports, module2) {
-    module2.exports = assert3;
+    module2.exports = assert;
     var AssertionError = class extends Error {
     };
     AssertionError.prototype.name = "AssertionError";
-    function assert3(t, m) {
+    function assert(t, m) {
       if (!t) {
         var err = new AssertionError(m);
         if (Error.captureStackTrace)
-          Error.captureStackTrace(err, assert3);
+          Error.captureStackTrace(err, assert);
         throw err;
       }
     }
@@ -2761,13 +2761,13 @@ var require_cipher = __commonJS({
       crypto_aead_chacha20poly1305_ietf_encrypt,
       crypto_aead_chacha20poly1305_ietf_decrypt
     } = require("sodium-universal/crypto_aead");
-    var assert3 = require_nanoassert();
+    var assert = require_nanoassert();
     var KEYLEN = 32;
     var NONCELEN = 8;
     var MACLEN = 16;
-    assert3(crypto_aead_chacha20poly1305_ietf_KEYBYTES === KEYLEN);
-    assert3(crypto_aead_chacha20poly1305_ietf_NPUBBYTES === 4 + NONCELEN);
-    assert3(crypto_aead_chacha20poly1305_ietf_ABYTES === MACLEN);
+    assert(crypto_aead_chacha20poly1305_ietf_KEYBYTES === KEYLEN);
+    assert(crypto_aead_chacha20poly1305_ietf_NPUBBYTES === 4 + NONCELEN);
+    assert(crypto_aead_chacha20poly1305_ietf_ABYTES === MACLEN);
     module2.exports = {
       KEYLEN,
       NONCELEN,
@@ -2778,10 +2778,10 @@ var require_cipher = __commonJS({
     };
     var ElongatedNonce = sodium_malloc(crypto_aead_chacha20poly1305_ietf_NPUBBYTES);
     function encrypt(out, k, n, ad, plaintext) {
-      assert3(out.byteLength >= plaintext.byteLength + MACLEN, "output buffer must be at least plaintext plus MACLEN bytes long");
-      assert3(k.byteLength === KEYLEN);
-      assert3(n.byteLength === NONCELEN);
-      assert3(ad == null ? true : ad.byteLength != null);
+      assert(out.byteLength >= plaintext.byteLength + MACLEN, "output buffer must be at least plaintext plus MACLEN bytes long");
+      assert(k.byteLength === KEYLEN);
+      assert(n.byteLength === NONCELEN);
+      assert(ad == null ? true : ad.byteLength != null);
       sodium_memzero(ElongatedNonce);
       ElongatedNonce.set(n, 4);
       encrypt.bytesWritten = crypto_aead_chacha20poly1305_ietf_encrypt(out.subarray(0, plaintext.byteLength + MACLEN), plaintext, ad, null, ElongatedNonce, k);
@@ -2791,10 +2791,10 @@ var require_cipher = __commonJS({
     encrypt.bytesWritten = 0;
     encrypt.bytesRead = 0;
     function decrypt(out, k, n, ad, ciphertext) {
-      assert3(out.byteLength >= ciphertext.byteLength - MACLEN);
-      assert3(k.byteLength === KEYLEN);
-      assert3(n.byteLength === NONCELEN);
-      assert3(ad == null ? true : ad.byteLength != null);
+      assert(out.byteLength >= ciphertext.byteLength - MACLEN);
+      assert(k.byteLength === KEYLEN);
+      assert(n.byteLength === NONCELEN);
+      assert(ad == null ? true : ad.byteLength != null);
       sodium_memzero(ElongatedNonce);
       ElongatedNonce.set(n, 4);
       decrypt.bytesWritten = crypto_aead_chacha20poly1305_ietf_decrypt(out.subarray(0, ciphertext.byteLength - MACLEN), null, ciphertext, ad, ElongatedNonce, k);
@@ -2809,8 +2809,8 @@ var require_cipher = __commonJS({
     var IntermediateKey = sodium_malloc(KEYLEN + MACLEN);
     sodium_memzero(IntermediateKey);
     function rekey(out, k) {
-      assert3(out.byteLength === KEYLEN);
-      assert3(k.byteLength === KEYLEN);
+      assert(out.byteLength === KEYLEN);
+      assert(k.byteLength === KEYLEN);
       sodium_memzero(IntermediateKey);
       IntermediateKey.set(k);
       encrypt(IntermediateKey, k, maxnonce, zerolen, zeros);
@@ -2829,7 +2829,7 @@ var require_cipher_state = __commonJS({
   "node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/cipher-state.js"(exports, module2) {
     var { sodium_memzero } = require("sodium-universal/memory");
     var { sodium_increment, sodium_memcmp, sodium_is_zero } = require("sodium-universal/helpers");
-    var assert3 = require_nanoassert();
+    var assert = require_nanoassert();
     var cipher = require_cipher();
     var STATELEN = cipher.KEYLEN + cipher.NONCELEN;
     var NONCELEN = cipher.NONCELEN;
@@ -2850,8 +2850,8 @@ var require_cipher_state = __commonJS({
     var NONCE_BEGIN = KEY_END;
     var NONCE_END = NONCE_BEGIN + cipher.NONCELEN;
     function initializeKey(state, key) {
-      assert3(state.byteLength === STATELEN);
-      assert3(key == null ? true : key.byteLength === cipher.KEYLEN);
+      assert(state.byteLength === STATELEN);
+      assert(key == null ? true : key.byteLength === cipher.KEYLEN);
       if (key == null) {
         sodium_memzero(state.subarray(KEY_BEGIN, KEY_END));
         return;
@@ -2860,20 +2860,20 @@ var require_cipher_state = __commonJS({
       sodium_memzero(state.subarray(NONCE_BEGIN, NONCE_END));
     }
     function hasKey(state) {
-      assert3(state.byteLength === STATELEN);
+      assert(state.byteLength === STATELEN);
       var k = state.subarray(KEY_BEGIN, KEY_END);
       return sodium_is_zero(k) === false;
     }
     function setNonce(state, nonce) {
-      assert3(state.byteLength === STATELEN);
-      assert3(nonce.byteLength === NONCELEN);
+      assert(state.byteLength === STATELEN);
+      assert(nonce.byteLength === NONCELEN);
       state.set(nonce, NONCE_BEGIN);
     }
     var maxnonce = new Uint8Array(8).fill(255);
     function encryptWithAd(state, out, ad, plaintext) {
-      assert3(state.byteLength === STATELEN);
-      assert3(out.byteLength != null);
-      assert3(plaintext.byteLength != null);
+      assert(state.byteLength === STATELEN);
+      assert(out.byteLength != null);
+      assert(plaintext.byteLength != null);
       var n = state.subarray(NONCE_BEGIN, NONCE_END);
       if (sodium_memcmp(n, maxnonce))
         throw new Error("Nonce overflow");
@@ -2898,9 +2898,9 @@ var require_cipher_state = __commonJS({
     encryptWithAd.bytesRead = 0;
     encryptWithAd.bytesWritten = 0;
     function decryptWithAd(state, out, ad, ciphertext) {
-      assert3(state.byteLength === STATELEN);
-      assert3(out.byteLength != null);
-      assert3(ciphertext.byteLength != null);
+      assert(state.byteLength === STATELEN);
+      assert(out.byteLength != null);
+      assert(ciphertext.byteLength != null);
       var n = state.subarray(NONCE_BEGIN, NONCE_END);
       if (sodium_memcmp(n, maxnonce))
         throw new Error("Nonce overflow");
@@ -2925,7 +2925,7 @@ var require_cipher_state = __commonJS({
     decryptWithAd.bytesRead = 0;
     decryptWithAd.bytesWritten = 0;
     function rekey(state) {
-      assert3(state.byteLength === STATELEN);
+      assert(state.byteLength === STATELEN);
       var k = state.subarray(KEY_BEGIN, KEY_END);
       cipher.rekey(k, k);
       rekey.bytesRead = cipher.rekey.bytesRead;
@@ -2939,21 +2939,21 @@ var require_cipher_state = __commonJS({
 // node_modules/.pnpm/nanoassert@1.1.0/node_modules/nanoassert/index.js
 var require_nanoassert2 = __commonJS({
   "node_modules/.pnpm/nanoassert@1.1.0/node_modules/nanoassert/index.js"(exports, module2) {
-    assert3.notEqual = notEqual;
-    assert3.notOk = notOk;
-    assert3.equal = equal;
-    assert3.ok = assert3;
-    module2.exports = assert3;
+    assert.notEqual = notEqual;
+    assert.notOk = notOk;
+    assert.equal = equal;
+    assert.ok = assert;
+    module2.exports = assert;
     function equal(a, b, m) {
-      assert3(a == b, m);
+      assert(a == b, m);
     }
     function notEqual(a, b, m) {
-      assert3(a != b, m);
+      assert(a != b, m);
     }
     function notOk(t, m) {
-      assert3(!t, m);
+      assert(!t, m);
     }
-    function assert3(t, m) {
+    function assert(t, m) {
       if (!t)
         throw new Error(m || "AssertionError");
     }
@@ -2965,7 +2965,7 @@ var require_hmac_blake2b = __commonJS({
   "node_modules/.pnpm/hmac-blake2b@2.0.0/node_modules/hmac-blake2b/index.js"(exports, module2) {
     var { sodium_malloc, sodium_memzero } = require("sodium-universal/memory");
     var { crypto_generichash, crypto_generichash_batch } = require("sodium-universal/crypto_generichash");
-    var assert3 = require_nanoassert2();
+    var assert = require_nanoassert2();
     var HASHLEN = 64;
     var BLOCKLEN = 128;
     var scratch = sodium_malloc(BLOCKLEN * 3);
@@ -2973,9 +2973,9 @@ var require_hmac_blake2b = __commonJS({
     var OuterKeyPad = scratch.subarray(BLOCKLEN * 1, BLOCKLEN * 2);
     var InnerKeyPad = scratch.subarray(BLOCKLEN * 2, BLOCKLEN * 3);
     module2.exports = function hmac(out, data, key) {
-      assert3(out.byteLength === HASHLEN);
-      assert3(key.byteLength != null);
-      assert3(Array.isArray(data) ? data.every((d) => d.byteLength != null) : data.byteLength != null);
+      assert(out.byteLength === HASHLEN);
+      assert(key.byteLength != null);
+      assert(Array.isArray(data) ? data.every((d) => d.byteLength != null) : data.byteLength != null);
       if (key.byteLength > BLOCKLEN) {
         crypto_generichash(HMACKey.subarray(0, HASHLEN), key);
         sodium_memzero(HMACKey.subarray(HASHLEN));
@@ -3003,7 +3003,7 @@ var require_dh = __commonJS({
   "node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/dh.js"(exports, module2) {
     var { crypto_kx_SEEDBYTES, crypto_kx_keypair, crypto_kx_seed_keypair } = require("sodium-universal/crypto_kx");
     var { crypto_scalarmult_BYTES, crypto_scalarmult_SCALARBYTES, crypto_scalarmult } = require("sodium-universal/crypto_scalarmult");
-    var assert3 = require_nanoassert();
+    var assert = require_nanoassert();
     var DHLEN = crypto_scalarmult_BYTES;
     var PKLEN = crypto_scalarmult_BYTES;
     var SKLEN = crypto_scalarmult_SCALARBYTES;
@@ -3018,20 +3018,20 @@ var require_dh = __commonJS({
       dh
     };
     function generateKeypair(pk, sk) {
-      assert3(pk.byteLength === PKLEN);
-      assert3(sk.byteLength === SKLEN);
+      assert(pk.byteLength === PKLEN);
+      assert(sk.byteLength === SKLEN);
       crypto_kx_keypair(pk, sk);
     }
     function generateSeedKeypair(pk, sk, seed) {
-      assert3(pk.byteLength === PKLEN);
-      assert3(sk.byteLength === SKLEN);
-      assert3(seed.byteLength === SKLEN);
+      assert(pk.byteLength === PKLEN);
+      assert(sk.byteLength === SKLEN);
+      assert(seed.byteLength === SKLEN);
       crypto_kx_seed_keypair(pk, sk, seed);
     }
     function dh(output, lsk, pk) {
-      assert3(output.byteLength === DHLEN);
-      assert3(lsk.byteLength === SKLEN);
-      assert3(pk.byteLength === PKLEN);
+      assert(output.byteLength === DHLEN);
+      assert(lsk.byteLength === SKLEN);
+      assert(pk.byteLength === PKLEN);
       crypto_scalarmult(
         output,
         lsk,
@@ -3046,13 +3046,13 @@ var require_hash = __commonJS({
   "node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/hash.js"(exports, module2) {
     var { sodium_malloc, sodium_memzero } = require("sodium-universal/memory");
     var { crypto_generichash_batch } = require("sodium-universal/crypto_generichash");
-    var assert3 = require_nanoassert();
+    var assert = require_nanoassert();
     var hmacBlake2b = require_hmac_blake2b();
     var dh = require_dh();
     var HASHLEN = 64;
     var BLOCKLEN = 128;
-    assert3(hmacBlake2b.KEYBYTES === BLOCKLEN, "mismatching hmac BLOCKLEN");
-    assert3(hmacBlake2b.BYTES === HASHLEN, "mismatching hmac HASHLEN");
+    assert(hmacBlake2b.KEYBYTES === BLOCKLEN, "mismatching hmac BLOCKLEN");
+    assert(hmacBlake2b.BYTES === HASHLEN, "mismatching hmac HASHLEN");
     module2.exports = {
       HASHLEN,
       BLOCKLEN,
@@ -3060,8 +3060,8 @@ var require_hash = __commonJS({
       hkdf
     };
     function hash(out, data) {
-      assert3(out.byteLength === HASHLEN);
-      assert3(Array.isArray(data));
+      assert(out.byteLength === HASHLEN);
+      assert(Array.isArray(data));
       crypto_generichash_batch(out, data);
     }
     function hmac(out, key, data) {
@@ -3072,11 +3072,11 @@ var require_hash = __commonJS({
     var Byte0x02 = new Uint8Array([2]);
     var Byte0x03 = new Uint8Array([3]);
     function hkdf(out1, out2, out3, chainingKey, inputKeyMaterial) {
-      assert3(out1.byteLength === HASHLEN);
-      assert3(out2.byteLength === HASHLEN);
-      assert3(out3 == null ? true : out3.byteLength === HASHLEN);
-      assert3(chainingKey.byteLength === HASHLEN);
-      assert3([0, 32, dh.DHLEN, dh.PKLEN].includes(inputKeyMaterial.byteLength));
+      assert(out1.byteLength === HASHLEN);
+      assert(out2.byteLength === HASHLEN);
+      assert(out3 == null ? true : out3.byteLength === HASHLEN);
+      assert(chainingKey.byteLength === HASHLEN);
+      assert([0, 32, dh.DHLEN, dh.PKLEN].includes(inputKeyMaterial.byteLength));
       sodium_memzero(TempKey);
       hmac(TempKey, chainingKey, [inputKeyMaterial]);
       hmac(out1, TempKey, [Byte0x01]);
@@ -3093,7 +3093,7 @@ var require_hash = __commonJS({
 var require_symmetric_state = __commonJS({
   "node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/symmetric-state.js"(exports, module2) {
     var { sodium_malloc, sodium_memzero } = require("sodium-universal/memory");
-    var assert3 = require_nanoassert();
+    var assert = require_nanoassert();
     var cipherState = require_cipher_state();
     var hash = require_hash();
     var STATELEN = hash.HASHLEN + hash.HASHLEN + cipherState.STATELEN;
@@ -3117,8 +3117,8 @@ var require_symmetric_state = __commonJS({
     var CIPHER_BEGIN = HASH_END;
     var CIPHER_END = CIPHER_BEGIN + cipherState.STATELEN;
     function initializeSymmetric(state, protocolName) {
-      assert3(state.byteLength === STATELEN);
-      assert3(protocolName.byteLength != null);
+      assert(state.byteLength === STATELEN);
+      assert(protocolName.byteLength != null);
       sodium_memzero(state);
       if (protocolName.byteLength <= HASHLEN)
         state.set(protocolName, HASH_BEGIN);
@@ -3129,8 +3129,8 @@ var require_symmetric_state = __commonJS({
     }
     var TempKey = sodium_malloc(HASHLEN);
     function mixKey(state, inputKeyMaterial) {
-      assert3(state.byteLength === STATELEN);
-      assert3(inputKeyMaterial.byteLength != null);
+      assert(state.byteLength === STATELEN);
+      assert(inputKeyMaterial.byteLength != null);
       hash.hkdf(
         state.subarray(CHAINING_KEY_BEGIN, CHAINING_KEY_END),
         TempKey,
@@ -3142,14 +3142,14 @@ var require_symmetric_state = __commonJS({
       sodium_memzero(TempKey);
     }
     function mixHash(state, data) {
-      assert3(state.byteLength === STATELEN);
+      assert(state.byteLength === STATELEN);
       var h = state.subarray(HASH_BEGIN, HASH_END);
       hash.hash(h, [h, data]);
     }
     var TempHash = sodium_malloc(HASHLEN);
     function mixKeyAndHash(state, inputKeyMaterial) {
-      assert3(state.byteLength === STATELEN);
-      assert3(inputKeyMaterial.byteLength != null);
+      assert(state.byteLength === STATELEN);
+      assert(inputKeyMaterial.byteLength != null);
       hash.hkdf(
         state.subarray(CHAINING_KEY_BEGIN, CHAINING_KEY_END),
         TempHash,
@@ -3163,14 +3163,14 @@ var require_symmetric_state = __commonJS({
       sodium_memzero(TempKey);
     }
     function getHandshakeHash(state, out) {
-      assert3(state.byteLength === STATELEN);
-      assert3(out.byteLength === HASHLEN);
+      assert(state.byteLength === STATELEN);
+      assert(out.byteLength === HASHLEN);
       out.set(state.subarray(HASH_BEGIN, HASH_END));
     }
     function encryptAndHash(state, ciphertext, plaintext) {
-      assert3(state.byteLength === STATELEN);
-      assert3(ciphertext.byteLength != null);
-      assert3(plaintext.byteLength != null);
+      assert(state.byteLength === STATELEN);
+      assert(ciphertext.byteLength != null);
+      assert(plaintext.byteLength != null);
       var cstate = state.subarray(CIPHER_BEGIN, CIPHER_END);
       var h = state.subarray(HASH_BEGIN, HASH_END);
       cipherState.encryptWithAd(cstate, ciphertext, h, plaintext);
@@ -3181,9 +3181,9 @@ var require_symmetric_state = __commonJS({
     encryptAndHash.bytesRead = 0;
     encryptAndHash.bytesWritten = 0;
     function decryptAndHash(state, plaintext, ciphertext) {
-      assert3(state.byteLength === STATELEN);
-      assert3(plaintext.byteLength != null);
-      assert3(ciphertext.byteLength != null);
+      assert(state.byteLength === STATELEN);
+      assert(plaintext.byteLength != null);
+      assert(ciphertext.byteLength != null);
       var cstate = state.subarray(CIPHER_BEGIN, CIPHER_END);
       var h = state.subarray(HASH_BEGIN, HASH_END);
       cipherState.decryptWithAd(cstate, plaintext, h, ciphertext);
@@ -3197,9 +3197,9 @@ var require_symmetric_state = __commonJS({
     var TempKey2 = sodium_malloc(HASHLEN);
     var zerolen = new Uint8Array(0);
     function split(state, cipherstate1, cipherstate2) {
-      assert3(state.byteLength === STATELEN);
-      assert3(cipherstate1.byteLength === cipherState.STATELEN);
-      assert3(cipherstate2.byteLength === cipherState.STATELEN);
+      assert(state.byteLength === STATELEN);
+      assert(cipherstate1.byteLength === cipherState.STATELEN);
+      assert(cipherstate2.byteLength === cipherState.STATELEN);
       hash.hkdf(
         TempKey1,
         TempKey2,
@@ -3222,7 +3222,7 @@ var require_symmetric_state = __commonJS({
 var require_handshake_state = __commonJS({
   "node_modules/.pnpm/noise-protocol@3.0.1/node_modules/noise-protocol/handshake-state.js"(exports, module2) {
     var { sodium_malloc, sodium_memzero, sodium_free } = require("sodium-universal/memory");
-    var assert3 = require_nanoassert();
+    var assert = require_nanoassert();
     var clone = require_clone();
     var symmetricState = require_symmetric_state();
     var cipherState = require_cipher_state();
@@ -3391,36 +3391,36 @@ var require_handshake_state = __commonJS({
       return buf;
     }
     function initialize(handshakePattern, initiator, prologue, s, e, rs, re) {
-      assert3(Object.keys(PATTERNS).includes(handshakePattern), "Unsupported handshake pattern");
-      assert3(typeof initiator === "boolean", "Initiator must be a boolean");
-      assert3(prologue.byteLength != null, "prolouge must be a Buffer");
-      assert3(e == null ? true : e.publicKey.byteLength === dh.PKLEN, `e.publicKey must be ${dh.PKLEN} bytes`);
-      assert3(e == null ? true : e.secretKey.byteLength === dh.SKLEN, `e.secretKey must be ${dh.SKLEN} bytes`);
-      assert3(rs == null ? true : rs.byteLength === dh.PKLEN, `rs must be ${dh.PKLEN} bytes`);
-      assert3(re == null ? true : re.byteLength === dh.PKLEN, `re must be ${dh.PKLEN} bytes`);
+      assert(Object.keys(PATTERNS).includes(handshakePattern), "Unsupported handshake pattern");
+      assert(typeof initiator === "boolean", "Initiator must be a boolean");
+      assert(prologue.byteLength != null, "prolouge must be a Buffer");
+      assert(e == null ? true : e.publicKey.byteLength === dh.PKLEN, `e.publicKey must be ${dh.PKLEN} bytes`);
+      assert(e == null ? true : e.secretKey.byteLength === dh.SKLEN, `e.secretKey must be ${dh.SKLEN} bytes`);
+      assert(rs == null ? true : rs.byteLength === dh.PKLEN, `rs must be ${dh.PKLEN} bytes`);
+      assert(re == null ? true : re.byteLength === dh.PKLEN, `re must be ${dh.PKLEN} bytes`);
       var state = new HandshakeState();
       var protocolName = Uint8Array.from(`Noise_${handshakePattern}_25519_ChaChaPoly_BLAKE2b`, toCharCode);
       symmetricState.initializeSymmetric(state.symmetricState, protocolName);
       symmetricState.mixHash(state.symmetricState, prologue);
       state.role = initiator === true ? INITIATOR : RESPONDER;
       if (s != null) {
-        assert3(s.publicKey.byteLength === dh.PKLEN, `s.publicKey must be ${dh.PKLEN} bytes`);
-        assert3(s.secretKey.byteLength === dh.SKLEN, `s.secretKey must be ${dh.SKLEN} bytes`);
+        assert(s.publicKey.byteLength === dh.PKLEN, `s.publicKey must be ${dh.PKLEN} bytes`);
+        assert(s.secretKey.byteLength === dh.SKLEN, `s.secretKey must be ${dh.SKLEN} bytes`);
         state.spk = sodiumBufferCopy(s.publicKey);
         state.ssk = sodiumBufferCopy(s.secretKey);
       }
       if (e != null) {
-        assert3(e.publicKey.byteLength === dh.PKLEN);
-        assert3(e.secretKey.byteLength === dh.SKLEN);
+        assert(e.publicKey.byteLength === dh.PKLEN);
+        assert(e.secretKey.byteLength === dh.SKLEN);
         state.epk = sodiumBufferCopy(e.publicKey);
         state.esk = sodiumBufferCopy(e.secretKey);
       }
       if (rs != null) {
-        assert3(rs.byteLength === dh.PKLEN);
+        assert(rs.byteLength === dh.PKLEN);
         state.rs = sodiumBufferCopy(rs);
       }
       if (re != null) {
-        assert3(re.byteLength === dh.PKLEN);
+        assert(re.byteLength === dh.PKLEN);
         state.re = sodiumBufferCopy(re);
       }
       var pat = PATTERNS[handshakePattern];
@@ -3429,11 +3429,11 @@ var require_handshake_state = __commonJS({
         for (var token of pattern) {
           switch (token) {
             case TOK_E:
-              assert3(state.role === patternRole ? state.epk.byteLength != null : state.re.byteLength != null);
+              assert(state.role === patternRole ? state.epk.byteLength != null : state.re.byteLength != null);
               symmetricState.mixHash(state.symmetricState, state.role === patternRole ? state.epk : state.re);
               break;
             case TOK_S:
-              assert3(state.role === patternRole ? state.spk.byteLength != null : state.rs.byteLength != null);
+              assert(state.role === patternRole ? state.spk.byteLength != null : state.rs.byteLength != null);
               symmetricState.mixHash(state.symmetricState, state.role === patternRole ? state.spk : state.rs);
               break;
             default:
@@ -3442,7 +3442,7 @@ var require_handshake_state = __commonJS({
         }
       }
       state.messagePatterns = clone(pat.messagePatterns);
-      assert3(
+      assert(
         state.messagePatterns.filter((p) => p[0] === INITIATOR).some((p) => p.includes(TOK_S)) ? state.spk !== null && state.ssk !== null : true,
         // Default if none is found
         "This handshake pattern requires a static keypair"
@@ -3451,18 +3451,18 @@ var require_handshake_state = __commonJS({
     }
     var DhResult = sodium_malloc(dh.DHLEN);
     function writeMessage(state, payload, messageBuffer) {
-      assert3(state instanceof HandshakeState);
-      assert3(payload.byteLength != null);
-      assert3(messageBuffer.byteLength != null);
+      assert(state instanceof HandshakeState);
+      assert(payload.byteLength != null);
+      assert(messageBuffer.byteLength != null);
       var mpat = state.messagePatterns.shift();
       var moffset = 0;
-      assert3(mpat != null);
-      assert3(state.role === mpat.shift());
+      assert(mpat != null);
+      assert(state.role === mpat.shift());
       for (var token of mpat) {
         switch (token) {
           case TOK_E:
-            assert3(state.epk == null);
-            assert3(state.esk == null);
+            assert(state.epk == null);
+            assert(state.esk == null);
             state.epk = sodium_malloc(dh.PKLEN);
             state.esk = sodium_malloc(dh.SKLEN);
             dh.generateKeypair(state.epk, state.esk);
@@ -3471,7 +3471,7 @@ var require_handshake_state = __commonJS({
             symmetricState.mixHash(state.symmetricState, state.epk);
             break;
           case TOK_S:
-            assert3(state.spk.byteLength === dh.PKLEN);
+            assert(state.spk.byteLength === dh.PKLEN);
             symmetricState.encryptAndHash(state.symmetricState, messageBuffer.subarray(moffset), state.spk);
             moffset += symmetricState.encryptAndHash.bytesWritten;
             break;
@@ -3517,25 +3517,25 @@ var require_handshake_state = __commonJS({
     }
     writeMessage.bytes = 0;
     function readMessage(state, message, payloadBuffer) {
-      assert3(state instanceof HandshakeState);
-      assert3(message.byteLength != null);
-      assert3(payloadBuffer.byteLength != null);
+      assert(state instanceof HandshakeState);
+      assert(message.byteLength != null);
+      assert(payloadBuffer.byteLength != null);
       var mpat = state.messagePatterns.shift();
       var moffset = 0;
-      assert3(mpat != null);
-      assert3(mpat.shift() !== state.role);
+      assert(mpat != null);
+      assert(mpat.shift() !== state.role);
       for (var token of mpat) {
         switch (token) {
           case TOK_E:
-            assert3(state.re == null);
-            assert3(message.byteLength - moffset >= dh.PKLEN);
+            assert(state.re == null);
+            assert(message.byteLength - moffset >= dh.PKLEN);
             state.re = sodium_malloc(dh.PKLEN);
             state.re.set(message.subarray(moffset, moffset + dh.PKLEN));
             moffset += dh.PKLEN;
             symmetricState.mixHash(state.symmetricState, state.re);
             break;
           case TOK_S:
-            assert3(state.rs == null);
+            assert(state.rs == null);
             state.rs = sodium_malloc(dh.PKLEN);
             var bytes = 0;
             if (symmetricState._hasKey(state.symmetricState)) {
@@ -3543,7 +3543,7 @@ var require_handshake_state = __commonJS({
             } else {
               bytes = dh.PKLEN;
             }
-            assert3(message.byteLength - moffset >= bytes);
+            assert(message.byteLength - moffset >= bytes);
             symmetricState.decryptAndHash(
               state.symmetricState,
               state.rs,
@@ -3660,7 +3660,7 @@ var require_simple_handshake = __commonJS({
     var noise = require_noise_protocol();
     var NoiseSymmetricState = require_symmetric_state();
     var NoiseHash = require_hash();
-    var assert3 = require_nanoassert();
+    var assert = require_nanoassert();
     var EMPTY = Buffer.alloc(0);
     function SimpleHandshake(isInitiator, opts) {
       if (!(this instanceof SimpleHandshake))
@@ -3695,11 +3695,11 @@ var require_simple_handshake = __commonJS({
     }
     SimpleHandshake.prototype.recv = function recv(data, cb) {
       var self = this;
-      assert3(self.finished === false, "Should not call recv if finished");
-      assert3(data != null, "must have data");
-      assert3(data.byteLength <= self._rx.byteLength, "too much data received");
-      assert3(self.waiting === true, "Wrong state, not ready to receive data");
-      assert3(self.split == null, "split should be null");
+      assert(self.finished === false, "Should not call recv if finished");
+      assert(data != null, "must have data");
+      assert(data.byteLength <= self._rx.byteLength, "too much data received");
+      assert(self.waiting === true, "Wrong state, not ready to receive data");
+      assert(self.split == null, "split should be null");
       var hasREBefore = self.state.re != null;
       var hasRSBefore = self.state.rs != null;
       try {
@@ -3732,9 +3732,9 @@ var require_simple_handshake = __commonJS({
       }
     };
     SimpleHandshake.prototype.send = function send(data, cb) {
-      assert3(this.finished === false, "Should not call send if finished");
-      assert3(this.waiting === false, "Wrong state, not ready to send data");
-      assert3(this.split == null, "split should be null");
+      assert(this.finished === false, "Should not call send if finished");
+      assert(this.waiting === false, "Wrong state, not ready to send data");
+      assert(this.split == null, "split should be null");
       data = data || EMPTY;
       try {
         this.split = noise.writeMessage(this.state, data, this._tx);
@@ -3752,7 +3752,7 @@ var require_simple_handshake = __commonJS({
       });
     };
     SimpleHandshake.prototype._finish = function _finish(err, msg, cb) {
-      assert3(this.finished === false, "Already finished");
+      assert(this.finished === false, "Already finished");
       const self = this;
       self.finished = true;
       self.waiting = false;
@@ -10674,8 +10674,8 @@ module.exports = __toCommonJS(src_exports);
 var import_hypercore2 = __toESM(require_hypercore());
 
 // packages/common/hypercore/src/crypto.ts
-var import_node_assert = __toESM(require("node:assert"));
 var import_node_util = require("node:util");
+var import_tiny_invariant = __toESM(require("tiny-invariant"));
 var import_crypto = require("@dxos/crypto");
 var import_util = require("@dxos/util");
 var createCodecEncoding = (codec, opts) => ({
@@ -10683,8 +10683,8 @@ var createCodecEncoding = (codec, opts) => ({
   decode: (buffer) => codec.decode(buffer, opts)
 });
 var createCrypto = (signer, publicKey) => {
-  (0, import_node_assert.default)(signer);
-  (0, import_node_assert.default)(publicKey);
+  (0, import_tiny_invariant.default)(signer);
+  (0, import_tiny_invariant.default)(publicKey);
   return {
     sign: (message, secretKey, cb) => {
       (0, import_node_util.callbackify)(signer.sign.bind(signer))(publicKey, message, (err, result) => {
@@ -10730,7 +10730,7 @@ var defaultReplicateOptions = {
 
 // packages/common/hypercore/src/hypercore-factory.ts
 var import_hypercore = __toESM(require_hypercore());
-var import_node_assert2 = __toESM(require("node:assert"));
+var import_tiny_invariant2 = __toESM(require("tiny-invariant"));
 var import_random_access_storage = require("@dxos/random-access-storage");
 
 // packages/common/hypercore/src/util.ts
@@ -10745,7 +10745,7 @@ var HypercoreFactory = class {
   }).createDirectory(), _options) {
     this._root = _root;
     this._options = _options;
-    (0, import_node_assert2.default)(this._root);
+    (0, import_tiny_invariant2.default)(this._root);
   }
   /**
   * Creates a feed using a storage factory prefixed with the feed's key.