@epfml/discojs 0.0.1

package/dist/client/federated.d.ts

@@ -0,0 +1,30 @@
+import { TrainingInformant, MetadataID, Weights } from '..';
+import { Base } from './base';
+/**
+ * Class that deals with communication with the centralized server when training
+ * a specific task in the federated setting.
+ */
+export declare class Federated extends Base {
+    private readonly clientID;
+    private readonly peer;
+    private round;
+    private urlTo;
+    private urlToMetadata;
+    /**
+     * Initialize the connection to the server. TODO: In the case of FeAI,
+     * should return the current server-side round for the task.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnection process when user quits the task.
+     */
+    disconnect(): Promise<void>;
+    postWeightsToServer(weights: Weights): Promise<void>;
+    postMetadata(metadataID: string, metadata: string): Promise<void>;
+    getMetadataMap(metadataID: MetadataID): Promise<Map<string, unknown>>;
+    getLatestServerRound(): Promise<number>;
+    pullRoundAndFetchWeights(): Promise<Weights | undefined>;
+    pullServerStatistics(trainingInformant: TrainingInformant): Promise<void>;
+    onRoundEndCommunication(updatedWeights: Weights, staleWeights: Weights, _: number, trainingInformant: TrainingInformant): Promise<Weights>;
+    onTrainEndCommunication(_: Weights, trainingInformant: TrainingInformant): Promise<void>;
+}

package/dist/client/federated.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Federated = void 0;
+var tslib_1 = require("tslib");
+var msgpack = (0, tslib_1.__importStar)(require("msgpack-lite"));
+var axios_1 = (0, tslib_1.__importDefault)(require("axios"));
+var uuid_1 = require("uuid");
+var __1 = require("..");
+var base_1 = require("./base");
+/**
+ * Class that deals with communication with the centralized server when training
+ * a specific task in the federated setting.
+ */
+var Federated = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(Federated, _super);
+    function Federated() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.clientID = (0, uuid_1.v4)();
+        _this.round = 0;
+        return _this;
+    }
+    Federated.prototype.urlTo = function (category) {
+        var url = new URL('', this.url);
+        url.pathname += [
+            'feai',
+            category,
+            this.task.taskID,
+            this.clientID
+        ].join('/');
+        return url.href;
+    };
+    Federated.prototype.urlToMetadata = function (metadataID) {
+        var url = new URL('', this.url);
+        url.pathname += [
+            'feai',
+            'metadata',
+            metadataID,
+            this.task.taskID,
+            this.round,
+            this.clientID
+        ].join('/');
+        return url.href;
+    };
+    /**
+     * Initialize the connection to the server. TODO: In the case of FeAI,
+     * should return the current server-side round for the task.
+     */
+    Federated.prototype.connect = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, axios_1.default.get(this.urlTo('connect'))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Disconnection process when user quits the task.
+     */
+    Federated.prototype.disconnect = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, axios_1.default.get(this.urlTo('disconnect'))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Federated.prototype.postWeightsToServer = function (weights) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var _a;
+            var _b, _c;
+            return (0, tslib_1.__generator)(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _a = axios_1.default;
+                        _b = {
+                            method: 'post',
+                            url: this.urlTo('weights')
+                        };
+                        _c = {};
+                        return [4 /*yield*/, __1.serialization.weights.encode(weights)];
+                    case 1: return [4 /*yield*/, _a.apply(void 0, [(_b.data = (_c.weights = _d.sent(),
+                                _c.round = this.round,
+                                _c),
+                                _b)])];
+                    case 2:
+                        _d.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Federated.prototype.postMetadata = function (metadataID, metadata) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, axios_1.default)({
+                            method: 'post',
+                            url: this.urlToMetadata(metadataID),
+                            data: {
+                                metadataID: metadata
+                            }
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Federated.prototype.getMetadataMap = function (metadataID) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var response, body;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, axios_1.default.get(this.urlToMetadata(metadataID))];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.data];
+                    case 2:
+                        body = _a.sent();
+                        return [2 /*return*/, new Map(msgpack.decode(body[metadataID]))];
+                }
+            });
+        });
+    };
+    Federated.prototype.getLatestServerRound = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var response;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, axios_1.default.get(this.urlTo('round'))];
+                    case 1:
+                        response = _a.sent();
+                        if (response.status === 200) {
+                            return [2 /*return*/, response.data.round];
+                        }
+                        console.log('Error getting weights: code', response.status);
+                        return [2 /*return*/, -1];
+                }
+            });
+        });
+    };
+    Federated.prototype.pullRoundAndFetchWeights = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var serverRound, response, serverWeights;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getLatestServerRound()];
+                    case 1:
+                        serverRound = _a.sent();
+                        return [4 /*yield*/, axios_1.default.get(this.urlTo('weights'))];
+                    case 2:
+                        response = _a.sent();
+                        serverWeights = __1.serialization.weights.decode(response.data);
+                        if (this.round < serverRound) {
+                            // Update the local round to match the server's
+                            this.round = serverRound;
+                            return [2 /*return*/, serverWeights];
+                        }
+                        else {
+                            return [2 /*return*/, undefined];
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Federated.prototype.pullServerStatistics = function (trainingInformant) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var response;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, axios_1.default.get(this.urlTo('statistics'))];
+                    case 1:
+                        response = _a.sent();
+                        trainingInformant.updateWithServerStatistics(response.data.statistics);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Federated.prototype.onRoundEndCommunication = function (updatedWeights, staleWeights, _, trainingInformant) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var noisyWeights, serverWeights;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        noisyWeights = __1.privacy.addDifferentialPrivacy(updatedWeights, staleWeights, this.task);
+                        return [4 /*yield*/, this.postWeightsToServer(noisyWeights)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.pullServerStatistics(trainingInformant)];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.pullRoundAndFetchWeights()];
+                    case 3:
+                        serverWeights = _a.sent();
+                        return [2 /*return*/, serverWeights !== null && serverWeights !== void 0 ? serverWeights : staleWeights];
+                }
+            });
+        });
+    };
+    Federated.prototype.onTrainEndCommunication = function (_, trainingInformant) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            return (0, tslib_1.__generator)(this, function (_a) {
+                trainingInformant.addMessage('Training finished.');
+                return [2 /*return*/];
+            });
+        });
+    };
+    return Federated;
+}(base_1.Base));
+exports.Federated = Federated;

