core-3nweb-client-lib 0.26.1 → 0.27.0

package/build/lib-common/objs-on-disk/file-layout.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { Layout } from "xsp-files";
+import { DiffInfo } from "../service-api/3nstorage/owner";
 export interface HeaderChunkInfo {
     len: number;
     fileOfs: number;
@@ -60,4 +61,22 @@ export declare class ObjVersionBytesLayout {
     addSegsOnFile(thisVerOfs: number, len: number, fileOfs: number): void;
     addBaseSegsOnFile(thisVerOfs: number, baseVerOfs: number, len: number, fileOfs: number): void;
     getBaseVersion(): number | undefined;
+    calcBaseAbsorptionParams(baseLayout: ObjVersionBytesLayout): BaseAbsorptionParams;
+    applyAbsorptionParams(params: BaseAbsorptionParams): void;
+    diffFromBase(): {
+        diff: DiffInfo;
+        newSegsPackOrder: FiniteChunk[];
+    };
 }
+interface ChunkCopyOp {
+    ofsInSrcFile: number;
+    len: number;
+    ofsInDstFile: number;
+}
+export interface BaseAbsorptionParams {
+    newBytesEnd: number;
+    newBase: number | undefined;
+    chunkReplacements: Map<number, (NewSegsChunkOnDisk | BaseSegsChunk)[]>;
+    copyOps: ChunkCopyOp[];
+}
+export {};

package/build/lib-common/objs-on-disk/file-layout.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2019 3NSoft Inc.
+ Copyright (C) 2019,  2022 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -81,7 +81,12 @@ class ObjVersionBytesLayout {
         return this.segsLayoutFrozen;
     }
     isFileComplete() {
-        return !this.segsChunks.find(chunk => ((chunk.type === 'new') || (chunk.type === 'new-endless')));
+        for (const chunk of this.segsChunks) {
+            if ((chunk.type === 'new') || (chunk.type === 'new-endless')) {
+                return true;
+            }
+        }
+        return true;
     }
     getLayoutOfs() {
         return this.bytesEnd;
@@ -90,8 +95,8 @@ class ObjVersionBytesLayout {
         return this.headerChunk;
     }
     segsLocations(thisVerOfs, len) {
-        assert_1.assert(Number.isInteger(thisVerOfs) && (thisVerOfs >= 0));
-        assert_1.assert(Number.isInteger(len) && (len >= 0));
+        (0, assert_1.assert)(Number.isInteger(thisVerOfs) && (thisVerOfs >= 0));
+        (0, assert_1.assert)(Number.isInteger(len) && (len >= 0));
         const segInfos = [];
         const end = thisVerOfs + len;
         for (let i = 0; (i < this.segsChunks.length) && (len > 0); i += 1) {
@@ -118,7 +123,7 @@ class ObjVersionBytesLayout {
                 len -= chop.len;
             }
             else {
-                const chop = json_utils_1.copy(chunk);
+                const chop = (0, json_utils_1.copy)(chunk);
                 chop.thisVerOfs = thisVerOfs;
                 if (chunk.type === 'new-endless') {
                     chop.type = 'new';
@@ -178,7 +183,7 @@ class ObjVersionBytesLayout {
     }
     addHeader(len, fileOfs) {
         this.ensureExpectedFileOfs(fileOfs);
-        assert_1.assert(Number.isInteger(len) && (len >= 0));
+        (0, assert_1.assert)(Number.isInteger(len) && (len >= 0));
         if (this.headerChunk) {
             throw new Error(`Header added second time to obj version bytes layout`);
         }
@@ -188,8 +193,8 @@ class ObjVersionBytesLayout {
     }
     addSegsOnFile(thisVerOfs, len, fileOfs) {
         this.ensureExpectedFileOfs(fileOfs);
-        assert_1.assert(Number.isInteger(thisVerOfs) && (thisVerOfs >= 0));
-        assert_1.assert(Number.isInteger(len) && (len >= 0));
+        (0, assert_1.assert)(Number.isInteger(thisVerOfs) && (thisVerOfs >= 0));
+        (0, assert_1.assert)(Number.isInteger(len) && (len >= 0));
         const s = {
             type: 'new-on-disk', thisVerOfs, len, fileOfs
         };
@@ -198,9 +203,9 @@ class ObjVersionBytesLayout {
     }
     addBaseSegsOnFile(thisVerOfs, baseVerOfs, len, fileOfs) {
         this.ensureExpectedFileOfs(fileOfs);
-        assert_1.assert(Number.isInteger(thisVerOfs) && (thisVerOfs >= 0));
-        assert_1.assert(Number.isInteger(baseVerOfs) && (baseVerOfs >= 0));
-        assert_1.assert(Number.isInteger(len) && (len >= 0));
+        (0, assert_1.assert)(Number.isInteger(thisVerOfs) && (thisVerOfs >= 0));
+        (0, assert_1.assert)(Number.isInteger(baseVerOfs) && (baseVerOfs >= 0));
+        (0, assert_1.assert)(Number.isInteger(len) && (len >= 0));
         const s = {
             type: 'base-on-disk', thisVerOfs, baseVerOfs, len, fileOfs
         };
@@ -210,6 +215,119 @@ class ObjVersionBytesLayout {
     getBaseVersion() {
         return this.baseVersion;
     }
+    calcBaseAbsorptionParams(baseLayout) {
+        (0, assert_1.assert)(this.isFileComplete() && baseLayout.isFileComplete());
+        const chunkReplacements = new Map();
+        const copyOps = [];
+        let newBytesEnd = this.bytesEnd;
+        for (let i = 0; i < this.segsChunks.length; i += 1) {
+            const chunk = this.segsChunks[i];
+            if (chunk.type === 'new-on-disk') {
+                continue;
+            }
+            if (chunk.type !== 'base') {
+                throw new Error(`Absorbing base is not implemented on chunk type ${chunk.type}.`);
+            }
+            const replacements = [];
+            // start in base version offset
+            let start = chunk.baseVerOfs;
+            const end = start + chunk.len;
+            for (let j = 0; j < baseLayout.segsChunks.length; j += 1) {
+                const bChunk = baseLayout.segsChunks[j];
+                if ((bChunk.type !== 'new-on-disk')
+                    && (bChunk.type !== 'base')) {
+                    throw new Error(`Absorbing base is not implemented on chunk type ${chunk.type}.`);
+                }
+                const bEnd = bChunk.thisVerOfs + bChunk.len;
+                if (bEnd <= start) {
+                    continue;
+                }
+                const cut = Math.min(end, bEnd);
+                const len = cut - start;
+                const thisVerOfs = chunk.thisVerOfs + (start - chunk.baseVerOfs);
+                const ofsIntoBChunk = start - bChunk.thisVerOfs;
+                if (bChunk.type === 'new-on-disk') {
+                    const op = {
+                        ofsInSrcFile: bChunk.fileOfs + ofsIntoBChunk,
+                        len,
+                        ofsInDstFile: newBytesEnd
+                    };
+                    copyOps.push(op);
+                    const replacementChunk = {
+                        type: 'new-on-disk',
+                        fileOfs: newBytesEnd,
+                        len,
+                        thisVerOfs
+                    };
+                    replacements.push(replacementChunk);
+                    newBytesEnd += len;
+                }
+                else if (bChunk.type === 'base') {
+                    const replacementChunk = {
+                        type: 'base',
+                        len,
+                        thisVerOfs,
+                        baseVerOfs: bChunk.baseVerOfs + ofsIntoBChunk
+                    };
+                    replacements.push(replacementChunk);
+                }
+                else {
+                    throw new Error(`This shouldn't be unreachable. Unimplemented chunk type?`);
+                }
+                start = cut;
+                if (start === end) {
+                    break;
+                }
+            }
+            (0, assert_1.assert)(start === end);
+            chunkReplacements.set(i, replacements);
+        }
+        return {
+            chunkReplacements, copyOps, newBytesEnd,
+            newBase: baseLayout.baseVersion
+        };
+    }
+    applyAbsorptionParams(params) {
+        this.bytesEnd = params.newBytesEnd;
+        this.baseVersion = params.newBase;
+        const changes = [];
+        for (const [segInd, newSegs] of params.chunkReplacements.entries()) {
+            const initSeg = this.segsChunks[segInd];
+            changes.push([initSeg, newSegs]);
+        }
+        for (const [initSeg, newSegs] of changes) {
+            const ind = this.segsChunks.indexOf(initSeg);
+            this.segsChunks.splice(ind, 1, ...newSegs);
+        }
+    }
+    diffFromBase() {
+        (0, assert_1.assert)(!!this.baseVersion && this.isFileComplete());
+        const sections = [];
+        const newSegsPackOrder = [];
+        let segsSize = 0;
+        let ofsInNewSegsPack = 0;
+        for (let i = 0; i < this.segsChunks.length; i += 1) {
+            const seg = this.segsChunks[i];
+            if ((seg.type === 'base') || (seg.type === 'base-on-disk')) {
+                sections.push([0, seg.baseVerOfs, seg.len]);
+            }
+            else {
+                // XXX with simplification second element (bizarre 0) will be gone
+                sections.push([1, 0, seg.len]);
+                newSegsPackOrder.push({
+                    thisVerOfs: seg.thisVerOfs, len: seg.len,
+                });
+                ofsInNewSegsPack += seg.len;
+            }
+            segsSize += seg.len;
+        }
+        const diff = {
+            baseVersion: this.baseVersion,
+            sections,
+            segsSize
+        };
+        return { diff, newSegsPackOrder };
+    }
 }
 exports.ObjVersionBytesLayout = ObjVersionBytesLayout;
 Object.freeze(ObjVersionBytesLayout.prototype);
@@ -223,7 +341,7 @@ function layoutSectionsToSegsChunks(sections) {
         }
         const chunk = layoutSectionToSegsChunk(section);
         if (chunk.type === 'new-endless') {
-            assert_1.assert(sections[sections.length - 1] === section, `Infinite layout section must be the last section`);
+            (0, assert_1.assert)(sections[sections.length - 1] === section, `Infinite layout section must be the last section`);
         }
         else {
             chunks.push(chunk);

package/build/lib-common/objs-on-disk/obj-file.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { Layout } from 'xsp-files';
-import { FiniteSegsChunk } from './file-layout';
+import { FiniteSegsChunk, FiniteChunk } from './file-layout';
+import { DiffInfo } from '../service-api/3nstorage/owner';
 export declare class ObjVersionFile {
     private path;
     private readonly layout;
@@ -9,9 +10,14 @@ export declare class ObjVersionFile {
     static forExisting(path: string): Promise<ObjVersionFile>;
     static createNew(path: string): Promise<ObjVersionFile>;
     private startCreatingFileOnDisk;
-    moveFile(newPath: string): Promise<void>;
+    moveFile(newPath: string, newHeader: Uint8Array | undefined): Promise<void>;
     removeFile(): Promise<void>;
     saveLayout(): Promise<void>;
+    /**
+     * @param fd already openned file descriptor
+     * @param ofs is an optional offset at which layout is written, when we need
+     * value different from current one in layout.
+     */
     private recordLayout;
     private withRWFile;
     getTotalSegsLen(): number;
@@ -29,6 +35,11 @@ export declare class ObjVersionFile {
     setSegsLayout(layout: Layout, saveLayout: boolean): Promise<void>;
     truncateEndlessLayout(): void;
     isFileComplete(): boolean;
+    absorbImmediateBaseVersion(baseVer: number, path: string): Promise<void>;
+    diffFromBase(): {
+        diff: DiffInfo;
+        newSegsPackOrder: FiniteChunk[];
+    };
 }
 export interface ObjFileParsingException extends web3n.RuntimeException {
     type: 'obj-file-parsing';

package/build/lib-common/objs-on-disk/obj-file.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2019 - 2020 3NSoft Inc.
+ Copyright (C) 2019 - 2020, 2022 3NSoft Inc.
  
  This program is free software: you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
@@ -27,6 +27,7 @@ const v1_obj_file_format_1 = require("./v1-obj-file-format");
 const fs_1 = require("fs");
 const file_layout_1 = require("./file-layout");
 const big_endian_1 = require("../big-endian");
+const assert_1 = require("../assert");
 class ObjVersionFile {
     constructor(path, layout) {
         this.path = path;
@@ -35,20 +36,8 @@ class ObjVersionFile {
         Object.seal(this);
     }
     static async forExisting(path) {
-        const fd = await fs.open(path, 'r');
-        try {
-            const layout = await parseObjVersionBytesLayout(fd)
-                .catch((err) => {
-                if (err.type === 'obj-file-parsing') {
-                    err.path = path;
-                }
-                throw err;
-            });
-            return new ObjVersionFile(path, layout);
-        }
-        finally {
-            await fs.close(fd).catch(noop);
-        }
+        const layout = await readLayoutFrom(path);
+        return new ObjVersionFile(path, layout);
     }
     static async createNew(path) {
         const layout = file_layout_1.ObjVersionBytesLayout.forNewFile();
@@ -59,10 +48,22 @@ class ObjVersionFile {
     startCreatingFileOnDisk() {
         this.writeProc.addStarted(createNewV1File(this.path));
     }
-    moveFile(newPath) {
+    moveFile(newPath, newHeader) {
         return this.writeProc.startOrChain(async () => {
+            var _a;
             await fs.rename(this.path, newPath);
             this.path = newPath;
+            if (newHeader) {
+                (0, assert_1.assert)(newHeader.length === ((_a = this.layout.headerLocation()) === null || _a === void 0 ? void 0 : _a.len));
+                const headerOfs = this.layout.headerLocation().fileOfs;
+                const fd = await fs.open(this.path, 'r+');
+                try {
+                    await fs.write(fd, headerOfs, (0, buffer_utils_1.toBuffer)(newHeader));
+                }
+                finally {
+                    await fs.close(fd).catch(noop);
+                }
+            }
         });
     }
     removeFile() {
@@ -71,9 +72,16 @@ class ObjVersionFile {
     saveLayout() {
         return this.withRWFile(fd => this.recordLayout(fd));
     }
-    async recordLayout(fd) {
+    /**
+     * @param fd already openned file descriptor
+     * @param ofs is an optional offset at which layout is written, when we need
+     * value different from current one in layout.
+     */
+    async recordLayout(fd, ofs) {
         const layoutBytes = this.layout.toBytes();
-        const ofs = this.layout.getLayoutOfs();
+        if (!ofs) {
+            ofs = this.layout.getLayoutOfs();
+        }
         await fs.writeFromBuf(fd, ofs, layoutBytes);
         await recordLayoutOffsetInV1(fd, ofs);
         await fs.ftruncate(fd, ofs + layoutBytes.length);
@@ -82,7 +90,7 @@ class ObjVersionFile {
         return this.writeProc.startOrChain(async () => {
             const fd = await fs.open(this.path, 'r+')
                 .catch(exc => {
-                throw error_1.errWithCause(exc, `Can't open for writing obj-version file ${this.path}`);
+                throw (0, error_1.errWithCause)(exc, `Can't open for writing obj-version file ${this.path}`);
             });
             try {
                 return await action(fd);
@@ -101,7 +109,7 @@ class ObjVersionFile {
     saveHeader(header, saveLayout) {
         return this.withRWFile(async (fd) => {
             const ofs = this.layout.getLayoutOfs();
-            await fs.writeFromBuf(fd, ofs, buffer_utils_1.toBuffer(header));
+            await fs.writeFromBuf(fd, ofs, (0, buffer_utils_1.toBuffer)(header));
             this.layout.addHeader(header.length, ofs);
             if (saveLayout) {
                 await this.recordLayout(fd);
@@ -111,7 +119,7 @@ class ObjVersionFile {
     saveSegs(segsChunks, thisVerOfs, baseVerOfs, saveLayout) {
         return this.withRWFile(async (fd) => {
             const ofs = this.layout.getLayoutOfs();
-            await fs.writeFromBuf(fd, ofs, buffer_utils_1.toBuffer(segsChunks));
+            await fs.writeFromBuf(fd, ofs, (0, buffer_utils_1.toBuffer)(segsChunks));
             if (baseVerOfs === undefined) {
                 this.layout.addSegsOnFile(thisVerOfs, segsChunks.length, ofs);
             }
@@ -128,18 +136,25 @@ class ObjVersionFile {
     }
     async withROFile(action) {
         const path = this.path;
-        const fd = await fs.open(path, 'r')
-            .catch((exc) => {
+        let fd;
+        try {
+            fd = await fs.open(path, 'r');
+        }
+        catch (exc) {
+            // in some use cases version file can be moved, and for this reason
+            // we make second attempt if path is newer
             if (exc.notFound && (path !== this.path)) {
-                return fs.open(this.path, 'r');
+                try {
+                    fd = await fs.open(this.path, 'r');
+                }
+                catch (exc) {
+                    throw (0, error_1.errWithCause)(exc, `Can't open for reading obj version file ${this.path}`);
+                }
             }
             else {
                 throw exc;
             }
-        })
-            .catch(exc => {
-            throw error_1.errWithCause(exc, `Can't open for reading obj version file ${this.path}`);
-        });
+        }
         try {
             return await action(fd);
         }
@@ -171,7 +186,7 @@ class ObjVersionFile {
             return;
         }
         await this.withROFile(async (fd) => {
-            const src = fs_1.createReadStream('', {
+            const src = (0, fs_1.createReadStream)('', {
                 fd,
                 autoClose: false,
                 start: chunkInfo.fileOfs,
@@ -204,7 +219,7 @@ class ObjVersionFile {
             for (const chunk of chunks) {
                 if ((chunk.type === 'new-on-disk')
                     || (chunk.type === 'base-on-disk')) {
-                    const src = fs_1.createReadStream('', {
+                    const src = (0, fs_1.createReadStream)('', {
                         fd,
                         autoClose: false,
                         start: chunk.fileOfs,
@@ -235,13 +250,43 @@ class ObjVersionFile {
     isFileComplete() {
         return this.layout.isFileComplete();
     }
+    async absorbImmediateBaseVersion(baseVer, path) {
+        (0, assert_1.assert)(baseVer === this.layout.getBaseVersion());
+        const baseLayout = await readLayoutFrom(path);
+        const absorptionParams = this.layout.calcBaseAbsorptionParams(baseLayout);
+        const src = await fs.open(path, 'r');
+        await this.withRWFile(async (fd) => {
+            if (absorptionParams.copyOps.length > 0) {
+                await this.recordLayout(fd, absorptionParams.newBytesEnd);
+                let buf = Buffer.allocUnsafe(absorptionParams.copyOps[0].len);
+                for (const op of absorptionParams.copyOps) {
+                    if (buf.length < op.len) {
+                        buf = Buffer.allocUnsafe(op.len);
+                    }
+                    const chunk = ((op.len < buf.length) ?
+                        buf.slice(0, op.len) : buf);
+                    await fs.readToBuf(src, op.ofsInSrcFile, chunk);
+                    await fs.writeFromBuf(fd, op.ofsInDstFile, chunk);
+                }
+            }
+            this.layout.applyAbsorptionParams(absorptionParams);
+            await this.recordLayout(fd);
+        })
+            .then(() => fs.close(src).catch(noop), async (exc) => {
+            await fs.close(src).catch(noop);
+            throw exc;
+        });
+    }
+    diffFromBase() {
+        return this.layout.diffFromBase();
+    }
 }
 exports.ObjVersionFile = ObjVersionFile;
 Object.freeze(ObjVersionFile.prototype);
 Object.freeze(ObjVersionFile);
 function noop() { }
 async function pipeBytes(src, sink) {
-    const deferred = deferred_1.defer();
+    const deferred = (0, deferred_1.defer)();
     src.pipe(sink, { end: false });
     src.on('error', (err) => {
         deferred.reject(err);
@@ -274,8 +319,8 @@ async function parseObjVersionBytesLayout(fd) {
         throw exc;
     });
     const fileStart = fstBytes.slice(0, 4);
-    if (bytes_equal_1.bytesEqual(fileStart, v1_obj_file_format_1.V1_FILE_START)) {
-        const layoutOfs = big_endian_1.uintFrom8Bytes(fstBytes, 4);
+    if ((0, bytes_equal_1.bytesEqual)(fileStart, v1_obj_file_format_1.V1_FILE_START)) {
+        const layoutOfs = (0, big_endian_1.uintFrom8Bytes)(fstBytes, 4);
         if (layoutOfs === 0) {
             throw parsingException(`Obj version file is in incomplete state`);
         }
@@ -302,10 +347,26 @@ async function createNewV1File(path) {
 }
 async function recordLayoutOffsetInV1(fd, ofs) {
     const ofsInBytes = Buffer.allocUnsafe(8);
-    big_endian_1.packUintTo8Bytes(ofs, ofsInBytes, 0);
+    (0, big_endian_1.packUintTo8Bytes)(ofs, ofsInBytes, 0);
     await fs.writeFromBuf(fd, v1_obj_file_format_1.V1_FILE_START.length, ofsInBytes)
         .catch(exc => {
-        throw error_1.errWithCause(exc, `Can't record layout offset in obj file`);
+        throw (0, error_1.errWithCause)(exc, `Can't record layout offset in obj file`);
     });
 }
+async function readLayoutFrom(path) {
+    const fd = await fs.open(path, 'r');
+    try {
+        const layout = await parseObjVersionBytesLayout(fd)
+            .catch((err) => {
+            if (err.type === 'obj-file-parsing') {
+                err.path = path;
+            }
+            throw err;
+        });
+        return layout;
+    }
+    finally {
+        await fs.close(fd).catch(noop);
+    }
+}
 Object.freeze(exports);

package/build/lib-common/objs-on-disk/utils.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Layout } from 'xsp-files';
 import { DiffInfo } from '../service-api/3nstorage/owner';
 import { ObjVersionFile } from './obj-file';

package/build/lib-common/objs-on-disk/utils.js

@@ -42,7 +42,7 @@ function diffToLayout(diff) {
 }
 exports.diffToLayout = diffToLayout;
 async function streamToObjFile(file, content, src, maxBufferLen) {
-    let deferred = deferred_1.defer();
+    let deferred = (0, deferred_1.defer)();
     const contentIter = content.values();
     let chunk = undefined;
     let buf = new bytes_fifo_buffer_1.BytesFIFOBuffer();
@@ -111,7 +111,7 @@ async function streamToObjFile(file, content, src, maxBufferLen) {
     });
     src.on('end', () => {
         if (chunk) {
-            complete(file_1.makeFileException(file_1.Code.endOfFile, '<input stream>'));
+            complete((0, file_1.makeFileException)(file_1.Code.endOfFile, '<input stream>'));
         }
         else {
             complete();
@@ -125,7 +125,7 @@ exports.streamToObjFile = streamToObjFile;
 function chunksInOrderedStream(len, headerLen, segsOfs) {
     const chunks = [];
     if (typeof headerLen === 'number') {
-        assert_1.assert(len >= headerLen);
+        (0, assert_1.assert)(len >= headerLen);
         chunks.push({ type: 'header', len: headerLen });
         len -= headerLen;
     }

package/build/lib-common/objs-on-disk/v1-obj-file-format.js

@@ -23,16 +23,16 @@ var headerChunkInfo;
 (function (headerChunkInfo) {
     function toBytes(hInfo) {
         const buf = Buffer.allocUnsafe(12);
-        big_endian_1.packUintTo4Bytes(hInfo.len, buf, 0);
-        big_endian_1.packUintTo8Bytes(hInfo.fileOfs, buf, 4);
+        (0, big_endian_1.packUintTo4Bytes)(hInfo.len, buf, 0);
+        (0, big_endian_1.packUintTo8Bytes)(hInfo.fileOfs, buf, 4);
         return buf;
     }
     headerChunkInfo.toBytes = toBytes;
     function fromBytes(b, i) {
         let bytesRead = 0;
-        const len = big_endian_1.uintFrom4Bytes(b, i + bytesRead);
+        const len = (0, big_endian_1.uintFrom4Bytes)(b, i + bytesRead);
         bytesRead += 4;
-        const fileOfs = big_endian_1.uintFrom8Bytes(b, i + bytesRead);
+        const fileOfs = (0, big_endian_1.uintFrom8Bytes)(b, i + bytesRead);
         bytesRead += 8;
         const hInfo = { len, fileOfs };
         return { hInfo: Object.freeze(hInfo), bytesRead };
@@ -60,18 +60,18 @@ var segsChunkInfo;
         let i = 0;
         buf[i] = flag;
         i += 1;
-        big_endian_1.packUintTo8Bytes(sInfo.thisVerOfs, buf, i);
+        (0, big_endian_1.packUintTo8Bytes)(sInfo.thisVerOfs, buf, i);
         i += 8;
         if (sInfo.type !== 'new-endless') {
-            big_endian_1.packUintTo8Bytes(sInfo.len, buf, 9);
+            (0, big_endian_1.packUintTo8Bytes)(sInfo.len, buf, 9);
             i += 8;
         }
         if ((sInfo.type === 'new-on-disk') || (sInfo.type === 'base-on-disk')) {
-            big_endian_1.packUintTo8Bytes(sInfo.fileOfs, buf, i);
+            (0, big_endian_1.packUintTo8Bytes)(sInfo.fileOfs, buf, i);
             i += 8;
         }
         if ((sInfo.type === 'base') || (sInfo.type === 'base-on-disk')) {
-            big_endian_1.packUintTo8Bytes(sInfo.baseVerOfs, buf, i);
+            (0, big_endian_1.packUintTo8Bytes)(sInfo.baseVerOfs, buf, i);
         }
         return buf;
     }
@@ -80,21 +80,21 @@ var segsChunkInfo;
         let bytesRead = 0;
         const flag = b[i + bytesRead];
         bytesRead += 1;
-        const thisVerOfs = big_endian_1.uintFrom8Bytes(b, i + bytesRead);
+        const thisVerOfs = (0, big_endian_1.uintFrom8Bytes)(b, i + bytesRead);
         bytesRead += 8;
         let len = undefined;
         if ((flag & IS_ENDLESS_BITMASK) === 0) {
-            len = big_endian_1.uintFrom8Bytes(b, i + bytesRead);
+            len = (0, big_endian_1.uintFrom8Bytes)(b, i + bytesRead);
             bytesRead += 8;
         }
         let fileOfs = undefined;
         if (flag & FILE_OFS_PRESENT_BITMASK) {
-            fileOfs = big_endian_1.uintFrom8Bytes(b, i + bytesRead);
+            fileOfs = (0, big_endian_1.uintFrom8Bytes)(b, i + bytesRead);
             bytesRead += 8;
         }
         let baseVerOfs = undefined;
         if (flag & BASE_VER_OFS_PRESENT_BITMASK) {
-            baseVerOfs = big_endian_1.uintFrom8Bytes(b, i + bytesRead);
+            baseVerOfs = (0, big_endian_1.uintFrom8Bytes)(b, i + bytesRead);
             bytesRead += 8;
         }
         const isOnDisk = (fileOfs !== undefined);
@@ -168,7 +168,7 @@ var layoutV1;
         if (a.baseVersion !== undefined) {
             flag |= BASE_PRESENT_BITMASK;
             baseBytes = Buffer.allocUnsafe(8);
-            big_endian_1.packUintTo8Bytes(a.baseVersion, baseBytes, 0);
+            (0, big_endian_1.packUintTo8Bytes)(a.baseVersion, baseBytes, 0);
             if (a.allBaseBytesInFile) {
                 flag |= ALL_BASE_BYTES_IN_FILE_BITMASK;
             }
@@ -214,7 +214,7 @@ var layoutV1;
         i += 1;
         let baseVersion = undefined;
         if (flag & BASE_PRESENT_BITMASK) {
-            baseVersion = big_endian_1.uintFrom8Bytes(b, i);
+            baseVersion = (0, big_endian_1.uintFrom8Bytes)(b, i);
             i += 8;
         }
         let headerChunk = undefined;

package/build/lib-common/processes/labelled-exec-pools.d.ts

@@ -10,7 +10,7 @@ declare class ProcessingPool<PoolLabel extends string> {
     private readonly inProcess;
     private readonly queue;
     isRunning: boolean;
-    constructor(label: PoolLabel, maxProcs: number, logError?: ((err: any, msg?: string | undefined) => Promise<void>) | undefined);
+    constructor(label: PoolLabel, maxProcs: number, logError?: ((err: any, msg?: string) => Promise<void>) | undefined);
     add(task: Task<any>): void;
     private processNextQueued;
     pause(): void;

package/build/lib-common/processes/labelled-exec-pools.js

@@ -92,7 +92,7 @@ class LabelledExecPools {
     constructor(setup, logError) {
         this.pools = new Map();
         this.isRunning = false;
-        assert_1.assert(setup.length > 0);
+        (0, assert_1.assert)(setup.length > 0);
         for (const { label, maxProcs } of setup) {
             const pool = new ProcessingPool(label, maxProcs, logError);
             this.pools.set(pool.label, pool);

package/build/lib-common/processes/pressure.js

@@ -35,7 +35,7 @@ class PressureValve {
             if (this.stopper) {
                 return;
             }
-            this.stopper = deferred_1.defer();
+            this.stopper = (0, deferred_1.defer)();
         }
         else {
             if (!this.stopper) {
@@ -47,7 +47,7 @@ class PressureValve {
     }
     pressWithError(err) {
         this.toggle(true);
-        this.stopper.reject(error_1.errWithCause(err, `Backpressure error`));
+        this.stopper.reject((0, error_1.errWithCause)(err, `Backpressure error`));
     }
 }
 exports.PressureValve = PressureValve;

package/build/lib-common/processes/synced.js

@@ -149,7 +149,7 @@ class SingleProc {
         }
     }
     startOrChain(action) {
-        const deferred = deferred_1.defer();
+        const deferred = (0, deferred_1.defer)();
         this.actions.push({ action, deferred });
         this.runIfIdle();
         return deferred.promise;