core-3nweb-client-lib 0.26.0 → 0.27.1

package/build/lib-client/3nstorage/xsp-fs/link-node.js

@@ -82,7 +82,7 @@ class LinkNode extends node_in_fs_1.NodeInFS {
         if (!name || !objId || !parentId) {
             throw new Error("Bad link parameter(s) given");
         }
-        this.crypto = new LinkPersistance(xsp_files_1.idToHeaderNonce(this.objId), key, this.storage.cryptor);
+        this.crypto = new LinkPersistance((0, xsp_files_1.idToHeaderNonce)(this.objId), key, this.storage.cryptor);
         Object.seal(this);
     }
     static async makeForNew(storage, parentId, name, key) {
@@ -92,12 +92,17 @@ class LinkNode extends node_in_fs_1.NodeInFS {
         return link;
     }
     static async makeForExisting(storage, parentId, name, objId, key) {
-        const src = await storage.getObj(objId);
+        const src = await storage.getObjSrc(objId);
         const link = new LinkNode(storage, name, objId, src.version, parentId, key);
         const { params, attrs, xattrs } = await link.crypto.read(src);
         link.setUpdatedState(params, src.version, attrs, xattrs);
+        link.setCurrentStateFrom(src);
         return link;
     }
+    async setCurrentStateFrom(src) {
+        const { params, attrs, xattrs } = await this.crypto.read(src);
+        this.setUpdatedState(params, src.version, attrs, xattrs);
+    }
     setUpdatedState(params, version, attrs, xattrs) {
         this.linkParams = params;
         super.setUpdatedParams(version, attrs, xattrs);

package/build/lib-client/3nstorage/xsp-fs/node-in-fs.d.ts

@@ -1,11 +1,14 @@
-import { Node, NodeType, Storage, RemoteEvent } from './common';
+import { FSChangeSrc, Node, NodeType, Storage, SyncedStorage } from './common';
 import { Observable } from 'rxjs';
 import { CommonAttrs, XAttrs } from './attrs';
 import { NodePersistance } from './node-persistence';
-import { UpSyncTaskInfo } from '../../../core/storage/synced/obj-status';
+import { ObjSource } from 'xsp-files';
 export declare type FSEvent = web3n.files.FolderEvent | web3n.files.FileEvent;
+declare type RemoteEvent = web3n.files.RemoteEvent;
 declare type XAttrsChanges = web3n.files.XAttrsChanges;
-declare type Stats = web3n.files.Stats;
+declare type SyncStatus = web3n.files.SyncStatus;
+declare type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
+declare type OptionsToUploadLocal = web3n.files.OptionsToUploadLocal;
 export declare abstract class NodeInFS<P extends NodePersistance> implements Node {
     protected readonly storage: Storage;
     readonly type: NodeType;
@@ -19,7 +22,7 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
     private writeProc;
     get version(): number;
     protected setCurrentVersion(newVersion: number): void;
-    private remoteEvents;
+    readonly isInSyncedStorage: boolean;
     protected constructor(storage: Storage, type: NodeType, name: string, objId: string, currentVersion: number, parentId: string | undefined);
     private updatedXAttrs;
     protected setUpdatedParams(version: number, attrs: CommonAttrs | undefined, xattrs: XAttrs | undefined): void;
@@ -32,17 +35,18 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
     getXAttr(xaName: string): any;
     listXAttrs(): string[];
     getAttrs(): CommonAttrs;
-    processRemoteEvent(event: RemoteEvent): Promise<void>;
-    private bufferRemoteEvent;
-    private getBufferedEvent;
-    localDelete(): Promise<void>;
-    broadcastUpSyncEvent(task: UpSyncTaskInfo): void;
+    listVersions(): Promise<{
+        current?: number;
+        archived?: number[];
+    }>;
+    archiveCurrent(version?: number): Promise<number>;
+    removeObj(src?: FSChangeSrc): Promise<void>;
     /**
      * This non-synchronized method deletes object from storage, and detaches
      * this node from storage. Make sure to call it inside access synchronization
      * construct.
      */
-    protected delete(remoteEvent?: boolean): Promise<void>;
+    protected delete(src: FSChangeSrc): Promise<void>;
     /**
      * This method runs node changing function in an exclusive manner.
      * Returned promise resolves to whatever change function returns.
@@ -56,24 +60,26 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
      * new current version, when change has been successful.
      */
     protected doChange<T>(awaitPrevChange: boolean, change: () => Promise<T>): Promise<T>;
-    /**
-     * This method is called on conflict with remote version. This method
-     * is called at ordered point in time requiring no further synchronization.
-     * @param remoteVersion is an object version on server
-     */
-    protected doOnConflict(remoteVersion: number): Promise<void>;
-    /**
-     * This non-synchronized method resolves conflict with remote version.
-     * @param remoteVersion
-     */
-    protected doOnExternalChange(remoteVersion: number): Promise<void>;
-    protected broadcastEvent(event: FSEvent, complete?: boolean): void;
+    protected broadcastEvent(event: FSEvent, complete?: boolean, childObjId?: string): void;
     /**
      * This is a lazily initialized field, when there is an external entity
      * that wants to see this node's events.
      */
     private events;
-    get event$(): Observable<FSEvent>;
-    sync(): Promise<Stats['sync']>;
+    get event$(): Observable<FSEvent | RemoteEvent>;
+    protected syncedStorage(): SyncedStorage;
+    syncStatus(): Promise<SyncStatus>;
+    updateStatusInfo(): Promise<SyncStatus>;
+    isSyncedVersionOnDisk(version: number): Promise<'partial' | 'complete' | 'none'>;
+    download(version: number): Promise<void>;
+    protected abstract setCurrentStateFrom(src: ObjSource): Promise<void>;
+    adoptRemote(opts: OptionsToAdopteRemote | undefined): Promise<void>;
+    protected needUpload(localVersion: number | undefined): Promise<{
+        localVersion: number;
+        uploadVersion: number;
+        createOnRemote: boolean;
+    } | undefined>;
+    upload(opts: OptionsToUploadLocal | undefined): Promise<void>;
+    private uploadHeaderChange;
 }
 export {};

package/build/lib-client/3nstorage/xsp-fs/node-in-fs.js

@@ -22,8 +22,10 @@ exports.NodeInFS = void 0;
  * reliance set.
  */
 const synced_1 = require("../../../lib-common/processes/synced");
+const common_1 = require("./common");
 const file_1 = require("../../../lib-common/exceptions/file");
 const error_1 = require("../../../lib-common/exceptions/error");
+const exceptions_1 = require("../exceptions");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const attrs_1 = require("./attrs");
@@ -39,12 +41,12 @@ class NodeInFS {
         this.attrs = undefined;
         this.xattrs = undefined;
         this.writeProc = undefined;
-        this.remoteEvents = undefined;
         /**
          * This is a lazily initialized field, when there is an external entity
          * that wants to see this node's events.
          */
         this.events = undefined;
+        this.isInSyncedStorage = (0, common_1.isSyncedStorage)(this.storage);
     }
     get version() {
         return this.currentVersion;
@@ -80,7 +82,7 @@ class NodeInFS {
         }
         return this.doChange(true, async () => {
             const { xattrs, newVersion } = this.getParamsForUpdate(changes);
-            const base = await this.storage.getObj(this.objId);
+            const base = await this.storage.getObjSrc(this.objId);
             const sub = await this.crypto.writeXAttrs(xattrs, newVersion, base);
             await this.storage.saveObj(this.objId, newVersion, sub);
             this.setUpdatedParams(newVersion, undefined, xattrs);
@@ -96,87 +98,59 @@ class NodeInFS {
     getAttrs() {
         return this.attrs;
     }
-    async processRemoteEvent(event) {
-        this.bufferRemoteEvent(event);
-        return this.doChange(true, async () => {
-            const event = this.getBufferedEvent();
-            if (!event) {
-                return;
-            }
-            if (event.type === 'remote-change') {
-                // TODO
-                // uploader should show if there is process for this obj uploads with version
-                // in the event, and if so, wait for completion of that process to either ignore
-                // remote event, or to set conflict, or whatever
-                // XXX should we use here synced storage methods here?
-                //     This method is called only in synced storage.
-                // XXX detect if there is a conflict
-                // need obj status info here
-                // if (conflict) {
-                // 	await this.doOnConflict();
-                // } else {
-                // 	await this.doOnExternalChange();
-                // }
+    async listVersions() {
+        return (await this.storage.status(this.objId)).listVersions();
+    }
+    async archiveCurrent(version) {
+        if (this.isInSyncedStorage) {
+            const storage = this.syncedStorage();
+            const status = await storage.status(this.objId);
+            const { state, synced } = status.syncStatus();
+            if (state !== 'synced') {
+                throw (0, exceptions_1.makeFSSyncException)(this.name, { notSynced: true });
             }
-            else if (event.type === 'remote-delete') {
-                await this.delete(true);
+            if (version) {
+                if (synced.latest !== version) {
+                    throw (0, exceptions_1.makeFSSyncException)(this.name, { versionMismatch: true });
+                }
             }
             else {
-                throw new Error(`Unknown remote bufferred event type ${JSON.stringify(event)}`);
+                version = synced.latest;
             }
-        });
-    }
-    bufferRemoteEvent(event) {
-        if (!this.remoteEvents) {
-            this.remoteEvents = [];
-        }
-        this.remoteEvents.push(event);
-        if (this.remoteEvents.length > 1) {
-            // XXX attempt to compress events
-        }
-    }
-    getBufferedEvent() {
-        if (!this.remoteEvents) {
-            return;
+            await storage.archiveVersionOnServer(this.objId, version);
+            await status.archiveCurrentVersion();
+            return version;
         }
-        const event = this.remoteEvents.shift();
-        if (this.remoteEvents.length === 0) {
-            this.remoteEvents = undefined;
+        else {
+            if (version) {
+                if (this.currentVersion !== version) {
+                    throw (0, file_1.makeFileException)(file_1.Code.versionMismatch, this.name);
+                }
+            }
+            else {
+                version = this.currentVersion;
+            }
+            const status = await this.storage.status(this.objId);
+            await status.archiveCurrentVersion();
+            return version;
         }
-        return event;
     }
-    localDelete() {
-        return this.doChange(true, () => this.delete());
-    }
-    broadcastUpSyncEvent(task) {
-        if (task.type === 'upload') {
-            this.broadcastEvent({
-                type: 'sync-upload',
-                path: this.name,
-                current: this.version,
-                uploaded: task.version
-            });
-        }
+    removeObj(src = 'local') {
+        return this.doChange(true, () => this.delete(src));
     }
     /**
      * This non-synchronized method deletes object from storage, and detaches
      * this node from storage. Make sure to call it inside access synchronization
      * construct.
      */
-    async delete(remoteEvent) {
-        if (remoteEvent) {
-            // XXX
-            throw Error(`Removal from remote side is not implemented, yet.`);
-        }
-        else {
-            await this.storage.removeObj(this.objId);
-        }
+    async delete(src) {
+        await this.storage.removeObj(this.objId);
         this.storage.nodes.delete(this);
         this.currentVersion = -1;
         const event = {
             type: 'removed',
             path: this.name,
-            isRemote: remoteEvent
+            src
         };
         this.broadcastEvent(event, true);
     }
@@ -197,90 +171,222 @@ class NodeInFS {
             this.writeProc = new synced_1.SingleProc();
         }
         if (!awaitPrevChange && this.writeProc.isProcessing()) {
-            throw file_1.makeFileException(file_1.Code.concurrentUpdate, this.name + ` type ${this.type}`);
+            throw (0, file_1.makeFileException)(file_1.Code.concurrentUpdate, this.name + ` type ${this.type}`);
         }
-        const res = await this.writeProc.startOrChain(() => {
+        const res = await this.writeProc.startOrChain(async () => {
             if (this.currentVersion < 0) {
-                throw file_1.makeFileException(file_1.Code.notFound, this.name, `Object is marked removed`);
+                throw (0, file_1.makeFileException)(file_1.Code.notFound, this.name, `Object is marked removed`);
+            }
+            try {
+                const res = await change();
+                return res;
             }
-            return change()
-                .catch((exc) => {
+            catch (exc) {
                 if (!exc.runtimeException) {
-                    throw error_1.errWithCause(exc, `Cannot save changes to ${this.type} ${this.name}, version ${this.version}`);
+                    throw (0, error_1.errWithCause)(exc, `Cannot save changes to ${this.type} ${this.name}, version ${this.version}`);
                 }
                 if (exc.type === 'storage') {
                     if (exc.concurrentTransaction) {
-                        throw file_1.makeFileException(file_1.Code.concurrentUpdate, this.name, exc);
+                        throw (0, file_1.makeFileException)(file_1.Code.concurrentUpdate, this.name, exc);
                     }
                     else if (exc.objNotFound) {
-                        throw file_1.makeFileException(file_1.Code.notFound, this.name, exc);
+                        throw (0, file_1.makeFileException)(file_1.Code.notFound, this.name, exc);
                     }
                 }
-                throw file_1.makeFileException(file_1.Code.ioError, this.name, exc);
-            });
+                else if ((exc.type === 'file')
+                    || (exc.type === 'fs-sync')) {
+                    throw exc;
+                }
+                throw (0, file_1.makeFileException)(file_1.Code.ioError, this.name, exc);
+            }
         });
         return res;
     }
-    /**
-     * This method is called on conflict with remote version. This method
-     * is called at ordered point in time requiring no further synchronization.
-     * @param remoteVersion is an object version on server
-     */
-    async doOnConflict(remoteVersion) {
-        // XXX
-        throw new Error('Unimplemented, yet');
-        // OLD CODE BELOW
-        // if (remoteVersion < this.version) { return; }
-        // await (this.storage as SyncedStorage).setCurrentSyncedVersion(
-        // 	this.objId, remoteVersion);
-        // this.setCurrentVersion(remoteVersion);
-    }
-    /**
-     * This non-synchronized method resolves conflict with remote version.
-     * @param remoteVersion
-     */
-    async doOnExternalChange(remoteVersion) {
-        if (remoteVersion <= this.version) {
-            return;
-        }
-        const src = await this.storage.getObj(this.objId);
-        const newVersion = src.version;
-        if (newVersion <= this.version) {
-            return;
+    broadcastEvent(event, complete, childObjId) {
+        if (this.events && complete) {
+            this.events.sink.next(event);
+            this.events.sink.complete();
+            this.events = undefined;
         }
-        this.setCurrentVersion(newVersion);
-        const event = {
-            type: 'file-change',
-            path: this.name,
-            isRemote: true
-        };
-        this.broadcastEvent(event);
+        this.storage.broadcastNodeEvent(this.objId, this.parentId, childObjId, event);
     }
-    broadcastEvent(event, complete) {
-        this.storage.broadcastNodeEvent(this.objId, this.parentId, event);
+    get event$() {
         if (!this.events) {
-            return;
+            const sink = new rxjs_1.Subject();
+            const out = sink.asObservable().pipe((0, operators_1.share)());
+            const storeSub = this.storage.getNodeEvents()
+                .pipe((0, operators_1.filter)(({ objId }) => (this.objId === objId)), (0, operators_1.map)(({ event }) => copyWithPathIfRemoteEvent(event, this.name)))
+                .subscribe({
+                next: event => sink.next(event),
+                complete: () => {
+                    var _a;
+                    sink.complete();
+                    if (((_a = this.events) === null || _a === void 0 ? void 0 : _a.sink) === sink) {
+                        this.events = undefined;
+                    }
+                },
+                error: err => {
+                    var _a;
+                    sink.error(err);
+                    if (((_a = this.events) === null || _a === void 0 ? void 0 : _a.sink) === sink) {
+                        this.events = undefined;
+                    }
+                }
+            });
+            this.events = { sink, out, storeSub };
         }
-        this.events.next(event);
-        if (complete) {
-            this.events.complete();
-            this.events = undefined;
+        return this.events.out;
+    }
+    syncedStorage() {
+        if (!this.isInSyncedStorage) {
+            throw new Error(`Storage is not synced`);
         }
+        return this.storage;
     }
-    get event$() {
-        if (!this.events) {
-            this.events = new rxjs_1.Subject();
+    async syncStatus() {
+        const storage = this.syncedStorage();
+        const status = (await storage.status(this.objId)).syncStatus();
+        if (this.parentId) {
+            const parent = storage.nodes.get(this.parentId);
+            if (parent) {
+                status.existsInSyncedParent =
+                    await parent.childExistsInSyncedVersion(this.objId);
+            }
+        }
+        return status;
+    }
+    async updateStatusInfo() {
+        const storage = this.syncedStorage();
+        const status = await storage.updateStatusInfo(this.objId);
+        return await this.syncStatus();
+    }
+    isSyncedVersionOnDisk(version) {
+        const storage = this.syncedStorage();
+        return storage.isRemoteVersionOnDisk(this.objId, version);
+    }
+    async download(version) {
+        const storage = this.syncedStorage();
+        return storage.download(this.objId, version);
+    }
+    adoptRemote(opts) {
+        return this.doChange(true, async () => {
+            const storage = this.syncedStorage();
+            try {
+                const adopted = await storage.adoptRemote(this.objId, opts);
+                if (!adopted) {
+                    return;
+                }
+                const src = await this.storage.getObjSrc(this.objId, adopted);
+                await this.setCurrentStateFrom(src);
+                const event = {
+                    type: 'file-change',
+                    src: 'sync',
+                    path: this.name,
+                    newVersion: this.version
+                };
+                this.broadcastEvent(event);
+            }
+            catch (exc) {
+                throw (0, common_1.setPathInExc)(exc, this.name);
+            }
+        });
+    }
+    async needUpload(localVersion) {
+        const { local, remote, synced } = await this.syncStatus();
+        if (localVersion) {
+            if (localVersion !== this.currentVersion) {
+                throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                    versionMismatch: true,
+                    localVersion: this.currentVersion,
+                    message: `Given local version ${localVersion} is not equal to current version ${this.currentVersion}`
+                });
+            }
+            if (!local || (local.latest !== localVersion)) {
+                throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                    versionMismatch: true,
+                    message: `No local version ${localVersion} to upload`
+                });
+            }
+        }
+        else {
+            if (!local || !this.currentVersion) {
+                return;
+            }
+            localVersion = this.currentVersion;
+        }
+        if (remote) {
+            if (remote.latest) {
+                const uploadVersion = remote.latest + 1;
+                return { createOnRemote: false, localVersion, uploadVersion };
+            }
+            else {
+                throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                    versionMismatch: true,
+                    removedOnServer: true
+                });
+            }
+        }
+        else if (synced) {
+            if (synced.latest) {
+                const uploadVersion = synced.latest + 1;
+                return { createOnRemote: false, localVersion, uploadVersion };
+            }
+            else {
+                throw (0, exceptions_1.makeFSSyncException)(this.name, {
+                    versionMismatch: true,
+                    removedOnServer: true
+                });
+            }
+        }
+        else {
+            const uploadVersion = 1;
+            return { createOnRemote: true, localVersion, uploadVersion };
         }
-        return this.events.asObservable().pipe(operators_1.share());
     }
-    async sync() {
-        if ((this.storage.type === 'synced')
-            || (this.storage.type === 'share')) {
-            return this.storage.getObjSyncInfo(this.objId);
+    async upload(opts) {
+        try {
+            const toUpload = await this.needUpload(opts === null || opts === void 0 ? void 0 : opts.localVersion);
+            if (!toUpload) {
+                return;
+            }
+            const { localVersion, createOnRemote, uploadVersion } = toUpload;
+            const uploadHeader = ((localVersion === uploadVersion) ? undefined :
+                await this.uploadHeaderChange(localVersion, uploadVersion));
+            const storage = this.syncedStorage();
+            await storage.upload(this.objId, localVersion, uploadVersion, uploadHeader, createOnRemote);
+            await this.doChange(true, async () => {
+                storage.dropCachedLocalObjVersionsLessOrEqual(this.objId, localVersion);
+                if (this.currentVersion === localVersion) {
+                    this.currentVersion = uploadVersion;
+                }
+            });
+        }
+        catch (exc) {
+            throw (0, common_1.setPathInExc)(exc, this.name);
         }
     }
+    async uploadHeaderChange(localVersion, uploadVersion) {
+        const currentSrc = await this.storage.getObjSrc(this.objId, localVersion);
+        const localHeader = await currentSrc.readHeader();
+        const uploadHeader = await this.crypto.reencryptHeader(localHeader, uploadVersion);
+        return { localHeader, localVersion, uploadHeader, uploadVersion };
+    }
 }
 exports.NodeInFS = NodeInFS;
 Object.freeze(NodeInFS.prototype);
 Object.freeze(NodeInFS);
+function copyWithPathIfRemoteEvent(e, path) {
+    switch (e.type) {
+        case 'remote-change':
+            return { type: e.type, path, newVersion: e.newVersion };
+        case 'remote-removal':
+            return { type: e.type, path };
+        case 'remote-version-archival':
+            return { type: e.type, path, archivedVersion: e.archivedVersion };
+        case 'remote-arch-ver-removal':
+            return { type: e.type, path, removedArchVer: e.removedArchVer };
+        default:
+            return e;
+    }
+}
 Object.freeze(exports);

package/build/lib-client/3nstorage/xsp-fs/node-persistence.d.ts

@@ -32,7 +32,7 @@ export declare abstract class NodePersistance {
         sinkPromise: Promise<FileByteSink>;
         sub: Subscribe;
     }>;
-    reencryptHeader: (initHeader: Uint8Array, newVersion: number) => Promise<Uint8Array>;
+    reencryptHeader(initHeader: Uint8Array, newVersion: number): Promise<Uint8Array>;
 }
 declare type FileByteSource = web3n.files.FileByteSource;
 declare type FileByteSink = web3n.files.FileByteSink;

package/build/lib-client/3nstorage/xsp-fs/node-persistence.js

@@ -28,7 +28,6 @@ const random = require("../../../lib-common/random-node");
 const pv1 = require("./xsp-payload-v1");
 const pv2 = require("./xsp-payload-v2");
 const SEG_SIZE = 16; // in 256-byte blocks = 4K in bytes
-const EMPTY_BYTE_ARR = new Uint8Array(0);
 /**
  * This does reading and writing, keeping keys. This and extending objects are
  * used in file system nodes as thematic place with persistence functionality.
@@ -38,14 +37,6 @@ class NodePersistance {
         this.zerothHeaderNonce = zerothHeaderNonce;
         this.key = key;
         this.cryptor = cryptor;
-        this.reencryptHeader = async (initHeader, newVersion) => {
-            if (!this.key) {
-                throw new Error("Cannot use wiped object.");
-            }
-            const headerContent = await this.cryptor.formatWN.open(initHeader, this.key);
-            const n = xsp_files_1.calculateNonce(this.zerothHeaderNonce, newVersion);
-            return this.cryptor.formatWN.pack(headerContent, n, this.key);
-        };
     }
     wipe() {
         if (this.key) {
@@ -57,7 +48,7 @@ class NodePersistance {
     }
     compareKey(keyB64) {
         const k = buffer_utils_1.base64.open(keyB64);
-        return xsp_files_1.compareVectors(k, this.key);
+        return (0, xsp_files_1.compareVectors)(k, this.key);
     }
     fileKeyInBase64() {
         if (!this.key) {
@@ -69,13 +60,13 @@ class NodePersistance {
         if (!this.key) {
             throw new Error("Cannot use wiped object.");
         }
-        return xsp_files_1.makeSegmentsWriter(this.key, this.zerothHeaderNonce, version, { type: 'new', segSize: SEG_SIZE, payloadFormat: 2 }, random.bytes, this.cryptor);
+        return (0, xsp_files_1.makeSegmentsWriter)(this.key, this.zerothHeaderNonce, version, { type: 'new', segSize: SEG_SIZE, payloadFormat: 2 }, random.bytes, this.cryptor);
     }
     async segWriterWithBase(newVersion, base) {
         if (!this.key) {
             throw new Error("Cannot use wiped object.");
         }
-        return xsp_files_1.makeSegmentsWriter(this.key, this.zerothHeaderNonce, newVersion, { type: 'update', base, payloadFormat: 2 }, random.bytes, this.cryptor);
+        return (0, xsp_files_1.makeSegmentsWriter)(this.key, this.zerothHeaderNonce, newVersion, { type: 'update', base, payloadFormat: 2 }, random.bytes, this.cryptor);
     }
     async decryptedByteSrc(src) {
         if (!this.key) {
@@ -83,10 +74,10 @@ class NodePersistance {
         }
         const version = src.version;
         const header = await src.readHeader();
-        const segReader = await xsp_files_1.makeSegmentsReader(this.key, this.zerothHeaderNonce, version, header, this.cryptor);
+        const segReader = await (0, xsp_files_1.makeSegmentsReader)(this.key, this.zerothHeaderNonce, version, header, this.cryptor);
         return {
             version,
-            byteSrc: xsp_files_1.makeDecryptedByteSource(src.segSrc, segReader),
+            byteSrc: (0, xsp_files_1.makeDecryptedByteSource)(src.segSrc, segReader),
             payloadFormat: segReader.payloadFormat
         };
     }
@@ -123,7 +114,7 @@ class NodePersistance {
     async writeWhole(content, newVersion, attrs, xattrs) {
         const bytes = (Array.isArray(content) ? content : [content]);
         const segWriter = await this.segWriter(newVersion);
-        const { sink, sub } = xsp_files_1.makeEncryptingByteSink(segWriter);
+        const { sink, sub } = (0, xsp_files_1.makeEncryptingByteSink)(segWriter);
         return (obs, backpressure) => {
             // sub must be called before payload creation that uses sink
             const unsub = sub(obs, backpressure);
@@ -134,7 +125,7 @@ class NodePersistance {
     }
     async writeXAttrs(xattrs, newVersion, base) {
         const segWriter = await this.segWriterWithBase(newVersion, base);
-        const { sink, sub } = xsp_files_1.makeEncryptingByteSink(segWriter);
+        const { sink, sub } = (0, xsp_files_1.makeEncryptingByteSink)(segWriter);
         return (obs, backpressure) => {
             // sub must be called before payload creation that uses sink
             const unsub = sub(obs, backpressure);
@@ -147,8 +138,8 @@ class NodePersistance {
         const segWriter = await (base ?
             this.segWriterWithBase(newVersion, base) :
             this.segWriter(newVersion));
-        const { sink, sub } = xsp_files_1.makeEncryptingByteSink(segWriter);
-        const defSink = deferred_1.defer();
+        const { sink, sub } = (0, xsp_files_1.makeEncryptingByteSink)(segWriter);
+        const defSink = (0, deferred_1.defer)();
         return {
             sinkPromise: defSink.promise,
             sub: (obs, backpressure) => {
@@ -174,6 +165,14 @@ class NodePersistance {
             }
         };
     }
+    async reencryptHeader(initHeader, newVersion) {
+        if (!this.key) {
+            throw new Error("Cannot use wiped object.");
+        }
+        const headerContent = await this.cryptor.formatWN.open(initHeader, this.key);
+        const n = (0, xsp_files_1.calculateNonce)(this.zerothHeaderNonce, newVersion);
+        return this.cryptor.formatWN.pack(headerContent, n, this.key);
+    }
 }
 exports.NodePersistance = NodePersistance;
 Object.freeze(NodePersistance.prototype);