package/dist/client/index.d.ts

@@ -0,0 +1,4 @@
+export { Base } from './base';
+export { Decentralized } from './decentralized';
+export { Federated } from './federated';
+export { Local } from './local';

package/dist/client/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Local = exports.Federated = exports.Decentralized = exports.Base = void 0;
+var base_1 = require("./base");
+Object.defineProperty(exports, "Base", { enumerable: true, get: function () { return base_1.Base; } });
+var decentralized_1 = require("./decentralized");
+Object.defineProperty(exports, "Decentralized", { enumerable: true, get: function () { return decentralized_1.Decentralized; } });
+var federated_1 = require("./federated");
+Object.defineProperty(exports, "Federated", { enumerable: true, get: function () { return federated_1.Federated; } });
+var local_1 = require("./local");
+Object.defineProperty(exports, "Local", { enumerable: true, get: function () { return local_1.Local; } });

package/dist/client/local.d.ts

@@ -0,0 +1,8 @@
+import { Weights } from '../types';
+import { Base } from './base';
+export declare class Local extends Base {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    onRoundEndCommunication(_: Weights): Promise<Weights>;
+    onTrainEndCommunication(): Promise<void>;
+}

package/dist/client/local.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Local = void 0;
+var tslib_1 = require("tslib");
+var base_1 = require("./base");
+// does pretty much nothing
+var Local = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(Local, _super);
+    function Local() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Local.prototype.connect = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () { return (0, tslib_1.__generator)(this, function (_a) {
+            return [2 /*return*/];
+        }); });
+    };
+    Local.prototype.disconnect = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () { return (0, tslib_1.__generator)(this, function (_a) {
+            return [2 /*return*/];
+        }); });
+    };
+    Local.prototype.onRoundEndCommunication = function (_) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () { return (0, tslib_1.__generator)(this, function (_a) {
+            return [2 /*return*/, _];
+        }); });
+    };
+    Local.prototype.onTrainEndCommunication = function () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () { return (0, tslib_1.__generator)(this, function (_a) {
+            return [2 /*return*/];
+        }); });
+    };
+    return Local;
+}(base_1.Base));
+exports.Local = Local;

