omnipin 2.1.1 → 2.1.2

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-var dag_pb_src_namespaceObject, car_namespaceObject, src_cbor_namespaceObject, schema_link_namespaceObject, request_namespaceObject, response_namespaceObject, sha256_namespaceObject, base10_namespaceObject, base16_namespaceObject, base2_namespaceObject, base256emoji_namespaceObject, base32_namespaceObject, base36_namespaceObject, base58_namespaceObject, base64_namespaceObject, base8_namespaceObject, bases_identity_namespaceObject, raw_namespaceObject, identity_namespaceObject, hashes_sha2_namespaceObject, MSB, MSBALL, INT, MSB$1, REST$1, _computedKey, _computedKey1, __require, Queue, Counter, Aborter, Walker, APIBuilder, Builder, codec_CODEC_TYPES, unixfs_Data, unixfs_UnixTime, unixfs_Metadata, COMPRESSED$1, COMPRESSED, curveDef, CODEC_TYPES, Data, DataType, __DataTypeValues, UnixTime, Metadata;
+var dag_pb_src_namespaceObject, car_namespaceObject, src_cbor_namespaceObject, schema_link_namespaceObject, request_namespaceObject, response_namespaceObject, sha256_namespaceObject, base10_namespaceObject, base16_namespaceObject, base2_namespaceObject, base256emoji_namespaceObject, base32_namespaceObject, base36_namespaceObject, base58_namespaceObject, base64_namespaceObject, base8_namespaceObject, bases_identity_namespaceObject, raw_namespaceObject, identity_namespaceObject, hashes_sha2_namespaceObject, MSB, MSBALL, INT, MSB$1, REST$1, _computedKey, __require, Queue, Counter, Aborter, Walker, APIBuilder, Builder, codec_CODEC_TYPES, unixfs_Data, unixfs_UnixTime, unixfs_Metadata, COMPRESSED$1, COMPRESSED, curveDef, CODEC_TYPES, Data, DataType, __DataTypeValues, UnixTime, Metadata;
 let _sha512Sync, _fsReadFn, _fsWriteFn, SHIFTED_RANK, EXCLUSIONS, DECOMP, RECOMP, MAPPED, IGNORED, CM, NSM, ESCAPE, GROUPS, WHOLE_VALID, WHOLE_MAP, VALID, EMOJI_LIST, EMOJI_ROOT, create, slab, SIZE, MAX, offset, __DataTypeValues1, _codec, _codec1, _codec2;
 function makeFullPath(cli, path = []) {
     return cli.parent ? makeFullPath(cli.parent, path) : path;
@@ -1430,7 +1430,7 @@ function parseError(error) {
         stack: error instanceof Error ? error.stack : void 0
     });
 }
