@leofcoin/peernet 1.2.1 → 1.2.3

package/exports/browser/peernet.d.ts

@@ -50,6 +50,7 @@ export default class Peernet {
     _peerHandler: PeerDiscovery;
     protos: {};
     version: any;
+    private _inMemoryBroadcasts;
     /**
      * @access public
      * @param {Object} options
@@ -106,6 +107,27 @@ export default class Peernet {
     addRequestHandler(name: any, method: any): void;
     sendMessage(peer: any, id: any, data: any): Promise<any>;
     handleDHT(peer: any, id: any, proto: any): Promise<void>;
+    /**
+     * Broadcasts data to the network and returns a hash that can be used by another peer
+     * to directly connect and download the data from the broadcasting peer.
+     *
+     * @param {Uint8Array|Buffer|Object|string} data - The data to broadcast
+     * @param {string} [storeName='data'] - The store to use for storing the data
+     * @returns {Promise<string>} The hash that can be shared for direct download
+     */
+    /**
+     * Broadcasts data to the network and returns a hash that can be used by another peer
+     * to directly connect and download the data from the broadcasting peer.
+     * The data is kept in memory only and not persisted to storage.
+     * @param {string} path - The path or identifier for the content being broadcasted
+     * @param {{content?: Uint8Array, links?: any[]}} data - The data to broadcast
+   
+     * @returns {Promise<string>} The hash that can be shared for direct download
+     */
+    broadcast(path: string, { content, links }: {
+        content?: Uint8Array;
+        links?: any[];
+    }): Promise<string>;
     handleData(peer: any, id: any, proto: any): Promise<any>;
     handleRequest(peer: any, id: any, proto: any): Promise<void>;
     /**

package/exports/browser/peernet.js

@@ -1,3 +1,3 @@
-export { P as default } from './peernet-CXod4Dva.js';
+export { P as default } from './peernet-BTtebeW3.js';
 import './identity-nIyW_Xm8.js';
 import './value-C3vAp-wb.js';

package/exports/browser/proto/file.proto.d.ts

@@ -1,6 +1,6 @@
 declare const _default: {
     path: string;
-    'content?': string;
+    'content?': Uint8Array<ArrayBuffer>;
     'links?': any[];
 };
 export default _default;

package/exports/{messages-CsDqTaBh.js → messages-C9lYBAhD.js}

@@ -182,7 +182,7 @@ class ChatMessage extends FormatInterface {
 
 var proto = {
     path: String(),
-    'content?': '',
+    'content?': new Uint8Array(),
     'links?': []
 };
 

package/exports/peernet.js

@@ -336,6 +336,7 @@ class Peernet {
     protos;
     version;
     #peerAttempts = {};
+    _inMemoryBroadcasts;
     /**
      * @access public
      * @param {Object} options
@@ -447,7 +448,7 @@ class Peernet {
         this.root = options.root;
         const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
         // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-CsDqTaBh.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-C9lYBAhD.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -612,10 +613,62 @@ class Peernet {
         const node = await this.prepareMessage(data);
         this.sendMessage(peer, id, node.encoded);
     }
+    /**
+     * Broadcasts data to the network and returns a hash that can be used by another peer
+     * to directly connect and download the data from the broadcasting peer.
+     *
+     * @param {Uint8Array|Buffer|Object|string} data - The data to broadcast
+     * @param {string} [storeName='data'] - The store to use for storing the data
+     * @returns {Promise<string>} The hash that can be shared for direct download
+     */
+    /**
+     * Broadcasts data to the network and returns a hash that can be used by another peer
+     * to directly connect and download the data from the broadcasting peer.
+     * The data is kept in memory only and not persisted to storage.
+     * @param {string} path - The path or identifier for the content being broadcasted
+     * @param {{content?: Uint8Array, links?: any[]}} data - The data to broadcast
+   
+     * @returns {Promise<string>} The hash that can be shared for direct download
+     */
+    async broadcast(path, { content, links }) {
+        let protoInput;
+        if (content)
+            protoInput = { path, content };
+        else if (links)
+            protoInput = { path, links };
+        const protoNode = await new globalThis.peernet.protos['peernet-file'](protoInput);
+        const hash = await protoNode.hash();
+        const encoded = await protoNode.encoded;
+        if (!this._inMemoryBroadcasts)
+            this._inMemoryBroadcasts = new Map();
+        this._inMemoryBroadcasts.set(hash, encoded);
+        await this.publish('broadcast', { hash, from: this.id });
+        return hash;
+    }
     async handleData(peer, id, proto) {
         let { hash, store } = proto.decoded;
         let data;
         try {
+            if (this._inMemoryBroadcasts && this._inMemoryBroadcasts.has(hash)) {
+                data = this._inMemoryBroadcasts.get(hash);
+                let resolvedHash = hash;
+                if (typeof hash === 'function') {
+                    resolvedHash = await hash();
+                }
+                // Decode the stored proto to extract the content or links
+                const FileProto = globalThis.peernet.protos['peernet-file'];
+                const fileProto = await new FileProto(data);
+                await fileProto.decode();
+                const { content, links } = fileProto.decoded;
+                console.log(links);
+                data = await new globalThis.peernet.protos['peernet-data-response']({
+                    hash: resolvedHash,
+                    data: links || content
+                });
+                const node = await this.prepareMessage(data);
+                await this.sendMessage(peer, id, node.encoded);
+                return;
+            }
             store = globalThis[`${store}Store`] || (await this.whichStore([...this.stores], hash));
             if (store && !store.private) {
                 data = await store.get(hash);
@@ -625,7 +678,7 @@ class Peernet {
                         data
                     });
                     const node = await this.prepareMessage(data);
-                    this.sendMessage(peer, id, node.encoded);
+                    await this.sendMessage(peer, id, node.encoded);
                 }
             }
             else {
@@ -633,6 +686,7 @@ class Peernet {
             }
         }
         catch (error) {
+            console.error('handleData: error', error);
             return this.requestData(hash, store);
         }
     }