package/dist/dataset/data_loader/data_loader.d.ts

@@ -0,0 +1,16 @@
+import { Dataset } from '../dataset_builder';
+import { Task } from '../../task';
+export interface DataConfig {
+    features?: string[];
+    labels?: string[];
+}
+export interface Data {
+    dataset: Dataset;
+    size: number;
+}
+export declare abstract class DataLoader<Source> {
+    protected task: Task;
+    constructor(task: Task);
+    abstract load(source: Source, config: DataConfig): Promise<Dataset>;
+    abstract loadAll(sources: Source[], config: DataConfig): Promise<Data>;
+}

package/dist/dataset/data_loader/data_loader.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataLoader = void 0;
+var DataLoader = /** @class */ (function () {
+    function DataLoader(task) {
+        this.task = task;
+    }
+    return DataLoader;
+}());
+exports.DataLoader = DataLoader;

package/dist/dataset/data_loader/image_loader.d.ts

@@ -0,0 +1,14 @@
+import * as tf from '@tensorflow/tfjs';
+import { Dataset } from '../dataset_builder';
+import { DataLoader, DataConfig, Data } from './data_loader';
+/**
+ * TODO @s314cy:
+ * Load labels and correctly match them with their respective images, with the following constraints:
+ * 1. Images are given as 1 image/1 file
+ * 2. Labels are given as multiple labels/1 file, each label file can contain a different amount of labels
+ */
+export declare abstract class ImageLoader<Source> extends DataLoader<Source> {
+    abstract readImageFrom(source: Source): Promise<tf.Tensor3D>;
+    load(image: Source, config?: DataConfig): Promise<Dataset>;
+    loadAll(images: Source[], config?: DataConfig): Promise<Data>;
+}

package/dist/dataset/data_loader/image_loader.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageLoader = void 0;
+var tslib_1 = require("tslib");
+var tf = (0, tslib_1.__importStar)(require("@tensorflow/tfjs"));
+var data_loader_1 = require("./data_loader");
+/**
+ * TODO @s314cy:
+ * Load labels and correctly match them with their respective images, with the following constraints:
+ * 1. Images are given as 1 image/1 file
+ * 2. Labels are given as multiple labels/1 file, each label file can contain a different amount of labels
+ */
+var ImageLoader = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(ImageLoader, _super);
+    function ImageLoader() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ImageLoader.prototype.load = function (image, config) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var tensorContainer;
+            var _a;
+            return (0, tslib_1.__generator)(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(config === undefined || config.labels === undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.readImageFrom(image)];
+                    case 1:
+                        tensorContainer = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        _a = {};
+                        return [4 /*yield*/, this.readImageFrom(image)];
+                    case 3:
+                        tensorContainer = (_a.xs = _b.sent(),
+                            _a.ys = config.labels[0],
+                            _a);
+                        _b.label = 4;
+                    case 4: return [2 /*return*/, tf.data.array([tensorContainer])];
+                }
+            });
+        });
+    };
+    ImageLoader.prototype.loadAll = function (images, config) {
+        var _a, _b;
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var labels, numberOfClasses, dataset;
+            var _this = this;
+            return (0, tslib_1.__generator)(this, function (_c) {
+                if ((config === null || config === void 0 ? void 0 : config.labels) !== undefined) {
+                    numberOfClasses = (_b = (_a = this.task.trainingInformation) === null || _a === void 0 ? void 0 : _a.LABEL_LIST) === null || _b === void 0 ? void 0 : _b.length;
+                    if (numberOfClasses === undefined) {
+                        throw new Error('wanted labels but none found in task');
+                    }
+                    labels = tf.oneHot(tf.tensor1d(config.labels, 'int32'), numberOfClasses).arraySync();
+                }
+                dataset = tf.data.generator(function () {
+                    var withLabels = (config === null || config === void 0 ? void 0 : config.labels) !== undefined;
+                    var index = 0;
+                    var iterator = {
+                        next: function () { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+                            var sample, label, value;
+                            return (0, tslib_1.__generator)(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (index === images.length) {
+                                            return [2 /*return*/, { done: true }];
+                                        }
+                                        return [4 /*yield*/, this.readImageFrom(images[index])];
+                                    case 1:
+                                        sample = _a.sent();
+                                        label = withLabels ? labels[index] : undefined;
+                                        value = withLabels ? { xs: sample, ys: label } : sample;
+                                        index++;
+                                        return [2 /*return*/, {
+                                                value: value,
+                                                done: false
+                                            }];
+                                }
+                            });
+                        }); }
+                    };
+                    return iterator; // Lazy
+                });
+                return [2 /*return*/, {
+                        dataset: dataset,
+                        size: images.length
+                    }];
+            });
+        });
+    };
+    return ImageLoader;
+}(data_loader_1.DataLoader));
+exports.ImageLoader = ImageLoader;

