build-raptor 0.131.0 → 0.133.0

package/dist/deps/misc/directory-scanner.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectoryScanner = void 0;
+const fs = __importStar(require("fs"));
+const fse = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const _1 = require(".");
+const strings_1 = require("./strings");
+const DEFAULT_OPTIONS = { predicate: () => true, startingPointMustExist: true };
+// TODO(imaman): use RepoRoot, PathInRepo
+class DirectoryScanner {
+    constructor(rootDir, options) {
+        this.rootDir = rootDir;
+        if (!path.isAbsolute(rootDir)) {
+            throw new Error(`rootDir must be absolute`);
+        }
+        this.rootDir = path.normalize(rootDir);
+        this.options = options ?? DEFAULT_OPTIONS;
+    }
+    isValid(relativePath, stat) {
+        if (!this.options.predicate) {
+            return true;
+        }
+        return this.options.predicate(relativePath, stat);
+    }
+    async scanTree(...a) {
+        const cb = a.length === 2 ? a[1] : a.length === 3 ? a[2] : (0, _1.shouldNeverHappen)(a);
+        const options = a.length === 2 ? DEFAULT_OPTIONS : a.length === 3 ? a[1] : (0, _1.shouldNeverHappen)(a);
+        const startingPoint = a.length === 2 ? a[0] : a.length === 3 ? a[0] : (0, _1.shouldNeverHappen)(a);
+        await this.scanTreeImpl(startingPoint, options, undefined, cb);
+    }
+    /**
+     * Recursively scans a file tree, returning relative paths to all files.
+     * @param startingPoint a relative path to start scanning files at. It is resolved to an absolute path by joining it
+     * to the root-dir value passed to the constructor. Trailing path separators are omitted (i.e. `'a/b///'` is
+     * equivalent to `'a/b'`).
+     * @returns an array of relative paths (relative from the `root` path  passed to the constructor)
+     */
+    async listPaths(startingPoint, options) {
+        const ret = [];
+        await this.scanTreeImpl(startingPoint, { ...DEFAULT_OPTIONS, ...options }, p => {
+            ret.push(p);
+        });
+        return ret;
+    }
+    /**
+     * Returns relative paths to all files at the file tree rooted at the given directory.
+     * @param dir directory to scan files under
+     * @returns an array of relative paths (relative to `dir`)
+     */
+    static async listPaths(dir, options) {
+        return await new DirectoryScanner(dir).listPaths('', options);
+    }
+    async scanTreeImpl(startingPoint, options, pathCallback, cb) {
+        const startingPointMustExist = options.startingPointMustExist ?? true;
+        if (path.isAbsolute(startingPoint)) {
+            throw new Error(`relativePath must be relative`);
+        }
+        const trimmedStartingPoint = (0, strings_1.trimTrailing)(startingPoint, path.sep);
+        const resolvedPath = path.normalize(path.join(this.rootDir, trimmedStartingPoint));
+        const exists = await fse.pathExists(resolvedPath);
+        if (!exists) {
+            if (startingPointMustExist) {
+                throw new Error(`Starting point does not exist (${resolvedPath})`);
+            }
+            return;
+        }
+        const predicate = (relativePath, stats) => runPred(relativePath, stats, this.options.predicate) && runPred(relativePath, stats, options.predicate);
+        await this.scanFileTree(resolvedPath, predicate, pathCallback, cb);
+    }
+    async scanFileTree(resolvedPath, predicate, pathCallback, cb) {
+        const relativePath = path.normalize(path.relative(this.rootDir, resolvedPath));
+        const stat = await this.getStat(resolvedPath);
+        if (relativePath !== '.' && !predicate(relativePath, stat)) {
+            return;
+        }
+        if (!stat.isDirectory()) {
+            if (cb) {
+                const content = this.readContent(resolvedPath, stat);
+                cb(relativePath, content, stat);
+            }
+            if (pathCallback) {
+                pathCallback(relativePath);
+            }
+            return;
+        }
+        const files = await this.readDirSorted(resolvedPath);
+        // TODO(imaman): make this loop concurrent. we need to use p-qeueu to avoid too much concurrency.
+        for (const file of files) {
+            await this.scanFileTree(path.join(resolvedPath, file), predicate, pathCallback, cb);
+        }
+    }
+    readContent(resolvedPath, stat) {
+        try {
+            if (stat.isSymbolicLink()) {
+                return Buffer.from(fs.readlinkSync(resolvedPath));
+            }
+            return fs.readFileSync(resolvedPath);
+        }
+        catch (e) {
+            throw new Error(`failed to read ${stat.isSymbolicLink() ? 'symbolic link' : 'file'} at ${resolvedPath}: ${e}`);
+        }
+    }
+    // IMPORTANT!
+    // It is very hard to properly test this function because it is hard to create a situation in which the underlying
+    // readdir() call will actually return a list which is not sortred. On the other hand, we cannot assume that, so
+    // we do have to proactively sort the list (but we cannot really write a test that will fail if we drop the line that
+    // does the sorting).
+    async readDirSorted(resolvedPath) {
+        try {
+            const ret = await fse.readdir(resolvedPath);
+            ret.sort();
+            return ret;
+        }
+        catch (e) {
+            throw new Error(`Cannot readdir ${resolvedPath}: ${e}`);
+        }
+    }
+    async getStat(resolvedPath) {
+        // This function is mainly for providing a human-readable error message with a menaingful stacktrace (fs-extra uses
+        // native calls which do not have a stacktrace).
+        try {
+            return fs.lstatSync(resolvedPath);
+        }
+        catch (e) {
+            throw new Error(`Cannot stat ${resolvedPath}: ${e}`);
+        }
+    }
+}
+exports.DirectoryScanner = DirectoryScanner;
+const runPred = (relativePath, stats, p) => (p ? p(relativePath, stats) : true);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/deps/misc/executor.d.ts

