@gadgetinc/ggt 0.1.16 → 0.1.18

package/lib/commands/sync.js

@@ -12,7 +12,6 @@ const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const inquirer_1 = require("inquirer");
 const lodash_1 = require("lodash");
 const lodash_2 = require("lodash");
-const lodash_3 = require("lodash");
 const normalize_path_1 = tslib_1.__importDefault(require("normalize-path"));
 const p_map_1 = tslib_1.__importDefault(require("p-map"));
 const p_queue_1 = tslib_1.__importDefault(require("p-queue"));
@@ -27,6 +26,7 @@ const errors_1 = require("../utils/errors");
 const flags_1 = require("../utils/flags");
 const fs_utils_1 = require("../utils/fs-utils");
 const graphql_1 = require("../__generated__/graphql");
+const promise_1 = require("../utils/promise");
 class Sync extends base_command_1.BaseCommand {
     constructor() {
         super(...arguments);
@@ -36,96 +36,151 @@ class Sync extends base_command_1.BaseCommand {
             writable: true,
             value: true
         });
+        /**
+         * The current status of the sync process.
+         */
         Object.defineProperty(this, "status", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: SyncStatus.STARTING
         });
+        /**
+         * The absolute path to the directory to sync files to.
+         */
         Object.defineProperty(this, "dir", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "recentWrites", {
+        /**
+         * A list of filepaths that have changed because of a remote file-sync event. This is used to avoid sending files that
+         * we recently received from a remote file-sync event.
+         */
+        Object.defineProperty(this, "recentRemoteChanges", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: new Set()
         });
+        /**
+         * A FIFO async callback queue that ensures we process file-sync events in the order they occurred.
+         */
         Object.defineProperty(this, "queue", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: new p_queue_1.default({ concurrency: 1 })
         });
+        /**
+         * A GraphQL client connected to the app's /edit/api/graphql-ws endpoint
+         */
         Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * Loads the .ignore file and provides methods for checking if a file should be ignored.