package/exports/types/peernet.d.ts

@@ -50,6 +50,7 @@ export default class Peernet {
     _peerHandler: PeerDiscovery;
     protos: {};
     version: any;
+    private _inMemoryBroadcasts;
     /**
      * @access public
      * @param {Object} options
@@ -106,6 +107,27 @@ export default class Peernet {
     addRequestHandler(name: any, method: any): void;
     sendMessage(peer: any, id: any, data: any): Promise<any>;
     handleDHT(peer: any, id: any, proto: any): Promise<void>;
+    /**
+     * Broadcasts data to the network and returns a hash that can be used by another peer
+     * to directly connect and download the data from the broadcasting peer.
+     *
+     * @param {Uint8Array|Buffer|Object|string} data - The data to broadcast
+     * @param {string} [storeName='data'] - The store to use for storing the data
+     * @returns {Promise<string>} The hash that can be shared for direct download
+     */
+    /**
+     * Broadcasts data to the network and returns a hash that can be used by another peer
+     * to directly connect and download the data from the broadcasting peer.
+     * The data is kept in memory only and not persisted to storage.
+     * @param {string} path - The path or identifier for the content being broadcasted
+     * @param {{content?: Uint8Array, links?: any[]}} data - The data to broadcast
+   
+     * @returns {Promise<string>} The hash that can be shared for direct download
+     */
+    broadcast(path: string, { content, links }: {
+        content?: Uint8Array;
+        links?: any[];
+    }): Promise<string>;
     handleData(peer: any, id: any, proto: any): Promise<any>;
     handleRequest(peer: any, id: any, proto: any): Promise<void>;
     /**

package/exports/types/proto/file.proto.d.ts

@@ -1,6 +1,6 @@
 declare const _default: {
     path: string;
-    'content?': string;
+    'content?': Uint8Array<ArrayBuffer>;
     'links?': any[];
 };
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "",
   "browser": "./exports/browser/peernet.js",
   "exports": {
@@ -37,13 +37,15 @@
     "@leofcoin/identity-utils": "^1.0.2",
     "@leofcoin/multi-wallet": "^3.1.8",
     "@leofcoin/storage": "^3.5.38",
+    "@mapbox/node-pre-gyp": "^2.0.3",
     "@netpeer/swarm": "^0.9.0",
     "@vandeurenglenn/base58": "^1.1.9",
     "@vandeurenglenn/debug": "^1.4.0",
-    "@vandeurenglenn/little-pubsub": "^1.5.1",
-    "inquirer": "^13.1.0",
+    "@vandeurenglenn/little-pubsub": "^1.5.2",
+    "inquirer": "^13.2.1",
     "qr-scanner": "^1.4.2",
-    "qrcode": "^1.5.4"
+    "qrcode": "^1.5.4",
+    "tar": "^7.5.6"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -51,8 +53,8 @@
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
     "@rollup/plugin-wasm": "^6.2.2",
-    "@types/node": "^25.0.3",
+    "@types/node": "^25.0.10",
     "@types/qrcode": "^1.5.6",
-    "rollup": "^4.54.0"
+    "rollup": "^4.56.0"
   }
 }

package/src/peernet.ts

@@ -67,6 +67,7 @@ export default class Peernet {
   version
 
   #peerAttempts: { [key: string]: number } = {}
+  private _inMemoryBroadcasts: any
   /**
    * @access public
    * @param {Object} options
@@ -394,10 +395,65 @@ export default class Peernet {
     this.sendMessage(peer, id, node.encoded)
   }
 
+  /**
+   * Broadcasts data to the network and returns a hash that can be used by another peer
+   * to directly connect and download the data from the broadcasting peer.
+   *
+   * @param {Uint8Array|Buffer|Object|string} data - The data to broadcast
+   * @param {string} [storeName='data'] - The store to use for storing the data
+   * @returns {Promise<string>} The hash that can be shared for direct download
+   */
+  /**
+   * Broadcasts data to the network and returns a hash that can be used by another peer
+   * to directly connect and download the data from the broadcasting peer.
+   * The data is kept in memory only and not persisted to storage.
+   * @param {string} path - The path or identifier for the content being broadcasted
+   * @param {{content?: Uint8Array, links?: any[]}} data - The data to broadcast
+ 
+   * @returns {Promise<string>} The hash that can be shared for direct download
+   */
+  async broadcast(path: string, { content, links }: { content?: Uint8Array; links?: any[] }): Promise<string> {
+    let protoInput: any
+    if (content) protoInput = { path, content }
+    else if (links) protoInput = { path, links }
+
+    const protoNode = await new globalThis.peernet.protos['peernet-file'](protoInput)
+    const hash = await protoNode.hash()
+    const encoded = await protoNode.encoded
+    if (!this._inMemoryBroadcasts) this._inMemoryBroadcasts = new Map()
+    this._inMemoryBroadcasts.set(hash, encoded)
+
+    await this.publish('broadcast', { hash, from: this.id })
+    return hash
+  }
+
   async handleData(peer, id, proto) {
     let { hash, store } = proto.decoded
     let data
     try {
+      if (this._inMemoryBroadcasts && this._inMemoryBroadcasts.has(hash)) {
+        data = this._inMemoryBroadcasts.get(hash)
+        let resolvedHash = hash
+        if (typeof hash === 'function') {
+          resolvedHash = await hash()
+        }
+        // Decode the stored proto to extract the content or links
+        const FileProto = globalThis.peernet.protos['peernet-file']
+        const fileProto = await new FileProto(data)
+        await fileProto.decode()
+        const { content, links } = fileProto.decoded
+        console.log(links)
+
+        data = await new globalThis.peernet.protos['peernet-data-response']({
+          hash: resolvedHash,
+          data: links || content
+        })
+
+        const node = await this.prepareMessage(data)
+        await this.sendMessage(peer, id, node.encoded)
+        return
+      }
+
       store = globalThis[`${store}Store`] || (await this.whichStore([...this.stores], hash))
 
       if (store && !store.private) {
@@ -410,12 +466,13 @@ export default class Peernet {
           })
 
           const node = await this.prepareMessage(data)
-          this.sendMessage(peer, id, node.encoded)
+          await this.sendMessage(peer, id, node.encoded)
         }
       } else {
         // ban (trying to access private st)
       }
     } catch (error) {
+      console.error('handleData: error', error)
       return this.requestData(hash, store)
     }
   }

