@bopen-io/wallet-toolbox 2.6.2-brc153.5 → 2.14.5

package/out/src/services/chaintracker/chaintracks/createIdbChaintracks.js

@@ -4,12 +4,6 @@ exports.createIdbChaintracks = createIdbChaintracks;
 const createDefaultIdbChaintracksOptions_1 = require("./createDefaultIdbChaintracksOptions");
 const configureChaintracksIngestors_1 = require("./configureChaintracksIngestors");
 async function createIdbChaintracks(...args) {
-    try {
-        return (0, configureChaintracksIngestors_1.createAndStartDefaultChaintracks)(args, createDefaultIdbChaintracksOptions_1.createDefaultIdbChaintracksOptions);
-    }
-    catch (error) {
-        console.error('Error setting up Chaintracks with Idb Storage:', error);
-        throw error;
-    }
+    return (0, configureChaintracksIngestors_1.createAndStartDefaultChaintracks)(args, createDefaultIdbChaintracksOptions_1.createDefaultIdbChaintracksOptions);
 }
 //# sourceMappingURL=createIdbChaintracks.js.map

package/out/src/services/chaintracker/chaintracks/createIdbChaintracks.js.map

@@ -1 +1 @@
-{"version":3,"file":"createIdbChaintracks.js","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/createIdbChaintracks.ts"],"names":[],"mappings":";;;AAIA,6FAAyF;AACzF,mFAGwC;AAEjC,KAAK,+BAAgC,GAAG,IAAiC;IAQ9E,IAAI,CAAC;QACH,OAAO,IAAA,gEAAgC,EAAwB,IAAI,EAAE,uEAAkC,CAAC,CAAA;IAC1G,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,gDAAgD,EAAE,KAAK,CAAC,CAAA;QACtE,MAAM,KAAK,CAAA;IACb,CAAC;AACH,CAAC"}
+{"version":3,"file":"createIdbChaintracks.js","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/createIdbChaintracks.ts"],"names":[],"mappings":";;;AAIA,6FAAyF;AACzF,mFAAoH;AAE7G,KAAK,+BAA+B,GAAG,IAAiC;IAQ7E,OAAO,IAAA,gEAAgC,EAAwB,IAAI,EAAE,uEAAkC,CAAC,CAAA;AAC1G,CAAC"}

package/out/src/services/chaintracker/chaintracks/createKnexChaintracks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createKnexChaintracks.d.ts","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/createKnexChaintracks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAA;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAA;AAEzE,OAAO,EAEL,KAAK,+BAA+B,EACrC,MAAM,4BAA4B,CAAA;AAEnC,wBAAsB,qBAAqB,CAAE,GAAG,IAAI,EAAE,+BAA+B,GAAG,OAAO,CAAC;IAC9F,KAAK,EAAE,KAAK,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,mBAAmB,CAAA;IAC1B,OAAO,EAAE,sBAAsB,CAAA;IAC/B,WAAW,EAAE,WAAW,CAAA;IACxB,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB,CAAC,CAOD"}
+{"version":3,"file":"createKnexChaintracks.d.ts","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/createKnexChaintracks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAA;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAA;AAEzE,OAAO,EAAwC,KAAK,+BAA+B,EAAE,MAAM,4BAA4B,CAAA;AAEvH,wBAAsB,qBAAqB,CAAC,GAAG,IAAI,EAAE,+BAA+B,GAAG,OAAO,CAAC;IAC7F,KAAK,EAAE,KAAK,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,mBAAmB,CAAA;IAC1B,OAAO,EAAE,sBAAsB,CAAA;IAC/B,WAAW,EAAE,WAAW,CAAA;IACxB,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB,CAAC,CAED"}

package/out/src/services/chaintracker/chaintracks/createKnexChaintracks.js

@@ -4,12 +4,6 @@ exports.createKnexChaintracks = createKnexChaintracks;
 const createDefaultKnexChaintracksOptions_1 = require("./createDefaultKnexChaintracksOptions");
 const configureKnexChaintracks_1 = require("./configureKnexChaintracks");
 async function createKnexChaintracks(...args) {
-    try {
-        return (0, configureKnexChaintracks_1.createAndStartDefaultKnexChaintracks)(args, createDefaultKnexChaintracksOptions_1.createDefaultKnexChaintracksOptions);
-    }
-    catch (error) {
-        console.error('Error setting up Chaintracks with Knex Storage:', error);
-        throw error;
-    }
+    return (0, configureKnexChaintracks_1.createAndStartDefaultKnexChaintracks)(args, createDefaultKnexChaintracksOptions_1.createDefaultKnexChaintracksOptions);
 }
 //# sourceMappingURL=createKnexChaintracks.js.map

package/out/src/services/chaintracker/chaintracks/createKnexChaintracks.js.map

