@leofcoin/peernet 1.2.2 → 1.2.4

package/README.md

@@ -70,20 +70,84 @@ const password = await passwordPrompt();
 const node = await new Peernet(config, password);
 ```
 
-## In-Memory Broadcasts
+## In-Memory Broadcasts: API and Usage
 
-Peernet supports in-memory data sharing for fast, temporary distribution of files or data objects between peers. This feature allows you to broadcast a file or data object, which is then available for retrieval by other peers (or yourself) until the process is restarted or the in-memory cache is cleared.
+**What is it?**  
+The `broadcast` method allows you to share files or folders with peers, storing them in-memory (not persisted to disk). Data is available for direct retrieval by hash until the process restarts.
+
+**API:**
+```typescript
+// For files:
+peernet.broadcast(path: string, { content: Uint8Array }): Promise<string>
+
+// For folders:
+peernet.broadcast(path: string, { links: Array<{ path: string, hash: string }> }): Promise<string>
+```
+
+**Parameters:**
+- `path` (string): The virtual path or identifier for the file or folder.
+- `content` (Uint8Array): The file data (for files).
+- `links` (Array): An array of `{ path, hash }` objects (for folders).
+
+**Returns:**  
+A `Promise` that resolves to a hash string, which can be used to retrieve the data.
+
+---
+
+### Examples
+
+**Broadcast a file:**
+```js
+const hash = await peernet.broadcast('/hello.txt', {
+  content: new TextEncoder().encode('Hello world!')
+});
+```
+
+**Broadcast a folder:**
+```js
+const folderHash = await peernet.broadcast('/my-folder', {
+  links: [
+    { path: '/hello.txt', hash: hash }
+  ]
+});
+```
+
+**Retrieve data by hash (peer side):**
+```js
+const proto = { decoded: { hash } };
+await peernet.handleData(peer, 'some-id', proto);
+// The peer will receive either .data (for files) or .links (for folders)
+```
+
+---
+
+### Notes
+
+- If you broadcast a folder, only the `links` property is required; `content` should be omitted.
+- If you broadcast a file, only the `content` property is required; `links` should be omitted.
+- The hash returned is unique to the content or folder structure.
+- Data is lost when the process restarts.
+
+### In-Memory Broadcasts
+
+
+Peernet supports in-memory data sharing for fast, temporary distribution of files or folders between peers. This feature allows you to broadcast a file (with content) or a folder (with just links), which is then available for retrieval by other peers (or yourself) until the process is restarted or the in-memory cache is cleared.
 
 ### Usage Example
 
 ```js
-// Broadcast a file or data object in-memory
-const fileObj = {
-  path: '/example',
-  content: new TextEncoder().encode('hello world'),
-  links: []
-};
-const hash = await peernet.broadcast(fileObj);
+// Broadcast a file in-memory
+const hash = await peernet.broadcast('/example', {
+  content: new TextEncoder().encode('hello world')
+});
+
+// Broadcast a folder (just links) in-memory
+const folderHash = await peernet.broadcast('/folder', {
+  links: [
+    { path: '/file1', hash: 'hash1' },
+    { path: '/file2', hash: 'hash2' }
+  ]
+});
 
 // Another peer can request the data by hash
 // (handled internally by peernet.handleData)