+         */
         Object.defineProperty(this, "ignorer", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * Watches the local filesystem for changes.
+         */
         Object.defineProperty(this, "watcher", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * Holds information about the state of the local filesystem. It's persisted to `.gadget/sync.json`.
+         */
         Object.defineProperty(this, "metadata", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: {
+                /**
+                 * The app this filesystem is synced to.
+                 */
                 app: "",
+                /**
+                 * The last filesVersion that was successfully written to the filesystem. This is used to determine if the remote
+                 * filesystem is ahead of the local one.
+                 */
                 filesVersion: "0",
+                /**
+                 * The largest mtime that was seen on the local filesystem before `ggt sync` stopped. This is used to determine if
+                 * the local filesystem has changed since the last sync.
+                 *
+                 * Note: This does not include the mtime of files that are ignored.
+                 */
                 mtime: 0,
             }
         });
+        /**
+         * A debounced function that enqueue's local file changes to be sent to Gadget.
+         */
         Object.defineProperty(this, "publish", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * Gracefully stops the sync.
+         */
         Object.defineProperty(this, "stop", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "finished", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "markFinished", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
     }
+    /**
+     * Turns an absolute filepath into a relative one from {@linkcode dir}.
+     */
     relative(to) {
         return path_1.default.relative(this.dir, to);
     }
+    /**
+     * Combines path segments into an absolute filepath that starts at {@linkcode dir}.
+     */
     absolute(...pathSegments) {
         return path_1.default.resolve(this.dir, ...pathSegments);
     }
-    normalize(filepath, isDirectory = false) {
+    /**
+     * Similar to {@linkcode relative} in that it turns a filepath into a relative one from {@linkcode dir}. However, it
+     * also changes any slashes to be posix/unix-like forward slashes, condenses repeated slashes into a single slash, and
+     * adds a trailing slash if the filepath is a directory.
+     *
+     * This is used when sending file-sync events to Gadget to ensure that the paths are consistent across platforms.
+     *
+     * @see https://www.npmjs.com/package/normalize-path
+     */
+    normalize(filepath, isDirectory) {
         return (0, normalize_path_1.default)(path_1.default.isAbsolute(filepath) ? this.relative(filepath) : filepath) + (isDirectory ? "/" : "");
     }
+    /**
+     * Pretty-prints changed and deleted filepaths to the console.
+     *
+     * @param prefix The prefix to print before each line.
+     * @param changed The normalized paths that have changed.
+     * @param deleted The normalized paths that have been deleted.
+     * @param options.limit The maximum number of lines to print. Defaults to 10. If debug is enabled, this is ignored.
+     */
     logPaths(prefix, changed, deleted, { limit = 10 } = {}) {
         const lines = (0, lodash_1.sortBy)([
-            ...changed.map((filepath) => (0, chalk_1.default) `{green ${prefix}} ${this.normalize(filepath)} {gray (changed)}`),
-            ...deleted.map((filepath) => (0, chalk_1.default) `{red ${prefix}} ${this.normalize(filepath)} {gray (deleted)}`),
+            ...changed.map((normalizedPath) => (0, chalk_1.default) `{green ${prefix}} ${normalizedPath} {gray (changed)}`),
+            ...deleted.map((normalizedPath) => (0, chalk_1.default) `{red ${prefix}} ${normalizedPath} {gray (deleted)}`),
         ], (line) => line.slice(line.indexOf(" ") + 1));
         let logged = 0;
         for (const line of lines) {
@@ -139,9 +194,16 @@ class Sync extends base_command_1.BaseCommand {
         this.log((0, chalk_1.default) `{gray ${(0, pluralize_1.default)("file", lines.length, true)} in total. ${changed.length} changed, ${deleted.length} deleted.}`);
         this.log();
     }
+    /**
+     * Initializes the sync process.
+     * - Ensures the directory exists.
+     * - Ensures the directory is empty or contains a `.gadget/sync.json` file.
+     * - Ensures an app is selected and that it matches the app the directory was previously synced to.
+     * - Ensures yarn v1 is installed.
+     * - Prompts the user how to resolve conflicts if the local filesystem has changed since the last sync.
+     */
     async init() {
         await super.init();
-        (0, assert_1.default)((0, lodash_2.isString)(this.args["directory"]));
         this.dir =
             this.config.windows && this.args["directory"].startsWith("~/")
                 ? path_1.default.join(this.config.home, this.args["directory"].slice(2))
@@ -182,7 +244,7 @@ class Sync extends base_command_1.BaseCommand {
         await context_1.context.setApp(this.metadata.app);
         this.client = new client_1.Client();
         // local files/folders that should never be published
-        this.ignorer = new fs_utils_1.Ignorer(this.dir, ["node_modules", ".gadget", ".git"]);
+        this.ignorer = new fs_utils_1.FSIgnorer(this.dir, ["node_modules", ".gadget", ".git"]);
         this.watcher = new chokidar_1.FSWatcher({
             ignored: (filepath) => this.ignorer.ignores(filepath),
             // don't emit an event for every watched file on boot
@@ -201,14 +263,14 @@ class Sync extends base_command_1.BaseCommand {
         const hasRemoteChanges = BigInt(remoteFilesVersion) > BigInt(this.metadata.filesVersion);
         const getChangedFiles = async () => {
             const files = new Map();
-            for await (const filepath of (0, fs_utils_1.walkDir)(this.dir, { ignorer: this.ignorer })) {
-                const stats = await fs_extra_1.default.stat(filepath);
+            for await (const absolutePath of (0, fs_utils_1.walkDir)(this.dir, { ignorer: this.ignorer })) {
+                const stats = await fs_extra_1.default.stat(absolutePath);
                 if (stats.mtime.getTime() > this.metadata.mtime) {
-                    files.set(this.absolute(filepath), stats);
+                    files.set(this.normalize(absolutePath, stats.isDirectory()), stats);
                 }
             }
-            // don't include the root directory
-            files.delete(this.dir);
+            // never include the root directory
+            files.delete("/");
             return files;
         };
         const changedFiles = await getChangedFiles();
@@ -232,21 +294,22 @@ class Sync extends base_command_1.BaseCommand {
             case Action.MERGE: {
                 // get all the changed files again in case more changed
                 const files = await getChangedFiles();
-                // we purposefully don't set the returned remoteFilesVersion here because we haven't processed the in-between versions yet
+                // We purposefully don't set the returned remoteFilesVersion here because we haven't received the remote changes
+                // yet. This will cause us to receive the local files that we just published + the remote files that were
+                // changed since the last sync.
                 await this.client.queryUnwrap({
                     query: exports.PUBLISH_FILE_SYNC_EVENTS_MUTATION,
                     variables: {
                         input: {
                             expectedRemoteFilesVersion: remoteFilesVersion,
-                            changed: await (0, p_map_1.default)(files, async ([filepath, stats]) => {
+                            changed: await (0, p_map_1.default)(files, async ([normalizedPath, stats]) => {
                                 if (stats.mtime.getTime() > this.metadata.mtime) {
                                     this.metadata.mtime = stats.mtime.getTime();
                                 }
-                                const isDirectory = stats.isDirectory();
                                 return {
-                                    path: this.normalize(filepath, isDirectory),
+                                    path: normalizedPath,
                                     mode: stats.mode,
-                                    content: isDirectory ? "" : await fs_extra_1.default.readFile(filepath, "base64"),
+                                    content: stats.isDirectory() ? "" : await fs_extra_1.default.readFile(this.absolute(normalizedPath), "base64"),
                                     encoding: graphql_1.FileSyncEncoding.Base64,
                                 };
                             }),
@@ -257,7 +320,9 @@ class Sync extends base_command_1.BaseCommand {
                 break;
             }
             case Action.RESET: {
-                await (0, p_map_1.default)(changedFiles, ([filepath]) => fs_extra_1.default.remove(filepath));
+                // delete all the local files that have changed since the last sync and set the files version to 0 so we receive
+                // all the remote files again, including any files that we just deleted that still exist
+                await (0, p_map_1.default)(changedFiles.keys(), (normalizedPath) => fs_extra_1.default.remove(this.absolute(normalizedPath)));
                 this.metadata.filesVersion = "0";
                 break;
             }
@@ -267,11 +332,12 @@ class Sync extends base_command_1.BaseCommand {
         }
         this.debug("started");
     }
+    /**
+     * Runs the sync process until it is stopped or an error occurs.
+     */
     async run() {
         let error;
-        this.finished = new Promise((resolve) => {
-            this.markFinished = resolve;
-        });
+        const stopped = new promise_1.PromiseSignal();
         this.stop = async (e) => {
             if (this.status != SyncStatus.RUNNING)
                 return;
@@ -289,7 +355,7 @@ class Sync extends base_command_1.BaseCommand {
                 await Promise.allSettled([this.watcher.close(), this.client.dispose()]);
                 this.debug("stopped");
                 this.status = SyncStatus.STOPPED;
-                this.markFinished();
+                stopped.resolve();
             }
         };
         for (const signal of ["SIGINT", "SIGTERM"]) {
@@ -313,13 +379,14 @@ class Sync extends base_command_1.BaseCommand {
             variables: () => ({ localFilesVersion: this.metadata.filesVersion }),
         }, {
             error: (error) => void this.stop(error),
-            next: ({ remoteFileSyncEvents: { remoteFilesVersion, changed, deleted } }) => {
-                const remoteFiles = new Map([...deleted, ...changed]
-                    .filter((event) => event.path.startsWith(".gadget/") || !this.ignorer.ignores(event.path))
-                    .map((e) => [e.path, e]));
-                void this.queue
-                    .add(async () => {
-                    if (!remoteFiles.size) {
+            next: ({ remoteFileSyncEvents }) => {
+                const remoteFilesVersion = remoteFileSyncEvents.remoteFilesVersion;
+                // we always ignore .gadget/ files so that we don't publish them (they're managed by gadget), but we still want to receive them
+                const filter = (event) => event.path.startsWith(".gadget/") || !this.ignorer.ignores(event.path);
+                const changed = remoteFileSyncEvents.changed.filter(filter);
+                const deleted = remoteFileSyncEvents.deleted.filter(filter);
+                this._enqueue(async () => {
+                    if (!changed.length && !deleted.length) {
                         if (BigInt(remoteFilesVersion) > BigInt(this.metadata.filesVersion)) {
                             // we still need to update filesVersion, otherwise our expectedFilesVersion will be behind the next time we publish
                             this.debug("updated local files version from %s to %s", this.metadata.filesVersion, remoteFilesVersion);
@@ -328,131 +395,130 @@ class Sync extends base_command_1.BaseCommand {
                         return;
                     }
                     this.log((0, chalk_1.default) `Received {gray ${(0, format_1.default)(new Date(), "pp")}}`);
-                    this.logPaths("←", changed.map((x) => x.path).filter((x) => remoteFiles.has(x)), deleted.map((x) => x.path).filter((x) => remoteFiles.has(x)));
-                    const handleFiles = async (files) => await (0, p_map_1.default)(files, async (file) => {
-                        if (!remoteFiles.has(file.path)) {
+                    this.logPaths("←", changed.map((x) => x.path), deleted.map((x) => x.path));
+                    // we need to processed deleted files first as we may delete an empty directory after a file has been put
+                    // into it. if processed out of order the new file is deleted as well
+                    await (0, p_map_1.default)(deleted, async (file) => {
+                        this.recentRemoteChanges.add(file.path);
+                        await fs_extra_1.default.remove(this.absolute(file.path));
+                    });
+                    await (0, p_map_1.default)(changed, async (file) => {
+                        this.recentRemoteChanges.add(file.path);
+                        const absolutePath = this.absolute(file.path);
+                        if (file.path.endsWith("/")) {
+                            await fs_extra_1.default.ensureDir(absolutePath, { mode: 0o755 });
                             return;
                         }
-                        const filepath = this.absolute(file.path);
-                        this.recentWrites.add(filepath);
-                        if ("content" in file) {
-                            if (!file.path.endsWith("/")) {
-                                this.recentWrites.add(path_1.default.dirname(filepath));
-                                await fs_extra_1.default.ensureDir(path_1.default.dirname(filepath), { mode: 0o755 });
-                                await fs_extra_1.default.writeFile(filepath, Buffer.from(file.content, file.encoding ?? graphql_1.FileSyncEncoding.Utf8), {
-                                    mode: file.mode,
-                                });
-                            }
-                            else {
-                                await fs_extra_1.default.ensureDir(filepath, { mode: 0o755 });
-                            }
-                            if (filepath == this.absolute("yarn.lock")) {
-                                await (0, execa_1.default)("yarn", ["install"], { cwd: this.dir }).catch((err) => {
-                                    this.debug("yarn install failed");
-                                    this.debug(err.message);
-                                });
-                            }
-                        }
-                        else {
-                            await fs_extra_1.default.remove(filepath);
+                        // we need to add the parent directory to recentRemoteChanges so that we don't try to publish it
+                        this.recentRemoteChanges.add(path_1.default.dirname(file.path) + "/");
+                        await fs_extra_1.default.ensureDir(path_1.default.dirname(absolutePath), { mode: 0o755 });
+                        await fs_extra_1.default.writeFile(absolutePath, Buffer.from(file.content, file.encoding), { mode: file.mode });
+                        if (absolutePath == this.absolute("yarn.lock")) {
+                            await (0, execa_1.default)("yarn", ["install"], { cwd: this.dir }).catch((err) => {
+                                this.debug("yarn install failed");
+                                this.debug(err.message);
+                            });
                         }
-                        if (filepath == this.ignorer.filepath) {
+                        if (absolutePath == this.ignorer.filepath) {
                             this.ignorer.reload();
                         }
-                    }, { stopOnError: false });
-                    // we need to processed deleted files first as we may delete an empty directory once a file has been put into it. if processed out of order the new file is deleted as well
-                    await handleFiles(deleted);
-                    await handleFiles(changed);
+                    });
                     this.debug("updated local files version from %s to %s", this.metadata.filesVersion, remoteFilesVersion);
                     this.metadata.filesVersion = remoteFilesVersion;
-                })
-                    .catch(this.stop);
+                    // always remove the root directory from recentRemoteChanges
+                    this.recentRemoteChanges.delete("./");
+                    // remove any files in recentRemoteChanges that are ignored (e.g. .gadget/ files)
+                    for (const filepath of this.recentRemoteChanges) {
+                        if (this.ignorer.ignores(filepath)) {
+                            this.recentRemoteChanges.delete(filepath);
+                        }
+                    }
+                });
             },
         });
         const localFilesBuffer = new Map();
-        this.publish = (0, lodash_3.debounce)(() => {
+        this.publish = (0, lodash_2.debounce)(() => {
             const localFiles = new Map(localFilesBuffer.entries());
             localFilesBuffer.clear();
-            void this.queue
-                .add(async () => {
+            this._enqueue(async () => {
                 const changed = [];
                 const deleted = [];
-                await (0, p_map_1.default)(localFiles, async ([filepath, file]) => {
+                await (0, p_map_1.default)(localFiles, async ([normalizedPath, file]) => {
                     if ("isDeleted" in file) {
-                        deleted.push({ path: this.normalize(filepath, file.isDirectory) });
+                        deleted.push({ path: normalizedPath });
+                        return;
                     }
-                    else {
-                        try {
-                            changed.push({
-                                path: this.normalize(filepath, file.isDirectory),
-                                mode: file.mode,
-                                content: file.isDirectory ? "" : await fs_extra_1.default.readFile(filepath, "base64"),
-                                encoding: graphql_1.FileSyncEncoding.Base64,
-                            });
-                        }
-                        catch (error) {
-                            // A file could have been changed and then deleted before we process the change event, so the readFile above will raise
-                            // an ENOENT. This is normal operation, so just ignore this event.
-                            (0, fs_utils_1.ignoreEnoent)(error);
-                        }
+                    try {
+                        changed.push({
+                            path: normalizedPath,
+                            mode: file.mode,
+                            content: file.isDirectory ? "" : await fs_extra_1.default.readFile(this.absolute(normalizedPath), "base64"),
+                            encoding: graphql_1.FileSyncEncoding.Base64,
+                        });
                     }
-                }, { stopOnError: false });
-                if (changed.length > 0 || deleted.length > 0) {
-                    const data = await this.client.queryUnwrap({
-                        query: exports.PUBLISH_FILE_SYNC_EVENTS_MUTATION,
-                        variables: { input: { expectedRemoteFilesVersion: this.metadata.filesVersion, changed, deleted } },
-                    });
-                    this.log((0, chalk_1.default) `Sent {gray ${(0, format_1.default)(new Date(), "pp")}}`);
-                    this.logPaths("→", changed.map((x) => x.path), deleted.map((x) => x.path));
-                    const { remoteFilesVersion } = data.publishFileSyncEvents;
-                    this.debug("remote files version after publishing %s", remoteFilesVersion);
-                    if (BigInt(remoteFilesVersion) > BigInt(this.metadata.filesVersion)) {
-                        this.debug("updated local files version from %s to %s", this.metadata.filesVersion, remoteFilesVersion);
-                        this.metadata.filesVersion = remoteFilesVersion;
+                    catch (error) {
+                        // A file could have been changed and then deleted before we process the change event, so the readFile
+                        // above will raise an ENOENT. This is normal operation, so just ignore this event.
+                        (0, fs_utils_1.ignoreEnoent)(error);
                     }
+                });
+                if (!changed.length && !deleted.length) {
+                    return;
+                }
+                const data = await this.client.queryUnwrap({
+                    query: exports.PUBLISH_FILE_SYNC_EVENTS_MUTATION,
+                    variables: { input: { expectedRemoteFilesVersion: this.metadata.filesVersion, changed, deleted } },
+                });
+                this.log((0, chalk_1.default) `Sent {gray ${(0, format_1.default)(new Date(), "pp")}}`);
+                this.logPaths("→", changed.map((x) => x.path), deleted.map((x) => x.path));
+                const { remoteFilesVersion } = data.publishFileSyncEvents;
+                this.debug("remote files version after publishing %s", remoteFilesVersion);
+                if (BigInt(remoteFilesVersion) > BigInt(this.metadata.filesVersion)) {
+                    this.debug("updated local files version from %s to %s", this.metadata.filesVersion, remoteFilesVersion);
+                    this.metadata.filesVersion = remoteFilesVersion;
                 }
-            })
-                .catch(this.stop);
+            });
         }, this.flags["file-push-delay"]);
         this.watcher
             .add(`${this.dir}/**/*`)
             .on("error", (error) => void this.stop(error))
-            .on("all", (event, filepath, stats) => {
-            const relativePath = this.relative(filepath);
+            .on("all", (event, absolutePath, stats) => {
+            const normalizedPath = this.normalize(absolutePath, event == "addDir" || event == "unlinkDir");
             if (stats?.isSymbolicLink?.()) {
-                this.debug("skipping event caused by symlink %s", relativePath);
+                this.debug("skipping event caused by symlink %s", normalizedPath);
                 return;
             }
-            if (filepath == this.ignorer.filepath) {
+            if (absolutePath == this.ignorer.filepath) {
                 this.ignorer.reload();
             }
-            else if (this.ignorer.ignores(filepath)) {
-                this.debug("skipping event caused by ignored file %s", relativePath);
+            else if (this.ignorer.ignores(absolutePath)) {
+                this.debug("skipping event caused by ignored file %s", normalizedPath);
                 return;
             }
-            // we only update the mtime if the file is not ignored, because if we restart and the mtime is set to an ignored file, then it could
-            // be greater than the mtime of all non ignored files and we'll think that local files have changed when only an ignored one has
+            // we only update the mtime if the file is not ignored, because if we restart and the mtime is set to an ignored
+            // file, then it could be greater than the mtime of all non ignored files and we'll think that local files have
+            // changed when only an ignored one has
             if (stats && stats.mtime.getTime() > this.metadata.mtime) {
                 this.metadata.mtime = stats.mtime.getTime();
             }
-            if (this.recentWrites.delete(filepath)) {
-                this.debug("skipping event caused by recent write %s", relativePath);
+            if (this.recentRemoteChanges.delete(normalizedPath)) {
+                this.debug("skipping event caused by recent write %s", normalizedPath);
                 return;
             }
-            this.debug("file changed %s", relativePath, event);
+            this.debug("file changed %s", normalizedPath, event);
             switch (event) {
                 case "add":
                 case "change":
                     (0, assert_1.default)(stats, "missing stats on add/change event");
-                    localFilesBuffer.set(filepath, { mode: stats.mode, mtime: stats.mtime.getTime(), isDirectory: false });
+                    localFilesBuffer.set(normalizedPath, { mode: stats.mode, isDirectory: false });
                     break;
                 case "addDir":
                     (0, assert_1.default)(stats, "missing stats on addDir event");
-                    localFilesBuffer.set(filepath, { mode: stats.mode, mtime: stats.mtime.getTime(), isDirectory: true });
+                    localFilesBuffer.set(normalizedPath, { mode: stats.mode, isDirectory: true });
                     break;
                 case "unlinkDir":
                 case "unlink":
-                    localFilesBuffer.set(filepath, { isDeleted: true, isDirectory: event === "unlinkDir" });
+                    localFilesBuffer.set(normalizedPath, { isDeleted: true, isDirectory: event === "unlinkDir" });
                     break;
             }
             this.publish();
@@ -479,7 +545,7 @@ class Sync extends base_command_1.BaseCommand {
       Watching for file changes... {gray Press Ctrl+C to stop}
     `));
         this.log();
-        await this.finished;
+        await stopped;
         if (error) {
             this.notify({ subtitle: "Uh oh!", message: "An error occurred while syncing files" });
             throw error;
@@ -488,6 +554,14 @@ class Sync extends base_command_1.BaseCommand {
             this.log("Goodbye!");
         }
     }
+    /**
+     * Enqueues a function that handles file-sync events onto the {@linkcode queue}.
+     *
+     * @param fn The function to enqueue.
+     */
+    _enqueue(fn) {
+        void this.queue.add(fn).catch(this.stop);
+    }
 }
 Object.defineProperty(Sync, "priority", {
     enumerable: true,