@@ -1 +1 @@
-{"version":3,"file":"createKnexChaintracks.js","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/createKnexChaintracks.ts"],"names":[],"mappings":";;;AAIA,+FAA2F;AAC3F,yEAGmC;AAE5B,KAAK,gCAAiC,GAAG,IAAqC;IAQnF,IAAI,CAAC;QACH,OAAO,IAAA,+DAAoC,EAAyB,IAAI,EAAE,yEAAmC,CAAC,CAAA;IAChH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,iDAAiD,EAAE,KAAK,CAAC,CAAA;QACvE,MAAM,KAAK,CAAA;IACb,CAAC;AACH,CAAC"}
+{"version":3,"file":"createKnexChaintracks.js","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/createKnexChaintracks.ts"],"names":[],"mappings":";;;AAIA,+FAA2F;AAC3F,yEAAuH;AAEhH,KAAK,gCAAgC,GAAG,IAAqC;IAQlF,OAAO,IAAA,+DAAoC,EAAyB,IAAI,EAAE,yEAAmC,CAAC,CAAA;AAChH,CAAC"}

package/out/src/services/chaintracker/chaintracks/createNoDbChaintracks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createNoDbChaintracks.d.ts","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/createNoDbChaintracks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAA;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAA;AAEzE,OAAO,EAEL,KAAK,2BAA2B,EACjC,MAAM,iCAAiC,CAAA;AAExC,wBAAsB,qBAAqB,CAAE,GAAG,IAAI,EAAE,2BAA2B,GAAG,OAAO,CAAC;IAC1F,KAAK,EAAE,KAAK,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,mBAAmB,CAAA;IAC1B,OAAO,EAAE,sBAAsB,CAAA;IAC/B,WAAW,EAAE,WAAW,CAAA;IACxB,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB,CAAC,CAOD"}
+{"version":3,"file":"createNoDbChaintracks.d.ts","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/createNoDbChaintracks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAA;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAA;AAEzE,OAAO,EAAoC,KAAK,2BAA2B,EAAE,MAAM,iCAAiC,CAAA;AAEpH,wBAAsB,qBAAqB,CAAC,GAAG,IAAI,EAAE,2BAA2B,GAAG,OAAO,CAAC;IACzF,KAAK,EAAE,KAAK,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,mBAAmB,CAAA;IAC1B,OAAO,EAAE,sBAAsB,CAAA;IAC/B,WAAW,EAAE,WAAW,CAAA;IACxB,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB,CAAC,CAED"}

package/out/src/services/chaintracker/chaintracks/createNoDbChaintracks.js

@@ -4,12 +4,6 @@ exports.createNoDbChaintracks = createNoDbChaintracks;
 const createDefaultNoDbChaintracksOptions_1 = require("./createDefaultNoDbChaintracksOptions");
 const configureChaintracksIngestors_1 = require("./configureChaintracksIngestors");
 async function createNoDbChaintracks(...args) {
-    try {
-        return (0, configureChaintracksIngestors_1.createAndStartDefaultChaintracks)(args, createDefaultNoDbChaintracksOptions_1.createDefaultNoDbChaintracksOptions);
-    }
-    catch (error) {
-        console.error('Error setting up Chaintracks with NoDb Storage:', error);
-        throw error;
-    }
+    return (0, configureChaintracksIngestors_1.createAndStartDefaultChaintracks)(args, createDefaultNoDbChaintracksOptions_1.createDefaultNoDbChaintracksOptions);
 }
 //# sourceMappingURL=createNoDbChaintracks.js.map

package/out/src/services/chaintracker/chaintracks/createNoDbChaintracks.js.map

@@ -1 +1 @@
-{"version":3,"file":"createNoDbChaintracks.js","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/createNoDbChaintracks.ts"],"names":[],"mappings":";;;AAIA,+FAA2F;AAC3F,mFAGwC;AAEjC,KAAK,gCAAiC,GAAG,IAAiC;IAQ/E,IAAI,CAAC;QACH,OAAO,IAAA,gEAAgC,EAAyB,IAAI,EAAE,yEAAmC,CAAC,CAAA;IAC5G,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,iDAAiD,EAAE,KAAK,CAAC,CAAA;QACvE,MAAM,KAAK,CAAA;IACb,CAAC;AACH,CAAC"}
+{"version":3,"file":"createNoDbChaintracks.js","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/createNoDbChaintracks.ts"],"names":[],"mappings":";;;AAIA,+FAA2F;AAC3F,mFAAoH;AAE7G,KAAK,gCAAgC,GAAG,IAAiC;IAQ9E,OAAO,IAAA,gEAAgC,EAAyB,IAAI,EAAE,yEAAmC,CAAC,CAAA;AAC5G,CAAC"}

package/out/src/services/chaintracker/chaintracks/index.all.d.ts

@@ -1,5 +1,8 @@
 export * from './index.client';
 export * from './util/ChaintracksFs';