@@ -0,0 +1,39 @@
+import PQueue from 'p-queue';
+/**
+ * Allows tasks (promises) to be executed with controlled concurrency, providing error-handling ("fail fast"), and notifications
+ * that allow consumers to track progress. Uses PQueue as the underlying priority queue.
+ *
+ * The execution of a task is essentially calling the callback function passed to the copnstructor (`workToDo`), passing
+ * to it a `T` value (`T` is a generic type, representing information about a single task).
+ *
+ * Fail-fast error handling: once a task is rejected, it is guaranteed that no further tasks will be execute. Tasks that
+ * started running before the rejection will continue to run. Subsequent calls to `schedule()` are allowed but those
+ * scheduled tasks will not be executed.
+ *
+ * Progress notifications: consumers can use `subscribe()` to register a handler that will be called whenever some
+ * progress in made (including progress due to task failures, or tasks that are no-op due to a previous failure).
+ */
+export declare class Executor<T> {
+    private readonly queue;
+    private readonly workToDo;
+    private firstError;
+    private publisher;
+    constructor(queue: PQueue, workToDo: (t: T) => Promise<void>);
+    /**
+     * Schedules a task to be executed. A task will be executed only if no earlier-executed task has failed.
+     * @param task information about the task to execute
+     */
+    schedule(task: T): void;
+    /**
+     * Registers handler to be called when any task settles (either succeeds or fails or is no-op due to an earlier
+     * failure). Once handler is registered, it is guranateed to be called exactly once for every subsequently scheduled
+     * task. A handler is not called for previously executed tasks. Handlers are call
+     *
+     * @param handler the callback function to register
+     */
+    subscribe(handler: (arg: {
+        lastSettled: T;
+        error?: unknown;
+    }) => void): void;
+    private process;
+}