@@ -92,16 +156,22 @@ const hash = await peernet.broadcast(fileObj);
 ### Detailed Example
 
 ```js
-// 1. Broadcast a file object in-memory
-const fileObj = {
-  path: '/example',
-  content: new TextEncoder().encode('Hello Peernet!'),
-  links: []
-};
-const hash = await peernet.broadcast(fileObj);
+// 1. Broadcast a file in-memory
+const hash = await peernet.broadcast('/example', {
+  content: new TextEncoder().encode('Hello Peernet!')
+});
 console.log('Broadcasted hash:', hash);
 
-// 2. Simulate a peer requesting the data by hash
+// 2. Broadcast a folder in-memory
+const folderHash = await peernet.broadcast('/folder', {
+  links: [
+    { path: '/file1', hash: 'hash1' },
+    { path: '/file2', hash: 'hash2' }
+  ]
+});
+console.log('Broadcasted folder hash:', folderHash);
+
+// 3. Simulate a peer requesting the data by hash
 const mockPeer = {
   connected: true,
   send: async (data, id) => {
@@ -109,8 +179,12 @@ const mockPeer = {
     const DataResponseProto = globalThis.peernet.protos['peernet-data-response'];
     const decodedProto = await new DataResponseProto(data);
     await decodedProto.decode();
-    const decodedContent = new TextDecoder().decode(decodedProto.decoded.data);
-    console.log('Received content:', decodedContent);
+    if (decodedProto.decoded.data) {
+      const decodedContent = new TextDecoder().decode(decodedProto.decoded.data);
+      console.log('Received content:', decodedContent);
+    } else if (decodedProto.decoded.links) {
+      console.log('Received folder links:', decodedProto.decoded.links);
+    }
   }
 };
 const proto = { decoded: { hash } };
@@ -138,6 +212,27 @@ await peernet.handleData(mockPeer, 'test-id', proto);
 
 Automated tests verify that broadcasting and retrieving in-memory data works as expected, including content integrity and hash matching.
 
+## Folder Support (Files with Just Links)
+
+
+Peernet supports "folders" as special file objects that contain only links to other files, without any content. This allows you to represent directory structures or collections of files.
+
+**Example: Broadcasting a Folder**
+```js
+const folderHash = await peernet.broadcast('/folder', {
+  links: [
+    { path: '/file1', hash: 'hash1' },
+    { path: '/file2', hash: 'hash2' }
+  ]
+});
+```
+
+**Retrieving a Folder**
+When a folder is retrieved (e.g., via `handleData`), its `links` array will be preserved, and `content` will be empty or undefined.
+
+**Test Coverage**
+Automated tests verify that broadcasting and retrieving folders works as expected, ensuring the links are preserved and content is empty or undefined.
+
 ## Development
 
 > **Note:** You need to install [jsproject](https://www.npmjs.com/package/@vandeurenglenn/project)

package/exports/browser/{client-BqvqxCzm.js → client-7chRAqOy.js}

@@ -1,4 +1,4 @@
-import { L as LittlePubSub, d as deflate_1, i as inflate_1, c as createDebugger } from './peernet-BuZSSOa0.js';
+import { L as LittlePubSub, d as deflate_1, i as inflate_1, c as createDebugger } from './peernet-D6QlSJ6B.js';
 import './identity-nIyW_Xm8.js';
 import './value-C3vAp-wb.js';
 
@@ -599,6 +599,8 @@ class Client {
                     url: 'join',
                     params: { version: this.version, peerId: this.peerId }
                 });
+                globalThis.pubsub.publishVerbose('star:connected', star);
+                debug(`setupStar ${star} succeeded`);
                 return this.#stars[star];
             }
             catch (e) {

package/exports/browser/{messages-C-z7iw3I.js → messages-BVmbvFj4.js}

@@ -1,4 +1,4 @@
-import { F as FormatInterface } from './peernet-BuZSSOa0.js';
+import { F as FormatInterface } from './peernet-D6QlSJ6B.js';
 import './identity-nIyW_Xm8.js';
 import './value-C3vAp-wb.js';
 

package/exports/browser/{peernet-BuZSSOa0.js → peernet-D6QlSJ6B.js}

@@ -8380,7 +8380,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-C-z7iw3I.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-BVmbvFj4.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8474,7 +8474,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-BqvqxCzm.js');
+        const importee = await import('./client-7chRAqOy.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -8557,25 +8557,17 @@ class Peernet {
      * 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 {Uint8Array|Buffer|Object|string} data - The data to broadcast
+     * @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(data) {
+    async broadcast(path, { content, links }) {
         let protoInput;
-        if (typeof data === 'string') {
-            protoInput = { path: '/', content: new TextEncoder().encode(data) };
-        }
-        else if (data instanceof Uint8Array || data instanceof Buffer) {
-            protoInput = { path: '/', content: data };
-        }
-        else if (typeof data === 'object' && data.path) {
-            protoInput = data;
-        }
-        else {
-            // fallback: treat as JSON string
-            protoInput = { path: '/', content: new TextEncoder().encode(JSON.stringify(data)) };
-        }
+        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;
@@ -8595,14 +8587,15 @@ class Peernet {
                 if (typeof hash === 'function') {
                     resolvedHash = await hash();
                 }
-                // Decode the stored proto to extract the content
+                // 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 fileContent = fileProto.decoded.content;
+                const { content, links } = fileProto.decoded;
+                console.log(links);
                 data = await new globalThis.peernet.protos['peernet-data-response']({
                     hash: resolvedHash,
-                    data: fileContent
+                    data: links || content
                 });
                 const node = await this.prepareMessage(data);
                 await this.sendMessage(peer, id, node.encoded);

package/exports/browser/peernet.d.ts

@@ -119,15 +119,15 @@ export default class Peernet {
      * 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 {Uint8Array|Buffer|Object|string} data - The data to broadcast
+     * @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(data: Uint8Array | Buffer | {
-        path: string;
+    broadcast(path: string, { content, links }: {
         content?: Uint8Array;
         links?: any[];
-    } | string): Promise<string>;
+    }): 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-BuZSSOa0.js';
+export { P as default } from './peernet-D6QlSJ6B.js';
 import './identity-nIyW_Xm8.js';
 import './value-C3vAp-wb.js';

package/exports/peernet.js

@@ -625,25 +625,17 @@ class Peernet {
      * 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 {Uint8Array|Buffer|Object|string} data - The data to broadcast
+     * @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(data) {
+    async broadcast(path, { content, links }) {
         let protoInput;
-        if (typeof data === 'string') {
-            protoInput = { path: '/', content: new TextEncoder().encode(data) };
-        }
-        else if (data instanceof Uint8Array || data instanceof Buffer) {
-            protoInput = { path: '/', content: data };
-        }
-        else if (typeof data === 'object' && data.path) {
-            protoInput = data;
-        }
-        else {
-            // fallback: treat as JSON string
-            protoInput = { path: '/', content: new TextEncoder().encode(JSON.stringify(data)) };
-        }
+        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;
@@ -663,14 +655,15 @@ class Peernet {
                 if (typeof hash === 'function') {
                     resolvedHash = await hash();
                 }
-                // Decode the stored proto to extract the content
+                // 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 fileContent = fileProto.decoded.content;
+                const { content, links } = fileProto.decoded;
+                console.log(links);
                 data = await new globalThis.peernet.protos['peernet-data-response']({
                     hash: resolvedHash,
-                    data: fileContent
+                    data: links || content
                 });
                 const node = await this.prepareMessage(data);
                 await this.sendMessage(peer, id, node.encoded);

package/exports/types/peernet.d.ts

@@ -119,15 +119,15 @@ export default class Peernet {
      * 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 {Uint8Array|Buffer|Object|string} data - The data to broadcast
+     * @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(data: Uint8Array | Buffer | {
-        path: string;
+    broadcast(path: string, { content, links }: {
         content?: Uint8Array;
         links?: any[];
-    } | string): Promise<string>;
+    }): Promise<string>;
     handleData(peer: any, id: any, proto: any): Promise<any>;
     handleRequest(peer: any, id: any, proto: any): Promise<void>;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/peernet",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "",
   "browser": "./exports/browser/peernet.js",
   "exports": {
@@ -38,14 +38,14 @@
     "@leofcoin/multi-wallet": "^3.1.8",
     "@leofcoin/storage": "^3.5.38",
     "@mapbox/node-pre-gyp": "^2.0.3",
-    "@netpeer/swarm": "^0.9.0",
+    "@netpeer/swarm": "^0.9.1",
     "@vandeurenglenn/base58": "^1.1.9",
     "@vandeurenglenn/debug": "^1.4.0",
     "@vandeurenglenn/little-pubsub": "^1.5.2",
-    "inquirer": "^13.2.1",
+    "inquirer": "^13.2.2",
     "qr-scanner": "^1.4.2",
     "qrcode": "^1.5.4",
-    "tar": "^7.5.6"
+    "tar": "^7.5.7"
   },
   "devDependencies": {
     "@rollup/plugin-commonjs": "^29.0.0",
@@ -53,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.10",
+    "@types/node": "^25.2.0",
     "@types/qrcode": "^1.5.6",
-    "rollup": "^4.56.0"
+    "rollup": "^4.57.1"
   }
 }

package/src/peernet.ts

@@ -407,24 +407,15 @@ export default class Peernet {
    * 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 {Uint8Array|Buffer|Object|string} data - The data to broadcast
+   * @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(
-    data: Uint8Array | Buffer | { path: string; content?: Uint8Array; links?: any[] } | string
-  ): Promise<string> {
+  async broadcast(path: string, { content, links }: { content?: Uint8Array; links?: any[] }): Promise<string> {
     let protoInput: any
-    if (typeof data === 'string') {
-      protoInput = { path: '/', content: new TextEncoder().encode(data) }
-    } else if (data instanceof Uint8Array || data instanceof Buffer) {
-      protoInput = { path: '/', content: data }
-    } else if (typeof data === 'object' && data.path) {
-      protoInput = data
-    } else {
-      // fallback: treat as JSON string
-      protoInput = { path: '/', content: new TextEncoder().encode(JSON.stringify(data)) }
-    }
+    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()
@@ -446,15 +437,18 @@ export default class Peernet {
         if (typeof hash === 'function') {
           resolvedHash = await hash()
         }
-        // Decode the stored proto to extract the content
+        // 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 fileContent = fileProto.decoded.content
+        const { content, links } = fileProto.decoded
+        console.log(links)
+
         data = await new globalThis.peernet.protos['peernet-data-response']({
           hash: resolvedHash,
-          data: fileContent
+          data: links || content
         })
+
         const node = await this.prepareMessage(data)
         await this.sendMessage(peer, id, node.encoded)
         return

package/test/peernet.test.js

@@ -242,12 +242,10 @@ test('error handling methods exist', () => {
 test('in-memory broadcast and handleData returns correct data', async () => {
   // Broadcast a valid file object with path
   const testString = 'hello in-memory world'
-  const fileObj = {
-    path: '/test',
-    content: new TextEncoder().encode(testString),
-    links: []
-  }
-  const hash = await peernet.broadcast(fileObj)
+  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
@@ -277,12 +275,9 @@ test('in-memory broadcast and handleData supports large binary data', async () =
   const size = 1024 * 1024 // 1MB
   const largeBuffer = new Uint8Array(size)
   for (let i = 0; i < size; i++) largeBuffer[i] = i % 256
-  const fileObj = {
-    path: '/large-binary',
-    content: largeBuffer,
-    links: []
-  }
-  const hash = await peernet.broadcast(fileObj)
+  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