+export * from './util/BulkFileDataCacheFs';
+export * from './util/NodeBulkFileDataValidator';
+export * from './util/DurableFileBulkFileDownloadBudget';
 export * from './Storage/ChaintracksStorageKnex';
 export * from './Storage/ChaintracksStorageMemory';
 export * from './createDefaultKnexChaintracksOptions';

package/out/src/services/chaintracker/chaintracks/index.all.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.all.d.ts","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/index.all.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAE9B,cAAc,sBAAsB,CAAA;AACpC,cAAc,kCAAkC,CAAA;AAChD,cAAc,oCAAoC,CAAA;AAElD,cAAc,uCAAuC,CAAA;AACrD,cAAc,yBAAyB,CAAA;AAEvC,cAAc,sBAAsB,CAAA;AACpC,cAAc,qCAAqC,CAAA;AACnD,cAAc,qCAAqC,CAAA"}
+{"version":3,"file":"index.all.d.ts","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/index.all.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAE9B,cAAc,sBAAsB,CAAA;AACpC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,kCAAkC,CAAA;AAChD,cAAc,0CAA0C,CAAA;AACxD,cAAc,kCAAkC,CAAA;AAChD,cAAc,oCAAoC,CAAA;AAElD,cAAc,uCAAuC,CAAA;AACrD,cAAc,yBAAyB,CAAA;AAEvC,cAAc,sBAAsB,CAAA;AACpC,cAAc,qCAAqC,CAAA;AACnD,cAAc,qCAAqC,CAAA"}

package/out/src/services/chaintracker/chaintracks/index.all.js

@@ -16,6 +16,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./index.client"), exports);
 __exportStar(require("./util/ChaintracksFs"), exports);
+__exportStar(require("./util/BulkFileDataCacheFs"), exports);
+__exportStar(require("./util/NodeBulkFileDataValidator"), exports);
+__exportStar(require("./util/DurableFileBulkFileDownloadBudget"), exports);
 __exportStar(require("./Storage/ChaintracksStorageKnex"), exports);
 __exportStar(require("./Storage/ChaintracksStorageMemory"), exports);
 __exportStar(require("./createDefaultKnexChaintracksOptions"), exports);

package/out/src/services/chaintracker/chaintracks/index.all.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.all.js","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/index.all.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iDAA8B;AAE9B,uDAAoC;AACpC,mEAAgD;AAChD,qEAAkD;AAElD,wEAAqD;AACrD,0DAAuC;AAEvC,uDAAoC;AACpC,sEAAmD;AACnD,sEAAmD"}
+{"version":3,"file":"index.all.js","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/index.all.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iDAA8B;AAE9B,uDAAoC;AACpC,6DAA0C;AAC1C,mEAAgD;AAChD,2EAAwD;AACxD,mEAAgD;AAChD,qEAAkD;AAElD,wEAAqD;AACrD,0DAAuC;AAEvC,uDAAoC;AACpC,sEAAmD;AACnD,sEAAmD"}

package/out/src/services/chaintracker/chaintracks/index.mobile.d.ts

@@ -8,6 +8,8 @@ export * from './Api/BulkStorageApi';
 export * from './Api/BulkIngestorApi';
 export * from './Api/LiveIngestorApi';
 export * from './Api/BlockHeaderApi';
+export * from './Api/BulkFileDataCacheApi';
+export * from './Api/BulkFileDataValidatorApi';
 export * from './Chaintracks';
 export * from './ChaintracksServiceClient';
 export * from './GoChaintracksServiceClient';
@@ -30,6 +32,9 @@ export * from './configureChaintracksIngestors';
 export * from './util/BulkFilesReader';
 export * from './util/HeightRange';
 export * from './util/BulkFileDataManager';
+export * from './util/BulkHeaderFile';
 export * from './util/ChaintracksFetch';
+export * from './util/FixedWindowBulkFileDownloadBudget';
+export * from './util/InlineBulkFileDataValidator';
 export * as utils from './util/blockHeaderUtilities';
 //# sourceMappingURL=index.mobile.d.ts.map