-function Provider_from(provider, _options = {}) {
+function Provider_from(provider) {
     if (!provider) throw new IsUndefinedError();
     return {
         ...provider,
@@ -2128,18 +2128,18 @@ function AbiParameters_decode(parameters, data, options = {}) {
             if ('address' === param.type) return function(cursor, options = {}) {
                 let address, { checksum = !1 } = options;
                 return [
-                    (address = Hex_fromBytes(function(value, start, end, options = {}) {
+                    (address = Hex_fromBytes(function(value, options = {}) {
                         let { strict } = options;
                         !1;
                         let value_ = value.slice(-20, void 0);
-                        return strict && function(value, start, end) {
+                        return strict && function(value, end) {
                             if ('number' == typeof end && Bytes_size(value) !== end - -20) throw new Bytes_SliceOffsetOutOfBoundsError({
                                 offset: end,
                                 position: 'end',
                                 size: Bytes_size(value)
                             });
-                        }(value_, 0, void 0), value_;
-                    }(cursor.readBytes(32), 0)), checksum ? Address_checksum(address) : address),
+                        }(value_, void 0), value_;
+                    }(cursor.readBytes(32))), checksum ? Address_checksum(address) : address),
                     32
                 ];
             }(cursor, {
@@ -2431,7 +2431,7 @@ function AbiError_decode(...parameters) {
         if (Array.isArray(parameters[0])) {
             let [abi, name, data, options] = parameters;
             return [
-                function(abi, name, options) {
+                function(abi, name) {
                     if ('Error' === name) return solidityError;
                     if ('Panic' === name) return solidityPanic;
                     if (validate(name, {
@@ -2982,7 +2982,7 @@ async function esm_verify(sig, message, publicKey) {
     return k = modlLE(hashed), kA = ExtendedPoint.fromAffine(pub).multiplyUnsafe(k), ExtendedPoint.fromAffine(r).add(kA).subtract(SB).multiplyUnsafe(esm_CURVE.h).equals(ExtendedPoint.ZERO);
 }
 function bytesEncoder(bytes) {
-    let bytesString = base64.encode(bytes).slice(1);
+    let bytesString = base64_base64.encode(bytes).slice(1);
     return [
         new Token(Type.map, 1 / 0, 1),
         new Token(Type.string, '/', 1),
@@ -3027,35 +3027,20 @@ function parseAbility(ability) {
     };
 }
 async function setup({ pk, proof }) {
-    let principal = signer_parse(pk), agentData = {
+    let agentData = {
         meta: {
             name: 'agent',
             type: 'device'
         },
-        principal,
+        principal: signer_parse(pk),
         delegations: new Map()
     }, agent = new Agent(agentData);
     try {
         let delegation = await proof_parse(proof), space = fromDelegation(delegation);
-        agentData.delegations.set(delegation.cid.toString(), {
+        return agentData.delegations.set(delegation.cid.toString(), {
             delegation,
             meta: {}
-        });
-        let raw = {
-            meta: agentData.meta,
-            principal: principal.toArchive(),
-            delegations: new Map()
-        };
-        for (let [key, value] of agentData.delegations)raw.delegations.set(key, {
-            meta: value.meta,
-            delegation: [
-                ...value.delegation.export()
-            ].map((b)=>({
-                    cid: b.cid.toString(),
-                    bytes: b.bytes.buffer.slice(b.bytes.byteOffset, b.bytes.byteOffset + b.bytes.byteLength)
-                }))
-        });
-        return {
+        }), {
             agent,
             space
         };
@@ -3082,20 +3067,15 @@ async function retry(fn, options = {}) {
     throw Error('Unexpected retry loop end');
 }
 async function poll(taskCid) {
-    return await retry(async ()=>{
-        let res = await receipts_get(taskCid);
-        if (res.error) if ('ReceiptNotFound' === res.error.name) throw res.error;
-        else throw new DOMException(`failed to fetch receipt for task: ${taskCid}`, 'AbortError');
-        return res.ok;
-    }, {
-        onFailedAttempt: console.warn,
-        retries: REQUEST_RETRIES
-    });
+    await new Promise((r)=>setTimeout(r, WAIT_MS));
+    let res = await receipts_get(taskCid);
+    if (res.error) throw res.error;
+    return res.ok;
 }
 async function receipts_get(taskCid) {
     let url = new URL(taskCid.toString(), receiptsEndpoint), workflowResponse = await fetch(url);
     if (404 === workflowResponse.status) return {
-        error: new ReceiptNotFound(taskCid)
+        error: new DOMException('Receipt not found', 'NotFoundError')
     };
     let agentMessageBytes = new Uint8Array(await workflowResponse.arrayBuffer()), agentMessage = await request_decode({
         body: agentMessageBytes,
@@ -3119,7 +3099,7 @@ async function receipts_get(taskCid) {
             };
         }
         return {
-            error: new ReceiptMissing(taskCid)
+            error: new DOMException(`failed to fetch receipt for task: ${taskCid}`, 'AbortError')
         };
     }
     return {
@@ -3582,7 +3562,7 @@ function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
                 newCommonPath.pop();
                 break;
             }
-            if (part !== props.commonPath[i] || function(pattern, options) {
+            if (part !== props.commonPath[i] || function(pattern) {
                 let scan = picomatch.scan(pattern);
                 return scan.isGlob || scan.negated;
             }(part) || i === parts.length - 1) break;
@@ -3685,12 +3665,12 @@ async function glob(patternsOrOptions, options) {
                 return "." !== relativePath && !partialMatcher(relativePath) || ignore(relativePath);
             },
             fs: options.fs ? {
-                readdir: options.fs.readdir || __rspack_external_fs.default.readdir,
-                readdirSync: options.fs.readdirSync || __rspack_external_fs.default.readdirSync,
-                realpath: options.fs.realpath || __rspack_external_fs.default.realpath,
-                realpathSync: options.fs.realpathSync || __rspack_external_fs.default.realpathSync,
-                stat: options.fs.stat || __rspack_external_fs.default.stat,
-                statSync: options.fs.statSync || __rspack_external_fs.default.statSync
+                readdir: options.fs.readdir || fs_0.readdir,
+                readdirSync: options.fs.readdirSync || fs_0.readdirSync,
+                realpath: options.fs.realpath || fs_0.realpath,
+                realpathSync: options.fs.realpathSync || fs_0.realpathSync,
+                stat: options.fs.stat || fs_0.stat,
+                statSync: options.fs.statSync || fs_0.statSync
             } : void 0,
             pathSeparator: "/",
             relativePaths: !0,
@@ -4135,6 +4115,30 @@ async function* buildFileBatch(file, blockstore, options) {
 function isSingleBlockImport(result) {
     return !0 === result.single;
 }
+function varintLen(x) {
+    var x1;
+    let n;
+    return x % 2 == 0 && x++, Math.floor((n = 0, (x1 = x) >= pb_size_maxInt32 && (x1 = Math.floor(x1 / pb_size_maxInt32), n = 32), x1 >= 65536 && (x1 >>>= 16, n += 16), x1 >= 256 && (x1 >>>= 8, n += 8), (n + pb_size_len8tab[x1] + 6) / 7));
+}
+function utf8ByteLength(str) {
+    let len = 0;
+    for(let i = 0; i < str.length; i++){
+        let c = str.charCodeAt(i);
+        c < 0x80 ? len++ : c < 0x800 ? len += 2 : c >= 0xD800 && c <= 0xDBFF && i + 1 < str.length ? (i++, len += 4) : len += 3;
+    }
+    return len;
+}
+function estimateLinkSize(nameBytes, child) {
+    return child?.cid != null && child?.size != null ? nameBytes + child.cid.byteLength : 0;
+}
+function calculateLinkSize(nameBytes, child) {
+    if (child?.cid != null && child?.size != null) {
+        var cidByteLength, tsize;
+        let linkLen;
+        return cidByteLength = child.cid.byteLength, tsize = Number(child.size), linkLen = 1 + varintLen(cidByteLength) + cidByteLength + (1 + varintLen(nameBytes) + nameBytes) + (1 + varintLen(tsize)), 1 + varintLen(linkLen) + linkLen;
+    }
+    return 0;
+}
 function add64(a, b) {
     let lo = a.lo + b.lo >>> 0, hi = a.hi + b.hi + +(lo < a.lo) >>> 0;
     return {
@@ -4290,13 +4294,13 @@ async function* dir_sharded_flush(bucket, blockstore, shardRoot, options) {
         if (child instanceof Bucket) {
             let shard;
             for await (let subShard of dir_sharded_flush(child, blockstore, null, options))shard = subShard;
-            if (null == shard) throw Error('Could not flush sharded directory, no subshard found');
+            if (null == shard) throw Error('Could not flush sharded directory, no sub-shard found');
             links.push({
                 Name: labelPrefix,
                 Tsize: Number(shard.size),
                 Hash: shard.cid
             }), childrenSize += shard.size;
-        } else if ('function' == typeof child.value.flush) {
+        } else if (dir_sharded_isDir(child.value)) {
             let flushedDir;
             for await (let entry of child.value.flush(blockstore))flushedDir = entry, yield flushedDir;
             if (null == flushedDir) throw Error('Did not flush dir');
@@ -4321,7 +4325,7 @@ async function* dir_sharded_flush(bucket, blockstore, shardRoot, options) {
         type: 'hamt-sharded-directory',
         data: Uint8Array.from(children.bitField().reverse()),
         fanout: BigInt(bucket.tableSize()),
-        hashType: HAMT_HASH_CODE,
+        hashType: DEFAULT_SHARD_HASH_CODE,
         mtime: shardRoot?.mtime,
         mode: shardRoot?.mode
     }), buffer = dag_pb_src_encode(util_prepare({
@@ -4334,20 +4338,69 @@ async function* dir_sharded_flush(bucket, blockstore, shardRoot, options) {
         size
     };
 }
-async function flatToShard(child, dir, threshold, options) {
-    let newDir = dir;
-    dir instanceof DirFlat && dir.estimateNodeSize() > threshold && (newDir = await convertToShard(dir, options));
+function dir_sharded_isDir(obj) {
+    return 'function' == typeof obj.flush;
+}
+async function calculateSize(bucket, shardRoot, blocks, options) {
+    let children = bucket._children, padLength = (bucket.tableSize() - 1).toString(16).length, links = [], sizeEstimate = 0;
+    for(let i = 0; i < children.length; i++){
+        let child = children.get(i);
+        if (null == child) continue;
+        let labelPrefix = i.toString(16).toUpperCase().padStart(padLength, '0');
+        if (child instanceof Bucket) {
+            let { size, cid } = await calculateSize(child, null, blocks, options);
+            links.push({
+                Name: labelPrefix,
+                Tsize: Number(size),
+                Hash: cid
+            }), sizeEstimate += labelPrefix.length + cid.byteLength;
+        } else if (dir_sharded_isDir(child.value)) {
+            let dir = child.value, size = dir.nodeSize;
+            if (null == dir.cid) throw Error('Child directory has not been persisted');
+            links.push({
+                Name: labelPrefix + child.key,
+                Tsize: Number(size),
+                Hash: dir.cid
+            }), sizeEstimate += labelPrefix.length + dir.cid.byteLength;
+        } else {
+            let value = child.value, label = labelPrefix + child.key, size = value.size;
+            links.push({
+                Name: label,
+                Tsize: Number(size),
+                Hash: value.cid
+            }), sizeEstimate += labelPrefix.length + value.cid.byteLength;
+        }
+    }
+    let buffer = dag_pb_src_encode(util_prepare({
+        Data: new UnixFS({
+            type: 'hamt-sharded-directory',
+            data: Uint8Array.from(children.bitField().reverse()),
+            fanout: BigInt(bucket.tableSize()),
+            hashType: DEFAULT_SHARD_HASH_CODE,
+            mtime: shardRoot?.mtime,
+            mode: shardRoot?.mode
+        }).marshal(),
+        Links: links
+    }));
+    return {
+        cid: await persist(buffer, blocks, options),
+        size: 'links-bytes' === options.shardSplitStrategy ? sizeEstimate : buffer.length
+    };
+}
+async function flatToShard(child, dir) {
+    let newDir = dir, shardSplitThresholdBytes = dir.options.shardSplitThresholdBytes ?? 262144;
+    dir instanceof DirFlat && await dir.estimateNodeSize() > shardSplitThresholdBytes && (newDir = await convertToShard(dir));
     let parent = newDir.parent;
     if (null != parent) {
         if (newDir !== dir) {
             if (null != child && (child.parent = newDir), null == newDir.parentKey) throw Error('No parent key found');
             await parent.put(newDir.parentKey, newDir);
         }
-        return flatToShard(newDir, parent, threshold, options);
+        return flatToShard(newDir, parent);
     }
     return newDir;
 }
-async function convertToShard(oldDir, options) {
+async function convertToShard(oldDir) {
     let newDir = new dir_sharded({
         root: oldDir.root,
         dir: !0,
@@ -4358,7 +4411,7 @@ async function convertToShard(oldDir, options) {
         flat: !1,
         mtime: oldDir.mtime,
         mode: oldDir.mode
-    }, options);
+    }, oldDir.options);
     for (let { key, child } of oldDir.eachChildSeries())await newDir.put(key, child);
     return newDir;
 }
@@ -4368,7 +4421,7 @@ async function addToTree(elem, tree, options) {
         let pathElem = pathElems[i];
         currentPath += `${'' !== currentPath ? '/' : ''}${pathElem}`;
         let last = i === lastIndex;
-        if (parent.dirty = !0, parent.cid = void 0, parent.size = void 0, last) await parent.put(pathElem, elem), tree = await flatToShard(null, parent, options.shardSplitThresholdBytes, options);
+        if (parent.dirty = !0, parent.cid = void 0, parent.size = void 0, last) await parent.put(pathElem, elem), tree = await flatToShard(null, parent);
         else {
             let dir = await parent.get(pathElem);
             null != dir && dir instanceof Dir || (dir = new DirFlat({
@@ -4394,21 +4447,25 @@ async function* flushAndYield(tree, blockstore) {
     yield* tree.flush(blockstore);
 }
 async function* src_importer(source, blockstore, options = {}) {
-    var options1, options2, options3;
-    let candidates, maxChildrenPerNode;
+    var options1, options2, options3, options4;
+    let candidates, chunkSize, maxChildrenPerNode, maxChildrenPerNode1;
     candidates = Symbol.asyncIterator in source || Symbol.iterator in source ? source : [
         source
-    ];
-    let wrapWithDirectory = options.wrapWithDirectory ?? !1, shardSplitThresholdBytes = options.shardSplitThresholdBytes ?? 262144, shardFanoutBits = options.shardFanoutBits ?? 8, cidVersion = options.cidVersion ?? 1, rawLeaves = options.rawLeaves ?? !0, leafType = options.leafType ?? 'file', fileImportConcurrency = options.fileImportConcurrency ?? 50, blockWriteConcurrency = options.blockWriteConcurrency ?? 10, reduceSingleLeafToSelf = options.reduceSingleLeafToSelf ?? !0, chunker = options.chunker ?? fixedSize(), chunkValidator = options.chunkValidator ?? defaultChunkValidator(), buildDag = options.dagBuilder ?? (options2 = {
+    ], 'unixfs-v0-2015' === options.profile ? (options.shardSplitStrategy = options.shardSplitStrategy ?? 'links-bytes', options.cidVersion = options.cidVersion ?? 0, options.rawLeaves = options.rawLeaves ?? !1, chunkSize = 262144, maxChildrenPerNode = 174) : 'unixfs-v1-2025' === options.profile && (options.shardSplitStrategy = options.shardSplitStrategy ?? 'block-bytes', options.cidVersion = options.cidVersion ?? 1, options.rawLeaves = options.rawLeaves ?? !0, chunkSize = DEFAULT_CHUNK_SIZE_1MIB, maxChildrenPerNode = 1024);
+    let wrapWithDirectory = options.wrapWithDirectory ?? !1, shardSplitThresholdBytes = options.shardSplitThresholdBytes ?? 262144, shardSplitStrategy = options.shardSplitStrategy ?? DEFAULT_SHARD_SPLIT_STRATEGY, shardFanoutBits = options.shardFanoutBits ?? 8, cidVersion = options.cidVersion ?? 1, rawLeaves = options.rawLeaves ?? !0, leafType = options.leafType ?? "file", fileImportConcurrency = options.fileImportConcurrency ?? 50, blockWriteConcurrency = options.blockWriteConcurrency ?? 10, reduceSingleLeafToSelf = options.reduceSingleLeafToSelf ?? !0, chunker = options.chunker ?? fixedSize({
+        chunkSize
+    }), chunkValidator = options.chunkValidator ?? defaultChunkValidator(), buildDag = options.dagBuilder ?? (options3 = {
         chunker,
         chunkValidator,
         wrapWithDirectory,
-        layout: options.layout ?? (maxChildrenPerNode = (void 0) ?? DEFAULT_MAX_CHILDREN_PER_NODE, async function balancedLayout(source, reduce) {
+        layout: options.layout ?? (options1 = {
+            maxChildrenPerNode
+        }, maxChildrenPerNode1 = options1?.maxChildrenPerNode ?? DEFAULT_MAX_CHILDREN_PER_NODE, async function balancedLayout(source, reduce) {
             let roots = [];
-            for await (let chunked of dist_src(source, maxChildrenPerNode))roots.push(await reduce(chunked));
+            for await (let chunked of dist_src(source, maxChildrenPerNode1))roots.push(await reduce(chunked));
             return roots.length > 1 ? balancedLayout(roots, reduce) : roots[0];
         }),
-        bufferImporter: options.bufferImporter ?? (options1 = {
+        bufferImporter: options.bufferImporter ?? (options2 = {
             cidVersion,
             rawLeaves,
             leafType,
@@ -4418,18 +4475,18 @@ async function* src_importer(source, blockstore, options = {}) {
             for await (let block of file.content)yield async ()=>{
                 let unixfs, opts = {
                     codec: dag_pb_src_namespaceObject,
-                    cidVersion: options1.cidVersion,
-                    onProgress: options1.onProgress
+                    cidVersion: options2.cidVersion,
+                    onProgress: options2.onProgress
                 };
-                options1.rawLeaves ? (opts.codec = raw_namespaceObject, opts.cidVersion = 1) : block = dag_pb_src_encode({
+                options2.rawLeaves ? (opts.codec = raw_namespaceObject, opts.cidVersion = 1) : block = dag_pb_src_encode({
                     Data: (unixfs = new UnixFS({
-                        type: options1.leafType,
+                        type: options2.leafType,
                         data: block
                     })).marshal(),
                     Links: []
                 });
                 let cid = await persist(block, blockstore, opts);
-                return bytesWritten += BigInt(block.byteLength), options1.onProgress?.(new CustomProgressEvent('unixfs:importer:progress:file:write', {
+                return bytesWritten += BigInt(block.byteLength), options2.onProgress?.(new CustomProgressEvent('unixfs:importer:progress:file:write', {
                     bytesWritten,
                     cid,
                     path: file.path
@@ -4457,7 +4514,7 @@ async function* src_importer(source, blockstore, options = {}) {
                     mode: entry.mode,
                     content: async function*() {
                         let bytesRead = 0n;
-                        for await (let chunk of options2.chunker(options2.chunkValidator(function(content) {
+                        for await (let chunk of options3.chunker(options3.chunkValidator(function(content) {
                             try {
                                 if (content instanceof Uint8Array) return async function*() {
                                     yield content;
@@ -4470,7 +4527,7 @@ async function* src_importer(source, blockstore, options = {}) {
                             throw new InvalidContentError('Content was invalid');
                         }(entry.content)))){
                             let currentChunkSize = BigInt(chunk.byteLength);
-                            bytesRead += currentChunkSize, options2.onProgress?.(new CustomProgressEvent('unixfs:importer:progress:file:read', {
+                            bytesRead += currentChunkSize, options3.onProgress?.(new CustomProgressEvent('unixfs:importer:progress:file:read', {
                                 bytesRead,
                                 chunkSize: currentChunkSize,
                                 path: entry.path
@@ -4478,22 +4535,23 @@ async function* src_importer(source, blockstore, options = {}) {
                         }
                     }(),
                     originalPath
-                }, fileBuilder = options2.fileBuilder ?? defaultFileBuilder;
-                yield async ()=>fileBuilder(file, blockstore, options2);
+                }, fileBuilder = options3.fileBuilder ?? defaultFileBuilder;
+                yield async ()=>fileBuilder(file, blockstore, options3);
             } else if (null != entry.path) {
                 let dir = {
                     path: entry.path,
                     mtime: entry.mtime,
                     mode: entry.mode,
                     originalPath
-                }, dirBuilder = options2.dirBuilder ?? defaultDirBuilder;
-                yield async ()=>dirBuilder(dir, blockstore, options2);
+                }, dirBuilder = options3.dirBuilder ?? defaultDirBuilder;
+                yield async ()=>dirBuilder(dir, blockstore, options3);
             } else throw Error('Import candidate must have content or path or both');
         }
     });
-    for await (let entry of (options.treeBuilder ?? (options3 = {
+    for await (let entry of (options.treeBuilder ?? (options4 = {
         wrapWithDirectory,
         shardSplitThresholdBytes,
+        shardSplitStrategy,
         shardFanoutBits,
         cidVersion,
         onProgress: options.onProgress
@@ -4504,13 +4562,13 @@ async function* src_importer(source, blockstore, options = {}) {
             path: '',
             dirty: !0,
             flat: !0
-        }, options3), singleRoot = !1;
+        }, options4), singleRoot = !1;
         for await (let entry of source){
             if (null == entry) continue;
             let dir = `${entry.originalPath ?? ''}`.split('/')[0];
-            null != dir && '' !== dir && (null == rootDir ? (rootDir = dir, singleRoot = !0) : rootDir !== dir && (singleRoot = !1)), tree = await addToTree(entry, tree, options3), entry.unixfs?.isDirectory() !== !0 && (yield entry);
+            null != dir && '' !== dir && (null == rootDir ? (rootDir = dir, singleRoot = !0) : rootDir !== dir && (singleRoot = !1)), tree = await addToTree(entry, tree, options4), entry.unixfs?.isDirectory() !== !0 && (yield entry);
         }
-        if (options3.wrapWithDirectory || singleRoot && tree.childCount() > 1) yield* flushAndYield(tree, block);
+        if (options4.wrapWithDirectory || singleRoot && tree.childCount() > 1) yield* flushAndYield(tree, block);
         else for (let unwrapped of tree.eachChildSeries())null != unwrapped && (yield* flushAndYield(unwrapped.child, block));
     }))(parallelBatch(buildDag(candidates, blockstore), fileImportConcurrency), blockstore))yield {
         cid: entry.cid,
@@ -4935,12 +4993,13 @@ function _writeString(buffer, str, offset, size) {
 function _leftPad(input, targetLength) {
     return String(input).padStart(targetLength, "0");
 }
-import * as __rspack_external_node_crypto_9ba42079 from "node:crypto";
-import * as __rspack_external_crypto from "crypto";
-import * as __rspack_external_fs from "fs";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import { parseArgs, styleText } from "node:util";
+import node_crypto, * as __rspack_external_node_crypto_9ba42079 from "node:crypto";
+import { createHash, createHmac, randomInt } from "node:crypto";
 import { setTimeout as promises_setTimeout } from "node:timers/promises";
+import crypto_0, * as __rspack_external_crypto from "crypto";
+import fs_0, * as __rspack_external_fs from "fs";
 import { promisify } from "util";
 import { Buffer } from "node:buffer";
 import { constants, createReadStream, createWriteStream } from "node:fs";
@@ -6279,9 +6338,9 @@ __webpack_require__.add({
     base58btc: ()=>base58_base58btc,
     base58flickr: ()=>base58flickr
 }), base64_namespaceObject = {}, __webpack_require__.r(base64_namespaceObject), __webpack_require__.d(base64_namespaceObject, {
-    base64: ()=>base64,
-    base64pad: ()=>base64pad,
-    base64url: ()=>base64url,
+    base64: ()=>base64_base64,
+    base64pad: ()=>base64_base64pad,
+    base64url: ()=>base64_base64url,
     base64urlpad: ()=>base64urlpad
 }), base8_namespaceObject = {}, __webpack_require__.r(base8_namespaceObject), __webpack_require__.d(base8_namespaceObject, {
     base8: ()=>base8
@@ -7518,8 +7577,8 @@ class HMAC extends utils_Hash {
         this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
     }
 }
-let hmac = (hash, key, message)=>new HMAC(hash, key).update(message).digest();
-hmac.create = (hash, key)=>new HMAC(hash, key);
+let hmac_hmac = (hash, key, message)=>new HMAC(hash, key).update(message).digest();
+hmac_hmac.create = (hash, key)=>new HMAC(hash, key);
 let utils_0n = BigInt(0), utils_1n = BigInt(1), utils_hasHexBuiltin = 'function' == typeof Uint8Array.from([]).toHex && 'function' == typeof Uint8Array.fromHex, abstract_utils_hexes = Array.from({
     length: 256
 }, (_, i)=>i.toString(16).padStart(2, '0')), utils_asciis = {
@@ -8203,7 +8262,7 @@ let utils_0n = BigInt(0), utils_1n = BigInt(1), utils_hasHexBuiltin = 'function'
         })({
             ...curveDef,
             hash: hash,
-            hmac: (key, ...msgs)=>hmac(hash, key, function(...arrays) {
+            hmac: (key, ...msgs)=>hmac_hmac(hash, key, function(...arrays) {
                     let sum = 0;
                     for(let i = 0; i < arrays.length; i++){
                         let a = arrays[i];
@@ -8371,7 +8430,7 @@ let aleph_te = new TextEncoder(), pinToAleph = async ({ cid, token, chain, verbo
     return requestOptions = ((token, requestOptions)=>{
         let [accessKeyId, secretAccessKey] = atob(token).split(':');
         if (!accessKeyId || !secretAccessKey) throw Error('Missing access key ID and secret access key');
-        let amzDate = new Date().toISOString().replace(/[:-]|\.\d{3}/g, '') + 'Z', dateStamp = amzDate.slice(0, 8), payloadHash = __rspack_external_node_crypto_9ba42079.createHash('sha256').update('').digest('hex'), canonicalHeaders = `content-length:${requestOptions.headers['Content-Length']}\nhost:${requestOptions.host}\nx-amz-content-sha256:${payloadHash}\nx-amz-date:${amzDate}\n`, signedHeaders = 'content-length;host;x-amz-content-sha256;x-amz-date', canonicalRequest = [
+        let amzDate = new Date().toISOString().replace(/[:-]|\.\d{3}/g, '') + 'Z', dateStamp = amzDate.slice(0, 8), payloadHash = createHash('sha256').update('').digest('hex'), canonicalHeaders = `content-length:${requestOptions.headers['Content-Length']}\nhost:${requestOptions.host}\nx-amz-content-sha256:${payloadHash}\nx-amz-date:${amzDate}\n`, signedHeaders = 'content-length;host;x-amz-content-sha256;x-amz-date', canonicalRequest = [
             requestOptions.method,
             requestOptions.path,
             '',
@@ -8379,16 +8438,16 @@ let aleph_te = new TextEncoder(), pinToAleph = async ({ cid, token, chain, verbo
             signedHeaders,
             payloadHash
         ].join(`
-`), hashedCanonicalRequest = __rspack_external_node_crypto_9ba42079.createHash('sha256').update(canonicalRequest).digest('hex'), credentialScope = `${dateStamp}/${requestOptions.region}/${requestOptions.service}/aws4_request`, stringToSign = [
+`), hashedCanonicalRequest = createHash('sha256').update(canonicalRequest).digest('hex'), credentialScope = `${dateStamp}/${requestOptions.region}/${requestOptions.service}/aws4_request`, stringToSign = [
             'AWS4-HMAC-SHA256',
             amzDate,
             credentialScope,
             hashedCanonicalRequest
         ].join(`
-`), kDate = __rspack_external_node_crypto_9ba42079.createHmac('sha256', 'AWS4' + secretAccessKey).update(dateStamp).digest(), kRegion = __rspack_external_node_crypto_9ba42079.createHmac('sha256', kDate).update(requestOptions.region).digest(), kService = __rspack_external_node_crypto_9ba42079.createHmac('sha256', kRegion).update(requestOptions.service).digest(), kSigning = __rspack_external_node_crypto_9ba42079.createHmac('sha256', kService).update('aws4_request').digest(), signature = __rspack_external_node_crypto_9ba42079.createHmac('sha256', kSigning).update(stringToSign).digest('hex');
+`), kDate = createHmac('sha256', 'AWS4' + secretAccessKey).update(dateStamp).digest(), kRegion = createHmac('sha256', kDate).update(requestOptions.region).digest(), kService = createHmac('sha256', kRegion).update(requestOptions.service).digest(), kSigning = createHmac('sha256', kService).update('aws4_request').digest(), signature = createHmac('sha256', kSigning).update(stringToSign).digest('hex');
         return requestOptions.headers['X-Amz-Content-Sha256'] = payloadHash, requestOptions.headers['X-Amz-Date'] = amzDate, requestOptions.headers.Authorization = `AWS4-HMAC-SHA256 Credential=${accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`, requestOptions;
     })(token, requestOptions), await fetch(`https://${requestOptions.host}/`, requestOptions).then((res)=>200 == res.status);
-}, utils_sign = (key, msg)=>new Uint8Array((0, __rspack_external_node_crypto_9ba42079.createHmac)('sha256', key).update(msg).digest());
+}, utils_sign = (key, msg)=>new Uint8Array(createHmac('sha256', key).update(msg).digest());
 class HttpRequest {
     method;
     protocol;
@@ -8462,9 +8521,9 @@ let createPresignedUrl = async ({ bucketName, apiUrl, file, token })=>{
             'AWS4-HMAC-SHA256',
             amzDate,
             credentialScope,
-            (0, __rspack_external_node_crypto_9ba42079.createHash)('sha256').update(canonicalRequest).digest('hex')
+            createHash('sha256').update(canonicalRequest).digest('hex')
         ].join(`
-`), signingKey = (kDate = utils_sign(`AWS4${secretAccessKey}`, dateStamp), kRegion = utils_sign(kDate, region), kService = utils_sign(kRegion, 's3'), utils_sign(kService, 'aws4_request')), signature = (0, __rspack_external_node_crypto_9ba42079.createHmac)('sha256', signingKey).update(stringToSign).digest('hex');
+`), signature = createHmac('sha256', (kDate = utils_sign(`AWS4${secretAccessKey}`, dateStamp), kRegion = utils_sign(kDate, region), kService = utils_sign(kRegion, 's3'), utils_sign(kService, 'aws4_request'))).update(stringToSign).digest('hex');
         return {
             ...request,
             query: {
@@ -8586,7 +8645,7 @@ class digest_Digest {
 }
 let node_digest = (payload)=>{
     let digest = new Uint8Array(digest_prefix.length + 32);
-    return digest.set(digest_prefix, 0), digest.set(__rspack_external_node_crypto_9ba42079.default.createHash('sha256').update(payload).digest(), digest_prefix.length), new digest_Digest(digest);
+    return digest.set(digest_prefix, 0), digest.set(node_crypto.createHash('sha256').update(payload).digest(), digest_prefix.length), new digest_Digest(digest);
 }, sha256_code = 18, objectTypeNames = [
     'Object',
     'RegExp',
@@ -11280,7 +11339,7 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
                 to,
                 data,
                 value,
-                gas: fromNumber(SIMULATION_GAS_LIMIT)
+                gas: SIMULATION_GAS_LIMIT
             },
             'latest'
         ]
@@ -11291,23 +11350,12 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
                 to,
                 data,
                 from,
-                gas: fromNumber(SIMULATION_GAS_LIMIT)
+                gas: SIMULATION_GAS_LIMIT
             },
             'latest'
         ]
     }), sendTransaction = async ({ provider, chainId, privateKey, to, data, from })=>{
-    let feeHistory = await provider.request({
-        method: 'eth_feeHistory',
-        params: [
-            '0x5',
-            'latest',
-            [
-                10,
-                50,
-                90
-            ]
-        ]
-    }), estimatedGas = await estimateGas({
+    let estimatedGas = await estimateGas({
         provider,
         from,
         to,
@@ -11320,9 +11368,17 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
             from,
             'latest'
         ]
-    })), baseFeePerGas = BigInt(feeHistory.baseFeePerGas.slice(-1)[0]);
-    if (!feeHistory.reward) throw Error('No reward in feeHistory');
-    let priorityFeePerGas = BigInt(feeHistory.reward.slice(-1)[0][1]), envelope = function(envelope, options = {}) {
+    })), block = await provider.request({
+        method: 'eth_getBlockByNumber',
+        params: [
+            'latest',
+            !1
+        ]
+    });
+    if (!block) throw Error('Failed to fetch latest block');
+    let baseFeePerGas = toBigInt(block.baseFeePerGas || '0x0'), maxPriorityFeePerGas = toBigInt(await provider.request({
+        method: 'eth_maxPriorityFeePerGas'
+    })), envelope = function(envelope, options = {}) {
         let { signature } = options, envelope_ = 'string' == typeof envelope ? function(serialized) {
             var value;
             let to_, transactionArray = (value = Hex_slice(serialized, 1), to_ = 'Hex', function decodeRlpCursor(cursor, to = 'Hex') {
@@ -11407,8 +11463,8 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
         };
     }({
         chainId,
-        maxFeePerGas: 2n * baseFeePerGas + priorityFeePerGas,
-        maxPriorityFeePerGas: priorityFeePerGas,
+        maxFeePerGas: 2n * baseFeePerGas + maxPriorityFeePerGas,
+        maxPriorityFeePerGas,
         to,
         data,
         value: 0n,
@@ -11441,43 +11497,44 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
     });
 }, waitForTransaction = async (provider, hash)=>{
     for(let attempt = 0; attempt < 10; attempt++){
-        let rawReceipt = await provider.request({
-            method: 'eth_getTransactionReceipt',
-            params: [
-                hash
-            ]
-        });
-        if (rawReceipt) {
-            var receipt;
-            if ('0x0' === rawReceipt.status) throw Error(`Transaction ${hash} reverted`);
-            let chainId = await provider.request({
-                method: 'eth_chainId'
+        try {
+            let rawReceipt = await provider.request({
+                method: 'eth_getTransactionReceipt',
+                params: [
+                    hash
+                ]
             });
-            return {
-                ...receipt = {
-                    ...rawReceipt,
-                    chainId
-                },
-                blobGasPrice: receipt.blobGasPrice ? BigInt(receipt.blobGasPrice) : void 0,
-                blobGasUsed: receipt.blobGasUsed ? BigInt(receipt.blobGasUsed) : void 0,
-                blockNumber: BigInt(receipt.blockNumber ?? 0n),
-                cumulativeGasUsed: BigInt(receipt.cumulativeGasUsed ?? 0n),
-                effectiveGasPrice: BigInt(receipt.effectiveGasPrice ?? 0n),
-                gasUsed: BigInt(receipt.gasUsed ?? 0n),
-                logs: receipt.logs.map((log)=>(function(log, _options = {}) {
-                        return {
+            if (rawReceipt) {
+                var receipt;
+                if ('0x0' === rawReceipt.status) throw Error(`Transaction ${hash} reverted`);
+                let chainId = await provider.request({
+                    method: 'eth_chainId'
+                });
+                return {
+                    ...receipt = {
+                        ...rawReceipt,
+                        chainId
+                    },
+                    blobGasPrice: receipt.blobGasPrice ? BigInt(receipt.blobGasPrice) : void 0,
+                    blobGasUsed: receipt.blobGasUsed ? BigInt(receipt.blobGasUsed) : void 0,
+                    blockNumber: BigInt(receipt.blockNumber ?? 0n),
+                    cumulativeGasUsed: BigInt(receipt.cumulativeGasUsed ?? 0n),
+                    effectiveGasPrice: BigInt(receipt.effectiveGasPrice ?? 0n),
+                    gasUsed: BigInt(receipt.gasUsed ?? 0n),
+                    logs: receipt.logs.map((log)=>({
                             ...log,
                             blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
                             logIndex: log.logIndex ? Number(log.logIndex) : null,
                             transactionIndex: log.transactionIndex ? Number(log.transactionIndex) : null
-                        };
-                    })(log, {
-                        pending: !1
-                    })),
-                status: fromRpcStatus[receipt.status],
-                transactionIndex: Number(receipt.transactionIndex ?? 0),
-                type: fromRpcType[receipt.type] || receipt.type
-            };
+                        })),
+                    status: fromRpcStatus[receipt.status],
+                    transactionIndex: Number(receipt.transactionIndex ?? 0),
+                    type: fromRpcType[receipt.type] || receipt.type
+                };
+            }
+        } catch (error) {
+            if (-32603 === error.code || error.message?.includes('receipt not found')) ;
+            else throw error;
         }
         let delay = Math.min(1000 * 2 ** attempt, 30000);
         await promises_setTimeout(delay);
@@ -11527,7 +11584,7 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
                     calls
                 ]),
                 to: chain.contracts.multicall3.address,
-                gas: fromNumber(SIMULATION_GAS_LIMIT)
+                gas: SIMULATION_GAS_LIMIT
             },
             'latest'
         ]
@@ -11839,7 +11896,7 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
         key: 'withIPFSIndexing',
         value: ''
     }
-], createDataSet_keys = metadata.map((item)=>item.key), createDataSet_values = metadata.map((item)=>item.value), priceBuffer = function(value, decimals = 0) {
+], createDataSet_keys = metadata.map((item)=>item.key), createDataSet_values = metadata.map((item)=>item.value), priceBuffer = function(decimals = 0) {
     if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test('0.5')) throw new InvalidDecimalNumberError({
         value: '0.5'
     });
@@ -11854,7 +11911,7 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
         (fraction = rounded > 9 ? `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, '0') : `${left}${rounded}`).length > decimals && (fraction = fraction.slice(1), integer = `${BigInt(integer) + 1n}`), fraction = fraction.slice(0, decimals);
     } else fraction = fraction.padEnd(decimals, '0');
     return BigInt(`${negative ? '-' : ''}${integer}${fraction}`);
-}(0, 18), createDataSet = async ({ providerURL, privateKey, payee, address: payer, verbose, chain, perMonth })=>{
+}(18), createDataSet = async ({ providerURL, privateKey, payee, address: payer, verbose, chain, perMonth })=>{
     let provider = filProvider[chain.id], [funds] = await getAccountInfo({
         address: payer,
         chain
@@ -11870,7 +11927,7 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
         });
         logger.info(`Transaction pending: ${chain.blockExplorer}/tx/${hash}`), await waitForTransaction(provider, hash), logger.success('Transaction succeeded');
     }
-    let clientDataSetId = BigInt((0, __rspack_external_node_crypto_9ba42079.randomInt)(100000000));
+    let clientDataSetId = BigInt(randomInt(100000000));
     logger.info(`Client data set ID: ${clientDataSetId}`);
     let recordKeeper = chain.contracts.storage.address;
     logger.info(`Record keeper address: ${recordKeeper}`);
@@ -12736,7 +12793,7 @@ let serializedType = '0x02', TxEnvelopeEip1559_type = 'eip1559', SIMULATION_GAS_
         verbose,
         datasetId,
         privateKey,
-        nonce: BigInt((0, __rspack_external_node_crypto_9ba42079.randomInt)(100000000)),
+        nonce: BigInt(randomInt(100000000)),
         clientDataSetId,
         chain
     });
@@ -13196,17 +13253,17 @@ class DIDKey extends did_DID {
         return `did:key:${base58_base58btc.encode(this)}`;
     }
 }
-let base64 = rfc4648({
+let base64_base64 = rfc4648({
     prefix: 'm',
     name: 'base64',
     alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
     bitsPerChar: 6
-}), base64pad = rfc4648({
+}), base64_base64pad = rfc4648({
     prefix: 'M',
     name: 'base64pad',
     alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
     bitsPerChar: 6
-}), base64url = rfc4648({
+}), base64_base64url = rfc4648({
     prefix: 'u',
     name: 'base64url',
     alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
@@ -13318,7 +13375,7 @@ let signature_algorithm = (signature)=>{
     return signature_view(bytes);
 }, signature_toJSON = (signature)=>({
         "/": {
-            bytes: base64.baseEncode(signature)
+            bytes: base64_base64.baseEncode(signature)
         }
     }), withDID = (key, id)=>new VerifierWithDID(id, key);
 class VerifierWithDID {
@@ -13424,7 +13481,7 @@ let PRIVATE_TAG_SIZE = encodingLength(0x1300), signer_SIZE = PRIVATE_TAG_SIZE +
         if (0xed !== code) throw Error("Given bytes must contain public key in multiformats with 237 tag");
     }
     return new Ed25519Signer(bytes);
-}, signer_parse = (principal, decoder)=>signer_decode((decoder || base64pad).decode(principal));
+}, signer_parse = (principal, decoder)=>signer_decode((decoder || base64_base64pad).decode(principal));
 class Ed25519Signer extends Uint8Array {
     get code() {
         return 0x1300;
@@ -13951,7 +14008,7 @@ class DagJsonTokenizer extends Tokenizer {
                                 let breakToken = this._next();
                                 if (!Type.equals(breakToken.type, Type.break)) throw Error('Invalid encoded Bytes form');
                             }
-                            let bytes = base64.decode(`m${innerValueToken.value}`);
+                            let bytes = base64_base64.decode(`m${innerValueToken.value}`);
                             return new Token(Type.bytes, bytes, innerValueToken.value.length);
                         }
                         this.tokenBuffer.push(innerValueToken);
@@ -13990,7 +14047,7 @@ let dag_json_src_encode = (node)=>{
     }, options), decode_decode(buf, options);
 };
 new TextDecoder(), new TextEncoder();
-let formatHeader = (version, alg)=>base64url.baseEncode(encodeHeader(version, alg)), formatPayload = (data)=>base64url.baseEncode(encodePayload(data)), encodeHeader = (v, alg)=>dag_json_src_encode({
+let formatHeader = (version, alg)=>base64_base64url.baseEncode(encodeHeader(version, alg)), formatPayload = (data)=>base64_base64url.baseEncode(encodePayload(data)), encodeHeader = (v, alg)=>dag_json_src_encode({
         alg,
         ucv: v,
         typ: "JWT"
@@ -14134,7 +14191,7 @@ class CBORView extends View {
     format() {
         var model;
         let header, payload, signature, signature1;
-        return header = formatHeader((model = this.model).v, model.s.algorithm), payload = formatPayload(model), signature1 = model.s, signature = base64url.baseEncode(signature1.raw), `${header}.${payload}.${signature}`;
+        return header = formatHeader((model = this.model).v, model.s.algorithm), payload = formatPayload(model), signature1 = model.s, signature = base64_base64url.baseEncode(signature1.raw), `${header}.${payload}.${signature}`;
     }
     encode() {
         return codec_cbor_encode(this.model);
@@ -14158,11 +14215,11 @@ class JWTView extends View {
 let hashes_sha2_sha256 = hasher_from({
     name: 'sha2-256',
     code: 0x12,
-    encode: (input)=>coerce(__rspack_external_crypto.default.createHash('sha256').update(input).digest())
+    encode: (input)=>coerce(crypto_0.createHash('sha256').update(input).digest())
 }), sha2_sha512 = hasher_from({
     name: 'sha2-512',
     code: 0x13,
-    encode: (input)=>coerce(__rspack_external_crypto.default.createHash('sha512').update(input).digest())
+    encode: (input)=>coerce(crypto_0.createHash('sha512').update(input).digest())
 }), defaultHasher = hashes_sha2_sha256, write = async (ucan, { hasher = defaultHasher } = {})=>{
     let [code, bytes] = ucan.jwt ? [
         raw_code,
@@ -14481,7 +14538,7 @@ class CarBufferReader {
         return new CarBufferReader(header, blocks);
     }
 }
-let fsread = __rspack_external_fs.default.readSync;
+let fsread = fs_0.readSync;
 class buffer_reader_CarBufferReader extends CarBufferReader {
     static readRaw(fd, blockIndex) {
         let read, { cid, blockLength, blockOffset } = blockIndex, bytes = new Uint8Array(blockLength);
@@ -15592,7 +15649,7 @@ let delegation_archive = async (delegation)=>{
                     ...((jwt)=>{
                         var raw;
                         let source, code, segments = jwt.split("."), [header, payload, signature] = 3 === segments.length ? segments : schema_fail(`Can't parse UCAN: ${jwt}: Expected JWT format: 3 dot-separated base64url-encoded values.`), { ucv, alg } = ((header)=>{
-                            let { ucv, alg, typ } = dag_json_src_decode(base64url.baseDecode(header));
+                            let { ucv, alg, typ } = dag_json_src_decode(base64_base64url.baseDecode(header));
                             return {
                                 typ: "JWT" === typ ? "JWT" : schema_ParseError.throw(`Expected typ to be a ${JSON.stringify("JWT")} instead got ${JSON.stringify(typ)}`),
                                 ucv: readVersion(ucv, "ucv"),
@@ -15600,12 +15657,12 @@ let delegation_archive = async (delegation)=>{
                             };
                         })(header);
                         return {
-                            ...(source = payload, readPayloadWith(dag_json_src_decode(base64url.baseDecode(source)), {
+                            ...(source = payload, readPayloadWith(dag_json_src_decode(base64_base64url.baseDecode(source)), {
                                 readPrincipal: readStringPrincipal,
                                 readProof: readStringProof
                             })),
                             v: ucv,
-                            s: (raw = base64url.baseDecode(signature), 0xd000 === (code = ((name)=>{
+                            s: (raw = base64_base64url.baseDecode(signature), 0xd000 === (code = ((name)=>{
                                 switch(name){
                                     case "ES256K":
                                         return 0xd0e7;
@@ -16222,7 +16279,7 @@ class Agent {
     }
 }
 let proof_parse = async (str)=>{
-    let cid = link_parse(str, base64);
+    let cid = link_parse(str, base64_base64);
     if (cid.code !== car_code) throw Error(`non CAR codec found: 0x${cid.code.toString(16)}`);
     let { ok, error } = await delegation_extract(cid.multihash.digest);
     if (error) throw Error('failed to extract delegation', {
@@ -16235,9 +16292,6 @@ class SharedSpace {
     constructor(model){
         this.model = model;
     }
-    get meta() {
-        return this.model.meta;
-    }
     did() {
         return this.model.id;
     }
@@ -16249,14 +16303,12 @@ let fromDelegation = ({ facts, capabilities })=>{
     if (result.error) throw Error(`Invalid delegation, expected capabilities[0].with to be DID, ${result.error}`, {
         cause: result.error
     });
-    let meta = facts[0]?.space ?? {};
     return new SharedSpace({
         id: result.ok,
         delegation: {
             facts,
             capabilities
-        },
-        meta
+        }
     });
 };
 class Piece {
@@ -17207,26 +17259,7 @@ capability_capability({
     }),
     derives: (claim, from)=>utils_and(equalWith(claim, from)) ?? checkLink(claim.nb.proof, from.nb.proof, 'nb.proof')
 });
-class ReceiptNotFound extends Error {
-    name = 'ReceiptNotFound';
-    taskCid;
-    constructor(taskCid){
-        super(), this.taskCid = taskCid;
-    }
-    get reason() {
-        return `receipt not found for task ${this.taskCid} in the indexed workflow`;
-    }
-}
-class ReceiptMissing extends Error {
-    name = 'ReceiptMissing';
-    taskCid;
-    constructor(taskCid){
-        super(), this.taskCid = taskCid;
-    }
-    get reason() {
-        return `receipt missing for task ${this.taskCid}`;
-    }
-}
+let WAIT_MS = 3000;
 blob_add.can;
 let blob_add_input = (digest, size)=>({
         blob: {
@@ -17234,7 +17267,6 @@ let blob_add_input = (digest, size)=>({
             size
         }
     }), CAR_V1_VERSION = 1;
-__rspack_external_fs.default;
 class CarWriter {
     constructor(roots, encoder){
         this._encoder = encoder, this._mutex = encoder.setRoots(roots), this._ended = !1;
@@ -17322,7 +17354,7 @@ class writer_CarWriter extends CarWriter {
         let bytes, readChunk, offset = 0;
         if ('number' == typeof fd) readChunk = async ()=>{
             var buffer, position;
-            return (await (buffer = bytes, position = offset, !_fsReadFn && (_fsReadFn = promisify(__rspack_external_fs.default.read)), _fsReadFn(fd, buffer, 0, 256, position))).bytesRead;
+            return (await (buffer = bytes, position = offset, !_fsReadFn && (_fsReadFn = promisify(fs_0.read)), _fsReadFn(fd, buffer, 0, 256, position))).bytesRead;
         };
         else if ('object' == typeof fd && 'function' == typeof fd.read) readChunk = async ()=>(await fd.read(bytes, 0, 256, offset)).bytesRead;
         else throw TypeError('Bad fd');
@@ -17336,7 +17368,7 @@ class writer_CarWriter extends CarWriter {
         if (fdReader.pos !== newHeader.length) throw Error(`updateRoots() can only overwrite a header of the same length (old header is ${fdReader.pos} bytes, new header is ${newHeader.length} bytes)`);
         if ('number' == typeof fd) {
             var length;
-            await (length = newHeader.length, !_fsWriteFn && (_fsWriteFn = promisify(__rspack_external_fs.default.write)), _fsWriteFn(fd, newHeader, 0, length, 0));
+            await (length = newHeader.length, !_fsWriteFn && (_fsWriteFn = promisify(fs_0.write)), _fsWriteFn(fd, newHeader, 0, length, 0));
         } else 'object' == typeof fd && 'function' == typeof fd.read && await fd.write(newHeader, 0, newHeader.length, 0);
     }
 }
@@ -17525,18 +17557,12 @@ let filecoin_offer_filecoinOffer = async (conf, piece, content)=>filecoinOffer.i
         });
     }
 };
-_computedKey = Symbol.toStringTag, _computedKey1 = Symbol.iterator;
+_computedKey = Symbol.iterator;
 class DigestMap {
     #data;
     constructor(entries){
         for (let [k, v] of (this.#data = new Map(), entries ?? []))this.set(k, v);
     }
-    get [_computedKey]() {
-        return 'DigestMap';
-    }
-    clear() {
-        this.#data.clear();
-    }
     get(key) {
         let data = this.#data.get(toBase58String(key));
         if (data) return data[1];
@@ -17547,7 +17573,7 @@ class DigestMap {
             value
         ]), this;
     }
-    [_computedKey1]() {
+    [_computedKey]() {
         return this.entries();
     }
     *entries() {
@@ -18385,14 +18411,17 @@ let fixedSize = (options = {})=>{
     let chunkSize = options.chunkSize ?? 262144;
     return async function*(source) {
         let list = new Uint8ArrayList(), currentLength = 0, emitted = !1;
-        for await (let buffer of source)for(list.append(buffer), currentLength += buffer.length; currentLength >= chunkSize;)if (yield list.slice(0, chunkSize), emitted = !0, chunkSize === list.length) list = new Uint8ArrayList(), currentLength = 0;
-        else {
-            let newBl = new Uint8ArrayList();
-            newBl.append(list.sublist(chunkSize)), list = newBl, currentLength -= chunkSize;
+        for await (let buffer of source)for(list.append(buffer), currentLength += buffer.length; currentLength >= chunkSize;){
+            let buf = list.subarray(0, chunkSize);
+            if (yield buf, emitted = !0, chunkSize === list.length) list = new Uint8ArrayList(), currentLength = 0;
+            else {
+                let newBl = new Uint8ArrayList();
+                newBl.append(list.sublist(chunkSize)), list = newBl, currentLength -= chunkSize;
+            }
         }
         (!emitted || currentLength > 0) && (yield list.subarray(0, currentLength));
     };
-}, pb_decode_textDecoder = new TextDecoder(), pb_encode_textEncoder = new TextEncoder(), pb_encode_maxInt32 = 4294967296, maxUInt32 = 2147483648, len8tab = [
+}, DEFAULT_SHARD_HASH_CODE = BigInt(0x22), DEFAULT_SHARD_SPLIT_STRATEGY = 'links-bytes', DEFAULT_CHUNK_SIZE_1MIB = 1048576, pb_decode_textDecoder = new TextDecoder(), pb_encode_textEncoder = new TextEncoder(), pb_encode_maxInt32 = 4294967296, maxUInt32 = 2147483648, len8tab = [
     0,
     1,
     2,
@@ -19336,7 +19365,7 @@ class CustomProgressEvent extends Event {
 }
 let persist = async (buffer, blockstore, options)=>{
     null == options.codec && (options.codec = dag_pb_src_namespaceObject);
-    let multihash = await hashes_sha2_sha256.digest(buffer), cid = cid_CID.create(options.cidVersion, options.codec.code, multihash);
+    let multihash = await hashes_sha2_sha256.digest(buffer), cid = cid_CID.create(options.cidVersion ?? 1, options.codec.code, multihash);
     return await blockstore.put(cid, buffer, options), cid;
 };
 class errors_InvalidParametersError extends Error {
@@ -19384,6 +19413,12 @@ class InvalidContentError extends Error {
         super(message);
     }
 }
+class InvalidShardingStrategyError extends Error {
+    static name = 'InvalidShardingStrategyError';
+    static code = 'ERR_SHARDING_STRATEGY';
+    name = InvalidContentError.name;
+    code = InvalidContentError.code;
+}
 let defaultDirBuilder = async (dir, blockstore, options)=>{
     let unixfs = new UnixFS({
         type: 'directory',
@@ -19416,13 +19451,13 @@ let defaultDirBuilder = async (dir, blockstore, options)=>{
                 cidVersion: options.cidVersion
             }), leaf.size = BigInt(leaf.block.length)), options.onProgress?.(new CustomProgressEvent('unixfs:importer:progress:file:layout', {
                 cid: leaf.cid,
-                path: leaf.originalPath
+                path: file.originalPath
             })), {
                 cid: leaf.cid,
                 path: file.path,
                 unixfs: leaf.unixfs,
                 size: leaf.size,
-                originalPath: leaf.originalPath
+                originalPath: file.originalPath
             };
         }
         let f = new UnixFS({
@@ -19476,177 +19511,588 @@ class Dir {
         this.options = options ?? {}, this.root = props.root, this.dir = props.dir, this.path = props.path, this.dirty = props.dirty, this.flat = props.flat, this.parent = props.parent, this.parentKey = props.parentKey, this.unixfs = props.unixfs, this.mode = props.mode, this.mtime = props.mtime;
     }
 }
-let CID_V0 = cid_CID.parse('QmUNLLsPACCz1vLxQVkXqqLX5R1X345qqfHbsf67hvA3Nn'), CID_V1 = cid_CID.parse('zdj7WbTaiJT1fgatdet9Ei9iDB5hdCxkbVyhyh8YTUnXMiwYi');
-class DirFlat extends Dir {
-    _children;
-    constructor(props, options){
-        super(props, options), this._children = new Map();
-    }
-    async put(name, value) {
-        this.cid = void 0, this.size = void 0, this.nodeSize = void 0, this._children.set(name, value);
-    }
-    async get(name) {
-        return Promise.resolve(this._children.get(name));
-    }
-    childCount() {
-        return this._children.size;
-    }
-    directChildrenCount() {
-        return this.childCount();
-    }
-    onlyChild() {
-        return this._children.values().next().value;
-    }
-    *eachChildSeries() {
-        for (let [key, child] of this._children.entries())yield {
-            key,
-            child
-        };
-    }
-    estimateNodeSize() {
-        if (void 0 !== this.nodeSize) return this.nodeSize;
-        for (let [name, child] of (this.nodeSize = 0, this._children.entries()))null != child.size && null != child.cid && (this.nodeSize += name.length + (1 === this.options.cidVersion ? CID_V1.bytes.byteLength : CID_V0.bytes.byteLength));
-        return this.nodeSize;
-    }
-    async *flush(block) {
-        let links = [];
-        for (let [name, child] of this._children.entries()){
-            let result = child;
-            if (child instanceof Dir) for await (let entry of child.flush(block))result = entry, yield entry;
-            null != result.size && null != result.cid && links.push({
-                Name: name,
-                Tsize: Number(result.size),
-                Hash: result.cid
-            });
-        }
-        let unixfs = new UnixFS({
-            type: 'directory',
-            mtime: this.mtime,
-            mode: this.mode
-        }), node = {
-            Data: unixfs.marshal(),
-            Links: links
-        }, buffer = dag_pb_src_encode(util_prepare(node)), cid = await persist(buffer, block, this.options), size = buffer.length + node.Links.reduce((acc, curr)=>acc + (curr.Tsize ?? 0), 0);
-        this.cid = cid, this.size = size, yield {
-            cid,
-            unixfs,
-            path: this.path,
-            size: BigInt(size)
-        };
-    }
-}
-hasher_from({
-    name: 'murmur3-32',
-    code: 0x23,
-    encode: (input)=>(function(number) {
-            let bytes = [
-                ,
-                ,
-                ,
-                , 
-            ];
-            for(let i = 0; i < 4; i++)bytes[i] = 0xff & number, number >>= 8;
-            return new Uint8Array(bytes);
-        })(function(key, seed = 0) {
-            var k;
-            let h1 = seed >>> 0, length = key.length, blocks = Math.floor(length / 4);
-            for(let i = 0; i < blocks; i++){
-                let k1 = function(key, i) {
-                    let offset = 4 * i;
-                    return (key[offset] | key[offset + 1] << 8 | key[offset + 2] << 16 | key[offset + 3] << 24) >>> 0;
-                }(key, i);
-                k1 = rotl32(k1 = mul32(k1, 0xcc9e2d51), 15), h1 ^= k1 = mul32(k1, 0x1b873593), h1 = mul32(h1 = rotl32(h1, 13), 5) + 0xe6546b64 >>> 0;
-            }
-            let tail = key.slice(4 * blocks), k1 = 0;
-            switch(tail.length){
-                case 3:
-                    k1 ^= tail[2] << 16;
-                case 2:
-                    k1 ^= tail[1] << 8;
-                case 1:
-                    k1 ^= tail[0], k1 = rotl32(k1 = mul32(k1, 0xcc9e2d51), 15), h1 ^= k1 = mul32(k1, 0x1b873593);
-            }
-            return h1 ^= length, k = h1, k ^= k >>> 16, k = mul32(k, 0x85ebca6b), k ^= k >>> 13, k = mul32(k, 0xc2b2ae35), h1 = k ^= k >>> 16;
-        }(input))
-});
-let murmur3128 = hasher_from({
-    name: 'murmur3-128',
-    code: 0x22,
-    encode: (input)=>murmurHash3_x64_128(input)
-});
-hasher_from({
-    name: 'murmur3-x64-64',
-    code: 0x22,
-    encode: (input)=>murmurHash3_x64_128(input).subarray(0, 8)
-});
-let sparse_array = __webpack_require__("./node_modules/sparse-array/index.js");
-class Bucket {
-    _options;
-    _popCount;
-    _parent;
-    _posAtParent;
-    _children;
-    key;
-    constructor(options, parent, posAtParent = 0){
-        this._options = options, this._popCount = 0, this._parent = parent, this._posAtParent = posAtParent, this._children = new sparse_array(), this.key = null;
-    }
-    async put(key, value) {
-        let place = await this._findNewBucketAndPos(key);
-        place.bucket._putAt(place, key, value);
-    }
-    async get(key) {
-        let child = await this._findChild(key);
-        if (null != child) return child.value;
-    }
-    async del(key) {
-        let place = await this._findPlace(key), child = place.bucket._at(place.pos);
-        null != child && child.key === key && place.bucket._delAt(place.pos);
-    }
-    leafCount() {
-        return this._children.compactArray().reduce((acc, child)=>child instanceof Bucket ? acc + child.leafCount() : acc + 1, 0);
-    }
-    childrenCount() {
-        return this._children.length;
-    }
-    onlyChild() {
-        return this._children.get(0);
-    }
-    *eachLeafSeries() {
-        for (let child of this._children.compactArray())child instanceof Bucket ? yield* child.eachLeafSeries() : yield child;
-    }
-    serialize(map, reduce) {
-        return reduce(this._children.reduce((acc, child, index)=>(null != child && (child instanceof Bucket ? acc.push(child.serialize(map, reduce)) : acc.push(map(child, index))), acc), []));
-    }
-    async asyncTransform(asyncMap, asyncReduce) {
-        return asyncTransformBucket(this, asyncMap, asyncReduce);
-    }
-    toJSON() {
-        return this.serialize(mapNode, reduceNodes);
-    }
-    prettyPrint() {
-        return JSON.stringify(this.toJSON(), null, '  ');
-    }
-    tableSize() {
-        return Math.pow(2, this._options.bits);
-    }
-    async _findChild(key) {
-        let result = await this._findPlace(key), child = result.bucket._at(result.pos);
-        if (!(child instanceof Bucket) && null != child && child.key === key) return child;
-    }
-    async _findPlace(key) {
-        let hashValue = this._options.hash('string' == typeof key ? from_string_node_fromString(key) : key), index = await hashValue.take(this._options.bits), child = this._children.get(index);
-        return child instanceof Bucket ? child._findPlace(hashValue) : {
-            bucket: this,
-            pos: index,
-            hash: hashValue,
-            existingChild: child
-        };
-    }
-    async _findNewBucketAndPos(key) {
-        let place = await this._findPlace(key);
-        if (null != place.existingChild && place.existingChild.key !== key) {
-            let bucket = new Bucket(this._options, place.bucket, place.pos);
-            place.bucket._putObjectAt(place.pos, bucket);
+let pb_size_maxInt32 = 4294967296, pb_size_len8tab = [
+    0,
+    1,
+    2,
+    2,
+    3,
+    3,
+    3,
+    3,
+    4,
+    4,
+    4,
+    4,
+    4,
+    4,
+    4,
+    4,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    5,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    6,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    7,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8,
+    8
+];
+class DirFlat extends Dir {
+    _children;
+    constructor(props, options){
+        super(props, options), this._children = new Map();
+    }
+    async put(name, value) {
+        if (void 0 !== this.nodeSize) {
+            let oldChild = this._children.get(name), nameBytes = utf8ByteLength(name), strategy = this.options?.shardSplitStrategy;
+            if ('links-bytes' === strategy) this.nodeSize -= estimateLinkSize(nameBytes, oldChild), this.nodeSize += estimateLinkSize(nameBytes, value);
+            else if ('block-bytes' === strategy) this.nodeSize -= calculateLinkSize(nameBytes, oldChild), this.nodeSize += calculateLinkSize(nameBytes, value);
+            else throw new InvalidShardingStrategyError(`Invalid shardSplitStrategy: ${strategy}`);
+            this.nodeSize < 0 && (this.nodeSize = void 0);
+        }
+        this.cid = void 0, this.size = void 0, this._children.set(name, value);
+    }
+    async get(name) {
+        return Promise.resolve(this._children.get(name));
+    }
+    childCount() {
+        return this._children.size;
+    }
+    directChildrenCount() {
+        return this.childCount();
+    }
+    onlyChild() {
+        return this._children.values().next().value;
+    }
+    *eachChildSeries() {
+        for (let [key, child] of this._children.entries())yield {
+            key,
+            child
+        };
+    }
+    marshal() {
+        let unixfs = new UnixFS({
+            type: 'directory',
+            mtime: this.mtime,
+            mode: this.mode
+        }), links = [];
+        for (let [name, child] of this._children.entries())if (null != child.size && null != child.cid) {
+            if (null == child.cid) throw Error('Directory contents must be flushed before marshaling');
+            links.push({
+                Hash: child.cid,
+                Name: name,
+                Tsize: null == child.size ? void 0 : Number(child.size)
+            });
+        }
+        return dag_pb_src_encode(util_prepare({
+            Data: unixfs.marshal(),
+            Links: links
+        }));
+    }
+    async estimateNodeSize() {
+        if (void 0 !== this.nodeSize) return this.nodeSize;
+        let strategy = this.options?.shardSplitStrategy;
+        if ('links-bytes' === strategy) for (let [name, child] of (this.nodeSize = 0, this._children.entries()))this.nodeSize += estimateLinkSize(utf8ByteLength(name), child);
+        else if ('block-bytes' === strategy) for (let [name, child] of (this.nodeSize = function(mode, mtime) {
+            let innerSize = 2;
+            if (void 0 !== mode && 493 !== mode && (innerSize += 1 + varintLen(mode)), null != mtime) {
+                let mtimeInner = 0, secs = Number(mtime.secs);
+                secs < 0 ? mtimeInner += 11 : mtimeInner += 1 + varintLen(secs), null != mtime.nsecs && (mtimeInner += 5), innerSize += 1 + varintLen(mtimeInner) + mtimeInner;
+            }
+            return 1 + varintLen(innerSize) + innerSize;
+        }(this.mode, this.mtime), this._children.entries()))this.nodeSize += calculateLinkSize(utf8ByteLength(name), child);
+        else throw new InvalidShardingStrategyError(`Invalid shardSplitStrategy: ${strategy}`);
+        return this.nodeSize;
+    }
+    async *flush(block) {
+        let links = [];
+        for (let [name, child] of this._children.entries()){
+            let result = child;
+            if (child instanceof Dir) for await (let entry of child.flush(block))result = entry, yield entry;
+            null != result.size && null != result.cid && links.push({
+                Name: name,
+                Tsize: Number(result.size),
+                Hash: result.cid
+            });
+        }
+        let unixfs = new UnixFS({
+            type: 'directory',
+            mtime: this.mtime,
+            mode: this.mode
+        }), node = {
+            Data: unixfs.marshal(),
+            Links: links
+        }, buffer = dag_pb_src_encode(util_prepare(node)), cid = await persist(buffer, block, this.options), size = buffer.length + node.Links.reduce((acc, curr)=>acc + (curr.Tsize ?? 0), 0);
+        this.cid = cid, this.size = size, yield {
+            cid,
+            unixfs,
+            path: this.path,
+            size: BigInt(size)
+        };
+    }
+}
+hasher_from({
+    name: 'murmur3-32',
+    code: 0x23,
+    encode: (input)=>(function(number) {
+            let bytes = [
+                ,
+                ,
+                ,
+                , 
+            ];
+            for(let i = 0; i < 4; i++)bytes[i] = 0xff & number, number >>= 8;
+            return new Uint8Array(bytes);
+        })(function(key, seed = 0) {
+            var k;
+            let h1 = seed >>> 0, length = key.length, blocks = Math.floor(length / 4);
+            for(let i = 0; i < blocks; i++){
+                let k1 = function(key, i) {
+                    let offset = 4 * i;
+                    return (key[offset] | key[offset + 1] << 8 | key[offset + 2] << 16 | key[offset + 3] << 24) >>> 0;
+                }(key, i);
+                k1 = rotl32(k1 = mul32(k1, 0xcc9e2d51), 15), h1 ^= k1 = mul32(k1, 0x1b873593), h1 = mul32(h1 = rotl32(h1, 13), 5) + 0xe6546b64 >>> 0;
+            }
+            let tail = key.slice(4 * blocks), k1 = 0;
+            switch(tail.length){
+                case 3:
+                    k1 ^= tail[2] << 16;
+                case 2:
+                    k1 ^= tail[1] << 8;
+                case 1:
+                    k1 ^= tail[0], k1 = rotl32(k1 = mul32(k1, 0xcc9e2d51), 15), h1 ^= k1 = mul32(k1, 0x1b873593);
+            }
+            return h1 ^= length, k = h1, k ^= k >>> 16, k = mul32(k, 0x85ebca6b), k ^= k >>> 13, k = mul32(k, 0xc2b2ae35), h1 = k ^= k >>> 16;
+        }(input))
+});
+let murmur3128 = hasher_from({
+    name: 'murmur3-128',
+    code: 0x22,
+    encode: (input)=>murmurHash3_x64_128(input)
+});
+hasher_from({
+    name: 'murmur3-x64-64',
+    code: 0x22,
+    encode: (input)=>murmurHash3_x64_128(input).subarray(0, 8)
+});
+class OpenFailedError extends Error {
+    static name = 'OpenFailedError';
+    static code = 'ERR_OPEN_FAILED';
+    name = OpenFailedError.name;
+    code = OpenFailedError.code;
+    constructor(message = 'Open failed'){
+        super(message);
+    }
+}
+class CloseFailedError extends Error {
+    static name = 'CloseFailedError';
+    static code = 'ERR_CLOSE_FAILED';
+    name = CloseFailedError.name;
+    code = CloseFailedError.code;
+    constructor(message = 'Close failed'){
+        super(message);
+    }
+}
+class PutFailedError extends Error {
+    static name = 'PutFailedError';
+    static code = 'ERR_PUT_FAILED';
+    name = PutFailedError.name;
+    code = PutFailedError.code;
+    constructor(message = 'Put failed'){
+        super(message);
+    }
+}
+class GetFailedError extends Error {
+    static name = 'GetFailedError';
+    static code = 'ERR_GET_FAILED';
+    name = GetFailedError.name;
+    code = GetFailedError.code;
+    constructor(message = 'Get failed'){
+        super(message);
+    }
+}
+class DeleteFailedError extends Error {
+    static name = 'DeleteFailedError';
+    static code = 'ERR_DELETE_FAILED';
+    name = DeleteFailedError.name;
+    code = DeleteFailedError.code;
+    constructor(message = 'Delete failed'){
+        super(message);
+    }
+}
+class HasFailedError extends Error {
+    static name = 'HasFailedError';
+    static code = 'ERR_HAS_FAILED';
+    name = HasFailedError.name;
+    code = HasFailedError.code;
+    constructor(message = 'Has failed'){
+        super(message);
+    }
+}
+class errors_NotFoundError extends Error {
+    static name = 'NotFoundError';
+    static code = 'ERR_NOT_FOUND';
+    name = errors_NotFoundError.name;
+    code = errors_NotFoundError.code;
+    constructor(message = 'Not Found'){
+        super(message);
+    }
+}
+class AbortError extends Error {
+    static name = 'AbortError';
+    static code = 'ERR_ABORTED';
+    name = AbortError.name;
+    code = AbortError.code;
+    constructor(message = 'Aborted'){
+        super(message);
+    }
+}
+class BaseBlockstore {
+    has(key, options) {
+        return Promise.reject(Error('.has is not implemented'));
+    }
+    put(key, val, options) {
+        return Promise.reject(Error('.put is not implemented'));
+    }
+    async *putMany(source, options) {
+        for await (let { cid, bytes } of source)await this.put(cid, bytes, options), yield cid;
+    }
+    get(key, options) {
+        throw Error('.get is not implemented');
+    }
+    async *getMany(source, options) {
+        for await (let key of source)yield {
+            cid: key,
+            bytes: this.get(key, options)
+        };
+    }
+    delete(key, options) {
+        return Promise.reject(Error('.delete is not implemented'));
+    }
+    async *deleteMany(source, options) {
+        for await (let key of source)await this.delete(key, options), yield key;
+    }
+    async *getAll(options) {
+        throw Error('.getAll is not implemented');
+    }
+}
+class BlackHoleBlockstore extends BaseBlockstore {
+    put(key, value, options) {
+        return options?.signal?.throwIfAborted(), key;
+    }
+    get(key, options) {
+        throw options?.signal?.throwIfAborted(), new errors_NotFoundError();
+    }
+    has(key, options) {
+        return options?.signal?.throwIfAborted(), !1;
+    }
+    async delete(cid, options) {
+        options?.signal?.throwIfAborted();
+    }
+    async *getAll(options) {
+        options?.signal?.throwIfAborted();
+    }
+}
+let sparse_array = __webpack_require__("./node_modules/sparse-array/index.js");
+class Bucket {
+    _options;
+    _popCount;
+    _parent;
+    _posAtParent;
+    _children;
+    key;
+    constructor(options, parent, posAtParent = 0){
+        this._options = options, this._popCount = 0, this._parent = parent, this._posAtParent = posAtParent, this._children = new sparse_array(), this.key = null;
+    }
+    async put(key, value) {
+        let place = await this._findNewBucketAndPos(key);
+        place.bucket._putAt(place, key, value);
+    }
+    async get(key) {
+        let child = await this._findChild(key);
+        if (null != child) return child.value;
+    }
+    async del(key) {
+        let place = await this._findPlace(key), child = place.bucket._at(place.pos);
+        null != child && child.key === key && place.bucket._delAt(place.pos);
+    }
+    leafCount() {
+        return this._children.compactArray().reduce((acc, child)=>child instanceof Bucket ? acc + child.leafCount() : acc + 1, 0);
+    }
+    childrenCount() {
+        return this._children.length;
+    }
+    onlyChild() {
+        return this._children.get(0);
+    }
+    *eachLeafSeries() {
+        for (let child of this._children.compactArray())child instanceof Bucket ? yield* child.eachLeafSeries() : yield child;
+    }
+    serialize(map, reduce) {
+        return reduce(this._children.reduce((acc, child, index)=>(null != child && (child instanceof Bucket ? acc.push(child.serialize(map, reduce)) : acc.push(map(child, index))), acc), []));
+    }
+    async asyncTransform(asyncMap, asyncReduce) {
+        return asyncTransformBucket(this, asyncMap, asyncReduce);
+    }
+    toJSON() {
+        return this.serialize(mapNode, reduceNodes);
+    }
+    prettyPrint() {
+        return JSON.stringify(this.toJSON(), null, '  ');
+    }
+    tableSize() {
+        return Math.pow(2, this._options.bits);
+    }
+    async _findChild(key) {
+        let result = await this._findPlace(key), child = result.bucket._at(result.pos);
+        if (!(child instanceof Bucket) && null != child && child.key === key) return child;
+    }
+    async _findPlace(key) {
+        let hashValue = this._options.hash('string' == typeof key ? from_string_node_fromString(key) : key), index = await hashValue.take(this._options.bits), child = this._children.get(index);
+        return child instanceof Bucket ? child._findPlace(hashValue) : {
+            bucket: this,
+            pos: index,
+            hash: hashValue,
+            existingChild: child
+        };
+    }
+    async _findNewBucketAndPos(key) {
+        let place = await this._findPlace(key);
+        if (null != place.existingChild && place.existingChild.key !== key) {
+            let bucket = new Bucket(this._options, place.bucket, place.pos);
+            place.bucket._putObjectAt(place.pos, bucket);
             let newPlace = await bucket._findPlace(place.existingChild.hash);
             return newPlace.bucket._putAt(newPlace, place.existingChild.key, place.existingChild.value), bucket._findNewBucketAndPos(place.hash);
         }
@@ -19772,10 +20218,10 @@ class InfiniteHash {
         this._buffers.push(buffer), this._availableBits += buffer.availableBits();
     }
 }
-let HAMT_HASH_CODE = BigInt(0x22), dir_sharded = class extends Dir {
-    _bucket;
+let dir_sharded = class extends Dir {
+    bucket;
     constructor(props, options){
-        super(props, options), this._bucket = function(options) {
+        super(props, options), this.bucket = function(options) {
             var hashFn;
             if (null == options || null == options.hashFn) throw Error('please define an options.hashFn');
             return new Bucket({
@@ -19790,151 +20236,38 @@ let HAMT_HASH_CODE = BigInt(0x22), dir_sharded = class extends Dir {
         });
     }
     async put(name, value) {
-        this.cid = void 0, this.size = void 0, this.nodeSize = void 0, await this._bucket.put(name, value);
+        this.cid = void 0, this.size = void 0, this.nodeSize = void 0, await this.bucket.put(name, value);
     }
     async get(name) {
-        return this._bucket.get(name);
+        return this.bucket.get(name);
     }
     childCount() {
-        return this._bucket.leafCount();
+        return this.bucket.leafCount();
     }
     directChildrenCount() {
-        return this._bucket.childrenCount();
+        return this.bucket.childrenCount();
     }
     onlyChild() {
-        return this._bucket.onlyChild();
+        return this.bucket.onlyChild();
     }
     *eachChildSeries() {
-        for (let { key, value } of this._bucket.eachLeafSeries())yield {
+        for (let { key, value } of this.bucket.eachLeafSeries())yield {
             key,
             child: value
         };
     }
-    estimateNodeSize() {
-        return void 0 !== this.nodeSize || (this.nodeSize = function calculateSize(bucket, shardRoot, options) {
-            let children = bucket._children, padLength = (bucket.tableSize() - 1).toString(16).length, links = [];
-            for(let i = 0; i < children.length; i++){
-                let child = children.get(i);
-                if (null == child) continue;
-                let labelPrefix = i.toString(16).toUpperCase().padStart(padLength, '0');
-                if (child instanceof Bucket) {
-                    let size = calculateSize(child, null, options);
-                    links.push({
-                        Name: labelPrefix,
-                        Tsize: Number(size),
-                        Hash: 0 === options.cidVersion ? CID_V0 : CID_V1
-                    });
-                } else if ('function' == typeof child.value.flush) {
-                    let size = child.value.nodeSize();
-                    links.push({
-                        Name: labelPrefix + child.key,
-                        Tsize: Number(size),
-                        Hash: 0 === options.cidVersion ? CID_V0 : CID_V1
-                    });
-                } else {
-                    let value = child.value;
-                    if (null == value.cid) continue;
-                    let label = labelPrefix + child.key, size = value.size;
-                    links.push({
-                        Name: label,
-                        Tsize: Number(size),
-                        Hash: value.cid
-                    });
-                }
-            }
-            return dag_pb_src_encode(util_prepare({
-                Data: new UnixFS({
-                    type: 'hamt-sharded-directory',
-                    data: Uint8Array.from(children.bitField().reverse()),
-                    fanout: BigInt(bucket.tableSize()),
-                    hashType: HAMT_HASH_CODE,
-                    mtime: shardRoot?.mtime,
-                    mode: shardRoot?.mode
-                }).marshal(),
-                Links: links
-            })).length;
-        }(this._bucket, this, this.options)), this.nodeSize;
+    async estimateNodeSize() {
+        if (void 0 !== this.nodeSize) return this.nodeSize;
+        let blockstore = new BlackHoleBlockstore(), result = await calculateSize(this.bucket, this, blockstore, this.options);
+        return this.nodeSize = result.size, this.nodeSize;
     }
     async *flush(blockstore) {
-        for await (let entry of dir_sharded_flush(this._bucket, blockstore, this, this.options))yield {
+        for await (let entry of dir_sharded_flush(this.bucket, blockstore, this, this.options))yield {
             ...entry,
             path: this.path
         };
     }
-}, toPathComponents = (path = '')=>path.split(/(?<!\\)\//).filter(Boolean);
-class OpenFailedError extends Error {
-    static name = 'OpenFailedError';
-    static code = 'ERR_OPEN_FAILED';
-    name = OpenFailedError.name;
-    code = OpenFailedError.code;
-    constructor(message = 'Open failed'){
-        super(message);
-    }
-}
-class CloseFailedError extends Error {
-    static name = 'CloseFailedError';
-    static code = 'ERR_CLOSE_FAILED';
-    name = CloseFailedError.name;
-    code = CloseFailedError.code;
-    constructor(message = 'Close failed'){
-        super(message);
-    }
-}
-class PutFailedError extends Error {
-    static name = 'PutFailedError';
-    static code = 'ERR_PUT_FAILED';
-    name = PutFailedError.name;
-    code = PutFailedError.code;
-    constructor(message = 'Put failed'){
-        super(message);
-    }
-}
-class GetFailedError extends Error {
-    static name = 'GetFailedError';
-    static code = 'ERR_GET_FAILED';
-    name = GetFailedError.name;
-    code = GetFailedError.code;
-    constructor(message = 'Get failed'){
-        super(message);
-    }
-}
-class DeleteFailedError extends Error {
-    static name = 'DeleteFailedError';
-    static code = 'ERR_DELETE_FAILED';
-    name = DeleteFailedError.name;
-    code = DeleteFailedError.code;
-    constructor(message = 'Delete failed'){
-        super(message);
-    }
-}
-class HasFailedError extends Error {
-    static name = 'HasFailedError';
-    static code = 'ERR_HAS_FAILED';
-    name = HasFailedError.name;
-    code = HasFailedError.code;
-    constructor(message = 'Has failed'){
-        super(message);
-    }
-}
-class errors_NotFoundError extends Error {
-    static name = 'NotFoundError';
-    static code = 'ERR_NOT_FOUND';
-    name = errors_NotFoundError.name;
-    code = errors_NotFoundError.code;
-    constructor(message = 'Not Found'){
-        super(message);
-    }
-}
-class AbortError extends Error {
-    static name = 'AbortError';
-    static code = 'ERR_ABORTED';
-    name = AbortError.name;
-    code = AbortError.code;
-    constructor(message = 'Aborted'){
-        super(message);
-    }
-}
-let it_all_dist_src = function(source) {
+}, toPathComponents = (path = '')=>path.split(/(?<!\\)\//).filter(Boolean), it_all_dist_src = function(source) {
     if (null != source[Symbol.asyncIterator]) return (async ()=>{
         let arr = [];
         for await (let entry of source)arr.push(entry);
@@ -20549,7 +20882,7 @@ let ENS_DEPLOYER_ROLE = keccak256(Bytes_fromString('ENS_DEPLOYER')), execTransac
                         let type, tokens = info.tokens = function(input, nf, ef) {
                             let ret = [], chars = [];
                             for(input = input.slice().reverse(); input.length;){
-                                let emoji = function(cps, eaten) {
+                                let emoji = function(cps) {
                                     let emoji, node = EMOJI_ROOT, pos = cps.length;
                                     for(; pos && (node = node.get(cps[--pos]));){
                                         let { V } = node;