package/dist/deps/misc/executor.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Executor = void 0;
+const typed_publisher_1 = require("./typed-publisher");
+/**
+ * Allows tasks (promises) to be executed with controlled concurrency, providing error-handling ("fail fast"), and notifications
+ * that allow consumers to track progress. Uses PQueue as the underlying priority queue.
+ *
+ * The execution of a task is essentially calling the callback function passed to the copnstructor (`workToDo`), passing
+ * to it a `T` value (`T` is a generic type, representing information about a single task).
+ *
+ * Fail-fast error handling: once a task is rejected, it is guaranteed that no further tasks will be execute. Tasks that
+ * started running before the rejection will continue to run. Subsequent calls to `schedule()` are allowed but those
+ * scheduled tasks will not be executed.
+ *
+ * Progress notifications: consumers can use `subscribe()` to register a handler that will be called whenever some
+ * progress in made (including progress due to task failures, or tasks that are no-op due to a previous failure).
+ */
+class Executor {
+    constructor(queue, workToDo) {
+        this.queue = queue;
+        this.workToDo = workToDo;
+        this.publisher = new typed_publisher_1.TypedPublisher();
+    }
+    /**
+     * Schedules a task to be executed. A task will be executed only if no earlier-executed task has failed.
+     * @param task information about the task to execute
+     */
+    schedule(task) {
+        this.queue.add(async () => this.process(task));
+    }
+    /**
+     * Registers handler to be called when any task settles (either succeeds or fails or is no-op due to an earlier
+     * failure). Once handler is registered, it is guranateed to be called exactly once for every subsequently scheduled
+     * task. A handler is not called for previously executed tasks. Handlers are call
+     *
+     * @param handler the callback function to register
+     */
+    subscribe(handler) {
+        return this.publisher.on('progressMade', handler);
+    }
+    async process(task) {
+        if (!this.firstError) {
+            try {
+                await this.workToDo(task);
+            }
+            catch (e) {
+                if (!this.firstError) {
+                    this.firstError = e;
+                }
+            }
+        }
+        // The event that is published intentionally includes an exception, even if it was emitted from the execution of
+        // some other vertex. This makes event handling easier on the subscriber side.
+        await this.publisher.publish('progressMade', { lastSettled: task, error: this.firstError });
+    }
+}
+exports.Executor = Executor;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhlY3V0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZXhlY3V0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUEsdURBQWtEO0FBRWxEOzs7Ozs7Ozs7Ozs7O0dBYUc7QUFDSCxNQUFhLFFBQVE7SUFLbkIsWUFBNkIsS0FBYSxFQUFtQixRQUFpQztRQUFqRSxVQUFLLEdBQUwsS0FBSyxDQUFRO1FBQW1CLGFBQVEsR0FBUixRQUFRLENBQXlCO1FBRnRGLGNBQVMsR0FBRyxJQUFJLGdDQUFjLEVBQXlELENBQUE7SUFFRSxDQUFDO0lBRWxHOzs7T0FHRztJQUNILFFBQVEsQ0FBQyxJQUFPO1FBQ2QsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsS0FBSyxJQUFJLEVBQUUsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUE7SUFDaEQsQ0FBQztJQUVEOzs7Ozs7T0FNRztJQUNILFNBQVMsQ0FBQyxPQUEyRDtRQUNuRSxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLGNBQWMsRUFBRSxPQUFPLENBQUMsQ0FBQTtJQUNuRCxDQUFDO0lBRU8sS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFPO1FBQzNCLElBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7WUFDckIsSUFBSSxDQUFDO2dCQUNILE1BQU0sSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQTtZQUMzQixDQUFDO1lBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztnQkFDWCxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO29CQUNyQixJQUFJLENBQUMsVUFBVSxHQUFHLENBQUMsQ0FBQTtnQkFDckIsQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDO1FBRUQsZ0hBQWdIO1FBQ2hILDhFQUE4RTtRQUM5RSxNQUFNLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLGNBQWMsRUFBRSxFQUFFLFdBQVcsRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQyxDQUFBO0lBQzdGLENBQUM7Q0FDRjtBQXpDRCw0QkF5Q0MifQ==

package/dist/deps/misc/file-system-storage-client.d.ts

@@ -0,0 +1,23 @@
+import { Key, StorageClient } from './storage-client';
+interface Options {
+    /**
+     * If defined, cleanup of the directory will be triggered if the toal size (in bytes) of all files in the directory
+     * exceeds this value. If undefined, no cleanup will take place.
+     */
+    triggerCleanupIfByteSizeExceeds?: number;
+}
+export declare class FilesystemStorageClient implements StorageClient {
+    private readonly dir;
+    private constructor();
+    static create(dir: string, options?: Options): Promise<FilesystemStorageClient>;
+    private keyToPath;
+    private hashToPath;
+    putObject(key: Key, content: string | Buffer): Promise<void>;
+    putContentAddressable(content: string | Buffer): Promise<string>;
+    getContentAddressable(hash: string): Promise<Buffer>;
+    getObject(key: Key): Promise<string>;
+    getObject(key: Key, type: 'string'): Promise<string>;
+    getObject(key: Key, type: 'buffer'): Promise<Buffer>;
+    objectExists(key: Key): Promise<boolean>;
+}
+export {};

package/dist/deps/misc/file-system-storage-client.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilesystemStorageClient = void 0;
+const fse = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const _1 = require(".");
+const clean_directory_1 = require("./clean-directory");
+const misc_1 = require("./misc");
+class FilesystemStorageClient {
+    constructor(dir) {
+        this.dir = dir;
+    }
+    static async create(dir, options) {
+        await fse.ensureDir(dir);
+        const { triggerCleanupIfByteSizeExceeds } = options ?? {};
+        if (triggerCleanupIfByteSizeExceeds) {
+            (0, clean_directory_1.cleanDirectory)(dir, 0.5, triggerCleanupIfByteSizeExceeds);
+        }
+        return new FilesystemStorageClient(dir);
+    }
+    keyToPath(key) {
+        return this.hashToPath('std', (0, misc_1.computeObjectHash)({ key }));
+    }
+    hashToPath(middle, s) {
+        return path.join(this.dir, `${middle}-${s}`);
+    }
+    async putObject(key, content) {
+        await fse.writeFile(this.keyToPath(key), content);
+    }
+    async putContentAddressable(content) {
+        const ret = (0, misc_1.computeHash)(content);
+        const p = this.hashToPath('cas', ret);
+        await fse.writeFile(p, content);
+        return ret;
+    }
+    async getContentAddressable(hash) {
+        const p = this.hashToPath('cas', hash);
+        return await fse.readFile(p);
+    }
+    async getObject(key, type = 'string') {
+        const p = this.keyToPath(key);
+        try {
+            if (type === 'string') {
+                return await fse.readFile(p, 'utf-8');
+            }
+            if (type === 'buffer') {
+                return await fse.readFile(p);
+            }
+            (0, _1.shouldNeverHappen)(type);
+        }
+        catch (e) {
+            throw new Error(`getObject() failed to read file for key: ${JSON.stringify(key)}: ${e}`);
+        }
+    }
+    async objectExists(key) {
+        return await fse.pathExists(this.keyToPath(key));
+    }
+}
+exports.FilesystemStorageClient = FilesystemStorageClient;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/deps/misc/folderify.d.ts