package/out/src/services/chaintracker/chaintracks/index.mobile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.mobile.d.ts","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/index.mobile.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAE/C,cAAc,sBAAsB,CAAA;AACpC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,wBAAwB,CAAA;AACtC,cAAc,2BAA2B,CAAA;AACzC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,sBAAsB,CAAA;AACpC,cAAc,uBAAuB,CAAA;AACrC,cAAc,uBAAuB,CAAA;AACrC,cAAc,sBAAsB,CAAA;AAEpC,cAAc,eAAe,CAAA;AAC7B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,8BAA8B,CAAA;AAE5C,cAAc,2BAA2B,CAAA;AACzC,cAAc,2BAA2B,CAAA;AAEzC,cAAc,0BAA0B,CAAA;AACxC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,sCAAsC,CAAA;AACpD,cAAc,kCAAkC,CAAA;AAChD,cAAc,uCAAuC,CAAA;AACrD,cAAc,qCAAqC,CAAA;AACnD,cAAc,+BAA+B,CAAA;AAE7C,cAAc,2BAA2B,CAAA;AACzC,cAAc,kCAAkC,CAAA;AAChD,cAAc,kCAAkC,CAAA;AAChD,cAAc,iCAAiC,CAAA;AAE/C,cAAc,uCAAuC,CAAA;AACrD,cAAc,yBAAyB,CAAA;AACvC,cAAc,iCAAiC,CAAA;AAE/C,cAAc,wBAAwB,CAAA;AACtC,cAAc,oBAAoB,CAAA;AAClC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,yBAAyB,CAAA;AAEvC,OAAO,KAAK,KAAK,MAAM,6BAA6B,CAAA"}
+{"version":3,"file":"index.mobile.d.ts","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/index.mobile.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAE/C,cAAc,sBAAsB,CAAA;AACpC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,wBAAwB,CAAA;AACtC,cAAc,2BAA2B,CAAA;AACzC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,sBAAsB,CAAA;AACpC,cAAc,uBAAuB,CAAA;AACrC,cAAc,uBAAuB,CAAA;AACrC,cAAc,sBAAsB,CAAA;AACpC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,gCAAgC,CAAA;AAE9C,cAAc,eAAe,CAAA;AAC7B,cAAc,4BAA4B,CAAA;AAC1C,cAAc,8BAA8B,CAAA;AAE5C,cAAc,2BAA2B,CAAA;AACzC,cAAc,2BAA2B,CAAA;AAEzC,cAAc,0BAA0B,CAAA;AACxC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,sCAAsC,CAAA;AACpD,cAAc,kCAAkC,CAAA;AAChD,cAAc,uCAAuC,CAAA;AACrD,cAAc,qCAAqC,CAAA;AACnD,cAAc,+BAA+B,CAAA;AAE7C,cAAc,2BAA2B,CAAA;AACzC,cAAc,kCAAkC,CAAA;AAChD,cAAc,kCAAkC,CAAA;AAChD,cAAc,iCAAiC,CAAA;AAE/C,cAAc,uCAAuC,CAAA;AACrD,cAAc,yBAAyB,CAAA;AACvC,cAAc,iCAAiC,CAAA;AAE/C,cAAc,wBAAwB,CAAA;AACtC,cAAc,oBAAoB,CAAA;AAClC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,uBAAuB,CAAA;AACrC,cAAc,yBAAyB,CAAA;AACvC,cAAc,0CAA0C,CAAA;AACxD,cAAc,oCAAoC,CAAA;AAElD,OAAO,KAAK,KAAK,MAAM,6BAA6B,CAAA"}

package/out/src/services/chaintracker/chaintracks/index.mobile.js

@@ -46,6 +46,8 @@ __exportStar(require("./Api/BulkStorageApi"), exports);
 __exportStar(require("./Api/BulkIngestorApi"), exports);
 __exportStar(require("./Api/LiveIngestorApi"), exports);
 __exportStar(require("./Api/BlockHeaderApi"), exports);
+__exportStar(require("./Api/BulkFileDataCacheApi"), exports);
+__exportStar(require("./Api/BulkFileDataValidatorApi"), exports);
 __exportStar(require("./Chaintracks"), exports);
 __exportStar(require("./ChaintracksServiceClient"), exports);
 __exportStar(require("./GoChaintracksServiceClient"), exports);
@@ -68,6 +70,9 @@ __exportStar(require("./configureChaintracksIngestors"), exports);
 __exportStar(require("./util/BulkFilesReader"), exports);
 __exportStar(require("./util/HeightRange"), exports);
 __exportStar(require("./util/BulkFileDataManager"), exports);
+__exportStar(require("./util/BulkHeaderFile"), exports);
 __exportStar(require("./util/ChaintracksFetch"), exports);
+__exportStar(require("./util/FixedWindowBulkFileDownloadBudget"), exports);
+__exportStar(require("./util/InlineBulkFileDataValidator"), exports);
 exports.utils = __importStar(require("./util/blockHeaderUtilities"));
 //# sourceMappingURL=index.mobile.js.map

