kurtosis-sdk 0.49.5

package/build/core/lib/enclaves/grpc_web_api_container_client.js

@@ -0,0 +1,415 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcWebApiContainerClient = void 0;
+const neverthrow_1 = require("neverthrow");
+class GrpcWebApiContainerClient {
+    constructor(client, enclaveId) {
+        this.client = client;
+        this.enclaveId = enclaveId;
+    }
+    getEnclaveId() {
+        return this.enclaveId;
+    }
+    loadModule(loadModuleArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const loadModulePromise = new Promise((resolve, _unusedReject) => {
+                this.client.loadModule(loadModuleArgs, {}, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const loadModulePromiseResult = yield loadModulePromise;
+            if (loadModulePromiseResult.isErr()) {
+                return (0, neverthrow_1.err)(loadModulePromiseResult.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    unloadModule(unloadModuleArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const unloadModulePromise = new Promise((resolve, _unusedReject) => {
+                this.client.unloadModule(unloadModuleArgs, {}, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const unloadModuleResult = yield unloadModulePromise;
+            if (unloadModuleResult.isErr()) {
+                return (0, neverthrow_1.err)(unloadModuleResult.error);
+            }
+            return (0, neverthrow_1.ok)(unloadModuleResult.value);
+        });
+    }
+    startServices(startServicesArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promiseStartServices = new Promise((resolve, _unusedReject) => {
+                this.client.startServices(startServicesArgs, {}, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const resultStartServices = yield promiseStartServices;
+            if (resultStartServices.isErr()) {
+                return (0, neverthrow_1.err)(resultStartServices.error);
+            }
+            const startServicesResponse = resultStartServices.value;
+            return (0, neverthrow_1.ok)(startServicesResponse);
+        });
+    }
+    removeService(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const removeServicePromise = new Promise((resolve, _unusedReject) => {
+                this.client.removeService(args, {}, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const resultRemoveService = yield removeServicePromise;
+            if (resultRemoveService.isErr()) {
+                return (0, neverthrow_1.err)(resultRemoveService.error);
+            }
+            return (0, neverthrow_1.ok)(resultRemoveService.value);
+        });
+    }
+    repartitionNetwork(repartitionArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promiseRepartition = new Promise((resolve, _unusedReject) => {
+                this.client.repartition(repartitionArgs, {}, (error, _unusedResponse) => {
+                    if (error === null) {
+                        resolve((0, neverthrow_1.ok)(null));
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const resultRepartition = yield promiseRepartition;
+            if (resultRepartition.isErr()) {
+                return (0, neverthrow_1.err)(resultRepartition.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    waitForHttpGetEndpointAvailability(availabilityArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promiseWaitForHttpGetEndpointAvailability = new Promise((resolve, _unusedReject) => {
+                this.client.waitForHttpGetEndpointAvailability(availabilityArgs, {}, (error, _unusedResponse) => {
+                    if (error === null) {
+                        resolve((0, neverthrow_1.ok)(null));
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const resultWaitForHttpGetEndpointAvailability = yield promiseWaitForHttpGetEndpointAvailability;
+            if (resultWaitForHttpGetEndpointAvailability.isErr()) {
+                return (0, neverthrow_1.err)(resultWaitForHttpGetEndpointAvailability.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    waitForHttpPostEndpointAvailability(availabilityArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promiseWaitForHttpPostEndpointAvailability = new Promise((resolve, _unusedReject) => {
+                this.client.waitForHttpPostEndpointAvailability(availabilityArgs, {}, (error, _unusedResponse) => {
+                    if (error === null) {
+                        resolve((0, neverthrow_1.ok)(null));
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const resultWaitForHttpPostEndpointAvailability = yield promiseWaitForHttpPostEndpointAvailability;
+            if (resultWaitForHttpPostEndpointAvailability.isErr()) {
+                return (0, neverthrow_1.err)(resultWaitForHttpPostEndpointAvailability.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    getServices(getServicesArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promiseGetServices = new Promise((resolve, _unusedReject) => {
+                this.client.getServices(getServicesArgs, {}, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const resultGetServices = yield promiseGetServices;
+            if (resultGetServices.isErr()) {
+                return (0, neverthrow_1.err)(resultGetServices.error);
+            }
+            const getServicesResponse = resultGetServices.value;
+            return (0, neverthrow_1.ok)(getServicesResponse);
+        });
+    }
+    getModules(getModulesArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const getModulesPromise = new Promise((resolve, _unusedReject) => {
+                this.client.getModules(getModulesArgs, {}, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const getModulesResult = yield getModulesPromise;
+            if (getModulesResult.isErr()) {
+                return (0, neverthrow_1.err)(getModulesResult.error);
+            }
+            const getModulesResponse = getModulesResult.value;
+            return (0, neverthrow_1.ok)(getModulesResponse);
+        });
+    }
+    executeModule(executeModuleArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const executeModulePromise = new Promise((resolve, _unusedReject) => {
+                this.client.executeModule(executeModuleArgs, {}, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const executeModuleResult = yield executeModulePromise;
+            if (executeModuleResult.isErr()) {
+                return (0, neverthrow_1.err)(executeModuleResult.error);
+            }
+            const executeModuleResponse = executeModuleResult.value;
+            return (0, neverthrow_1.ok)(executeModuleResponse);
+        });
+    }
+    execCommand(execCommandArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const execCommandPromise = new Promise((resolve, _unusedReject) => {
+                this.client.execCommand(execCommandArgs, {}, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const execCommandResponseResult = yield execCommandPromise;
+            if (execCommandResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(execCommandResponseResult.error);
+            }
+            const execCommandResponse = execCommandResponseResult.value;
+            return (0, neverthrow_1.ok)(execCommandResponse);
+        });
+    }
+    pauseService(pauseServiceArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pauseServicePromise = new Promise((resolve, _unusedReject) => {
+                this.client.pauseService(pauseServiceArgs, {}, (error) => {
+                    if (error === null) {
+                        resolve((0, neverthrow_1.ok)(null));
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const pauseServiceResult = yield pauseServicePromise;
+            if (pauseServiceResult.isErr()) {
+                return (0, neverthrow_1.err)(pauseServiceResult.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    unpauseService(unpauseServiceArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const unpauseServicePromise = new Promise((resolve, _unusedReject) => {
+                this.client.unpauseService(unpauseServiceArgs, {}, (error) => {
+                    if (error === null) {
+                        resolve((0, neverthrow_1.ok)(null));
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const unpauseServiceResult = yield unpauseServicePromise;
+            if (unpauseServiceResult.isErr()) {
+                return (0, neverthrow_1.err)(unpauseServiceResult.error);
+            }
+            return (0, neverthrow_1.ok)(null);
+        });
+    }
+    uploadFiles(uploadFilesArtifactArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const uploadFilesArtifactPromise = new Promise((resolve, _unusedReject) => {
+                this.client.uploadFilesArtifact(uploadFilesArtifactArgs, {}, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const uploadFilesArtifactResponseResult = yield uploadFilesArtifactPromise;
+            if (uploadFilesArtifactResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(uploadFilesArtifactResponseResult.error);
+            }
+            const uploadFilesArtifactResponse = uploadFilesArtifactResponseResult.value;
+            return (0, neverthrow_1.ok)(uploadFilesArtifactResponse);
+        });
+    }
+    storeWebFilesArtifact(storeWebFilesArtifactArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storeWebFilesArtifactPromise = new Promise((resolve, _unusedReject) => {
+                this.client.storeWebFilesArtifact(storeWebFilesArtifactArgs, {}, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const storeWebFilesArtifactResponseResult = yield storeWebFilesArtifactPromise;
+            if (storeWebFilesArtifactResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(storeWebFilesArtifactResponseResult.error);
+            }
+            const storeWebFilesArtifactResponse = storeWebFilesArtifactResponseResult.value;
+            return (0, neverthrow_1.ok)(storeWebFilesArtifactResponse);
+        });
+    }
+    storeFilesArtifactFromService(storeFilesArtifactFromServiceArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storeFilesArtifactFromServicePromise = new Promise((resolve, _unusedReject) => {
+                this.client.storeFilesArtifactFromService(storeFilesArtifactFromServiceArgs, {}, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const storeFilesArtifactFromServiceResponseResult = yield storeFilesArtifactFromServicePromise;
+            if (storeFilesArtifactFromServiceResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(storeFilesArtifactFromServiceResponseResult.error);
+            }
+            const storeFilesArtifactFromServiceResponse = storeFilesArtifactFromServiceResponseResult.value;
+            return (0, neverthrow_1.ok)(storeFilesArtifactFromServiceResponse);
+        });
+    }
+    renderTemplatesToFilesArtifact(renderTemplatesToFilesArtifactArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const renderTemplatesToFilesArtifactPromise = new Promise((resolve, _unusedReject) => {
+                this.client.renderTemplatesToFilesArtifact(renderTemplatesToFilesArtifactArgs, {}, (error, response) => {
+                    if (error === null) {
+                        if (!response) {
+                            resolve((0, neverthrow_1.err)(new Error("No error was encountered but the response was still falsy; this should never happen")));
+                        }
+                        else {
+                            resolve((0, neverthrow_1.ok)(response));
+                        }
+                    }
+                    else {
+                        resolve((0, neverthrow_1.err)(error));
+                    }
+                });
+            });
+            const renderTemplatesToFilesArtifactResponseResult = yield renderTemplatesToFilesArtifactPromise;
+            if (renderTemplatesToFilesArtifactResponseResult.isErr()) {
+                return (0, neverthrow_1.err)(renderTemplatesToFilesArtifactResponseResult.error);
+            }
+            const renderTemplatesToFilesArtifactResponse = renderTemplatesToFilesArtifactResponseResult.value;
+            return (0, neverthrow_1.ok)(renderTemplatesToFilesArtifactResponse);
+        });
+    }
+}
+exports.GrpcWebApiContainerClient = GrpcWebApiContainerClient;

package/build/core/lib/enclaves/node_tgz_archiver.d.ts

@@ -0,0 +1,6 @@
+import "neverthrow";
+import { GenericTgzArchiver } from "./generic_tgz_archiver";
+import { Result } from "neverthrow";
+export declare class NodeTgzArchiver implements GenericTgzArchiver {
+    createTgzByteArray(pathToArchive: string): Promise<Result<Uint8Array, Error>>;
+}

package/build/core/lib/enclaves/node_tgz_archiver.js

@@ -0,0 +1,94 @@
+"use strict";
+/*
+ * Copyright (c) 2022 - present Kurtosis Technologies Inc.
+ * All Rights Reserved.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeTgzArchiver = void 0;
+require("neverthrow");
+const neverthrow_1 = require("neverthrow");
+const filesystem = require("fs");
+const path = require("path");
+const os = require("os");
+const tar = require("tar");
+const COMPRESSION_EXTENSION = ".tgz";
+const GRPC_DATA_TRANSFER_LIMIT = 3999000; //3.999 Mb. 1kb wiggle room. 1kb being about the size of a 2 paragraph readme.
+const COMPRESSION_TEMP_FOLDER_PREFIX = "temp-node-archiver-compression-";
+class NodeTgzArchiver {
+    createTgzByteArray(pathToArchive) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //Check if it exists
+            if (!filesystem.existsSync(pathToArchive)) {
+                return (0, neverthrow_1.err)(new Error(`Path '${pathToArchive}' does not exist.`));
+            }
+            if (pathToArchive === "/") {
+                return (0, neverthrow_1.err)(new Error("Cannot archive the root directory"));
+            }
+            const srcParentDirpath = path.dirname(pathToArchive);
+            const srcFilename = path.basename(pathToArchive);
+            const isPathToArchiveDirectory = filesystem.lstatSync(pathToArchive).isDirectory();
+            //Make directory for usage.
+            const osTempDirpath = os.tmpdir();
+            const tempDirpathPrefix = path.join(osTempDirpath, COMPRESSION_TEMP_FOLDER_PREFIX);
+            const tempDirpathResult = yield filesystem.promises.mkdtemp(tempDirpathPrefix).then((folder) => {
+                return (0, neverthrow_1.ok)(folder);
+            }).catch((tempDirErr) => {
+                return (0, neverthrow_1.err)(tempDirErr);
+            });
+            if (tempDirpathResult.isErr()) {
+                return (0, neverthrow_1.err)(tempDirpathResult.error);
+            }
+            const tempDirpath = tempDirpathResult.value;
+            const destFilename = srcFilename + COMPRESSION_EXTENSION;
+            const destFilepath = path.join(tempDirpath, destFilename);
+            const filenamesToUpload = isPathToArchiveDirectory ? filesystem.readdirSync(pathToArchive) : [srcFilename];
+            if (filenamesToUpload.length == 0) {
+                return (0, neverthrow_1.err)(new Error(`The directory '${pathToArchive}' you are trying to upload is empty`));
+            }
+            const targzPromise = tar.create({
+                cwd: isPathToArchiveDirectory ? pathToArchive : srcParentDirpath,
+                gzip: true,
+                file: destFilepath,
+            }, filenamesToUpload).then((_) => {
+                return (0, neverthrow_1.ok)(null);
+            }).catch((err) => {
+                // Use duck-typing to detect Error types
+                if (err && err.stack && err.message) {
+                    return err(err);
+                }
+                return err(new Error(`A non-Error object '${err}' was thrown when compressing '${pathToArchive}' to '${destFilepath}'`));
+            });
+            const targzResult = yield targzPromise;
+            if (targzResult.isErr()) {
+                return (0, neverthrow_1.err)(targzResult.error);
+            }
+            if (!filesystem.existsSync(destFilepath)) {
+                return (0, neverthrow_1.err)(new Error(`Your files were compressed but could not be found at '${destFilepath}'.`));
+            }
+            const stats = filesystem.statSync(destFilepath);
+            if (stats.size >= GRPC_DATA_TRANSFER_LIMIT) {
+                return (0, neverthrow_1.err)(new Error("The files you are trying to upload, which are now compressed, exceed or reach 4mb, " +
+                    "a limit imposed by gRPC. Please reduce the total file size and ensure it can compress to a size below 4mb."));
+            }
+            if (stats.size <= 0) {
+                return (0, neverthrow_1.err)(new Error("Something went wrong during compression. The compressed file size is 0 bytes."));
+            }
+            const data = filesystem.readFileSync(destFilepath);
+            if (data.length != stats.size) {
+                return (0, neverthrow_1.err)(new Error(`Something went wrong while reading your recently compressed file '${destFilename}'.` +
+                    `The file size of ${stats.size} bytes and read size of ${data.length} bytes are not equal.`));
+            }
+            return (0, neverthrow_1.ok)(data);
+        });
+    }
+}
+exports.NodeTgzArchiver = NodeTgzArchiver;

package/build/core/lib/enclaves/partition_connection.d.ts

@@ -0,0 +1,20 @@
+import { PartitionConnectionInfo } from "../../kurtosis_core_rpc_api_bindings/api_container_service_pb";
+export interface PartitionConnection {
+    getPartitionConnectionInfo: () => PartitionConnectionInfo;
+}
+export declare class UnblockedPartitionConnection {
+    private readonly packetLossPercentage;
+    constructor();
+    getPartitionConnectionInfo(): PartitionConnectionInfo;
+}
+export declare class BlockedPartitionConnection {
+    private readonly packetLossPercentage;
+    constructor();
+    getPartitionConnectionInfo(): PartitionConnectionInfo;
+}
+export declare class SoftPartitionConnection {
+    private readonly packetLossPercentage;
+    constructor(packetLossPercentage: number);
+    getPartitionConnectionInfo(): PartitionConnectionInfo;
+    private static isValidPacketLossValue;
+}

package/build/core/lib/enclaves/partition_connection.js

@@ -0,0 +1,62 @@
+"use strict";
+/*
+ * Copyright (c) 2021 - present Kurtosis Technologies Inc.
+ * All Rights Reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftPartitionConnection = exports.BlockedPartitionConnection = exports.UnblockedPartitionConnection = void 0;
+const api_container_service_pb_1 = require("../../kurtosis_core_rpc_api_bindings/api_container_service_pb");
+const constructor_calls_1 = require("../constructor_calls");
+const UNBLOCKED_PARTITION_CONNECTION_PACKET_LOSS_VALUE = 0;
+const BLOCKED_PARTITION_CONNECTION_PACKET_LOSS_VALUE = 100;
+//Random packet loss is specified in the 'tc' command in percent. The smallest possible non-zero value is: 2^32 = 0.0000000232% More info: https://wiki.linuxfoundation.org/networking/netem
+const SMALLEST_POSSIBLE_NON_ZERO_PACKET_LOSS_VALUE = 0.0000000232;
+const MAX_POSSIBLE_PACKET_LOSS_VALUE = 100;
+// ====================================================================================================
+//                                    	 Implementations
+// ====================================================================================================
+// UnblockedPartitionConnection use this type of PartitionConnection when you want to establish that the connection is not partitioned
+class UnblockedPartitionConnection {
+    constructor() {
+        this.packetLossPercentage = UNBLOCKED_PARTITION_CONNECTION_PACKET_LOSS_VALUE;
+    }
+    getPartitionConnectionInfo() {
+        return (0, constructor_calls_1.newPartitionConnectionInfo)(this.packetLossPercentage);
+    }
+}
+exports.UnblockedPartitionConnection = UnblockedPartitionConnection;
+// BlockedPartitionConnection use this type of PartitionConnection when you want to create a hard partition
+class BlockedPartitionConnection {
+    constructor() {
+        this.packetLossPercentage = BLOCKED_PARTITION_CONNECTION_PACKET_LOSS_VALUE;
+    }
+    getPartitionConnectionInfo() {
+        let partitionConnectionInfo = new api_container_service_pb_1.PartitionConnectionInfo();
+        partitionConnectionInfo.setPacketLossPercentage(this.packetLossPercentage);
+        return partitionConnectionInfo;
+    }
+}
+exports.BlockedPartitionConnection = BlockedPartitionConnection;
+// SoftPartitionConnection use this type of PartitionConnection when you want to create a partition with x% percentage of packet loss
+class SoftPartitionConnection {
+    constructor(packetLossPercentage) {
+        if (!SoftPartitionConnection.isValidPacketLossValue(packetLossPercentage)) {
+            throw new Error(`The packet loss percentage value ${packetLossPercentage} is not allowed, 
+            it should be >= ${SMALLEST_POSSIBLE_NON_ZERO_PACKET_LOSS_VALUE} 
+            and <= ${MAX_POSSIBLE_PACKET_LOSS_VALUE}`);
+        }
+        this.packetLossPercentage = packetLossPercentage;
+    }
+    getPartitionConnectionInfo() {
+        let partitionConnectionInfo = new api_container_service_pb_1.PartitionConnectionInfo();
+        partitionConnectionInfo.setPacketLossPercentage(this.packetLossPercentage);
+        return partitionConnectionInfo;
+    }
+    // ====================================================================================================
+    // 									   Private helper methods
+    // ====================================================================================================
+    static isValidPacketLossValue(packetLossPercentage) {
+        return packetLossPercentage >= SMALLEST_POSSIBLE_NON_ZERO_PACKET_LOSS_VALUE && packetLossPercentage <= MAX_POSSIBLE_PACKET_LOSS_VALUE;
+    }
+}
+exports.SoftPartitionConnection = SoftPartitionConnection;

package/build/core/lib/enclaves/template_and_data.d.ts

@@ -0,0 +1,5 @@
+export declare class TemplateAndData {
+    readonly template: string;
+    readonly templateData: any;
+    constructor(template: string, templateData: any);
+}

package/build/core/lib/enclaves/template_and_data.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateAndData = void 0;
+// Docs available at https://docs.kurtosistech.com/kurtosis-core/lib-documentation
+class TemplateAndData {
+    constructor(template, templateData) {
+        this.template = template;
+        this.templateData = templateData;
+    }
+}
+exports.TemplateAndData = TemplateAndData;

package/build/core/lib/enclaves/web_tgz_archiver.d.ts

@@ -0,0 +1,5 @@
+import { GenericTgzArchiver } from "./generic_tgz_archiver";
+import { Result } from "neverthrow";
+export declare class WebTgzArchiver implements GenericTgzArchiver {
+    createTgzByteArray(pathToArchive: string): Promise<Result<Uint8Array, Error>>;
+}

package/build/core/lib/enclaves/web_tgz_archiver.js

@@ -0,0 +1,26 @@
+"use strict";
+/*
+ * Copyright (c) 2022 - present Kurtosis Technologies Inc.
+ * All Rights Reserved.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebTgzArchiver = void 0;
+const neverthrow_1 = require("neverthrow");
+class WebTgzArchiver {
+    createTgzByteArray(pathToArchive) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, neverthrow_1.err)(new Error("Sending compressed archives over the Web API is not implemented yet." +
+                "Please use the Node.js API instead."));
+        });
+    }
+}
+exports.WebTgzArchiver = WebTgzArchiver;

package/build/core/lib/modules/module_context.d.ts

@@ -0,0 +1,9 @@
+import { Result } from "neverthrow";
+import { GenericApiContainerClient } from "../enclaves/generic_api_container_client";
+export declare type ModuleID = string;
+export declare class ModuleContext {
+    private readonly client;
+    private readonly moduleId;
+    constructor(client: GenericApiContainerClient, moduleId: ModuleID);
+    execute(serializedParams: string): Promise<Result<string, Error>>;
+}