package/dist/dataset/data_loader/index.d.ts

@@ -0,0 +1,3 @@
+export { Data, DataConfig, DataLoader } from './data_loader';
+export { ImageLoader } from './image_loader';
+export { TabularLoader } from './tabular_loader';

package/dist/dataset/data_loader/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TabularLoader = exports.ImageLoader = exports.DataLoader = void 0;
+var data_loader_1 = require("./data_loader");
+Object.defineProperty(exports, "DataLoader", { enumerable: true, get: function () { return data_loader_1.DataLoader; } });
+var image_loader_1 = require("./image_loader");
+Object.defineProperty(exports, "ImageLoader", { enumerable: true, get: function () { return image_loader_1.ImageLoader; } });
+var tabular_loader_1 = require("./tabular_loader");
+Object.defineProperty(exports, "TabularLoader", { enumerable: true, get: function () { return tabular_loader_1.TabularLoader; } });

package/dist/dataset/data_loader/tabular_loader.d.ts

@@ -0,0 +1,29 @@
+import { DataLoader, DataConfig, Data } from './data_loader';
+import { Dataset } from '../dataset_builder';
+import { Task } from '../../task';
+import * as tf from '@tensorflow/tfjs';
+export declare abstract class TabularLoader<Source> extends DataLoader<Source> {
+    private readonly delimiter;
+    constructor(task: Task, delimiter: string);
+    /**
+     * Creates a CSV dataset object based off the given source.
+     * @param source File object, URL string or local file system path.
+     * @param csvConfig Object expected by TF.js to create a CSVDataset.
+     * @returns The CSVDataset object built upon the given source.
+     */
+    abstract loadTabularDatasetFrom(source: Source, csvConfig: Record<string, unknown>): tf.data.CSVDataset;
+    /**
+     * Expects delimiter-separated tabular data made of N columns. The data may be
+     * potentially split among several sources. Every source should contain N-1
+     * feature columns and 1 single label column.
+     * @param source List of File objects, URLs or file system paths.
+     * @param config
+     * @returns A TF.js dataset built upon read tabular data stored in the given sources.
+     */
+    load(source: Source, config?: DataConfig): Promise<Dataset>;
+    /**
+      * Creates the CSV datasets based off the given sources, then fuses them into a single CSV
+      * dataset.
+      */
+    loadAll(sources: Source[], config: DataConfig): Promise<Data>;
+}