package/src/proto/file.proto.js

@@ -1,5 +1,5 @@
 export default {
   path: String(),
-  'content?': '',
+  'content?': new Uint8Array(),
   'links?': []
 }

package/test/peernet.test.js

@@ -43,3 +43,262 @@ test('provides callable helpers', () => {
   assert.equal(typeof peernet.publish, 'function')
   assert.equal(typeof peernet.subscribe, 'function')
 })
+
+test('pubsub subscribe registers callback', async () => {
+  const topic = 'test-topic'
+  let callbackCalled = false
+
+  const callback = () => {
+    callbackCalled = true
+  }
+
+  // Subscribe to topic
+  await peernet.subscribe(topic, callback)
+
+  // Manually publish to globalSub to test subscription registration
+  globalThis.globalSub.publish(topic, 'test-data')
+
+  // Give async operation a moment to process
+  await new Promise((resolve) => setTimeout(resolve, 10))
+
+  assert.ok(callbackCalled)
+})
+
+test('addProto registers protocol', () => {
+  const protoName = 'test-protocol'
+  const protoObject = { test: 'data' }
+
+  peernet.addProto(protoName, protoObject)
+
+  assert.equal(globalThis.peernet.protos[protoName], protoObject)
+})
+
+test('addProto does not overwrite existing protocol', () => {
+  const protoName = 'existing-proto'
+  const originalProto = { original: true }
+  const newProto = { new: true }
+
+  peernet.addProto(protoName, originalProto)
+  const firstRegistered = globalThis.peernet.protos[protoName]
+
+  peernet.addProto(protoName, newProto)
+  const afterSecondAdd = globalThis.peernet.protos[protoName]
+
+  assert.equal(firstRegistered, originalProto)
+  assert.equal(afterSecondAdd, originalProto)
+})
+
+test('addCodec is callable', () => {
+  const mockCodec = { name: 'test-codec' }
+  // addCodec may return undefined, just verify it doesn't throw
+  assert.equal(typeof peernet.addCodec, 'function')
+  peernet.addCodec(mockCodec)
+})
+
+test('selectAccount delegates to identity', () => {
+  const accountName = 'test-account'
+  // selectAccount may return undefined, just verify it doesn't throw
+  assert.equal(typeof peernet.selectAccount, 'function')
+})
+
+test('identity has loaded account data', () => {
+  assert.ok(peernet.identity.accounts !== undefined)
+  assert.ok(peernet.identity.selectedAccount !== undefined)
+})
+
+test('peerId matches identity id', () => {
+  assert.equal(peernet.peerId, peernet.identity.id)
+  assert.equal(peernet.id, peernet.identity.id)
+})
+
+test('data store operations', () => {
+  const hash = 'test-hash-123'
+  const testData = new Uint8Array([1, 2, 3, 4, 5])
+
+  // Test put operation - may hang, so just verify method exists
+  assert.equal(typeof peernet.put, 'function')
+
+  // Test has operation - verify method exists
+  assert.equal(typeof peernet.has, 'function')
+})
+
+test('get attempts to retrieve from store', async () => {
+  const hash = 'nonexistent-hash'
+  // Just verify method exists
+  assert.equal(typeof peernet.get, 'function')
+})
+
+test('message object provides get/put/has', () => {
+  const messageObj = peernet.message
+  assert.equal(typeof messageObj.get, 'function')
+  assert.equal(typeof messageObj.put, 'function')
+  assert.equal(typeof messageObj.has, 'function')
+})
+
+test('data object provides get/put/has', () => {
+  const dataObj = peernet.data
+  assert.equal(typeof dataObj.get, 'function')
+  assert.equal(typeof dataObj.put, 'function')
+  assert.equal(typeof dataObj.has, 'function')
+})
+
+test('block object provides get/put/has', () => {
+  const blockObj = peernet.block
+  assert.equal(typeof blockObj.get, 'function')
+  assert.equal(typeof blockObj.put, 'function')
+  assert.equal(typeof blockObj.has, 'function')
+})
+
+test('transaction object provides get/put/has', () => {
+  const txObj = peernet.transaction
+  assert.equal(typeof txObj.get, 'function')
+  assert.equal(typeof txObj.put, 'function')
+  assert.equal(typeof txObj.has, 'function')
+})
+
+test('folder object provides get/put/has', () => {
+  const folderObj = peernet.folder
+  assert.equal(typeof folderObj.get, 'function')
+  assert.equal(typeof folderObj.put, 'function')
+  assert.equal(typeof folderObj.has, 'function')
+})
+
+test('Buffer property is available', () => {
+  assert.ok(peernet.Buffer)
+  assert.equal(peernet.Buffer, Buffer)
+})
+
+test('handleData is callable', () => {
+  assert.equal(typeof peernet.handleData, 'function')
+})
+
+test('handleDHT is callable', () => {
+  assert.equal(typeof peernet.handleDHT, 'function')
+})
+
+test('handleRequest is callable', () => {
+  assert.equal(typeof peernet.handleRequest, 'function')
+})
+
+test('walk is callable', () => {
+  assert.equal(typeof peernet.walk, 'function')
+})
+
+test('providersFor is callable', () => {
+  assert.equal(typeof peernet.providersFor, 'function')
+})
+
+test('addRequestHandler is callable', () => {
+  assert.equal(typeof peernet.addRequestHandler, 'function')
+})
+
+test('sendMessage is callable', () => {
+  assert.equal(typeof peernet.sendMessage, 'function')
+})
+
+test('start method exists', () => {
+  // Just verify method exists and is callable
+  assert.equal(typeof peernet.start, 'function')
+})
+
+test('default stores are initialized', () => {
+  const defaultStores = peernet.defaultStores
+  assert.ok(Array.isArray(defaultStores))
+  assert.ok(defaultStores.includes('account'))
+  assert.ok(defaultStores.includes('wallet'))
+  assert.ok(defaultStores.includes('block'))
+  assert.ok(defaultStores.includes('transaction'))
+  assert.ok(defaultStores.includes('chain'))
+  assert.ok(defaultStores.includes('data'))
+  assert.ok(defaultStores.includes('message'))
+})
+
+test('identity has all expected methods', () => {
+  assert.equal(typeof peernet.identity.sign, 'function')
+  assert.equal(typeof peernet.identity.export, 'function')
+  assert.equal(typeof peernet.identity.import, 'function')
+  assert.equal(typeof peernet.identity.lock, 'function')
+  assert.equal(typeof peernet.identity.unlock, 'function')
+  assert.equal(typeof peernet.identity.getAccounts, 'function')
+})
+
+test('identity wallet is loaded', () => {
+  assert.ok(peernet.identity.id)
+  assert.ok(typeof peernet.identity.id === 'string')
+  assert.ok(peernet.identity.id.length > 0)
+})
+
+test('selected account is set', () => {
+  assert.ok(peernet.identity.selectedAccount)
+  assert.ok(typeof peernet.identity.selectedAccount === 'string')
+})
+
+test('error handling methods exist', () => {
+  assert.equal(typeof peernet.handleDHT, 'function')
+  assert.equal(typeof peernet.handleData, 'function')
+  assert.equal(typeof peernet.handleRequest, 'function')
+})
+
+test('in-memory broadcast and handleData returns correct data', async () => {
+  // Broadcast a valid file object with path
+  const testString = 'hello in-memory world'
+  const path = '/test'
+  const content = new TextEncoder().encode(testString)
+
+  const hash = await peernet.broadcast(path, { content })
+
+  // Prepare a mock peer and capture sendMessage output
+  let sentNode = null
+  const mockPeer = {
+    connected: true,
+    send: async (data, id) => {
+      sentNode = { data, id }
+      return Promise.resolve()
+    }
+  }
+  const proto = {
+    decoded: { hash }
+  }
+  await peernet.handleData(mockPeer, 'test-id', proto)
+
+  assert.ok(sentNode)
+  const DataResponseProto = globalThis.peernet.protos['peernet-data-response']
+  const decodedProto = await new DataResponseProto(sentNode.data)
+  await decodedProto.decode()
+  const decodedContent = new TextDecoder().decode(decodedProto.decoded.data)
+  assert.equal(decodedProto.decoded.hash, hash)
+  assert.equal(decodedContent, testString)
+})
+
+test('in-memory broadcast and handleData supports large binary data', async () => {
+  // Create a large binary buffer (e.g., 1MB)
+  const size = 1024 * 1024 // 1MB
+  const largeBuffer = new Uint8Array(size)
+  for (let i = 0; i < size; i++) largeBuffer[i] = i % 256
+  const path = '/large-binary'
+  const content = largeBuffer
+  const hash = await peernet.broadcast(path, { content })
+
+  // Prepare a mock peer and capture sendMessage output
+  let sentNode = null
+  const mockPeer = {
+    connected: true,
+    send: async (data, id) => {
+      sentNode = { data, id }
+      return Promise.resolve()
+    }
+  }
+  const proto = {
+    decoded: { hash }
+  }
+  await peernet.handleData(mockPeer, 'test-id', proto)
+
+  assert.ok(sentNode)
+  const DataResponseProto = globalThis.peernet.protos['peernet-data-response']
+  const decodedProto = await new DataResponseProto(sentNode.data)
+  await decodedProto.decode()
+  assert.equal(decodedProto.decoded.hash, hash)
+  const receivedBuffer = Buffer.from(decodedProto.decoded.data)
+  const originalBuffer = Buffer.from(largeBuffer)
+  assert.equal(Buffer.compare(receivedBuffer, originalBuffer), 0)
+})

