@gadgetinc/ggt 0.1.17 → 0.2.0

package/lib/commands/sync.js

@@ -1,346 +1,256 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PUBLISH_FILE_SYNC_EVENTS_MUTATION = exports.REMOTE_FILES_VERSION_QUERY = exports.REMOTE_FILE_SYNC_EVENTS_SUBSCRIPTION = exports.Action = exports.SyncStatus = void 0;
-const tslib_1 = require("tslib");
-const core_1 = require("@oclif/core");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const assert_1 = tslib_1.__importDefault(require("assert"));
-const chokidar_1 = require("chokidar");
-const format_1 = tslib_1.__importDefault(require("date-fns/format"));
-const execa_1 = tslib_1.__importDefault(require("execa"));
-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 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"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const pluralize_1 = tslib_1.__importDefault(require("pluralize"));
-const ts_dedent_1 = tslib_1.__importDefault(require("ts-dedent"));
-const which_1 = tslib_1.__importDefault(require("which"));
-const base_command_1 = require("../utils/base-command");
-const client_1 = require("../utils/client");
-const context_1 = require("../utils/context");
-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);
-        Object.defineProperty(this, "requireUser", {
-            enumerable: true,
-            configurable: true,
-            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
-        });
-        /**
-         * 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
-        });
+import { _ as _class_private_field_get } from "@swc/helpers/_/_class_private_field_get";
+import { _ as _class_private_field_init } from "@swc/helpers/_/_class_private_field_init";
+import { _ as _class_private_field_set } from "@swc/helpers/_/_class_private_field_set";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { Args, Flags } from "@oclif/core";
+import assert from "assert";
+import chalkTemplate from "chalk-template";
+import { FSWatcher } from "chokidar";
+import { format } from "date-fns";
+import { execa } from "execa";
+import fs from "fs-extra";
+import inquirer from "inquirer";
+import _ from "lodash";
+import normalizePath from "normalize-path";
+import pMap from "p-map";
+import PQueue from "p-queue";
+import path from "path";
+import pluralize from "pluralize";
+import { dedent } from "ts-dedent";
+import which from "which";
+import { FileSyncEncoding } from "../__generated__/graphql.js";
+import { BaseCommand } from "../utils/base-command.js";
+import { Client } from "../utils/client.js";
+import { context } from "../utils/context.js";
+import { InvalidSyncAppFlagError, InvalidSyncFileError, YarnNotFoundError } from "../utils/errors.js";
+import { app } from "../utils/flags.js";
+import { FSIgnorer, ignoreEnoent, isEmptyDir, walkDir } from "../utils/fs-utils.js";
+import { PromiseSignal } from "../utils/promise.js";
+class Sync extends BaseCommand {
+    /**
+   * Turns an absolute filepath into a relative one from {@linkcode dir}.
+   */ relative(to) {
+        return path.relative(this.dir, to);
     }
     /**
-     * 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.resolve(this.dir, ...pathSegments);
     }
     /**
-     * Combines path segments into an absolute filepath that starts at {@linkcode dir}.
-     */
-    absolute(...pathSegments) {
-        return path_1.default.resolve(this.dir, ...pathSegments);
+   * 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 normalizePath(path.isAbsolute(filepath) ? this.relative(filepath) : filepath) + (isDirectory ? "/" : "");
     }
     /**
-     * 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 repeat slashes into a single slash.
-     *
-     * 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 = false) {
-        return (0, normalize_path_1.default)(path_1.default.isAbsolute(filepath) ? this.relative(filepath) : filepath) + (isDirectory ? "/" : "");
+   * Instead of deleting files, we move them to .gadget/backup so that users can recover them if something goes wrong.
+   */ async softDelete(normalizedPath) {
+        try {
+            await fs.move(this.absolute(normalizedPath), this.absolute(".gadget/backup", normalizedPath), {
+                overwrite: true
+            });
+        } catch (error) {
+            // replicate the behavior of `rm -rf` and ignore ENOENT
+            ignoreEnoent(error);
+        }
     }
     /**
-     * Pretty-prints changed and deleted filepaths to the console.
-     *
-     * @param prefix The prefix to print before each line.
-     * @param changed The filepaths that have changed.
-     * @param deleted The filepaths 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)}`),
-        ], (line) => line.slice(line.indexOf(" ") + 1));
+   * 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 = _.sortBy([
+            ...changed.map((normalizedPath)=>chalkTemplate`{green ${prefix}} ${normalizedPath} {gray (changed)}`),
+            ...deleted.map((normalizedPath)=>chalkTemplate`{red ${prefix}} ${normalizedPath} {gray (deleted)}`)
+        ], (line)=>line.slice(line.indexOf(" ") + 1));
         let logged = 0;
-        for (const line of lines) {
+        for (const line of lines){
             this.log(line);
-            if (++logged == limit && !this.debugEnabled)
-                break;
+            if (++logged == limit && !this.debugEnabled) break;
         }
         if (lines.length > logged) {
-            this.log((0, chalk_1.default) `{gray … ${lines.length - logged} more}`);
+            this.log(chalkTemplate`{gray … ${lines.length - logged} more}`);
         }
-        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(chalkTemplate`{gray ${pluralize("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() {
+   * 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();
-        this.dir =
-            this.config.windows && this.args["directory"].startsWith("~/")
-                ? path_1.default.join(this.config.home, this.args["directory"].slice(2))
-                : path_1.default.resolve(this.args["directory"]);
-        const getApp = async () => {
-            if (this.flags.app)
-                return this.flags.app;
-            if (this.metadata.app)
-                return this.metadata.app;
-            const selected = await (0, inquirer_1.prompt)({
+        assert(_.isString(this.args["directory"]));
+        this.dir = this.config.windows && this.args["directory"].startsWith("~/") ? path.join(this.config.home, this.args["directory"].slice(2)) : path.resolve(this.args["directory"]);
+        const getApp = async ()=>{
+            if (this.flags.app) return this.flags.app;
+            if (this.state?.app) return this.state.app;
+            const selected = await inquirer.prompt({
                 type: "list",
                 name: "app",
                 message: "Please select the app to sync to.",
-                choices: await context_1.context.getAvailableApps().then((apps) => apps.map((app) => app.slug)),
+                choices: await context.getAvailableApps().then((apps)=>apps.map((app)=>app.slug))
             });
             return selected.app;
         };
-        if (await (0, fs_utils_1.isEmptyDir)(this.dir)) {
-            this.metadata.app = await getApp();
-        }
-        else {
+        if (await isEmptyDir(this.dir)) {
+            const app = await getApp();
+            this.state = SyncState.create(this.dir, {
+                app
+            });
+        } else {
             try {
-                this.metadata = await fs_extra_1.default.readJson(this.absolute(".gadget", "sync.json"));
-                if (!this.metadata.app) {
-                    this.metadata.app = await getApp();
-                }
-            }
-            catch (error) {
+                this.state = SyncState.load(this.dir);
+            } catch (error) {
                 if (!this.flags.force) {
-                    throw new errors_1.InvalidSyncFileError(error, this, this.flags.app);
+                    throw new InvalidSyncFileError(error, this, this.flags.app);
                 }
-                this.metadata.app = await getApp();
+                const app = await getApp();
+                this.state = SyncState.create(this.dir, {
+                    app
+                });
             }
         }
-        if (this.flags.app && this.flags.app !== this.metadata.app && !this.flags.force) {
-            throw new errors_1.InvalidSyncAppFlagError(this);
+        if (this.flags.app && this.flags.app !== this.state.app && !this.flags.force) {
+            throw new InvalidSyncAppFlagError(this);
         }
-        await context_1.context.setApp(this.metadata.app);
-        this.client = new client_1.Client();
+        await context.setApp(this.state.app);
+        this.client = new Client();
         // local files/folders that should never be published
-        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),
+        this.ignorer = new FSIgnorer(this.dir, [
+            "node_modules",
+            ".gadget",
+            ".git"
+        ]);
+        this.watcher = new FSWatcher({
+            ignored: (filepath)=>this.ignorer.ignores(filepath),
             // don't emit an event for every watched file on boot
             ignoreInitial: true,
             // make sure stats are always present on add/change events
             alwaysStat: true,
             // wait for the entire file to be written before emitting add/change events
-            awaitWriteFinish: { pollInterval: this.flags["file-poll-interval"], stabilityThreshold: this.flags["file-stability-threshold"] },
+            awaitWriteFinish: {
+                pollInterval: this.flags["file-poll-interval"],
+                stabilityThreshold: this.flags["file-stability-threshold"]
+            }
         });
         this.debug("starting");
-        if (!which_1.default.sync("yarn", { nothrow: true })) {
-            throw new errors_1.YarnNotFoundError();
+        if (!which.sync("yarn", {
+            nothrow: true
+        })) {
+            throw new YarnNotFoundError();
         }
-        await fs_extra_1.default.ensureDir(this.dir);
-        const { remoteFilesVersion } = await this.client.queryUnwrap({ query: exports.REMOTE_FILES_VERSION_QUERY });
-        const hasRemoteChanges = BigInt(remoteFilesVersion) > BigInt(this.metadata.filesVersion);
-        const getChangedFiles = async () => {
+        await fs.ensureDir(this.dir);
+        const { remoteFilesVersion  } = await this.client.queryUnwrap({
+            query: REMOTE_FILES_VERSION_QUERY
+        });
+        const hasRemoteChanges = BigInt(remoteFilesVersion) > BigInt(this.state.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);
-                if (stats.mtime.getTime() > this.metadata.mtime) {
-                    files.set(this.absolute(filepath), stats);
+            for await (const absolutePath of walkDir(this.dir, {
+                ignorer: this.ignorer
+            })){
+                const stats = await fs.stat(absolutePath);
+                if (stats.mtime.getTime() > this.state.mtime) {
+                    files.set(this.normalize(absolutePath, stats.isDirectory()), stats);
                 }
             }
             // never include the root directory
-            files.delete(this.dir);
+            files.delete("/");
             return files;
         };
         const changedFiles = await getChangedFiles();
         const hasLocalChanges = changedFiles.size > 0;
         if (hasLocalChanges) {
             this.log("Local files have changed since you last synced");
-            this.logPaths("-", Array.from(changedFiles.keys()), [], { limit: changedFiles.size });
+            this.logPaths("-", Array.from(changedFiles.keys()), [], {
+                limit: changedFiles.size
+            });
             this.log();
         }
-        this.debug("init %O", { metadata: this.metadata, remoteFilesVersion, hasRemoteChanges, hasLocalChanges });
+        this.debug("init %O", {
+            metadata: this.state,
+            remoteFilesVersion,
+            hasRemoteChanges,
+            hasLocalChanges
+        });
         let action;
         if (hasLocalChanges) {
-            ({ action } = await (0, inquirer_1.prompt)({
+            ({ action  } = await inquirer.prompt({
                 type: "list",
                 name: "action",
-                choices: [Action.CANCEL, Action.MERGE, Action.RESET],
-                message: hasRemoteChanges ? "Remote files have also changed. How would you like to proceed?" : "How would you like to proceed?",
+                choices: [
+                    Action.CANCEL,
+                    Action.MERGE,
+                    Action.RESET
+                ],
+                message: hasRemoteChanges ? "Remote files have also changed. How would you like to proceed?" : "How would you like to proceed?"
             }));
         }
-        switch (action) {
-            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 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]) => {
-                                if (stats.mtime.getTime() > this.metadata.mtime) {
-                                    this.metadata.mtime = stats.mtime.getTime();
-                                }
-                                const isDirectory = stats.isDirectory();
-                                return {
-                                    path: this.normalize(filepath, isDirectory),
-                                    mode: stats.mode,
-                                    content: isDirectory ? "" : await fs_extra_1.default.readFile(filepath, "base64"),
-                                    encoding: graphql_1.FileSyncEncoding.Base64,
-                                };
-                            }),
-                            deleted: [],
-                        },
-                    },
-                });
-                break;
-            }
-            case Action.RESET: {
-                // 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, ([filepath]) => fs_extra_1.default.remove(filepath));
-                this.metadata.filesVersion = "0";
-                break;
-            }
-            case Action.CANCEL: {
-                process.exit(0);
-            }
+        switch(action){
+            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 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: PUBLISH_FILE_SYNC_EVENTS_MUTATION,
+                        variables: {
+                            input: {
+                                expectedRemoteFilesVersion: remoteFilesVersion,
+                                changed: await pMap(files, async ([normalizedPath, stats])=>{
+                                    if (stats.mtime.getTime() > this.state.mtime) {
+                                        this.state.mtime = stats.mtime.getTime();
+                                    }
+                                    return {
+                                        path: normalizedPath,
+                                        mode: stats.mode,
+                                        content: stats.isDirectory() ? "" : await fs.readFile(this.absolute(normalizedPath), "base64"),
+                                        encoding: FileSyncEncoding.Base64
+                                    };
+                                }),
+                                deleted: []
+                            }
+                        }
+                    });
+                    break;
+                }
+            case Action.RESET:
+                {
+                    // 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 pMap(changedFiles.keys(), (normalizedPath)=>this.softDelete(normalizedPath));
+                    this.state.filesVersion = 0n;
+                    break;
+                }
+            case Action.CANCEL:
+                {
+                    process.exit(0);
+                }
         }
         this.debug("started");
     }
     /**
-     * Runs the sync process until it is stopped or an error occurs.
-     */
-    async run() {
+   * Runs the sync process until it is stopped or an error occurs.
+   */ async run() {
         let error;
-        const stopped = new promise_1.PromiseSignal();
-        this.stop = async (e) => {
-            if (this.status != SyncStatus.RUNNING)
-                return;
+        const stopped = new PromiseSignal();
+        this.stop = async (e)=>{
+            if (this.status != SyncStatus.RUNNING) return;
             error = e;
             this.debug("stopping");
             this.status = SyncStatus.STOPPING;
@@ -349,25 +259,29 @@ class Sync extends base_command_1.BaseCommand {
                 this.watcher.removeAllListeners();
                 this.publish.flush();
                 await this.queue.onIdle();
-            }
-            finally {
-                await fs_extra_1.default.outputJSON(this.absolute(".gadget", "sync.json"), this.metadata, { spaces: 2 });
-                await Promise.allSettled([this.watcher.close(), this.client.dispose()]);
+            } finally{
+                this.state.flush();
+                await Promise.allSettled([
+                    this.watcher.close(),
+                    this.client.dispose()
+                ]);
                 this.debug("stopped");
                 this.status = SyncStatus.STOPPED;
                 stopped.resolve();
             }
         };
-        for (const signal of ["SIGINT", "SIGTERM"]) {
-            process.on(signal, () => {
-                if (this.status != SyncStatus.RUNNING)
-                    return;
-                this.log((0, chalk_1.default) ` Stopping... {gray (press Ctrl+C again to force)}`);
+        for (const signal of [
+            "SIGINT",
+            "SIGTERM"
+        ]){
+            process.on(signal, ()=>{
+                if (this.status != SyncStatus.RUNNING) return;
+                this.log(chalkTemplate` Stopping... {gray (press Ctrl+C again to force)}`);
                 void this.stop();
                 // When ggt is run via npx, and the user presses Ctrl+C, npx sends SIGINT twice in quick succession. In order to prevent the second
                 // SIGINT from triggering the force exit listener, we wait a bit before registering it. This is a bit of a hack, but it works.
-                setTimeout(() => {
-                    process.once(signal, () => {
+                setTimeout(()=>{
+                    process.once(signal, ()=>{
                         this.log(" Exiting immediately. Note that files may not have finished syncing.");
                         process.exit(1);
                     });
@@ -375,210 +289,258 @@ class Sync extends base_command_1.BaseCommand {
             });
         }
         const unsubscribe = this.client.subscribeUnwrap({
-            query: exports.REMOTE_FILE_SYNC_EVENTS_SUBSCRIPTION,
-            variables: () => ({ localFilesVersion: this.metadata.filesVersion }),
+            query: REMOTE_FILE_SYNC_EVENTS_SUBSCRIPTION,
+            variables: ()=>({
+                    localFilesVersion: String(this.state.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) {
-                        if (BigInt(remoteFilesVersion) > BigInt(this.metadata.filesVersion)) {
+            error: (error)=>void this.stop(error),
+            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) > this.state.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);
-                            this.metadata.filesVersion = remoteFilesVersion;
+                            this.debug("updated local files version from %s to %s", this.state.filesVersion, remoteFilesVersion);
+                            this.state.filesVersion = remoteFilesVersion;
                         }
                         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.log(chalkTemplate`Received {gray ${format(new Date(), "pp")}}`);
+                    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 will be deleted as well
+                    await pMap(deleted, async (file)=>{
+                        this.recentRemoteChanges.add(file.path);
+                        await this.softDelete(file.path);
+                    });
+                    await pMap(changed, async (file)=>{
+                        this.recentRemoteChanges.add(file.path);
+                        const absolutePath = this.absolute(file.path);
+                        if (file.path.endsWith("/")) {
+                            await fs.ensureDir(absolutePath, {
+                                mode: 0o755
+                            });
                             return;
                         }
-                        const filepath = this.absolute(file.path);
-                        this.recentRemoteChanges.add(filepath);
-                        if ("content" in file) {
-                            if (!file.path.endsWith("/")) {
-                                this.recentRemoteChanges.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.dirname(file.path) + "/");
+                        await fs.ensureDir(path.dirname(absolutePath), {
+                            mode: 0o755
+                        });
+                        await fs.writeFile(absolutePath, Buffer.from(file.content, file.encoding), {
+                            mode: file.mode
+                        });
+                        if (absolutePath == this.absolute("yarn.lock")) {
+                            await execa("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);
-            },
+                    });
+                    this.debug("updated local files version from %s to %s", this.state.filesVersion, remoteFilesVersion);
+                    this.state.filesVersion = remoteFilesVersion;
+                    // 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_2.debounce)(() => {
+        this.publish = _.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 pMap(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.readFile(this.absolute(normalizedPath), "base64"),
+                            encoding: 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.
+                        ignoreEnoent(error);
                     }
-                }, { 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;
+                });
+                if (!changed.length && !deleted.length) {
+                    return;
+                }
+                const data = await this.client.queryUnwrap({
+                    query: PUBLISH_FILE_SYNC_EVENTS_MUTATION,
+                    variables: {
+                        input: {
+                            expectedRemoteFilesVersion: String(this.state.filesVersion),
+                            changed,
+                            deleted
+                        }
                     }
+                });
+                this.log(chalkTemplate`Sent {gray ${format(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) > this.state.filesVersion) {
+                    this.debug("updated local files version from %s to %s", this.state.filesVersion, remoteFilesVersion);
+                    this.state.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);
+        this.watcher.add(`${this.dir}/**/*`).on("error", (error)=>void this.stop(error)).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
-            if (stats && stats.mtime.getTime() > this.metadata.mtime) {
-                this.metadata.mtime = stats.mtime.getTime();
+            if (stats && stats.mtime.getTime() > this.state.mtime) {
+                this.state.mtime = stats.mtime.getTime();
             }
-            if (this.recentRemoteChanges.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);
-            switch (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 });
+                    assert(stats, "missing stats on add/change event");
+                    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 });
+                    assert(stats, "missing stats on addDir event");
+                    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();
         });
         this.status = SyncStatus.RUNNING;
         // app should be defined at this point
-        (0, assert_1.default)(context_1.context.app);
+        assert(context.app);
         this.log();
-        this.log((0, ts_dedent_1.default)((0, chalk_1.default) `
+        this.log(dedent(chalkTemplate`
       {bold ggt v${this.config.version}}
 
-      App         ${context_1.context.app.slug}
-      Editor      https://${context_1.context.app.slug}.gadget.app/edit
-      Playground  https://${context_1.context.app.slug}.gadget.app/api/graphql/playground
-      Docs        https://docs.gadget.dev/api/${context_1.context.app.slug}
+      App         ${context.app.slug}
+      Editor      https://${context.app.slug}.gadget.app/edit
+      Playground  https://${context.app.slug}.gadget.app/api/graphql/playground
+      Docs        https://docs.gadget.dev/api/${context.app.slug}
 
-      {underline Endpoints} ${context_1.context.app.hasSplitEnvironments
-            ? `
-        - https://${context_1.context.app.primaryDomain}
-        - https://${context_1.context.app.slug}--development.gadget.app`
-            : `
-        - https://${context_1.context.app.primaryDomain}`}
+      {underline Endpoints} ${context.app.hasSplitEnvironments ? `
+        - https://${context.app.primaryDomain}
+        - https://${context.app.slug}--development.gadget.app` : `
+        - https://${context.app.primaryDomain}`}
 
       Watching for file changes... {gray Press Ctrl+C to stop}
     `));
         this.log();
         await stopped;
         if (error) {
-            this.notify({ subtitle: "Uh oh!", message: "An error occurred while syncing files" });
+            this.notify({
+                subtitle: "Uh oh!",
+                message: "An error occurred while syncing files"
+            });
             throw error;
-        }
-        else {
+        } else {
             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);
+    }
+    constructor(...args){
+        super(...args);
+        _define_property(this, "requireUser", true);
+        /**
+   * The current status of the sync process.
+   */ _define_property(this, "status", SyncStatus.STARTING);
+        /**
+   * The absolute path to the directory to sync files to.
+   */ _define_property(this, "dir", void 0);
+        /**
+   * 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.
+   */ _define_property(this, "recentRemoteChanges", new Set());
+        /**
+   * A FIFO async callback queue that ensures we process file-sync events in the order they occurred.
+   */ _define_property(this, "queue", new PQueue({
+            concurrency: 1
+        }));
+        /**
+   * A GraphQL client connected to the app's /edit/api/graphql-ws endpoint
+   */ _define_property(this, "client", void 0);
+        /**
+   * Loads the .ignore file and provides methods for checking if a file should be ignored.
+   */ _define_property(this, "ignorer", void 0);
+        /**
+   * Watches the local filesystem for changes.
+   */ _define_property(this, "watcher", void 0);
+        /**
+   * The state of the local filesystem.
+   */ _define_property(this, "state", void 0);
+        /**
+   * A debounced function that enqueue's local file changes to be sent to Gadget.
+   */ _define_property(this, "publish", void 0);
+        /**
+   * Gracefully stops the sync.
+   */ _define_property(this, "stop", void 0);
+    }
 }
-Object.defineProperty(Sync, "priority", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: 1
-});
-Object.defineProperty(Sync, "summary", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: "Sync your Gadget application's source code to and from your local filesystem."
-});
-Object.defineProperty(Sync, "usage", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: "sync [DIRECTORY] [--app <name>]"
-});
-Object.defineProperty(Sync, "description", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: (0, ts_dedent_1.default)((0, chalk_1.default) `
+_define_property(Sync, "priority", 1);
+_define_property(Sync, "summary", "Sync your Gadget application's source code to and from your local filesystem.");
+_define_property(Sync, "usage", "sync [DIRECTORY] [--app <name>]");
+_define_property(Sync, "description", dedent(chalkTemplate`
     Sync provides the ability to sync your Gadget application's source code to and from your local
     filesystem. While {gray ggt sync} is running, local file changes are immediately reflected within
     Gadget, while files that are changed remotely are immediately saved to your local filesystem.
@@ -602,62 +564,47 @@ Object.defineProperty(Sync, "description", {
       - Since file changes are immediately reflected in Gadget, avoid the following while {gray ggt sync} is running:
           - Deleting all your files
           - Moving all your files to a different directory
-  `)
+  `));
+_define_property(Sync, "args", {
+    directory: Args.string({
+        description: "The directory to sync files to. If the directory doesn't exist, it will be created.",
+        default: "."
+    })
 });
-Object.defineProperty(Sync, "args", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: {
-        directory: core_1.Args.string({
-            description: "The directory to sync files to. If the directory doesn't exist, it will be created.",
-            default: ".",
-        }),
-    }
-});
-Object.defineProperty(Sync, "flags", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: {
-        app: (0, flags_1.app)({
-            summary: "The Gadget application to sync files to.",
-        }),
-        force: core_1.Flags.boolean({
-            summary: "Whether to sync even if we can't determine the state of your local files relative to your remote ones.",
-            default: false,
-        }),
-        "file-push-delay": core_1.Flags.integer({
-            summary: "Delay in milliseconds before pushing files to your app.",
-            helpGroup: "file",
-            helpValue: "ms",
-            default: 100,
-            hidden: true,
-        }),
-        "file-stability-threshold": core_1.Flags.integer({
-            name: "file-stability-threshold",
-            summary: "Time in milliseconds a file's size must remain the same.",
-            helpGroup: "file",
-            helpValue: "ms",
-            default: 500,
-            hidden: true,
-        }),
-        "file-poll-interval": core_1.Flags.integer({
-            name: "file-poll-interval",
-            description: "Interval in milliseconds between polling a file's size.",
-            helpGroup: "file",
-            helpValue: "ms",
-            default: 100,
-            hidden: true,
-        }),
-    }
+_define_property(Sync, "flags", {
+    app: app({
+        summary: "The Gadget application to sync files to."
+    }),
+    force: Flags.boolean({
+        summary: "Whether to sync even if we can't determine the state of your local files relative to your remote ones.",
+        default: false
+    }),
+    "file-push-delay": Flags.integer({
+        summary: "Delay in milliseconds before pushing files to your app.",
+        helpGroup: "file",
+        helpValue: "ms",
+        default: 100,
+        hidden: true
+    }),
+    "file-stability-threshold": Flags.integer({
+        name: "file-stability-threshold",
+        summary: "Time in milliseconds a file's size must remain the same.",
+        helpGroup: "file",
+        helpValue: "ms",
+        default: 500,
+        hidden: true
+    }),
+    "file-poll-interval": Flags.integer({
+        name: "file-poll-interval",
+        description: "Interval in milliseconds between polling a file's size.",
+        helpGroup: "file",
+        helpValue: "ms",
+        default: 100,
+        hidden: true
+    })
 });
-Object.defineProperty(Sync, "examples", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: [
-        (0, ts_dedent_1.default)((0, chalk_1.default) `
+_define_property(Sync, "examples", [
+    dedent(chalkTemplate`
       {gray $ ggt sync --app my-app ~/gadget/my-app}
 
       App         my-app
@@ -682,24 +629,110 @@ Object.defineProperty(Sync, "examples", {
 
       ^C Stopping... {gray (press Ctrl+C again to force)}
       Goodbye!
-    `),
-    ]
-});
-exports.default = Sync;
-var SyncStatus;
-(function (SyncStatus) {
+    `)
+]);
+export { Sync as default };
+var /**
+   * Saves the current state of the filesystem to `.gadget/sync.json`.
+   */ _save = /*#__PURE__*/ new WeakMap();
+/**
+ * Holds information about the state of the local filesystem. It's persisted to `.gadget/sync.json`.
+ */ export class SyncState {
+    /**
+   * The app this filesystem is synced to.
+   */ get app() {
+        return this._inner.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.
+   */ get filesVersion() {
+        return BigInt(this._inner.filesVersion);
+    }
+    set filesVersion(value) {
+        this._inner.filesVersion = String(value);
+        _class_private_field_get(this, _save).call(this);
+    }
+    /**
+   * 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.
+   */ // eslint-disable-next-line @typescript-eslint/member-ordering
+    get mtime() {
+        return this._inner.mtime;
+    }
+    set mtime(value) {
+        this._inner.mtime = value;
+        _class_private_field_get(this, _save).call(this);
+    }
+    /**
+   * Creates a new SyncFile instance and saves it to the filesystem.
+   *
+   * @param rootDir The root directory of the app.
+   * @param app The app slug.
+   * @returns A new SyncFile instance.
+   */ static create(rootDir, opts) {
+        const state = new SyncState(rootDir, {
+            filesVersion: "0",
+            mtime: 0,
+            ...opts
+        });
+        _class_private_field_get(state, _save).call(state);
+        state.flush();
+        return state;
+    }
+    /**
+   * Loads a SyncFile instance from the filesystem.
+   *
+   * @param rootDir The root directory of the app.
+   * @returns The SyncFile instance.
+   */ static load(rootDir) {
+        const state = fs.readJsonSync(path.join(rootDir, ".gadget/sync.json"));
+        assert(_.isString(state.app), "missing or invalid app");
+        assert(_.isString(state.filesVersion), "missing or invalid filesVersion");
+        assert(_.isNumber(state.mtime), "missing or invalid mtime");
+        return new SyncState(rootDir, {
+            app: state.app,
+            filesVersion: state.filesVersion,
+            mtime: state.mtime
+        });
+    }
+    /**
+   * Flushes any pending writes to the filesystem.
+   */ flush() {
+        _class_private_field_get(this, _save).flush();
+    }
+    constructor(_rootDir, inner){
+        _define_property(this, "_rootDir", void 0);
+        _define_property(this, "_inner", void 0);
+        _class_private_field_init(this, _save, {
+            writable: true,
+            value: void 0
+        });
+        this._rootDir = _rootDir;
+        _class_private_field_set(this, _save, _.debounce(()=>{
+            fs.outputJSONSync(path.join(this._rootDir, ".gadget/sync.json"), this._inner, {
+                spaces: 2
+            });
+        }, 100));
+        this._inner = inner;
+    }
+}
+export var SyncStatus;
+(function(SyncStatus) {
     SyncStatus[SyncStatus["STARTING"] = 0] = "STARTING";
     SyncStatus[SyncStatus["RUNNING"] = 1] = "RUNNING";
     SyncStatus[SyncStatus["STOPPING"] = 2] = "STOPPING";
     SyncStatus[SyncStatus["STOPPED"] = 3] = "STOPPED";
-})(SyncStatus = exports.SyncStatus || (exports.SyncStatus = {}));
-var Action;
-(function (Action) {
+})(SyncStatus || (SyncStatus = {}));
+export var Action;
+(function(Action) {
     Action["CANCEL"] = "Cancel (Ctrl+C)";
     Action["MERGE"] = "Merge local files with remote ones";
     Action["RESET"] = "Reset local files to remote ones";
-})(Action = exports.Action || (exports.Action = {}));
-exports.REMOTE_FILE_SYNC_EVENTS_SUBSCRIPTION = `
+})(Action || (Action = {}));
+export const REMOTE_FILE_SYNC_EVENTS_SUBSCRIPTION = /* GraphQL */ `
   subscription RemoteFileSyncEvents($localFilesVersion: String!) {
     remoteFileSyncEvents(localFilesVersion: $localFilesVersion, encoding: base64) {
       remoteFilesVersion
@@ -715,16 +748,17 @@ exports.REMOTE_FILE_SYNC_EVENTS_SUBSCRIPTION = `
     }
   }
 `;
-exports.REMOTE_FILES_VERSION_QUERY = `
+export const REMOTE_FILES_VERSION_QUERY = /* GraphQL */ `
   query RemoteFilesVersion {
     remoteFilesVersion
   }
 `;
-exports.PUBLISH_FILE_SYNC_EVENTS_MUTATION = `
+export const PUBLISH_FILE_SYNC_EVENTS_MUTATION = /* GraphQL */ `
   mutation PublishFileSyncEvents($input: PublishFileSyncEventsInput!) {
     publishFileSyncEvents(input: $input) {
       remoteFilesVersion
     }
   }
 `;
+
 //# sourceMappingURL=sync.js.map