package/out/src/services/chaintracker/chaintracks/index.mobile.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.mobile.js","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/index.mobile.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,uDAAoC;AACpC,6DAA0C;AAC1C,yDAAsC;AACtC,4DAAyC;AACzC,8DAA2C;AAC3C,uDAAoC;AACpC,wDAAqC;AACrC,wDAAqC;AACrC,uDAAoC;AAEpC,gDAA6B;AAC7B,6DAA0C;AAC1C,+DAA4C;AAE5C,4DAAyC;AACzC,4DAAyC;AAEzC,2DAAwC;AACxC,kEAA+C;AAC/C,uEAAoD;AACpD,mEAAgD;AAChD,wEAAqD;AACrD,sEAAmD;AACnD,gEAA6C;AAE7C,4DAAyC;AACzC,mEAAgD;AAChD,mEAAgD;AAChD,kEAA+C;AAE/C,wEAAqD;AACrD,0DAAuC;AACvC,kEAA+C;AAE/C,yDAAsC;AACtC,qDAAkC;AAClC,6DAA0C;AAC1C,0DAAuC;AAEvC,QAAY,KAAK,wDAAmC"}
+{"version":3,"file":"index.mobile.js","sourceRoot":"","sources":["../../../../../src/services/chaintracker/chaintracks/index.mobile.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,uDAAoC;AACpC,6DAA0C;AAC1C,yDAAsC;AACtC,4DAAyC;AACzC,8DAA2C;AAC3C,uDAAoC;AACpC,wDAAqC;AACrC,wDAAqC;AACrC,uDAAoC;AACpC,6DAA0C;AAC1C,iEAA8C;AAE9C,gDAA6B;AAC7B,6DAA0C;AAC1C,+DAA4C;AAE5C,4DAAyC;AACzC,4DAAyC;AAEzC,2DAAwC;AACxC,kEAA+C;AAC/C,uEAAoD;AACpD,mEAAgD;AAChD,wEAAqD;AACrD,sEAAmD;AACnD,gEAA6C;AAE7C,4DAAyC;AACzC,mEAAgD;AAChD,mEAAgD;AAChD,kEAA+C;AAE/C,wEAAqD;AACrD,0DAAuC;AACvC,kEAA+C;AAE/C,yDAAsC;AACtC,qDAAkC;AAClC,6DAA0C;AAC1C,wDAAqC;AACrC,0DAAuC;AACvC,2EAAwD;AACxD,qEAAkD;AAElD,QAAY,KAAK,wDAAmC"}

package/out/src/services/chaintracker/chaintracks/util/BulkFileDataCacheFs.d.ts

@@ -0,0 +1,51 @@
+import type { BulkFileDataCacheApi } from '../Api/BulkFileDataCacheApi';
+import type { BulkHeaderFileInfo } from './BulkHeaderFile';
+export interface BulkFileDataCacheFsOptions {
+    /** Root for immutable content-addressed cache objects. */
+    rootFolder: string;
+    /** Read-only legacy locations consulted during in-place migration. */
+    legacyRoots?: string[];
+    /** Maximum wait for a per-object cross-process mutation lock. Default: 30 seconds. */
+    lockTimeoutMsecs?: number;
+    /** Delay between lock attempts. Default: 25 milliseconds. */
+    lockRetryMsecs?: number;
+}
+/**
+ * Atomic filesystem implementation of the bulk-header cache contract.
+ *
+ * This Node-only export is intentionally absent from browser and mobile entry
+ * points. Cache contents are untrusted until the manager verifies their exact
+ * byte length and SHA-256 digest.
+ *
+ * @public
+ */
+export declare class BulkFileDataCacheFs implements BulkFileDataCacheApi {
+    private static readonly MAX_HEADERS_PER_FILE;
+    private static readonly MAX_LEGACY_ROOTS;
+    private static readonly SAFE_FILE_NAME;
+    private readonly rootFolder;
+    private readonly legacyRoots;
+    private readonly lockTimeoutMsecs;
+    private readonly lockRetryMsecs;
+    constructor(rootFolderOrOptions: string | BulkFileDataCacheFsOptions);
+    private legacyFilePath;
+    private validateFileName;
+    private validateRoot;
+    private expectedBytes;
+    private validateData;
+    private digestHex;
+    private objectPath;
+    private legacyRejectionMarker;
+    get(file: Readonly<BulkHeaderFileInfo>): Promise<Uint8Array | undefined>;
+    set(file: Readonly<BulkHeaderFileInfo>, data: Uint8Array): Promise<void>;
+    private setNoLock;
+    promoteValidated(file: Readonly<BulkHeaderFileInfo>, data: Uint8Array): Promise<void>;
+    quarantine(file: Readonly<BulkHeaderFileInfo>, reason: string, rejectedData?: Uint8Array): Promise<void>;
+    private quarantineNoLock;
+    delete(file: Readonly<BulkHeaderFileInfo>): Promise<void>;
+    private readBoundedFile;
+    private positiveInteger;
+    private snapshotFile;
+    private withObjectLock;
+}
+//# sourceMappingURL=BulkFileDataCacheFs.d.ts.map

package/out/src/services/chaintracker/chaintracks/util/BulkFileDataCacheFs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BulkFileDataCacheFs.d.ts","sourceRoot":"","sources":["../../../../../../src/services/chaintracker/chaintracks/util/BulkFileDataCacheFs.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAE1D,MAAM,WAAW,0BAA0B;IACzC,0DAA0D;IAC1D,UAAU,EAAE,MAAM,CAAA;IAClB,sEAAsE;IACtE,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB,sFAAsF;IACtF,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,6DAA6D;IAC7D,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED;;;;;;;;GAQG;AACH,qBAAa,mBAAoB,YAAW,oBAAoB;IAC9D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAAU;IACtD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,CAAK;IAC7C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAwC;IAE9E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAU;IACtC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAQ;IACzC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;IAEvC,YAAY,mBAAmB,EAAE,MAAM,GAAG,0BAA0B,EAoBnE;IAED,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,YAAY;IAUpB,OAAO,CAAC,SAAS;IASjB,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,qBAAqB;IAIvB,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAqB7E;IAEK,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAK7E;YAEa,SAAS;IAsBjB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAY1F;IAEK,UAAU,CAAC,IAAI,EAAE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAa7G;YAEa,gBAAgB;IA4BxB,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAE9D;YAEa,eAAe;IA+B7B,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,YAAY;YAeN,cAAc;CAsD7B"}

package/out/src/services/chaintracker/chaintracks/util/BulkFileDataCacheFs.js

@@ -0,0 +1,394 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkFileDataCacheFs = void 0;
+const node_fs_1 = require("node:fs");
+const node_crypto_1 = require("node:crypto");
+const path = __importStar(require("node:path"));
+/**
+ * Atomic filesystem implementation of the bulk-header cache contract.
+ *
+ * This Node-only export is intentionally absent from browser and mobile entry
+ * points. Cache contents are untrusted until the manager verifies their exact
+ * byte length and SHA-256 digest.
+ *
+ * @public
+ */
+class BulkFileDataCacheFs {
+    static MAX_HEADERS_PER_FILE = 100_000;
+    static MAX_LEGACY_ROOTS = 64;
+    static SAFE_FILE_NAME = /^[A-Za-z0-9][A-Za-z0-9._~-]{0,254}$/;
+    rootFolder;
+    legacyRoots;
+    lockTimeoutMsecs;
+    lockRetryMsecs;
+    constructor(rootFolderOrOptions) {
+        const options = typeof rootFolderOrOptions === 'string' ? { rootFolder: rootFolderOrOptions } : rootFolderOrOptions;
+        if (options == null || typeof options !== 'object' || Array.isArray(options)) {
+            throw new Error('Bulk-header cache options must be a root path or options object.');
+        }
+        this.rootFolder = this.validateRoot(options.rootFolder, 'rootFolder');
+        this.lockTimeoutMsecs = this.positiveInteger(options.lockTimeoutMsecs ?? 30_000, 'lockTimeoutMsecs');
+        this.lockRetryMsecs = this.positiveInteger(options.lockRetryMsecs ?? 25, 'lockRetryMsecs');
+        if (this.lockRetryMsecs > this.lockTimeoutMsecs) {
+            throw new Error('lockRetryMsecs must be no greater than lockTimeoutMsecs.');
+        }
+        const legacyRoots = options.legacyRoots ?? [];
+        if (!Array.isArray(legacyRoots) || legacyRoots.length > BulkFileDataCacheFs.MAX_LEGACY_ROOTS) {
+            throw new Error(`legacyRoots must be an array of no more than ${BulkFileDataCacheFs.MAX_LEGACY_ROOTS} paths.`);
+        }
+        this.legacyRoots = [];
+        for (let index = 0; index < legacyRoots.length; index++) {
+            if (!Object.hasOwn(legacyRoots, index))
+                throw new Error('legacyRoots must be a dense array of paths.');
+            this.legacyRoots.push(this.validateRoot(legacyRoots[index], `legacyRoots[${index}]`));
+        }
+    }
+    legacyFilePath(root, file) {
+        this.validateFileName(file);
+        return path.join(root, file.fileName);
+    }
+    validateFileName(file) {
+        if (typeof file.fileName !== 'string' ||
+            !BulkFileDataCacheFs.SAFE_FILE_NAME.test(file.fileName) ||
+            path.basename(file.fileName) !== file.fileName ||
+            file.fileName === '.' ||
+            file.fileName === '..') {
+            throw new Error(`Invalid bulk-header cache file name: ${file.fileName}`);
+        }
+    }
+    validateRoot(value, name) {
+        if (typeof value !== 'string' || value.trim() === '' || /[\r\n]/.test(value) || value.includes('\u0000')) {
+            throw new Error(`${name} must be a non-empty filesystem path without control lines.`);
+        }
+        const resolved = path.resolve(value);
+        if (resolved === path.parse(resolved).root)
+            throw new Error(`${name} cannot be a filesystem root.`);
+        return resolved;
+    }
+    expectedBytes(file) {
+        if (!Number.isSafeInteger(file.count) || file.count < 1 || file.count > BulkFileDataCacheFs.MAX_HEADERS_PER_FILE) {
+            throw new Error(`Invalid bulk-header count for ${file.fileName}`);
+        }
+        return file.count * 80;
+    }
+    validateData(file, data) {
+        if (!(data instanceof Uint8Array))
+            throw new Error(`Invalid bulk-header data for ${file.fileName}`);
+        if (data.byteLength !== this.expectedBytes(file)) {
+            throw new Error(`Invalid bulk-header data length for ${file.fileName}`);
+        }
+        if ((0, node_crypto_1.createHash)('sha256').update(data).digest('base64') !== file.fileHash) {
+            throw new Error(`Invalid bulk-header data digest for ${file.fileName}`);
+        }
+    }
+    digestHex(file) {
+        if (file.fileHash == null)
+            throw new Error(`Missing bulk-header digest for ${file.fileName}`);
+        const digest = Buffer.from(file.fileHash, 'base64');
+        if (digest.length !== 32 || digest.toString('base64') !== file.fileHash) {
+            throw new Error(`Invalid bulk-header digest for ${file.fileName}`);
+        }
+        return digest.toString('hex');
+    }
+    objectPath(file) {
+        this.validateFileName(file);
+        const digest = this.digestHex(file);
+        return path.join(this.rootFolder, 'objects', digest.slice(0, 2), `${digest}.headers`);
+    }
+    legacyRejectionMarker(file) {
+        return path.join(this.rootFolder, 'quarantine', `${this.digestHex(file)}.legacy-rejected.json`);
+    }
+    async get(file) {
+        file = this.snapshotFile(file);
+        try {
+            return await this.readBoundedFile(this.objectPath(file), file);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        try {
+            await node_fs_1.promises.access(this.legacyRejectionMarker(file));
+            return undefined;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        for (const root of this.legacyRoots) {
+            try {
+                return await this.readBoundedFile(this.legacyFilePath(root, file), file);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        return undefined;
+    }
+    async set(file, data) {
+        file = this.snapshotFile(file);
+        const ownedData = data instanceof Uint8Array ? data.slice() : data;
+        this.validateData(file, ownedData);
+        await this.withObjectLock(file, async () => await this.setNoLock(file, ownedData));
+    }
+    async setNoLock(file, data) {
+        const destination = this.objectPath(file);
+        const folder = path.dirname(destination);
+        await node_fs_1.promises.mkdir(folder, { recursive: true });
+        const temporary = path.join(folder, `.${path.basename(destination)}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+        let handle;
+        try {
+            handle = await node_fs_1.promises.open(temporary, 'wx', 0o600);
+            await handle.writeFile(data);
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            await node_fs_1.promises.rename(temporary, destination);
+            await syncDirectory(folder);
+        }
+        finally {
+            await handle?.close().catch(() => undefined);
+            await node_fs_1.promises.unlink(temporary).catch(error => {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            });
+        }
+    }
+    async promoteValidated(file, data) {
+        file = this.snapshotFile(file);
+        const ownedData = data instanceof Uint8Array ? data.slice() : data;
+        this.validateData(file, ownedData);
+        await this.withObjectLock(file, async () => {
+            try {
+                await node_fs_1.promises.access(this.objectPath(file));
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+                await this.setNoLock(file, ownedData);
+            }
+        });
+    }
+    async quarantine(file, reason, rejectedData) {
+        file = this.snapshotFile(file);
+        if (typeof reason !== 'string' || reason.length > 4096 || /[\r\n]/.test(reason) || reason.includes('\u0000')) {
+            throw new Error('Bulk-header quarantine reason must be a single-line string no longer than 4096 characters.');
+        }
+        if (rejectedData !== undefined && !(rejectedData instanceof Uint8Array)) {
+            throw new Error('Rejected bulk-header data exceeds the bounded cache-object size.');
+        }
+        rejectedData = rejectedData?.slice();
+        if (rejectedData !== undefined && rejectedData.byteLength > this.expectedBytes(file) + 1) {
+            throw new Error('Rejected bulk-header data exceeds the bounded cache-object size.');
+        }
+        await this.withObjectLock(file, async () => await this.quarantineNoLock(file, reason, rejectedData));
+    }
+    async quarantineNoLock(file, reason, rejectedData) {
+        const source = this.objectPath(file);
+        const quarantineFolder = path.join(this.rootFolder, 'quarantine');
+        const destination = path.join(quarantineFolder, `${this.digestHex(file)}.${Date.now()}.${(0, node_crypto_1.randomUUID)()}.invalid`);
+        await node_fs_1.promises.mkdir(quarantineFolder, { recursive: true });
+        try {
+            const candidate = await this.readBoundedFile(source, file);
+            if (rejectedData != null && !Buffer.from(candidate).equals(Buffer.from(rejectedData)))
+                return;
+            await node_fs_1.promises.rename(source, destination);
+            await syncDirectory(path.dirname(source));
+            await syncDirectory(quarantineFolder);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            if (this.legacyRoots.length === 0)
+                return;
+            // Legacy entries are intentionally read-only. Once replacement succeeds,
+            // the content-addressed object takes precedence without destroying the
+            // old deployment's only retained bytes.
+            await writeAtomicFile(this.legacyRejectionMarker(file), Buffer.from(JSON.stringify({ fileName: file.fileName, fileHash: file.fileHash, reason })));
+        }
+    }
+    async delete(file) {
+        await this.quarantine(file, 'delete requested through legacy cache contract');
+    }
+    async readBoundedFile(source, file) {
+        const maximum = this.expectedBytes(file);
+        const handle = await node_fs_1.promises.open(source, 'r');
+        try {
+            const stat = await handle.stat();
+            if (!stat.isFile())
+                throw new Error(`Bulk-header cache object is not a regular file: ${file.fileName}`);
+            const requested = stat.size > maximum ? maximum + 1 : stat.size;
+            const data = new Uint8Array(requested);
+            let offset = 0;
+            while (offset < data.length) {
+                const { bytesRead } = await handle.read(data, offset, data.length - offset, offset);
+                if (bytesRead === 0)
+                    break;
+                offset += bytesRead;
+            }
+            let result = offset === data.length ? data : data.slice(0, offset);
+            if (result.length <= maximum) {
+                const extra = new Uint8Array(1);
+                const { bytesRead } = await handle.read(extra, 0, 1, result.length);
+                if (bytesRead > 0) {
+                    const grown = new Uint8Array(result.length + 1);
+                    grown.set(result);
+                    grown[result.length] = extra[0];
+                    result = grown;
+                }
+            }
+            return result;
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    positiveInteger(value, name) {
+        if (!Number.isSafeInteger(value) || value < 1 || value > 60 * 60 * 1000) {
+            throw new Error(`${name} must be an integer from 1 through 3600000.`);
+        }
+        return value;
+    }
+    snapshotFile(file) {
+        if (file == null || typeof file !== 'object' || Array.isArray(file)) {
+            throw new Error('Bulk-header cache metadata must be a data object.');
+        }
+        const values = {};
+        for (const name of ['fileName', 'fileHash', 'count']) {
+            const descriptor = Object.getOwnPropertyDescriptor(file, name);
+            if (descriptor == null || !Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+                throw new Error(`Bulk-header cache metadata ${name} must be an own data property.`);
+            }
+            values[name] = descriptor.value;
+        }
+        return values;
+    }
+    async withObjectLock(file, work) {
+        const destination = this.objectPath(file);
+        const lockFolder = `${destination}.lock`;
+        const ownerFile = path.join(lockFolder, 'owner');
+        const token = (0, node_crypto_1.randomUUID)();
+        const startedAt = Date.now();
+        await node_fs_1.promises.mkdir(path.dirname(destination), { recursive: true });
+        for (;;) {
+            try {
+                await node_fs_1.promises.mkdir(lockFolder, { mode: 0o700 });
+                try {
+                    await node_fs_1.promises.writeFile(ownerFile, token, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+                }
+                catch (error) {
+                    await node_fs_1.promises.rmdir(lockFolder).catch(() => undefined);
+                    throw error;
+                }
+                break;
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+                if (Date.now() - startedAt >= this.lockTimeoutMsecs) {
+                    throw new Error(`Timed out acquiring bulk-header cache lock ${lockFolder}. ` +
+                        'The lock is never reclaimed automatically after a crash; verify that no writer is active before removing it.');
+                }
+                await new Promise(resolve => setTimeout(resolve, this.lockRetryMsecs));
+            }
+        }
+        let outcome;
+        try {
+            outcome = { ok: true, value: await work() };
+        }
+        catch (error) {
+            outcome = { ok: false, error };
+        }
+        let releaseError;
+        try {
+            let owner;
+            try {
+                owner = await node_fs_1.promises.readFile(ownerFile, 'utf8');
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+            if (owner === token) {
+                await node_fs_1.promises.unlink(ownerFile);
+                await node_fs_1.promises.rmdir(lockFolder);
+            }
+        }
+        catch (error) {
+            releaseError = error;
+        }
+        if (!outcome.ok)
+            throw outcome.error;
+        if (releaseError != null)
+            throw releaseError;
+        return outcome.value;
+    }
+}
+exports.BulkFileDataCacheFs = BulkFileDataCacheFs;
+async function writeAtomicFile(destination, data) {
+    const folder = path.dirname(destination);
+    await node_fs_1.promises.mkdir(folder, { recursive: true });
+    const temporary = path.join(folder, `.${path.basename(destination)}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+    let handle;
+    try {
+        handle = await node_fs_1.promises.open(temporary, 'wx', 0o600);
+        await handle.writeFile(data);
+        await handle.sync();
+        await handle.close();
+        handle = undefined;
+        await node_fs_1.promises.rename(temporary, destination);
+        await syncDirectory(folder);
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+        await node_fs_1.promises.unlink(temporary).catch(error => {
+            if (error.code !== 'ENOENT')
+                throw error;
+        });
+    }
+}
+async function syncDirectory(folder) {
+    let handle;
+    try {
+        handle = await node_fs_1.promises.open(folder, 'r');
+        await handle.sync();
+    }
+    finally {
+        await handle?.close();
+    }
+}
+//# sourceMappingURL=BulkFileDataCacheFs.js.map