core-3nweb-client-lib 0.43.7 → 0.43.9

package/build/api-defs/files.d.ts

@@ -43,6 +43,7 @@ declare namespace web3n.files {
 		notImplemented?: true;
 		attrsNotEnabledInFS?: true;
 		versionMismatch?: true;
+		storageIsNotSyncedType?: true;
 		isEndless?: true;
 		storageClosed?: true;
 		remoteNotSet?: true;
@@ -71,6 +72,7 @@ declare namespace web3n.files {
 		localVersion?: number;
 		remoteVersion?: number;
 		alreadyUploading?: true;
+		uploadTaskId?: number;
 		versionNotFound?: true;
 		childNeverUploaded?: true;
 		childName?: string;
@@ -147,8 +149,18 @@ declare namespace web3n.files {
 		 */
 		version?: number;
 
+		/**
+		 * This gives a number of bytes that should be downloaded to have file
+		 * completly on a device.
+		 */
+		bytesNeedDownload?: number;
+
+		versionSyncBranch?: SyncBranch;
+
 	}
 
+	type SyncBranch = 'local' | 'synced' | 'remote';
+
 	/**
 	 * Sync status contains info about possible version branches with possible
 	 * states:
@@ -400,7 +412,7 @@ declare namespace web3n.files {
 		 */
 		getByteSource(): Promise<FileByteSource>;
 
-		watch(observer: Observer<FileEvent|RemoteEvent>): () => void;
+		watch(observer: Observer<FileEvent|RemoteEvent|UploadEvent>): () => void;
 
 	}
 
@@ -464,6 +476,12 @@ declare namespace web3n.files {
 
 	interface ReadonlyFileVersionedAPI {
 
+		/**
+		 * This returns a promise, resolvable to stats of the file.
+		 * @param flags are optional flags to read archived or remote versions.
+		 */
+		stat(flags?: VersionedReadFlags): Promise<Stats>;
+
 		getXAttr(
 			xaName: string, flags?: VersionedReadFlags
 		): Promise<{ attr: any; version: number; }>;
@@ -516,6 +534,8 @@ declare namespace web3n.files {
 		listVersions(
 			flags?: VersionedReadFlags
 		): Promise<{ current?: number; archived?: number[]; }>;
+		// XXX
+		// ): Promise<{ current?: number; archived?: number[]; synced?: number; conflictingRemote?: number[]; }>;
 
 		/**
 		 * File from synced storage has this api
@@ -639,6 +659,19 @@ declare namespace web3n.files {
 
 	interface WritableFileSyncAPI extends ReadonlyFileSyncAPI {
 
+		/**
+		 * This starts/schedules an upload, if it hasn't been already.
+		 * Upload in conflicting and behind state of sync requires explicit upload version.
+		 * Undefined is returned when upload is not needed, e.g. version is already synced.
+		 * Upload version and upload task id are returned together with an indicator of whether
+		 * this call has started upload, or it has already been going on.
+		 * Upload task id can be used to watch upload process.
+		 * @param opts 
+		 */
+		startUpload(
+			opts?: OptionsToUploadLocal
+		): Promise<{ uploadVersion: number; uploadTaskId: number; }|undefined>;
+
 		/**
 		 * Upload in conflicting and behind state of sync requires explicit upload version.
 		 * @param opts 
@@ -730,16 +763,16 @@ declare namespace web3n.files {
 		readLink(path: string): Promise<SymLink>;
 
 		watchFolder(
-			path: string, observer: Observer<FolderEvent|RemoteEvent>
+			path: string, observer: Observer<FolderEvent|RemoteEvent|UploadEvent>
 		): () => void;
 
 		watchFile(
-			path: string, observer: Observer<FileEvent|RemoteEvent>
+			path: string, observer: Observer<FileEvent|RemoteEvent|UploadEvent>
 		): () => void;
 
 		watchTree(
 			path: string, depth: number|undefined,
-			observer: Observer<FolderEvent|FileEvent|RemoteEvent>
+			observer: Observer<FolderEvent|FileEvent|RemoteEvent|UploadEvent>
 		): () => void;
 
 		close(): Promise<void>;
@@ -1082,6 +1115,14 @@ declare namespace web3n.files {
 
 	interface ReadonlyFSVersionedAPI {
 
+		/**
+		 * This returns a promise, resolvable to stats of an entity at a given
+		 * path.
+		 * @param path
+		 * @param flags are optional flags to read archived or remote versions.
+		 */
+		stat(path: string, flags?: VersionedReadFlags): Promise<Stats>;
+
 		getXAttr(
 			path: string, xaName: string, flags?: VersionedReadFlags
 		): Promise<{ attr: any; version: number; }>;
@@ -1293,6 +1334,20 @@ declare namespace web3n.files {
 
 	interface WritableFSSyncAPI extends ReadonlyFSSyncAPI {
 
+		/**
+		 * This starts/schedules an upload, if it hasn't been already.
+		 * Upload in conflicting and behind state of sync requires explicit upload version.
+		 * Undefined is returned when upload is not needed, e.g. version is already synced.
+		 * Upload version and upload task id are returned together with an indicator of whether
+		 * this call has started upload, or it has already been going on.
+		 * Upload task id can be used to watch upload process.
+		 * @param path 
+		 * @param opts 
+		 */
+		startUpload(
+			path: string, opts?: OptionsToUploadLocal
+		): Promise<{ uploadVersion: number; uploadTaskId: number; }|undefined>;
+
 		/**
 		 * Upload in conflicting and behind state of sync requires explicit upload version.
 		 * @param path 
@@ -1392,4 +1447,27 @@ declare namespace web3n.files {
 		newVersion: number;
 	}
 
+	type UploadEvent = UploadStartEvent | UploadProgressEvent | UploadDoneEvent;
+
+	interface UploadEventBase extends FSEvent {
+		uploadTaskId: number;
+		localVersion: number;
+		uploadVersion: number;
+	}
+
+	interface UploadStartEvent extends UploadEventBase {
+		type: 'upload-started';
+		totalBytesToUpload: number;
+	}
+
+	interface UploadProgressEvent extends UploadEventBase {
+		type: 'upload-progress';
+		totalBytesToUpload: number;
+		bytesLeftToUpload: number;
+	}
+
+	interface UploadDoneEvent extends UploadEventBase {
+		type: 'upload-done';
+	}
+
 }

package/build/core/storage/synced/obj-files.d.ts

@@ -90,5 +90,6 @@ export declare class SyncedObj {
     statusObj(): ObjStatus;
     recordRemovalUploadAndGC(): Promise<void>;
     isRemoteVersionOnDisk(version: number): Promise<'complete' | 'partial' | 'none'>;
+    getNumOfBytesNeedingDownload(version: number): Promise<number | 'unknown'>;
     downloadRemoteVersion(version: number): Promise<void>;
 }

package/build/core/storage/synced/obj-files.js

@@ -408,6 +408,22 @@ class SyncedObj {
         const objVer = await this.instanceOfRemoteObjVer(version);
         return (objVer.doesFileNeedDownload() ? 'complete' : 'partial');
     }
+    async getNumOfBytesNeedingDownload(version) {
+        if (!this.status.isAmongRemote(version)) {
+            if (this.localVers.has(version)) {
+                return 0;
+            }
+            else {
+                throw (0, exceptions_1.makeObjVersionNotFoundExc)(this.objId, version);
+            }
+        }
+        const verPath = this.remoteVerPath(version);
+        if (!(await isOnDisk(verPath))) {
+            return 'unknown';
+        }
+        const objVer = await this.instanceOfRemoteObjVer(version);
+        return objVer.numOfBytesNeedingDownload();
+    }
     async downloadRemoteVersion(version) {
         const objVer = await this.instanceOfRemoteObjVer(version);
         await objVer.downloadMissingSections();

package/build/core/storage/synced/obj-status.d.ts

@@ -149,4 +149,5 @@ export declare class ObjStatus implements SyncedObjStatus, UploadStatusRecorder
     isAmongRemote(version: number): boolean;
 }
 export declare function readAndCheckStatus(objFolder: string, objId: ObjId): Promise<ObjStatusInfo>;
+export declare function countBytesIn(info: UploadInfo): number;
 export {};

package/build/core/storage/synced/obj-status.js

@@ -18,6 +18,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjStatus = exports.STATUS_FILE_NAME = void 0;
 exports.readAndCheckStatus = readAndCheckStatus;
+exports.countBytesIn = countBytesIn;
 const path_1 = require("path");
 const exceptions_1 = require("../../../lib-client/xsp-fs/exceptions");
 const json_saving_1 = require("../common/json-saving");
@@ -717,4 +718,21 @@ function uploadInStatus(upload) {
         };
     }
 }
+function countBytesIn(info) {
+    if ((info.type === 'removal') || !info.needUpload) {
+        return 0;
+    }
+    if (info.needUpload.type === 'ordered-whole') {
+        const { segsLeft, header } = info.needUpload;
+        return (segsLeft + (header !== null && header !== void 0 ? header : 0));
+    }
+    else {
+        const { header, newSegsLeft } = info.needUpload;
+        let count = (header !== null && header !== void 0 ? header : 0);
+        for (const { len } of newSegsLeft) {
+            count += len;
+        }
+        return count;
+    }
+}
 Object.freeze(exports);

package/build/core/storage/synced/storage.d.ts

@@ -10,6 +10,7 @@ type FolderEvent = web3n.files.FolderEvent;
 type FileEvent = web3n.files.FileEvent;
 type SyncStatus = web3n.files.SyncStatus;
 type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
+type UploadEvent = web3n.files.UploadEvent;
 export declare class SyncedStore implements ISyncedStorage {
     private readonly files;
     private readonly remoteStorage;
@@ -37,10 +38,12 @@ export declare class SyncedStore implements ISyncedStorage {
     status(objId: ObjId): Promise<SyncedObjStatus>;
     adoptRemote(objId: ObjId, opts: OptionsToAdopteRemote | undefined): Promise<number | undefined>;
     updateStatusInfo(objId: ObjId): Promise<SyncStatus>;
-    isObjOnDisk(objId: ObjId): Promise<boolean>;
     isRemoteVersionOnDisk(objId: ObjId, version: number): Promise<'complete' | 'partial' | 'none'>;
     download(objId: ObjId, version: number): Promise<void>;
-    upload(objId: ObjId, localVersion: number, uploadVersion: number, uploadHeader: UploadHeaderChange | undefined, createOnRemote: boolean): Promise<void>;
+    startUpload(objId: ObjId, localVersion: number, uploadVersion: number, uploadHeader: UploadHeaderChange | undefined, createOnRemote: boolean, eventSink: (event: UploadEvent) => void): Promise<{
+        uploadTaskId: number;
+        completion: Promise<void>;
+    }>;
     uploadObjRemoval(objId: ObjId): Promise<void>;
     dropCachedLocalObjVersionsLessOrEqual(objId: ObjId, version: number): void;
     archiveVersionOnServer(objId: ObjId, version: number): Promise<void>;
@@ -52,6 +55,7 @@ export declare class SyncedStore implements ISyncedStorage {
     getObjSrcOfRemoteVersion(objId: ObjId, version: number): Promise<ObjSource>;
     saveObj(objId: ObjId, version: number, encSub: Subscribe): Promise<void>;
     removeObj(objId: string): Promise<void>;
+    getNumOfBytesNeedingDownload(objId: string, version: number): Promise<number | 'unknown'>;
     close(): Promise<void>;
     suspendNetworkActivity(): void;
     resumeNetworkActivity(): void;

package/build/core/storage/synced/storage.js

@@ -114,10 +114,6 @@ class SyncedStore {
             throw exc;
         }
     }
-    async isObjOnDisk(objId) {
-        const obj = await this.files.findObj(objId);
-        return !!obj;
-    }
     async isRemoteVersionOnDisk(objId, version) {
         const obj = await this.getObjOrThrow(objId, true);
         return obj.isRemoteVersionOnDisk(version);
@@ -126,20 +122,15 @@ class SyncedStore {
         const obj = await this.getObjOrThrow(objId, true);
         return obj.downloadRemoteVersion(version);
     }
-    async upload(objId, localVersion, uploadVersion, uploadHeader, createOnRemote) {
+    async startUpload(objId, localVersion, uploadVersion, uploadHeader, createOnRemote, eventSink) {
         const obj = await this.getObjOrThrow(objId, true);
-        const syncedBase = await obj.combineLocalBaseIfPresent(localVersion);
-        if (uploadHeader) {
-            await obj.saveUploadHeaderFile(uploadHeader);
-        }
-        await this.uploader.uploadFromDisk(obj, localVersion, uploadVersion, uploadHeader === null || uploadHeader === void 0 ? void 0 : uploadHeader.uploadHeader, syncedBase, createOnRemote);
-        await obj.recordUploadCompletion(localVersion, uploadVersion, (uploadHeader ? {
-            newHeader: uploadHeader.uploadHeader,
-            originalHeader: uploadHeader.localHeader
-        } : undefined));
-        if (localVersion > uploadVersion) {
-            await obj.removeLocalVersionFilesLessThan(localVersion);
-        }
+        const { completion, uploadTaskId } = await this.uploader.startUploadFromDisk(obj, localVersion, uploadVersion, uploadHeader, createOnRemote, eventSink);
+        return {
+            uploadTaskId,
+            completion: completion.then(() => {
+                this.dropCachedLocalObjVersionsLessOrEqual(objId, localVersion);
+            })
+        };
     }
     async uploadObjRemoval(objId) {
         if (!objId) {
@@ -233,6 +224,10 @@ class SyncedStore {
         }
         await obj.removeCurrentVersion();
     }
+    async getNumOfBytesNeedingDownload(objId, version) {
+        const obj = await this.getObjOrThrow(objId);
+        return obj.getNumOfBytesNeedingDownload(version);
+    }
     async close() {
         try {
             await this.uploader.stop();

package/build/core/storage/synced/upsyncer.d.ts

@@ -4,11 +4,16 @@ import { MonoTypeOperatorFunction } from "rxjs";
 import { FileWrite } from "../../../lib-client/objs-on-disk/file-writing-proc";
 import { LogError } from "../../../lib-client/logging/log-to-file";
 import { NewVersionUpload } from "./obj-status";
+import { UploadHeaderChange } from "../../../lib-client/xsp-fs/common";
+type UploadEvent = web3n.files.UploadEvent;
 export type FileWriteTapOperator = MonoTypeOperatorFunction<FileWrite[]>;
 export declare class UpSyncer {
     private readonly remoteStorage;
     private readonly logError;
     private readonly execPools;
+    private readonly tasksByObjIds;
+    private readonly tasksByIds;
+    private readonly syncedUploadStarts;
     constructor(remoteStorage: StorageOwner, logError: LogError);
     start(): void;
     stop(): Promise<void>;
@@ -18,10 +23,14 @@ export declare class UpSyncer {
      */
     tapFileWrite(obj: SyncedObj, isNew: boolean, newVersion: number, baseVersion?: number): FileWriteTapOperator;
     removeCurrentVersionOf(obj: SyncedObj): Promise<void>;
-    uploadFromDisk(obj: SyncedObj, localVersion: number, uploadVersion: number, uploadHeader: Uint8Array | undefined, syncedBase: number | undefined, createOnRemote: boolean): Promise<void>;
+    startUploadFromDisk(obj: SyncedObj, localVersion: number, uploadVersion: number, uploadHeader: UploadHeaderChange | undefined, createOnRemote: boolean, eventSink: (event: UploadEvent) => void): Promise<{
+        completion: Promise<void>;
+        uploadTaskId: number;
+    }>;
 }
 export interface UploadStatusRecorder {
     recordUploadStart(info: NewVersionUpload): Promise<void>;
     recordUploadCancellation(info: NewVersionUpload): Promise<void>;
     recordUploadInterimState(info: NewVersionUpload): Promise<void>;
 }
+export {};

package/build/core/storage/synced/upsyncer.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2020, 2022 3NSoft Inc.
+ Copyright (C) 2020, 2022, 2025 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
@@ -20,14 +20,19 @@ exports.UpSyncer = void 0;
 const labelled_exec_pools_1 = require("../../../lib-common/processes/labelled-exec-pools");
 const exceptions_1 = require("../../../lib-client/xsp-fs/exceptions");
 const assert_1 = require("../../../lib-common/assert");
+const obj_status_1 = require("./obj-status");
 const deferred_1 = require("../../../lib-common/processes/deferred");
 const buffer_utils_1 = require("../../../lib-common/buffer-utils");
+const synced_1 = require("../../../lib-common/processes/synced");
 const MAX_CHUNK_SIZE = 512 * 1024;
 const MAX_FAST_UPLOAD = 2 * 1024 * 1024;
 class UpSyncer {
     constructor(remoteStorage, logError) {
         this.remoteStorage = remoteStorage;
         this.logError = logError;
+        this.tasksByObjIds = new Map();
+        this.tasksByIds = new Map();
+        this.syncedUploadStarts = new synced_1.NamedProcs();
         this.execPools = new labelled_exec_pools_1.LabelledExecPools([
             { label: 'long', maxProcs: 1 },
             { label: 'fast', maxProcs: 1 }
@@ -62,17 +67,54 @@ class UpSyncer {
         }
         await obj.recordRemovalUploadAndGC();
     }
-    async uploadFromDisk(obj, localVersion, uploadVersion, uploadHeader, syncedBase, createOnRemote) {
-        const task = await UploadTask.for(obj, localVersion, uploadVersion, uploadHeader, syncedBase, createOnRemote, this.remoteStorage, this.execPools);
-        this.execPools.add(task);
-        await task.completion();
+    async startUploadFromDisk(obj, localVersion, uploadVersion, uploadHeader, createOnRemote, eventSink) {
+        const foundTask = this.tasksByObjIds.get(obj.objId);
+        if (foundTask) {
+            throw (0, exceptions_1.makeFSSyncException)('', {
+                alreadyUploading: true,
+                uploadTaskId: foundTask.taskId
+            });
+        }
+        const uploadStart = this.syncedUploadStarts.latestTaskAtThisMoment(obj.objId);
+        if (uploadStart) {
+            return uploadStart;
+        }
+        return this.syncedUploadStarts.start(obj.objId, async () => {
+            let uploadTaskId;
+            do {
+                uploadTaskId = Math.floor(Number.MAX_SAFE_INTEGER * Math.random());
+            } while (this.tasksByIds.has(uploadTaskId));
+            const syncedBase = await obj.combineLocalBaseIfPresent(localVersion);
+            if (uploadHeader) {
+                await obj.saveUploadHeaderFile(uploadHeader);
+            }
+            const task = await UploadTask.for(obj, localVersion, uploadVersion, uploadHeader === null || uploadHeader === void 0 ? void 0 : uploadHeader.uploadHeader, syncedBase, createOnRemote, uploadTaskId, eventSink, this.remoteStorage, this.execPools, async () => {
+                if (this.tasksByIds.delete(task.taskId)) {
+                    this.tasksByObjIds.delete(task.objId);
+                }
+                await obj.recordUploadCompletion(localVersion, uploadVersion, (uploadHeader ? {
+                    newHeader: uploadHeader.uploadHeader,
+                    originalHeader: uploadHeader.localHeader
+                } : undefined));
+                if (localVersion > uploadVersion) {
+                    await obj.removeLocalVersionFilesLessThan(localVersion);
+                }
+            });
+            this.tasksByIds.set(uploadTaskId, task);
+            this.tasksByObjIds.set(task.objId, task);
+            const completion = task.completion();
+            completion.catch(noop);
+            this.execPools.add(task);
+            return { completion, uploadTaskId };
+        });
     }
 }
 exports.UpSyncer = UpSyncer;
 Object.freeze(UpSyncer.prototype);
 Object.freeze(UpSyncer);
 class UploadTask {
-    constructor(remoteStorage, objId, objStatus, src, execPools, info, uploadHeader) {
+    constructor(taskId, remoteStorage, objId, objStatus, src, execPools, info, uploadHeader, doAtCompletion, eventSink) {
+        this.taskId = taskId;
         this.remoteStorage = remoteStorage;
         this.objId = objId;
         this.objStatus = objStatus;
@@ -80,11 +122,15 @@ class UploadTask {
         this.execPools = execPools;
         this.info = info;
         this.uploadHeader = uploadHeader;
+        this.doAtCompletion = doAtCompletion;
+        this.eventSink = eventSink;
         this.uploadCompletion = (0, deferred_1.defer)();
         this.execLabel = executorLabelFor(this.info.needUpload);
+        this.totalBytesToUpload = (0, obj_status_1.countBytesIn)(this.info);
+        this.emitUploadEvent('upload-started', { totalBytesToUpload: this.totalBytesToUpload });
         Object.seal(this);
     }
-    static async for(obj, localVersion, uploadVersion, uploadHeader, syncedBase, createObj, remoteStorage, execPools) {
+    static async for(obj, localVersion, uploadVersion, uploadHeader, syncedBase, createObj, taskId, eventSink, remoteStorage, execPools, doAtCompletion) {
         const src = await obj.getObjSrcFromLocalAndSyncedBranch(localVersion);
         let needUpload;
         if (syncedBase) {
@@ -103,7 +149,7 @@ class UploadTask {
         };
         const objStatus = obj.statusObj();
         await objStatus.recordUploadStart(info);
-        return new UploadTask(remoteStorage, obj.objId, objStatus, src, execPools, info, uploadHeader);
+        return new UploadTask(taskId, remoteStorage, obj.objId, objStatus, src, execPools, info, uploadHeader, doAtCompletion, eventSink);
     }
     neededExecutor() {
         return (!this.info.needUpload ? undefined : this.execLabel);
@@ -111,6 +157,16 @@ class UploadTask {
     completion() {
         return this.uploadCompletion.promise;
     }
+    emitUploadEvent(type, fields) {
+        this.eventSink({
+            type,
+            localVersion: this.info.localVersion,
+            uploadTaskId: this.taskId,
+            uploadVersion: this.info.uploadVersion,
+            path: '',
+            ...fields
+        });
+    }
     async process() {
         if (!this.info.needUpload) {
             return;
@@ -138,10 +194,17 @@ class UploadTask {
             }
             await this.objStatus.recordUploadInterimState(this.info);
             if (this.info.needUpload) {
+                this.emitUploadEvent('upload-progress', {
+                    totalBytesToUpload: this.totalBytesToUpload,
+                    bytesLeftToUpload: (0, obj_status_1.countBytesIn)(this.info)
+                });
                 this.execPools.add(this);
             }
             else {
-                this.uploadCompletion.resolve();
+                await this.doAtCompletion().finally(() => {
+                    this.uploadCompletion.resolve();
+                    this.emitUploadEvent('upload-done', {});
+                });
             }
         }
         catch (exc) {

package/build/core-ipc/file.d.ts

@@ -5,12 +5,11 @@ type ReadonlyFile = web3n.files.ReadonlyFile;
 type ReadonlyFileVersionedAPI = web3n.files.ReadonlyFileVersionedAPI;
 type WritableFile = web3n.files.WritableFile;
 type WritableFileVersionedAPI = web3n.files.WritableFileVersionedAPI;
+type WritableFileSyncAPI = web3n.files.WritableFileSyncAPI;
 type File = web3n.files.File;
 type Stats = web3n.files.Stats;
 type SyncStatus = web3n.files.SyncStatus;
 type XAttrsChanges = web3n.files.XAttrsChanges;
-type FileEvent = web3n.files.FileEvent;
-type RemoteEvent = web3n.files.RemoteEvent;
 type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
 type OptionsToUploadLocal = web3n.files.OptionsToUploadLocal;
 type VersionedReadFlags = web3n.files.VersionedReadFlags;
@@ -39,14 +38,18 @@ export declare namespace readBytes {
 }
 export declare function packJSON(json: any): EnvelopeBody;
 export declare function unpackJSON(buf: EnvelopeBody): any;
-export declare function packFileEvent(e: FileEvent | RemoteEvent): Buffer;
-export declare function unpackFileEvent(buf: EnvelopeBody): FileEvent | RemoteEvent;
+export declare function packEvent<T extends object>(e: T): Buffer;
+export declare function unpackEvent<T extends object>(buf: EnvelopeBody): T;
 export interface VersionedReadFlagsMsg {
     archivedVersion?: Value<number>;
     remoteVersion?: Value<number>;
 }
 export declare function versionedReadFlagsFromMsg(msg: VersionedReadFlagsMsg | undefined): VersionedReadFlags | undefined;
 export declare function versionedReadFlagsToMsg(flags: VersionedReadFlags | undefined): VersionedReadFlagsMsg | undefined;
+export declare namespace vStat {
+    function wrapService(fn: ReadonlyFileVersionedAPI['stat']): ExposedFn;
+    function makeCaller(caller: Caller, objPath: string[]): ReadonlyFileVersionedAPI['stat'];
+}
 export declare namespace vGetXAttr {
     interface Reply {
         version: number;
@@ -150,6 +153,26 @@ export interface OptionsToUploadLocalMsg {
 }
 export declare function optionsToUploadLocalToMsg(opts?: OptionsToUploadLocal): OptionsToUploadLocalMsg | undefined;
 export declare function optionsToUploadLocalFromMsg(opts?: OptionsToUploadLocalMsg): OptionsToUploadLocal | undefined;
+export declare namespace vsStartUpload {
+    const requestType: ProtoType<{
+        opts?: OptionsToUploadLocalMsg;
+    }>;
+    const replyType: ProtoType<{
+        startedUpload?: {
+            uploadVersion: number;
+            uploadTaskId: number;
+        };
+    }>;
+    function wrapService(fn: WritableFileSyncAPI['startUpload']): ExposedFn;
+    function makeCaller(caller: Caller, objPath: string[]): WritableFileSyncAPI['startUpload'];
+}
+export declare namespace vsUpload {
+    const replyType: ProtoType<{
+        uploadedVersion?: Value<number>;
+    }>;
+    function wrapService(fn: WritableFileSyncAPI['upload']): ExposedFn;
+    function makeCaller(caller: Caller, objPath: string[]): WritableFileSyncAPI['upload'];
+}
 export interface OptionsToAdopteRemoteMsg {
     dropLocalVer?: Value<boolean>;
     remoteVersion?: Value<number>;