package/dist/dataset/data_loader/tabular_loader.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TabularLoader = void 0;
+var tslib_1 = require("tslib");
+var data_loader_1 = require("./data_loader");
+var immutable_1 = require("immutable");
+var TabularLoader = /** @class */ (function (_super) {
+    (0, tslib_1.__extends)(TabularLoader, _super);
+    function TabularLoader(task, delimiter) {
+        var _this = _super.call(this, task) || this;
+        _this.delimiter = delimiter;
+        return _this;
+    }
+    /**
+     * Expects delimiter-separated tabular data made of N columns. The data may be
+     * potentially split among several sources. Every source should contain N-1
+     * feature columns and 1 single label column.
+     * @param source List of File objects, URLs or file system paths.
+     * @param config
+     * @returns A TF.js dataset built upon read tabular data stored in the given sources.
+     */
+    TabularLoader.prototype.load = function (source, config) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var columnConfigs, csvConfig;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                /**
+                 * Prepare the CSV config object based off the given features and labels.
+                 * If labels is empty, then the returned dataset is comprised of samples only.
+                 * Otherwise, each entry is of the form `{ xs, ys }` with `xs` as features and `ys`
+                 * as labels.
+                 */
+                if ((config === null || config === void 0 ? void 0 : config.features) === undefined) {
+                    // TODO @s314cy
+                    throw new Error('not implemented');
+                }
+                columnConfigs = (0, immutable_1.Map)((0, immutable_1.Set)(config.features).map(function (feature) { return [feature, { required: false, isLabel: false }]; })).merge((0, immutable_1.Set)(config.labels).map(function (label) { return [label, { required: true, isLabel: true }]; }));
+                csvConfig = {
+                    hasHeader: true,
+                    columnConfigs: columnConfigs.toObject(),
+                    configuredColumnsOnly: true,
+                    delimiter: this.delimiter
+                };
+                return [2 /*return*/, this.loadTabularDatasetFrom(source, csvConfig).map(function (t) {
+                        if (typeof t === 'object' && ('xs' in t) && ('ys' in t)) {
+                            return t;
+                        }
+                        throw new Error('expected TensorContainerObject');
+                    }).map(function (t) {
+                        // TODO order may not be stable between tensor
+                        var _a = t, xs = _a.xs, ys = _a.ys;
+                        return {
+                            xs: Object.values(xs),
+                            ys: Object.values(ys)
+                        };
+                    })];
+            });
+        });
+    };
+    /**
+      * Creates the CSV datasets based off the given sources, then fuses them into a single CSV
+      * dataset.
+      */
+    TabularLoader.prototype.loadAll = function (sources, config) {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+            var datasets, dataset;
+            var _this = this;
+            return (0, tslib_1.__generator)(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(sources.map(function (source) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () { return (0, tslib_1.__generator)(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, this.load(source, config)];
+                                case 1: return [2 /*return*/, _a.sent()];
+                            }
+                        }); }); }))];
+                    case 1:
+                        datasets = _a.sent();
+                        dataset = (0, immutable_1.List)(datasets).reduce(function (acc, dataset) { return acc.concatenate(dataset); });
+                        return [2 /*return*/, {
+                                dataset: dataset,
+                                size: dataset.size // TODO: needs to be tested
+                            }];
+                }
+            });
+        });
+    };
+    return TabularLoader;
+}(data_loader_1.DataLoader));
+exports.TabularLoader = TabularLoader;

package/dist/dataset/dataset_builder.d.ts

@@ -0,0 +1,17 @@
+import * as tf from '@tensorflow/tfjs';
+import { DataLoader, Data } from './data_loader/data_loader';
+import { Task } from '@/task';
+export declare type Dataset = tf.data.Dataset<tf.TensorContainer>;
+export declare class DatasetBuilder<Source> {
+    private readonly task;
+    private readonly dataLoader;
+    private sources;
+    private readonly labelledSources;
+    private built;
+    constructor(dataLoader: DataLoader<Source>, task: Task);
+    addFiles(sources: Source[], label?: string): void;
+    clearFiles(label?: string): void;
+    build(): Promise<Data>;
+    isBuilt(): boolean;
+    size(): number;
+}