@@ -0,0 +1,8 @@
+type Jsonable = {
+    [x: string]: string | number | boolean | string[] | number[] | boolean | Jsonable | Jsonable[];
+};
+export type FolderifyRecipe = Record<string, string | Jsonable>;
+export declare function folderify(prefix: string, recipe: FolderifyRecipe): Promise<string>;
+export declare function folderify(recipe: FolderifyRecipe): Promise<string>;
+export declare function writeRecipe(destinationDir: string, recipe: FolderifyRecipe): Promise<void>;
+export {};

package/dist/deps/misc/folderify.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.folderify = folderify;
+exports.writeRecipe = writeRecipe;
+const fse = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const Tmp = __importStar(require("tmp-promise"));
+const constructs_1 = require("./constructs");
+async function folderify(...args) {
+    const recipe = args.length === 2 ? args[1] : args.length === 1 ? args[0] : (0, constructs_1.shouldNeverHappen)(args);
+    const prefix = args.length === 2 ? args[0] : args.length === 1 ? '' : (0, constructs_1.shouldNeverHappen)(args);
+    const ret = (await Tmp.dir()).path;
+    await writeRecipe(path.join(ret, prefix), recipe);
+    return ret;
+}
+async function writeRecipe(destinationDir, recipe) {
+    const keys = Object.keys(recipe).map(p => path.normalize(p));
+    const set = new Set(keys);
+    for (const key of keys) {
+        if (key === '.') {
+            throw new Error(`bad input - the recipe contains a file name which is either empty ('') or a dot ('.')`);
+        }
+        let curr = key;
+        while (true) {
+            curr = path.dirname(curr);
+            if (curr === '.') {
+                break;
+            }
+            if (set.has(curr)) {
+                throw new Error(`bad input - a file (${key}) is nested under another file (${curr})`);
+            }
+        }
+    }
+    const createFile = async (relativePath, content) => {
+        const file = path.join(destinationDir, relativePath);
+        const dir = path.dirname(file);
+        await fse.mkdirp(dir);
+        try {
+            if (typeof content === 'string') {
+                await fse.writeFile(file, content);
+            }
+            else {
+                await fse.writeJSON(file, content);
+            }
+        }
+        catch (e) {
+            throw new Error(`writeRecipe() failed to write file ${relativePath} under ${destinationDir}: ${e}`);
+        }
+    };
+    // TODO(imaman): Use promises()
+    await Promise.all(Object.entries(recipe).map(async ([key, value]) => await createFile(key, value)));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/deps/misc/graph.d.ts

@@ -0,0 +1,29 @@
+import { ObjectMap } from './object-map';
+interface TraverseOptions {
+    direction: 'forward' | 'backwards';
+}
+export declare class Graph<V> {
+    private readonly vToId;
+    private readonly vertexMap;
+    constructor(vToId: (v: V) => string);
+    copy(): Graph<V>;
+    edge(from: V, to: V): void;
+    private toVertex;
+    vertex(v: V): void;
+    remove(v: V): void;
+    vertices(): V[];
+    outDegree(v: V): number;
+    neighborsOf(v: V): V[];
+    backNeighborsOf(v: V): V[];
+    roots(): V[];
+    traverseFrom(startingPoints: V, options?: TraverseOptions): V[];
+    traverseFrom(startingPoints: V[], options?: TraverseOptions): V[];
+    toJSON(): Record<string, string[]>;
+    toString(): string;
+    static fromJSON(json: Record<string, string[]>): Graph<string>;
+    isCyclic(): boolean;
+    execute(concurrency: number, workToDo: (v: V) => Promise<void>, batchScheduler?: BatchScheduler<V>): Promise<void>;
+    makeVertexMap<T>(): ObjectMap<V, T>;
+}
+export type BatchScheduler<V> = (batch: V[]) => Graph<V> | undefined;
+export {};