package/test-output.log

@@ -0,0 +1,84 @@
+✔ initializes with provided options (0.407125ms)
+✔ exposes identity instance (0.051667ms)
+✔ has a DHT instance (0.04425ms)
+✔ returns peers and connections safely (0.267542ms)
+✔ provides callable helpers (0.048958ms)
+✔ pubsub subscribe registers callback (10.395584ms)
+✔ addProto registers protocol (0.160417ms)
+✔ addProto does not overwrite existing protocol (0.057709ms)
+✔ addCodec is callable (0.063084ms)
+✔ selectAccount delegates to identity (0.068584ms)
+✔ identity has loaded account data (0.241875ms)
+✔ peerId matches identity id (0.031375ms)
+✔ data store operations (0.030125ms)
+✔ get attempts to retrieve from store (0.035667ms)
+✔ message object provides get/put/has (0.053917ms)
+✔ data object provides get/put/has (0.045833ms)
+✔ block object provides get/put/has (0.067375ms)
+✔ transaction object provides get/put/has (0.042333ms)
+✔ folder object provides get/put/has (0.034167ms)
+✔ Buffer property is available (0.024417ms)
+✔ handleData is callable (0.017709ms)
+✔ handleDHT is callable (0.016167ms)
+✔ handleRequest is callable (0.016417ms)
+✔ walk is callable (0.015459ms)
+✔ providersFor is callable (0.015583ms)
+✔ addRequestHandler is callable (0.015375ms)
+✔ sendMessage is callable (0.01625ms)
+✔ start method exists (0.02675ms)
+✔ default stores are initialized (0.0275ms)
+✔ identity has all expected methods (0.020084ms)
+✔ identity wallet is loaded (0.019333ms)
+✔ selected account is set (0.016208ms)
+✔ error handling methods exist (0.017083ms)
+DEBUG_HANDLE_DATA: entering in-memory branch { hash: 'BA43QACTNQLBH6SW7NO7ZQ63I3USRUBTD5DOWLEUFJGMY6JN2BSUAES54X' }
+DEBUG_HANDLE_DATA: got from _inMemoryBroadcasts {
+  type: 'object',
+  isUint8Array: true,
+  length: 34,
+  slice: [
+    230, 224,   1,   5,  47,
+    116, 101, 115, 116,  21,
+    104, 101, 108, 108, 111,
+     32
+  ]
+}
+✔ in-memory broadcast and handleData returns correct data (4.52275ms)
+DEBUG_HANDLE_DATA: entering in-memory branch { hash: 'BA43QACYLVOY2HRRGV4NOUDQ3GWPQ7YZVBBM5DOKGZIY4UOYMS3K3JSCVV' }
+DEBUG_HANDLE_DATA: got from _inMemoryBroadcasts {
+  type: 'object',
+  isUint8Array: true,
+  length: 1048599,
+  slice: [
+    230, 224,   1,  13, 47, 108,
+     97, 114, 103, 101, 45,  98,
+    105, 110,  97, 114
+  ]
+}
+DEBUG_TEST receivedBuffer {
+  type: 'object',
+  isUint8Array: true,
+  length: 1048576,
+  slice: [
+     0,  1,  2,  3,  4,  5,
+     6,  7,  8,  9, 10, 11,
+    12, 13, 14, 15
+  ]
+}
+DEBUG_TEST originalBuffer {
+  length: 1048576,
+  slice: [
+     0,  1,  2,  3,  4,  5,
+     6,  7,  8,  9, 10, 11,
+    12, 13, 14, 15
+  ]
+}
+✔ in-memory broadcast and handleData supports large binary data (163.195292ms)
+ℹ tests 35
+ℹ suites 0
+ℹ pass 35
+ℹ fail 0
+ℹ cancelled 0
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms 366.132458