@leofcoin/peernet 1.2.28 → 1.2.30

package/README.md

@@ -103,6 +103,50 @@ const hash = await peernet.broadcast('/hello.txt', {
 });
 ```
 
+Files larger than 256 KiB are automatically split into independently hashed pieces. The returned hash identifies a manifest, so receivers can verify every piece and request only pieces they still need. Override the piece size with `chunkSize`:
+
+```js
+const hash = await peernet.broadcast('/video.mp4', {
+  content: videoBytes,
+  chunkSize: 1024 * 1024
+})
+```
+
+For a pausable/resumable download, use the transfer controller:
+
+```js
+const transfer = peernet.download(hash, { pin: true })
+const unsubscribe = transfer.onProgress(({ transferredBytes, totalBytes, state }) => {
+  console.log(state, transferredBytes, totalBytes)
+})
+
+transfer.pause()
+transfer.resume() // already completed pieces are not fetched again
+
+const bytes = await transfer.result
+unsubscribe()
+```
+
+`peernet.cat(hash)` also reassembles chunked files transparently. `pin: true` caches verified pieces in the local data store, allowing a later transfer instance to reuse them.
+
+Downloads pipeline four chunks by default. Known manifest providers are reused for all chunk hashes and chunk requests rotate across those peers, allowing different pieces to arrive concurrently from different providers. Configure the queue with `transferConcurrency`. Chunk size adapts to payload size (256 KiB normally, 1 MiB from 32 MiB, and 4 MiB from 256 MiB); an explicit `chunkSize` always overrides it.
+
+### Large blocks
+
+Blocks larger than 1 MiB are also chunked internally, without changing the public block API or the canonical block hash supplied by the chain:
+
+```js
+await peernet.block.put(blockHash, encodedBlock)
+const encodedBlockAgain = await peernet.block.get(blockHash)
+
+const transfer = peernet.block.download(blockHash)
+transfer.pause()
+transfer.resume()
+const bytes = await transfer.result
+```
+
+The block manifest remains stored under the canonical block hash; individual chunks have their own transport hashes. Peernet verifies every chunk before reconstruction. The chain layer must still verify the reconstructed canonical block hash and perform normal consensus validation before loading it. Defaults can be configured with `blockChunkThreshold` and `blockChunkSize` in the Peernet constructor.
+
 **Broadcast a folder:**
 ```js
 const folderHash = await peernet.broadcast('/my-folder', {
@@ -263,4 +307,3 @@ npm i -g @vandeurenglenn/project
 ## License
 
 MIT
-

package/exports/browser/{browser-CWeoyGUw.js → browser-D-r0O9Qn.js}

@@ -1,4 +1,4 @@
-import { m as getDefaultExportFromCjs } from './identity-CYVPDmkf.js';
+import { m as getDefaultExportFromCjs } from './identity-ChyyZSve.js';
 
 function _mergeNamespaces(n, m) {
 	m.forEach(function (e) {

package/exports/browser/browser-_hiyXwPp.js

@@ -0,0 +1,147 @@
+import { m as getDefaultExportFromCjs } from './identity-ChyyZSve.js';
+
+function _mergeNamespaces(n, m) {
+	m.forEach(function (e) {
+		e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+			if (k !== 'default' && !(k in n)) {
+				var d = Object.getOwnPropertyDescriptor(e, k);
+				Object.defineProperty(n, k, d.get ? d : {
+					enumerable: true,
+					get: function () { return e[k]; }
+				});
+			}
+		});
+	});
+	return Object.freeze(n);
+}
+
+var global;
+var hasRequiredGlobal;
+
+function requireGlobal () {
+	if (hasRequiredGlobal) return global;
+	hasRequiredGlobal = 1;
+	var naiveFallback = function () {
+		if (typeof self === "object" && self) return self;
+		if (typeof window === "object" && window) return window;
+		throw new Error("Unable to resolve global `this`");
+	};
+
+	global = (function () {
+		if (this) return this;
+
+		// Unexpected strict mode (may happen if e.g. bundled into ESM module)
+
+		// Fallback to standard globalThis if available
+		if (typeof globalThis === "object" && globalThis) return globalThis;
+
+		// Thanks @mathiasbynens -> https://mathiasbynens.be/notes/globalthis
+		// In all ES5+ engines global object inherits from Object.prototype
+		// (if you approached one that doesn't please report)
+		try {
+			Object.defineProperty(Object.prototype, "__global__", {
+				get: function () { return this; },
+				configurable: true
+			});
+		} catch (error) {
+			// Unfortunate case of updates to Object.prototype being restricted
+			// via preventExtensions, seal or freeze
+			return naiveFallback();
+		}
+		try {
+			// Safari case (window.__global__ works, but __global__ does not)
+			if (!__global__) return naiveFallback();
+			return __global__;
+		} finally {
+			delete Object.prototype.__global__;
+		}
+	})();
+	return global;
+}
+
+var version$1 = "1.0.35";
+var require$$0 = {
+	version: version$1};
+
+var version;
+var hasRequiredVersion;
+
+function requireVersion () {
+	if (hasRequiredVersion) return version;
+	hasRequiredVersion = 1;
+	version = require$$0.version;
+	return version;
+}
+
+var browser$2;
+var hasRequiredBrowser;
+
+function requireBrowser () {
+	if (hasRequiredBrowser) return browser$2;
+	hasRequiredBrowser = 1;
+	var _globalThis;
+	if (typeof globalThis === 'object') {
+		_globalThis = globalThis;
+	} else {
+		try {
+			_globalThis = requireGlobal();
+		} catch (error) {
+		} finally {
+			if (!_globalThis && typeof window !== 'undefined') { _globalThis = window; }
+			if (!_globalThis) { throw new Error('Could not determine global this'); }
+		}
+	}
+
+	var NativeWebSocket = _globalThis.WebSocket || _globalThis.MozWebSocket;
+	var websocket_version = requireVersion();
+
+
+	/**
+	 * Expose a W3C WebSocket class with just one or two arguments.
+	 */
+	function W3CWebSocket(uri, protocols) {
+		var native_instance;
+
+		if (protocols) {
+			native_instance = new NativeWebSocket(uri, protocols);
+		}
+		else {
+			native_instance = new NativeWebSocket(uri);
+		}
+
+		/**
+		 * 'native_instance' is an instance of nativeWebSocket (the browser's WebSocket
+		 * class). Since it is an Object it will be returned as it is when creating an
+		 * instance of W3CWebSocket via 'new W3CWebSocket()'.
+		 *
+		 * ECMAScript 5: http://bclary.com/2004/11/07/#a-13.2.2
+		 */
+		return native_instance;
+	}
+	if (NativeWebSocket) {
+		['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'].forEach(function(prop) {
+			Object.defineProperty(W3CWebSocket, prop, {
+				get: function() { return NativeWebSocket[prop]; }
+			});
+		});
+	}
+
+	/**
+	 * Module exports.
+	 */
+	browser$2 = {
+	    'w3cwebsocket' : NativeWebSocket ? W3CWebSocket : null,
+	    'version'      : websocket_version
+	};
+	return browser$2;
+}
+
+var browserExports = requireBrowser();
+var browser = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
+
+var browser$1 = /*#__PURE__*/_mergeNamespaces({
+	__proto__: null,
+	default: browser
+}, [browserExports]);
+
+export { browser$1 as b };