@actual-app/cli 26.5.0 → 26.6.0-nightly.20260504

package/dist/cli.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
+import { join } from "node:path";
+import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import * as api from "@actual-app/api";
-import { mkdirSync, readFileSync } from "fs";
+import { randomBytes } from "node:crypto";
 import { homedir } from "os";
-import { join } from "path";
+import { join as join$1 } from "path";
+import { readFileSync as readFileSync$1 } from "fs";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -1044,8 +1047,8 @@ var require_suggestSimilar = /* @__PURE__ */ __commonJSMin(((exports) => {
 var require_command = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var EventEmitter = __require("node:events").EventEmitter;
 	var childProcess = __require("node:child_process");
-	var path$4 = __require("node:path");
-	var fs$1 = __require("node:fs");
+	var path$5 = __require("node:path");
+	var fs$2 = __require("node:fs");
 	var process$1 = __require("node:process");
 	var { Argument, humanReadableArgName } = require_argument();
 	var { CommanderError } = require_error();
@@ -1941,7 +1944,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 		* @param {string} subcommandName
 		*/
 		_checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-			if (fs$1.existsSync(executableFile)) return;
+			if (fs$2.existsSync(executableFile)) return;
 			const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
  - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
@@ -1964,10 +1967,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
 				".cjs"
 			];
 			function findFile(baseDir, baseName) {
-				const localBin = path$4.resolve(baseDir, baseName);
-				if (fs$1.existsSync(localBin)) return localBin;
-				if (sourceExt.includes(path$4.extname(baseName))) return void 0;
-				const foundExt = sourceExt.find((ext) => fs$1.existsSync(`${localBin}${ext}`));
+				const localBin = path$5.resolve(baseDir, baseName);
+				if (fs$2.existsSync(localBin)) return localBin;
+				if (sourceExt.includes(path$5.extname(baseName))) return void 0;
+				const foundExt = sourceExt.find((ext) => fs$2.existsSync(`${localBin}${ext}`));
 				if (foundExt) return `${localBin}${foundExt}`;
 			}
 			this._checkForMissingMandatoryOptions();
@@ -1977,21 +1980,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
 			if (this._scriptPath) {
 				let resolvedScriptPath;
 				try {
-					resolvedScriptPath = fs$1.realpathSync(this._scriptPath);
+					resolvedScriptPath = fs$2.realpathSync(this._scriptPath);
 				} catch {
 					resolvedScriptPath = this._scriptPath;
 				}
-				executableDir = path$4.resolve(path$4.dirname(resolvedScriptPath), executableDir);
+				executableDir = path$5.resolve(path$5.dirname(resolvedScriptPath), executableDir);
 			}
 			if (executableDir) {
 				let localFile = findFile(executableDir, executableFile);
 				if (!localFile && !subcommand._executableFile && this._scriptPath) {
-					const legacyName = path$4.basename(this._scriptPath, path$4.extname(this._scriptPath));
+					const legacyName = path$5.basename(this._scriptPath, path$5.extname(this._scriptPath));
 					if (legacyName !== this._name) localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
 				}
 				executableFile = localFile || executableFile;
 			}
-			launchWithNode = sourceExt.includes(path$4.extname(executableFile));
+			launchWithNode = sourceExt.includes(path$5.extname(executableFile));
 			let proc;
 			if (process$1.platform !== "win32") if (launchWithNode) {
 				args.unshift(executableFile);
@@ -2759,7 +2762,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
 		* @return {Command}
 		*/
 		nameFromFilename(filename) {
-			this._name = path$4.basename(filename, path$4.extname(filename));
+			this._name = path$5.basename(filename, path$5.extname(filename));
 			return this;
 		}
 		/**
@@ -3039,22 +3042,108 @@ var { program: program$1, createCommand, createArgument, createOption, Commander
 	exports.InvalidOptionArgumentError = InvalidArgumentError;
 })))(), 1)).default;
 //#endregion
+//#region src/utils.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseBoolFlag(value, flagName) {
+	if (value !== "true" && value !== "false") throw new Error(`Invalid ${flagName}: "${value}". Expected "true" or "false".`);
+	return value === "true";
+}
+function parseIntFlag(value, flagName) {
+	const parsed = value.trim() === "" ? NaN : Number(value);
+	if (!Number.isInteger(parsed)) throw new Error(`Invalid ${flagName}: "${value}". Expected an integer.`);
+	return parsed;
+}
+function parseNonNegativeIntFlag(value, flagName) {
+	const parsed = parseIntFlag(value, flagName);
+	if (parsed < 0) throw new Error(`Invalid ${flagName}: "${value}". Expected a non-negative integer.`);
+	return parsed;
+}
+function parseBoolEnv(raw, source) {
+	if (raw === void 0) return void 0;
+	const lower = raw.toLowerCase();
+	if (raw === "1" || lower === "true") return true;
+	if (raw === "0" || lower === "false") return false;
+	throw new Error(`Invalid ${source}: "${raw}". Expected "true", "false", "1", or "0".`);
+}
+//#endregion
+//#region src/cache.ts
+var CACHE_FILE_NAME = "state.json";
+var META_ROOT_DIR = ".actual-cli";
+function getMetaDir(dataDir, syncId) {
+	return join(dataDir, META_ROOT_DIR, syncId);
+}
+function cachePath(metaDir) {
+	return join(metaDir, CACHE_FILE_NAME);
+}
+function isCacheState(value) {
+	if (!isRecord(value)) return false;
+	return value.version === 1 && typeof value.syncId === "string" && typeof value.budgetId === "string" && typeof value.serverUrl === "string" && typeof value.lastSyncedAt === "number" && typeof value.lastDownloadedAt === "number";
+}
+function readCacheState(metaDir) {
+	let raw;
+	try {
+		raw = readFileSync(cachePath(metaDir), "utf-8");
+	} catch {
+		return null;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	return isCacheState(parsed) ? parsed : null;
+}
+function writeCacheState(metaDir, state) {
+	try {
+		mkdirSync(metaDir, { recursive: true });
+		const target = cachePath(metaDir);
+		const tmp = `${target}.${process.pid}-${randomBytes(4).toString("hex")}.tmp`;
+		writeFileSync(tmp, JSON.stringify(state));
+		renameSync(tmp, target);
+	} catch {}
+}
+function decideSyncAction({ state, config, now, ttlMs, mutates, refresh, encrypted }) {
+	if (state === null) return { action: "download" };
+	if (state.syncId !== config.syncId) return { action: "download" };
+	if (state.serverUrl !== config.serverUrl) return { action: "download" };
+	if (mutates || refresh || ttlMs === 0 || encrypted) return {
+		action: "sync",
+		state
+	};
+	const age = now - state.lastSyncedAt;
+	if (age < 0) return {
+		action: "sync",
+		state
+	};
+	if (age < ttlMs) return {
+		action: "skip",
+		state
+	};
+	return {
+		action: "sync",
+		state
+	};
+}
+//#endregion
 //#region ../../node_modules/resolve-from/index.js
 var require_resolve_from = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var path$3 = __require("path");
+	var path$4 = __require("path");
 	var Module = __require("module");
-	var fs = __require("fs");
+	var fs$1 = __require("fs");
 	var resolveFrom = (fromDir, moduleId, silent) => {
 		if (typeof fromDir !== "string") throw new TypeError(`Expected \`fromDir\` to be of type \`string\`, got \`${typeof fromDir}\``);
 		if (typeof moduleId !== "string") throw new TypeError(`Expected \`moduleId\` to be of type \`string\`, got \`${typeof moduleId}\``);
 		try {
-			fromDir = fs.realpathSync(fromDir);
+			fromDir = fs$1.realpathSync(fromDir);
 		} catch (err) {
-			if (err.code === "ENOENT") fromDir = path$3.resolve(fromDir);
+			if (err.code === "ENOENT") fromDir = path$4.resolve(fromDir);
 			else if (silent) return null;
 			else throw err;
 		}
-		const fromFile = path$3.join(fromDir, "noop.js");
+		const fromFile = path$4.join(fromDir, "noop.js");
 		const resolveFileName = () => Module._resolveFilename(moduleId, {
 			id: fromFile,
 			filename: fromFile,
@@ -3107,13 +3196,13 @@ var require_parent_module = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 //#endregion
 //#region ../../node_modules/import-fresh/index.js
 var require_import_fresh = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var path$2 = __require("path");
+	var path$3 = __require("path");
 	var resolveFrom = require_resolve_from();
 	var parentModule = require_parent_module();
 	module.exports = (moduleId) => {
 		if (typeof moduleId !== "string") throw new TypeError("Expected a string");
 		const parentPath = parentModule(__filename);
-		const filePath = resolveFrom(parentPath ? path$2.dirname(parentPath) : __dirname, moduleId);
+		const filePath = resolveFrom(parentPath ? path$3.dirname(parentPath) : __dirname, moduleId);
 		const oldModule = __require.cache[filePath];
 		if (oldModule && oldModule.parent) {
 			let i = oldModule.parent.children.length;
@@ -3135,7 +3224,7 @@ var require_is_arrayish = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/error-ex/index.js
 var require_error_ex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var util$1 = __require("util");
+	var util$2 = __require("util");
 	var isArrayish = require_is_arrayish();
 	var errorEx = function errorEx(name, properties) {
 		if (!name || name.constructor !== String) {
@@ -3196,7 +3285,7 @@ var require_error_ex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		if (Object.setPrototypeOf) {
 			Object.setPrototypeOf(errorExError.prototype, Error.prototype);
 			Object.setPrototypeOf(errorExError, Error);
-		} else util$1.inherits(errorExError, Error);
+		} else util$2.inherits(errorExError, Error);
 		return errorExError;
 	};
 	errorEx.append = function(str, def) {
@@ -8960,7 +9049,7 @@ var require_buffer_from = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#region ../../node_modules/source-map-support/source-map-support.js
 var require_source_map_support = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var SourceMapConsumer = require_source_map().SourceMapConsumer;
-	var path$1 = __require("path");
+	var path$2 = __require("path");
 	var fs;
 	try {
 		fs = __require("fs");
@@ -9037,15 +9126,15 @@ var require_source_map_support = /* @__PURE__ */ __commonJSMin(((exports, module
 	});
 	function supportRelativeURL(file, url) {
 		if (!file) return url;
-		var dir = path$1.dirname(file);
+		var dir = path$2.dirname(file);
 		var match = /^\w+:\/\/[^\/]*/.exec(dir);
 		var protocol = match ? match[0] : "";
 		var startPath = dir.slice(protocol.length);
 		if (protocol && /^\/\w\:/.test(startPath)) {
 			protocol += "/";
-			return protocol + path$1.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
+			return protocol + path$2.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
 		}
-		return protocol + path$1.resolve(dir.slice(protocol.length), url);
+		return protocol + path$2.resolve(dir.slice(protocol.length), url);
 	}
 	function retrieveSourceMapURL(source) {
 		var fileData;
@@ -157356,40 +157445,40 @@ var require_defaults = /* @__PURE__ */ __commonJSMin(((exports) => {
 //#endregion
 //#region ../../node_modules/env-paths/index.js
 var require_env_paths = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var path = __require("path");
+	var path$1 = __require("path");
 	var os$1 = __require("os");
 	var homedir = os$1.homedir();
 	var tmpdir = os$1.tmpdir();
 	var { env } = process;
 	var macos = (name) => {
-		const library = path.join(homedir, "Library");
+		const library = path$1.join(homedir, "Library");
 		return {
-			data: path.join(library, "Application Support", name),
-			config: path.join(library, "Preferences", name),
-			cache: path.join(library, "Caches", name),
-			log: path.join(library, "Logs", name),
-			temp: path.join(tmpdir, name)
+			data: path$1.join(library, "Application Support", name),
+			config: path$1.join(library, "Preferences", name),
+			cache: path$1.join(library, "Caches", name),
+			log: path$1.join(library, "Logs", name),
+			temp: path$1.join(tmpdir, name)
 		};
 	};
 	var windows = (name) => {
-		const appData = env.APPDATA || path.join(homedir, "AppData", "Roaming");
-		const localAppData = env.LOCALAPPDATA || path.join(homedir, "AppData", "Local");
+		const appData = env.APPDATA || path$1.join(homedir, "AppData", "Roaming");
+		const localAppData = env.LOCALAPPDATA || path$1.join(homedir, "AppData", "Local");
 		return {
-			data: path.join(localAppData, name, "Data"),
-			config: path.join(appData, name, "Config"),
-			cache: path.join(localAppData, name, "Cache"),
-			log: path.join(localAppData, name, "Log"),
-			temp: path.join(tmpdir, name)
+			data: path$1.join(localAppData, name, "Data"),
+			config: path$1.join(appData, name, "Config"),
+			cache: path$1.join(localAppData, name, "Cache"),
+			log: path$1.join(localAppData, name, "Log"),
+			temp: path$1.join(tmpdir, name)
 		};
 	};
 	var linux = (name) => {
-		const username = path.basename(homedir);
+		const username = path$1.basename(homedir);
 		return {
-			data: path.join(env.XDG_DATA_HOME || path.join(homedir, ".local", "share"), name),
-			config: path.join(env.XDG_CONFIG_HOME || path.join(homedir, ".config"), name),
-			cache: path.join(env.XDG_CACHE_HOME || path.join(homedir, ".cache"), name),
-			log: path.join(env.XDG_STATE_HOME || path.join(homedir, ".local", "state"), name),
-			temp: path.join(tmpdir, username, name)
+			data: path$1.join(env.XDG_DATA_HOME || path$1.join(homedir, ".local", "share"), name),
+			config: path$1.join(env.XDG_CONFIG_HOME || path$1.join(homedir, ".config"), name),
+			cache: path$1.join(env.XDG_CACHE_HOME || path$1.join(homedir, ".cache"), name),
+			log: path$1.join(env.XDG_STATE_HOME || path$1.join(homedir, ".local", "state"), name),
+			temp: path$1.join(tmpdir, username, name)
 		};
 	};
 	var envPaths = (name, options) => {
@@ -157924,7 +158013,7 @@ var require_ExplorerSync = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.ExplorerSync = ExplorerSync;
 }));
 //#endregion
-//#region src/utils.ts
+//#region src/config.ts
 var import_dist = (/* @__PURE__ */ __commonJSMin(((exports) => {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.defaultLoadersSync = exports.defaultLoaders = exports.globalConfigSearchPlacesSync = exports.globalConfigSearchPlaces = exports.getDefaultSearchPlacesSync = exports.getDefaultSearchPlaces = exports.cosmiconfigSync = exports.cosmiconfig = void 0;
@@ -158085,21 +158174,7 @@ var import_dist = (/* @__PURE__ */ __commonJSMin(((exports) => {
 	}
 	exports.cosmiconfigSync = cosmiconfigSync;
 })))();
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function parseBoolFlag(value, flagName) {
-	if (value !== "true" && value !== "false") throw new Error(`Invalid ${flagName}: "${value}". Expected "true" or "false".`);
-	return value === "true";
-}
-function parseIntFlag(value, flagName) {
-	const parsed = value.trim() === "" ? NaN : Number(value);
-	if (!Number.isInteger(parsed)) throw new Error(`Invalid ${flagName}: "${value}". Expected an integer.`);
-	return parsed;
-}
-//#endregion
-//#region src/config.ts
-var configFileKeys = [
+var stringKeys = [
 	"serverUrl",
 	"password",
 	"sessionToken",
@@ -158107,11 +158182,22 @@ var configFileKeys = [
 	"dataDir",
 	"encryptionPassword"
 ];
+var numberKeys = ["cacheTtl", "lockTimeout"];
+var booleanKeys = ["noLock"];
+var configFileKeys = [
+	...stringKeys,
+	...numberKeys,
+	...booleanKeys
+];
 function validateConfigFileContent(value) {
 	if (!isRecord(value)) throw new Error("Invalid config file: expected an object with keys: " + configFileKeys.join(", "));
 	for (const key of Object.keys(value)) {
 		if (!configFileKeys.includes(key)) throw new Error(`Invalid config file: unknown key "${key}"`);
-		if (value[key] !== void 0 && typeof value[key] !== "string") throw new Error(`Invalid config file: key "${key}" must be a string, got ${typeof value[key]}`);
+		const v = value[key];
+		if (v === void 0) continue;
+		if (stringKeys.includes(key) && typeof v !== "string") throw new Error(`Invalid config file: key "${key}" must be a string, got ${typeof v}`);
+		if (numberKeys.includes(key) && (typeof v !== "number" || !Number.isInteger(v) || v < 0)) throw new Error(`Invalid config file: key "${key}" must be a non-negative integer`);
+		if (booleanKeys.includes(key) && typeof v !== "boolean") throw new Error(`Invalid config file: key "${key}" must be a boolean, got ${typeof v}`);
 	}
 	return value;
 }
@@ -158129,13 +158215,20 @@ async function loadConfigFile() {
 	if (result && !result.isEmpty) return validateConfigFileContent(result.config);
 	return {};
 }
+function parseNonNegativeIntEnv(raw, source) {
+	return raw === void 0 ? void 0 : parseNonNegativeIntFlag(raw, source);
+}
+function validateNonNegativeInt(value, name) {
+	if (!Number.isInteger(value) || value < 0) throw new Error(`Invalid ${name}: expected a non-negative integer, got ${value}`);
+	return value;
+}
 async function resolveConfig(cliOpts) {
 	const fileConfig = await loadConfigFile();
 	const serverUrl = cliOpts.serverUrl ?? process.env.ACTUAL_SERVER_URL ?? fileConfig.serverUrl ?? "";
 	const password = cliOpts.password ?? process.env.ACTUAL_PASSWORD ?? fileConfig.password;
 	const sessionToken = cliOpts.sessionToken ?? process.env.ACTUAL_SESSION_TOKEN ?? fileConfig.sessionToken;
 	const syncId = cliOpts.syncId ?? process.env.ACTUAL_SYNC_ID ?? fileConfig.syncId;
-	const dataDir = cliOpts.dataDir ?? process.env.ACTUAL_DATA_DIR ?? fileConfig.dataDir ?? join(homedir(), ".actual-cli", "data");
+	const dataDir = cliOpts.dataDir ?? process.env.ACTUAL_DATA_DIR ?? fileConfig.dataDir ?? join$1(homedir(), ".actual-cli", "data");
 	const encryptionPassword = cliOpts.encryptionPassword ?? process.env.ACTUAL_ENCRYPTION_PASSWORD ?? fileConfig.encryptionPassword;
 	if (!serverUrl) throw new Error("Server URL is required. Set --server-url, ACTUAL_SERVER_URL env var, or serverUrl in config file.");
 	if (!password && !sessionToken) throw new Error("Authentication required. Set --password/--session-token, ACTUAL_PASSWORD/ACTUAL_SESSION_TOKEN env var, or password/sessionToken in config file.");
@@ -158145,7 +158238,1465 @@ async function resolveConfig(cliOpts) {
 		sessionToken,
 		syncId,
 		dataDir,
-		encryptionPassword
+		encryptionPassword,
+		cacheTtl: validateNonNegativeInt(cliOpts.cacheTtl ?? parseNonNegativeIntEnv(process.env.ACTUAL_CACHE_TTL, "ACTUAL_CACHE_TTL") ?? fileConfig.cacheTtl ?? 60, "cacheTtl"),
+		lockTimeout: validateNonNegativeInt(cliOpts.lockTimeout ?? parseNonNegativeIntEnv(process.env.ACTUAL_LOCK_TIMEOUT, "ACTUAL_LOCK_TIMEOUT") ?? fileConfig.lockTimeout ?? 10, "lockTimeout"),
+		refresh: (cliOpts.refresh ?? false) || cliOpts.cache === false,
+		noLock: (cliOpts.lock === false ? true : void 0) ?? parseBoolEnv(process.env.ACTUAL_NO_LOCK, "ACTUAL_NO_LOCK") ?? fileConfig.noLock ?? false
+	};
+}
+//#endregion
+//#region ../../node_modules/graceful-fs/polyfills.js
+var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var constants = __require("constants");
+	var origCwd = process.cwd;
+	var cwd = null;
+	var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+	process.cwd = function() {
+		if (!cwd) cwd = origCwd.call(process);
+		return cwd;
+	};
+	try {
+		process.cwd();
+	} catch (er) {}
+	if (typeof process.chdir === "function") {
+		var chdir = process.chdir;
+		process.chdir = function(d) {
+			cwd = null;
+			chdir.call(process, d);
+		};
+		if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+	}
+	module.exports = patch;
+	function patch(fs) {
+		if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) patchLchmod(fs);
+		if (!fs.lutimes) patchLutimes(fs);
+		fs.chown = chownFix(fs.chown);
+		fs.fchown = chownFix(fs.fchown);
+		fs.lchown = chownFix(fs.lchown);
+		fs.chmod = chmodFix(fs.chmod);
+		fs.fchmod = chmodFix(fs.fchmod);
+		fs.lchmod = chmodFix(fs.lchmod);
+		fs.chownSync = chownFixSync(fs.chownSync);
+		fs.fchownSync = chownFixSync(fs.fchownSync);
+		fs.lchownSync = chownFixSync(fs.lchownSync);
+		fs.chmodSync = chmodFixSync(fs.chmodSync);
+		fs.fchmodSync = chmodFixSync(fs.fchmodSync);
+		fs.lchmodSync = chmodFixSync(fs.lchmodSync);
+		fs.stat = statFix(fs.stat);
+		fs.fstat = statFix(fs.fstat);
+		fs.lstat = statFix(fs.lstat);
+		fs.statSync = statFixSync(fs.statSync);
+		fs.fstatSync = statFixSync(fs.fstatSync);
+		fs.lstatSync = statFixSync(fs.lstatSync);
+		if (fs.chmod && !fs.lchmod) {
+			fs.lchmod = function(path, mode, cb) {
+				if (cb) process.nextTick(cb);
+			};
+			fs.lchmodSync = function() {};
+		}
+		if (fs.chown && !fs.lchown) {
+			fs.lchown = function(path, uid, gid, cb) {
+				if (cb) process.nextTick(cb);
+			};
+			fs.lchownSync = function() {};
+		}
+		if (platform === "win32") fs.rename = typeof fs.rename !== "function" ? fs.rename : (function(fs$rename) {
+			function rename(from, to, cb) {
+				var start = Date.now();
+				var backoff = 0;
+				fs$rename(from, to, function CB(er) {
+					if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
+						setTimeout(function() {
+							fs.stat(to, function(stater, st) {
+								if (stater && stater.code === "ENOENT") fs$rename(from, to, CB);
+								else cb(er);
+							});
+						}, backoff);
+						if (backoff < 100) backoff += 10;
+						return;
+					}
+					if (cb) cb(er);
+				});
+			}
+			if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+			return rename;
+		})(fs.rename);
+		fs.read = typeof fs.read !== "function" ? fs.read : (function(fs$read) {
+			function read(fd, buffer, offset, length, position, callback_) {
+				var callback;
+				if (callback_ && typeof callback_ === "function") {
+					var eagCounter = 0;
+					callback = function(er, _, __) {
+						if (er && er.code === "EAGAIN" && eagCounter < 10) {
+							eagCounter++;
+							return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+						}
+						callback_.apply(this, arguments);
+					};
+				}
+				return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+			}
+			if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+			return read;
+		})(fs.read);
+		fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : (function(fs$readSync) {
+			return function(fd, buffer, offset, length, position) {
+				var eagCounter = 0;
+				while (true) try {
+					return fs$readSync.call(fs, fd, buffer, offset, length, position);
+				} catch (er) {
+					if (er.code === "EAGAIN" && eagCounter < 10) {
+						eagCounter++;
+						continue;
+					}
+					throw er;
+				}
+			};
+		})(fs.readSync);
+		function patchLchmod(fs) {
+			fs.lchmod = function(path, mode, callback) {
+				fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
+					if (err) {
+						if (callback) callback(err);
+						return;
+					}
+					fs.fchmod(fd, mode, function(err) {
+						fs.close(fd, function(err2) {
+							if (callback) callback(err || err2);
+						});
+					});
+				});
+			};
+			fs.lchmodSync = function(path, mode) {
+				var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
+				var threw = true;
+				var ret;
+				try {
+					ret = fs.fchmodSync(fd, mode);
+					threw = false;
+				} finally {
+					if (threw) try {
+						fs.closeSync(fd);
+					} catch (er) {}
+					else fs.closeSync(fd);
+				}
+				return ret;
+			};
+		}
+		function patchLutimes(fs) {
+			if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
+				fs.lutimes = function(path, at, mt, cb) {
+					fs.open(path, constants.O_SYMLINK, function(er, fd) {
+						if (er) {
+							if (cb) cb(er);
+							return;
+						}
+						fs.futimes(fd, at, mt, function(er) {
+							fs.close(fd, function(er2) {
+								if (cb) cb(er || er2);
+							});
+						});
+					});
+				};
+				fs.lutimesSync = function(path, at, mt) {
+					var fd = fs.openSync(path, constants.O_SYMLINK);
+					var ret;
+					var threw = true;
+					try {
+						ret = fs.futimesSync(fd, at, mt);
+						threw = false;
+					} finally {
+						if (threw) try {
+							fs.closeSync(fd);
+						} catch (er) {}
+						else fs.closeSync(fd);
+					}
+					return ret;
+				};
+			} else if (fs.futimes) {
+				fs.lutimes = function(_a, _b, _c, cb) {
+					if (cb) process.nextTick(cb);
+				};
+				fs.lutimesSync = function() {};
+			}
+		}
+		function chmodFix(orig) {
+			if (!orig) return orig;
+			return function(target, mode, cb) {
+				return orig.call(fs, target, mode, function(er) {
+					if (chownErOk(er)) er = null;
+					if (cb) cb.apply(this, arguments);
+				});
+			};
+		}
+		function chmodFixSync(orig) {
+			if (!orig) return orig;
+			return function(target, mode) {
+				try {
+					return orig.call(fs, target, mode);
+				} catch (er) {
+					if (!chownErOk(er)) throw er;
+				}
+			};
+		}
+		function chownFix(orig) {
+			if (!orig) return orig;
+			return function(target, uid, gid, cb) {
+				return orig.call(fs, target, uid, gid, function(er) {
+					if (chownErOk(er)) er = null;
+					if (cb) cb.apply(this, arguments);
+				});
+			};
+		}
+		function chownFixSync(orig) {
+			if (!orig) return orig;
+			return function(target, uid, gid) {
+				try {
+					return orig.call(fs, target, uid, gid);
+				} catch (er) {
+					if (!chownErOk(er)) throw er;
+				}
+			};
+		}
+		function statFix(orig) {
+			if (!orig) return orig;
+			return function(target, options, cb) {
+				if (typeof options === "function") {
+					cb = options;
+					options = null;
+				}
+				function callback(er, stats) {
+					if (stats) {
+						if (stats.uid < 0) stats.uid += 4294967296;
+						if (stats.gid < 0) stats.gid += 4294967296;
+					}
+					if (cb) cb.apply(this, arguments);
+				}
+				return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
+			};
+		}
+		function statFixSync(orig) {
+			if (!orig) return orig;
+			return function(target, options) {
+				var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
+				if (stats) {
+					if (stats.uid < 0) stats.uid += 4294967296;
+					if (stats.gid < 0) stats.gid += 4294967296;
+				}
+				return stats;
+			};
+		}
+		function chownErOk(er) {
+			if (!er) return true;
+			if (er.code === "ENOSYS") return true;
+			if (!process.getuid || process.getuid() !== 0) {
+				if (er.code === "EINVAL" || er.code === "EPERM") return true;
+			}
+			return false;
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Stream = __require("stream").Stream;
+	module.exports = legacy;
+	function legacy(fs) {
+		return {
+			ReadStream,
+			WriteStream
+		};
+		function ReadStream(path, options) {
+			if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+			Stream.call(this);
+			var self = this;
+			this.path = path;
+			this.fd = null;
+			this.readable = true;
+			this.paused = false;
+			this.flags = "r";
+			this.mode = 438;
+			this.bufferSize = 64 * 1024;
+			options = options || {};
+			var keys = Object.keys(options);
+			for (var index = 0, length = keys.length; index < length; index++) {
+				var key = keys[index];
+				this[key] = options[key];
+			}
+			if (this.encoding) this.setEncoding(this.encoding);
+			if (this.start !== void 0) {
+				if ("number" !== typeof this.start) throw TypeError("start must be a Number");
+				if (this.end === void 0) this.end = Infinity;
+				else if ("number" !== typeof this.end) throw TypeError("end must be a Number");
+				if (this.start > this.end) throw new Error("start must be <= end");
+				this.pos = this.start;
+			}
+			if (this.fd !== null) {
+				process.nextTick(function() {
+					self._read();
+				});
+				return;
+			}
+			fs.open(this.path, this.flags, this.mode, function(err, fd) {
+				if (err) {
+					self.emit("error", err);
+					self.readable = false;
+					return;
+				}
+				self.fd = fd;
+				self.emit("open", fd);
+				self._read();
+			});
+		}
+		function WriteStream(path, options) {
+			if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+			Stream.call(this);
+			this.path = path;
+			this.fd = null;
+			this.writable = true;
+			this.flags = "w";
+			this.encoding = "binary";
+			this.mode = 438;
+			this.bytesWritten = 0;
+			options = options || {};
+			var keys = Object.keys(options);
+			for (var index = 0, length = keys.length; index < length; index++) {
+				var key = keys[index];
+				this[key] = options[key];
+			}
+			if (this.start !== void 0) {
+				if ("number" !== typeof this.start) throw TypeError("start must be a Number");
+				if (this.start < 0) throw new Error("start must be >= zero");
+				this.pos = this.start;
+			}
+			this.busy = false;
+			this._queue = [];
+			if (this.fd === null) {
+				this._open = fs.open;
+				this._queue.push([
+					this._open,
+					this.path,
+					this.flags,
+					this.mode,
+					void 0
+				]);
+				this.flush();
+			}
+		}
+	}
+}));
+//#endregion
+//#region ../../node_modules/graceful-fs/clone.js
+var require_clone = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = clone;
+	var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+		return obj.__proto__;
+	};
+	function clone(obj) {
+		if (obj === null || typeof obj !== "object") return obj;
+		if (obj instanceof Object) var copy = { __proto__: getPrototypeOf(obj) };
+		else var copy = Object.create(null);
+		Object.getOwnPropertyNames(obj).forEach(function(key) {
+			Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+		});
+		return copy;
+	}
+}));
+//#endregion
+//#region ../../node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var fs = __require("fs");
+	var polyfills = require_polyfills();
+	var legacy = require_legacy_streams();
+	var clone = require_clone();
+	var util$1 = __require("util");
+	/* istanbul ignore next - node 0.x polyfill */
+	var gracefulQueue;
+	var previousSymbol;
+	/* istanbul ignore else - node 0.x polyfill */
+	if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+		gracefulQueue = Symbol.for("graceful-fs.queue");
+		previousSymbol = Symbol.for("graceful-fs.previous");
+	} else {
+		gracefulQueue = "___graceful-fs.queue";
+		previousSymbol = "___graceful-fs.previous";
+	}
+	function noop() {}
+	function publishQueue(context, queue) {
+		Object.defineProperty(context, gracefulQueue, { get: function() {
+			return queue;
+		} });
+	}
+	var debug = noop;
+	if (util$1.debuglog) debug = util$1.debuglog("gfs4");
+	else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) debug = function() {
+		var m = util$1.format.apply(util$1, arguments);
+		m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+		console.error(m);
+	};
+	if (!fs[gracefulQueue]) {
+		publishQueue(fs, global[gracefulQueue] || []);
+		fs.close = (function(fs$close) {
+			function close(fd, cb) {
+				return fs$close.call(fs, fd, function(err) {
+					if (!err) resetQueue();
+					if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+			Object.defineProperty(close, previousSymbol, { value: fs$close });
+			return close;
+		})(fs.close);
+		fs.closeSync = (function(fs$closeSync) {
+			function closeSync(fd) {
+				fs$closeSync.apply(fs, arguments);
+				resetQueue();
+			}
+			Object.defineProperty(closeSync, previousSymbol, { value: fs$closeSync });
+			return closeSync;
+		})(fs.closeSync);
+		if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) process.on("exit", function() {
+			debug(fs[gracefulQueue]);
+			__require("assert").equal(fs[gracefulQueue].length, 0);
+		});
+	}
+	if (!global[gracefulQueue]) publishQueue(global, fs[gracefulQueue]);
+	module.exports = patch(clone(fs));
+	if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+		module.exports = patch(fs);
+		fs.__patched = true;
+	}
+	function patch(fs) {
+		polyfills(fs);
+		fs.gracefulify = patch;
+		fs.createReadStream = createReadStream;
+		fs.createWriteStream = createWriteStream;
+		var fs$readFile = fs.readFile;
+		fs.readFile = readFile;
+		function readFile(path, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$readFile(path, options, cb);
+			function go$readFile(path, options, cb, startTime) {
+				return fs$readFile(path, options, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$readFile,
+						[
+							path,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$writeFile = fs.writeFile;
+		fs.writeFile = writeFile;
+		function writeFile(path, data, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$writeFile(path, data, options, cb);
+			function go$writeFile(path, data, options, cb, startTime) {
+				return fs$writeFile(path, data, options, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$writeFile,
+						[
+							path,
+							data,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$appendFile = fs.appendFile;
+		if (fs$appendFile) fs.appendFile = appendFile;
+		function appendFile(path, data, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$appendFile(path, data, options, cb);
+			function go$appendFile(path, data, options, cb, startTime) {
+				return fs$appendFile(path, data, options, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$appendFile,
+						[
+							path,
+							data,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$copyFile = fs.copyFile;
+		if (fs$copyFile) fs.copyFile = copyFile;
+		function copyFile(src, dest, flags, cb) {
+			if (typeof flags === "function") {
+				cb = flags;
+				flags = 0;
+			}
+			return go$copyFile(src, dest, flags, cb);
+			function go$copyFile(src, dest, flags, cb, startTime) {
+				return fs$copyFile(src, dest, flags, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$copyFile,
+						[
+							src,
+							dest,
+							flags,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$readdir = fs.readdir;
+		fs.readdir = readdir;
+		var noReaddirOptionVersions = /^v[0-5]\./;
+		function readdir(path, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir(path, options, cb, startTime) {
+				return fs$readdir(path, fs$readdirCallback(path, options, cb, startTime));
+			} : function go$readdir(path, options, cb, startTime) {
+				return fs$readdir(path, options, fs$readdirCallback(path, options, cb, startTime));
+			};
+			return go$readdir(path, options, cb);
+			function fs$readdirCallback(path, options, cb, startTime) {
+				return function(err, files) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$readdir,
+						[
+							path,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else {
+						if (files && files.sort) files.sort();
+						if (typeof cb === "function") cb.call(this, err, files);
+					}
+				};
+			}
+		}
+		if (process.version.substr(0, 4) === "v0.8") {
+			var legStreams = legacy(fs);
+			ReadStream = legStreams.ReadStream;
+			WriteStream = legStreams.WriteStream;
+		}
+		var fs$ReadStream = fs.ReadStream;
+		if (fs$ReadStream) {
+			ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+			ReadStream.prototype.open = ReadStream$open;
+		}
+		var fs$WriteStream = fs.WriteStream;
+		if (fs$WriteStream) {
+			WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+			WriteStream.prototype.open = WriteStream$open;
+		}
+		Object.defineProperty(fs, "ReadStream", {
+			get: function() {
+				return ReadStream;
+			},
+			set: function(val) {
+				ReadStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		Object.defineProperty(fs, "WriteStream", {
+			get: function() {
+				return WriteStream;
+			},
+			set: function(val) {
+				WriteStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		var FileReadStream = ReadStream;
+		Object.defineProperty(fs, "FileReadStream", {
+			get: function() {
+				return FileReadStream;
+			},
+			set: function(val) {
+				FileReadStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		var FileWriteStream = WriteStream;
+		Object.defineProperty(fs, "FileWriteStream", {
+			get: function() {
+				return FileWriteStream;
+			},
+			set: function(val) {
+				FileWriteStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		function ReadStream(path, options) {
+			if (this instanceof ReadStream) return fs$ReadStream.apply(this, arguments), this;
+			else return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+		}
+		function ReadStream$open() {
+			var that = this;
+			open(that.path, that.flags, that.mode, function(err, fd) {
+				if (err) {
+					if (that.autoClose) that.destroy();
+					that.emit("error", err);
+				} else {
+					that.fd = fd;
+					that.emit("open", fd);
+					that.read();
+				}
+			});
+		}
+		function WriteStream(path, options) {
+			if (this instanceof WriteStream) return fs$WriteStream.apply(this, arguments), this;
+			else return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+		}
+		function WriteStream$open() {
+			var that = this;
+			open(that.path, that.flags, that.mode, function(err, fd) {
+				if (err) {
+					that.destroy();
+					that.emit("error", err);
+				} else {
+					that.fd = fd;
+					that.emit("open", fd);
+				}
+			});
+		}
+		function createReadStream(path, options) {
+			return new fs.ReadStream(path, options);
+		}
+		function createWriteStream(path, options) {
+			return new fs.WriteStream(path, options);
+		}
+		var fs$open = fs.open;
+		fs.open = open;
+		function open(path, flags, mode, cb) {
+			if (typeof mode === "function") cb = mode, mode = null;
+			return go$open(path, flags, mode, cb);
+			function go$open(path, flags, mode, cb, startTime) {
+				return fs$open(path, flags, mode, function(err, fd) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$open,
+						[
+							path,
+							flags,
+							mode,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		return fs;
+	}
+	function enqueue(elem) {
+		debug("ENQUEUE", elem[0].name, elem[1]);
+		fs[gracefulQueue].push(elem);
+		retry();
+	}
+	var retryTimer;
+	function resetQueue() {
+		var now = Date.now();
+		for (var i = 0; i < fs[gracefulQueue].length; ++i) if (fs[gracefulQueue][i].length > 2) {
+			fs[gracefulQueue][i][3] = now;
+			fs[gracefulQueue][i][4] = now;
+		}
+		retry();
+	}
+	function retry() {
+		clearTimeout(retryTimer);
+		retryTimer = void 0;
+		if (fs[gracefulQueue].length === 0) return;
+		var elem = fs[gracefulQueue].shift();
+		var fn = elem[0];
+		var args = elem[1];
+		var err = elem[2];
+		var startTime = elem[3];
+		var lastTime = elem[4];
+		if (startTime === void 0) {
+			debug("RETRY", fn.name, args);
+			fn.apply(null, args);
+		} else if (Date.now() - startTime >= 6e4) {
+			debug("TIMEOUT", fn.name, args);
+			var cb = args.pop();
+			if (typeof cb === "function") cb.call(null, err);
+		} else {
+			var sinceAttempt = Date.now() - lastTime;
+			var sinceStart = Math.max(lastTime - startTime, 1);
+			if (sinceAttempt >= Math.min(sinceStart * 1.2, 100)) {
+				debug("RETRY", fn.name, args);
+				fn.apply(null, args.concat([startTime]));
+			} else fs[gracefulQueue].push(elem);
+		}
+		if (retryTimer === void 0) retryTimer = setTimeout(retry, 0);
+	}
+}));
+//#endregion
+//#region ../../node_modules/retry/lib/retry_operation.js
+var require_retry_operation = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function RetryOperation(timeouts, options) {
+		if (typeof options === "boolean") options = { forever: options };
+		this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+		this._timeouts = timeouts;
+		this._options = options || {};
+		this._maxRetryTime = options && options.maxRetryTime || Infinity;
+		this._fn = null;
+		this._errors = [];
+		this._attempts = 1;
+		this._operationTimeout = null;
+		this._operationTimeoutCb = null;
+		this._timeout = null;
+		this._operationStart = null;
+		if (this._options.forever) this._cachedTimeouts = this._timeouts.slice(0);
+	}
+	module.exports = RetryOperation;
+	RetryOperation.prototype.reset = function() {
+		this._attempts = 1;
+		this._timeouts = this._originalTimeouts;
+	};
+	RetryOperation.prototype.stop = function() {
+		if (this._timeout) clearTimeout(this._timeout);
+		this._timeouts = [];
+		this._cachedTimeouts = null;
+	};
+	RetryOperation.prototype.retry = function(err) {
+		if (this._timeout) clearTimeout(this._timeout);
+		if (!err) return false;
+		var currentTime = (/* @__PURE__ */ new Date()).getTime();
+		if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+			this._errors.unshift(/* @__PURE__ */ new Error("RetryOperation timeout occurred"));
+			return false;
+		}
+		this._errors.push(err);
+		var timeout = this._timeouts.shift();
+		if (timeout === void 0) if (this._cachedTimeouts) {
+			this._errors.splice(this._errors.length - 1, this._errors.length);
+			this._timeouts = this._cachedTimeouts.slice(0);
+			timeout = this._timeouts.shift();
+		} else return false;
+		var self = this;
+		var timer = setTimeout(function() {
+			self._attempts++;
+			if (self._operationTimeoutCb) {
+				self._timeout = setTimeout(function() {
+					self._operationTimeoutCb(self._attempts);
+				}, self._operationTimeout);
+				if (self._options.unref) self._timeout.unref();
+			}
+			self._fn(self._attempts);
+		}, timeout);
+		if (this._options.unref) timer.unref();
+		return true;
+	};
+	RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+		this._fn = fn;
+		if (timeoutOps) {
+			if (timeoutOps.timeout) this._operationTimeout = timeoutOps.timeout;
+			if (timeoutOps.cb) this._operationTimeoutCb = timeoutOps.cb;
+		}
+		var self = this;
+		if (this._operationTimeoutCb) this._timeout = setTimeout(function() {
+			self._operationTimeoutCb();
+		}, self._operationTimeout);
+		this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+		this._fn(this._attempts);
+	};
+	RetryOperation.prototype.try = function(fn) {
+		console.log("Using RetryOperation.try() is deprecated");
+		this.attempt(fn);
+	};
+	RetryOperation.prototype.start = function(fn) {
+		console.log("Using RetryOperation.start() is deprecated");
+		this.attempt(fn);
+	};
+	RetryOperation.prototype.start = RetryOperation.prototype.try;
+	RetryOperation.prototype.errors = function() {
+		return this._errors;
+	};
+	RetryOperation.prototype.attempts = function() {
+		return this._attempts;
+	};
+	RetryOperation.prototype.mainError = function() {
+		if (this._errors.length === 0) return null;
+		var counts = {};
+		var mainError = null;
+		var mainErrorCount = 0;
+		for (var i = 0; i < this._errors.length; i++) {
+			var error = this._errors[i];
+			var message = error.message;
+			var count = (counts[message] || 0) + 1;
+			counts[message] = count;
+			if (count >= mainErrorCount) {
+				mainError = error;
+				mainErrorCount = count;
+			}
+		}
+		return mainError;
+	};
+}));
+//#endregion
+//#region ../../node_modules/retry/lib/retry.js
+var require_retry$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var RetryOperation = require_retry_operation();
+	exports.operation = function(options) {
+		return new RetryOperation(exports.timeouts(options), {
+			forever: options && options.forever,
+			unref: options && options.unref,
+			maxRetryTime: options && options.maxRetryTime
+		});
+	};
+	exports.timeouts = function(options) {
+		if (options instanceof Array) return [].concat(options);
+		var opts = {
+			retries: 10,
+			factor: 2,
+			minTimeout: 1 * 1e3,
+			maxTimeout: Infinity,
+			randomize: false
+		};
+		for (var key in options) opts[key] = options[key];
+		if (opts.minTimeout > opts.maxTimeout) throw new Error("minTimeout is greater than maxTimeout");
+		var timeouts = [];
+		for (var i = 0; i < opts.retries; i++) timeouts.push(this.createTimeout(i, opts));
+		if (options && options.forever && !timeouts.length) timeouts.push(this.createTimeout(i, opts));
+		timeouts.sort(function(a, b) {
+			return a - b;
+		});
+		return timeouts;
+	};
+	exports.createTimeout = function(attempt, opts) {
+		var random = opts.randomize ? Math.random() + 1 : 1;
+		var timeout = Math.round(random * opts.minTimeout * Math.pow(opts.factor, attempt));
+		timeout = Math.min(timeout, opts.maxTimeout);
+		return timeout;
+	};
+	exports.wrap = function(obj, options, methods) {
+		if (options instanceof Array) {
+			methods = options;
+			options = null;
+		}
+		if (!methods) {
+			methods = [];
+			for (var key in obj) if (typeof obj[key] === "function") methods.push(key);
+		}
+		for (var i = 0; i < methods.length; i++) {
+			var method = methods[i];
+			var original = obj[method];
+			obj[method] = function retryWrapper(original) {
+				var op = exports.operation(options);
+				var args = Array.prototype.slice.call(arguments, 1);
+				var callback = args.pop();
+				args.push(function(err) {
+					if (op.retry(err)) return;
+					if (err) arguments[0] = op.mainError();
+					callback.apply(this, arguments);
+				});
+				op.attempt(function() {
+					original.apply(obj, args);
+				});
+			}.bind(obj, original);
+			obj[method].options = options;
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/retry/index.js
+var require_retry = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_retry$1();
+}));
+//#endregion
+//#region ../../node_modules/signal-exit/signals.js
+var require_signals = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = [
+		"SIGABRT",
+		"SIGALRM",
+		"SIGHUP",
+		"SIGINT",
+		"SIGTERM"
+	];
+	if (process.platform !== "win32") module.exports.push("SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+	if (process.platform === "linux") module.exports.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT", "SIGUNUSED");
+}));
+//#endregion
+//#region ../../node_modules/signal-exit/index.js
+var require_signal_exit = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var process = global.process;
+	var processOk = function(process) {
+		return process && typeof process === "object" && typeof process.removeListener === "function" && typeof process.emit === "function" && typeof process.reallyExit === "function" && typeof process.listeners === "function" && typeof process.kill === "function" && typeof process.pid === "number" && typeof process.on === "function";
+	};
+	/* istanbul ignore if */
+	if (!processOk(process)) module.exports = function() {
+		return function() {};
+	};
+	else {
+		var assert = __require("assert");
+		var signals = require_signals();
+		var isWin = /^win/i.test(process.platform);
+		var EE = __require("events");
+		/* istanbul ignore if */
+		if (typeof EE !== "function") EE = EE.EventEmitter;
+		var emitter;
+		if (process.__signal_exit_emitter__) emitter = process.__signal_exit_emitter__;
+		else {
+			emitter = process.__signal_exit_emitter__ = new EE();
+			emitter.count = 0;
+			emitter.emitted = {};
+		}
+		if (!emitter.infinite) {
+			emitter.setMaxListeners(Infinity);
+			emitter.infinite = true;
+		}
+		module.exports = function(cb, opts) {
+			/* istanbul ignore if */
+			if (!processOk(global.process)) return function() {};
+			assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
+			if (loaded === false) load();
+			var ev = "exit";
+			if (opts && opts.alwaysLast) ev = "afterexit";
+			var remove = function() {
+				emitter.removeListener(ev, cb);
+				if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) unload();
+			};
+			emitter.on(ev, cb);
+			return remove;
+		};
+		var unload = function unload() {
+			if (!loaded || !processOk(global.process)) return;
+			loaded = false;
+			signals.forEach(function(sig) {
+				try {
+					process.removeListener(sig, sigListeners[sig]);
+				} catch (er) {}
+			});
+			process.emit = originalProcessEmit;
+			process.reallyExit = originalProcessReallyExit;
+			emitter.count -= 1;
+		};
+		module.exports.unload = unload;
+		var emit = function emit(event, code, signal) {
+			/* istanbul ignore if */
+			if (emitter.emitted[event]) return;
+			emitter.emitted[event] = true;
+			emitter.emit(event, code, signal);
+		};
+		var sigListeners = {};
+		signals.forEach(function(sig) {
+			sigListeners[sig] = function listener() {
+				/* istanbul ignore if */
+				if (!processOk(global.process)) return;
+				if (process.listeners(sig).length === emitter.count) {
+					unload();
+					emit("exit", null, sig);
+					/* istanbul ignore next */
+					emit("afterexit", null, sig);
+					/* istanbul ignore next */
+					if (isWin && sig === "SIGHUP") sig = "SIGINT";
+					/* istanbul ignore next */
+					process.kill(process.pid, sig);
+				}
+			};
+		});
+		module.exports.signals = function() {
+			return signals;
+		};
+		var loaded = false;
+		var load = function load() {
+			if (loaded || !processOk(global.process)) return;
+			loaded = true;
+			emitter.count += 1;
+			signals = signals.filter(function(sig) {
+				try {
+					process.on(sig, sigListeners[sig]);
+					return true;
+				} catch (er) {
+					return false;
+				}
+			});
+			process.emit = processEmit;
+			process.reallyExit = processReallyExit;
+		};
+		module.exports.load = load;
+		var originalProcessReallyExit = process.reallyExit;
+		var processReallyExit = function processReallyExit(code) {
+			/* istanbul ignore if */
+			if (!processOk(global.process)) return;
+			process.exitCode = code || 0;
+			emit("exit", process.exitCode, null);
+			/* istanbul ignore next */
+			emit("afterexit", process.exitCode, null);
+			/* istanbul ignore next */
+			originalProcessReallyExit.call(process, process.exitCode);
+		};
+		var originalProcessEmit = process.emit;
+		var processEmit = function processEmit(ev, arg) {
+			if (ev === "exit" && processOk(global.process)) {
+				/* istanbul ignore else */
+				if (arg !== void 0) process.exitCode = arg;
+				var ret = originalProcessEmit.apply(this, arguments);
+				/* istanbul ignore next */
+				emit("exit", process.exitCode, null);
+				/* istanbul ignore next */
+				emit("afterexit", process.exitCode, null);
+				/* istanbul ignore next */
+				return ret;
+			} else return originalProcessEmit.apply(this, arguments);
+		};
+	}
+}));
+//#endregion
+//#region ../../node_modules/proper-lockfile/lib/mtime-precision.js
+var require_mtime_precision = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var cacheSymbol = Symbol();
+	function probe(file, fs, callback) {
+		const cachedPrecision = fs[cacheSymbol];
+		if (cachedPrecision) return fs.stat(file, (err, stat) => {
+			/* istanbul ignore if */
+			if (err) return callback(err);
+			callback(null, stat.mtime, cachedPrecision);
+		});
+		const mtime = /* @__PURE__ */ new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
+		fs.utimes(file, mtime, mtime, (err) => {
+			/* istanbul ignore if */
+			if (err) return callback(err);
+			fs.stat(file, (err, stat) => {
+				/* istanbul ignore if */
+				if (err) return callback(err);
+				const precision = stat.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
+				Object.defineProperty(fs, cacheSymbol, { value: precision });
+				callback(null, stat.mtime, precision);
+			});
+		});
+	}
+	function getMtime(precision) {
+		let now = Date.now();
+		if (precision === "s") now = Math.ceil(now / 1e3) * 1e3;
+		return new Date(now);
+	}
+	module.exports.probe = probe;
+	module.exports.getMtime = getMtime;
+}));
+//#endregion
+//#region ../../node_modules/proper-lockfile/lib/lockfile.js
+var require_lockfile = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var path = __require("path");
+	var fs = require_graceful_fs();
+	var retry = require_retry();
+	var onExit = require_signal_exit();
+	var mtimePrecision = require_mtime_precision();
+	var locks = {};
+	function getLockFile(file, options) {
+		return options.lockfilePath || `${file}.lock`;
+	}
+	function resolveCanonicalPath(file, options, callback) {
+		if (!options.realpath) return callback(null, path.resolve(file));
+		options.fs.realpath(file, callback);
+	}
+	function acquireLock(file, options, callback) {
+		const lockfilePath = getLockFile(file, options);
+		options.fs.mkdir(lockfilePath, (err) => {
+			if (!err) return mtimePrecision.probe(lockfilePath, options.fs, (err, mtime, mtimePrecision) => {
+				/* istanbul ignore if */
+				if (err) {
+					options.fs.rmdir(lockfilePath, () => {});
+					return callback(err);
+				}
+				callback(null, mtime, mtimePrecision);
+			});
+			if (err.code !== "EEXIST") return callback(err);
+			if (options.stale <= 0) return callback(Object.assign(/* @__PURE__ */ new Error("Lock file is already being held"), {
+				code: "ELOCKED",
+				file
+			}));
+			options.fs.stat(lockfilePath, (err, stat) => {
+				if (err) {
+					if (err.code === "ENOENT") return acquireLock(file, {
+						...options,
+						stale: 0
+					}, callback);
+					return callback(err);
+				}
+				if (!isLockStale(stat, options)) return callback(Object.assign(/* @__PURE__ */ new Error("Lock file is already being held"), {
+					code: "ELOCKED",
+					file
+				}));
+				removeLock(file, options, (err) => {
+					if (err) return callback(err);
+					acquireLock(file, {
+						...options,
+						stale: 0
+					}, callback);
+				});
+			});
+		});
+	}
+	function isLockStale(stat, options) {
+		return stat.mtime.getTime() < Date.now() - options.stale;
+	}
+	function removeLock(file, options, callback) {
+		options.fs.rmdir(getLockFile(file, options), (err) => {
+			if (err && err.code !== "ENOENT") return callback(err);
+			callback();
+		});
+	}
+	function updateLock(file, options) {
+		const lock = locks[file];
+		/* istanbul ignore if */
+		if (lock.updateTimeout) return;
+		lock.updateDelay = lock.updateDelay || options.update;
+		lock.updateTimeout = setTimeout(() => {
+			lock.updateTimeout = null;
+			options.fs.stat(lock.lockfilePath, (err, stat) => {
+				const isOverThreshold = lock.lastUpdate + options.stale < Date.now();
+				if (err) {
+					if (err.code === "ENOENT" || isOverThreshold) return setLockAsCompromised(file, lock, Object.assign(err, { code: "ECOMPROMISED" }));
+					lock.updateDelay = 1e3;
+					return updateLock(file, options);
+				}
+				if (!(lock.mtime.getTime() === stat.mtime.getTime())) return setLockAsCompromised(file, lock, Object.assign(/* @__PURE__ */ new Error("Unable to update lock within the stale threshold"), { code: "ECOMPROMISED" }));
+				const mtime = mtimePrecision.getMtime(lock.mtimePrecision);
+				options.fs.utimes(lock.lockfilePath, mtime, mtime, (err) => {
+					const isOverThreshold = lock.lastUpdate + options.stale < Date.now();
+					if (lock.released) return;
+					if (err) {
+						if (err.code === "ENOENT" || isOverThreshold) return setLockAsCompromised(file, lock, Object.assign(err, { code: "ECOMPROMISED" }));
+						lock.updateDelay = 1e3;
+						return updateLock(file, options);
+					}
+					lock.mtime = mtime;
+					lock.lastUpdate = Date.now();
+					lock.updateDelay = null;
+					updateLock(file, options);
+				});
+			});
+		}, lock.updateDelay);
+		/* istanbul ignore else */
+		if (lock.updateTimeout.unref) lock.updateTimeout.unref();
+	}
+	function setLockAsCompromised(file, lock, err) {
+		lock.released = true;
+		/* istanbul ignore if */
+		if (lock.updateTimeout) clearTimeout(lock.updateTimeout);
+		if (locks[file] === lock) delete locks[file];
+		lock.options.onCompromised(err);
+	}
+	function lock(file, options, callback) {
+		/* istanbul ignore next */
+		options = {
+			stale: 1e4,
+			update: null,
+			realpath: true,
+			retries: 0,
+			fs,
+			onCompromised: (err) => {
+				throw err;
+			},
+			...options
+		};
+		options.retries = options.retries || 0;
+		options.retries = typeof options.retries === "number" ? { retries: options.retries } : options.retries;
+		options.stale = Math.max(options.stale || 0, 2e3);
+		options.update = options.update == null ? options.stale / 2 : options.update || 0;
+		options.update = Math.max(Math.min(options.update, options.stale / 2), 1e3);
+		resolveCanonicalPath(file, options, (err, file) => {
+			if (err) return callback(err);
+			const operation = retry.operation(options.retries);
+			operation.attempt(() => {
+				acquireLock(file, options, (err, mtime, mtimePrecision) => {
+					if (operation.retry(err)) return;
+					if (err) return callback(operation.mainError());
+					const lock = locks[file] = {
+						lockfilePath: getLockFile(file, options),
+						mtime,
+						mtimePrecision,
+						options,
+						lastUpdate: Date.now()
+					};
+					updateLock(file, options);
+					callback(null, (releasedCallback) => {
+						if (lock.released) return releasedCallback && releasedCallback(Object.assign(/* @__PURE__ */ new Error("Lock is already released"), { code: "ERELEASED" }));
+						unlock(file, {
+							...options,
+							realpath: false
+						}, releasedCallback);
+					});
+				});
+			});
+		});
+	}
+	function unlock(file, options, callback) {
+		options = {
+			fs,
+			realpath: true,
+			...options
+		};
+		resolveCanonicalPath(file, options, (err, file) => {
+			if (err) return callback(err);
+			const lock = locks[file];
+			if (!lock) return callback(Object.assign(/* @__PURE__ */ new Error("Lock is not acquired/owned by you"), { code: "ENOTACQUIRED" }));
+			lock.updateTimeout && clearTimeout(lock.updateTimeout);
+			lock.released = true;
+			delete locks[file];
+			removeLock(file, options, callback);
+		});
+	}
+	function check(file, options, callback) {
+		options = {
+			stale: 1e4,
+			realpath: true,
+			fs,
+			...options
+		};
+		options.stale = Math.max(options.stale || 0, 2e3);
+		resolveCanonicalPath(file, options, (err, file) => {
+			if (err) return callback(err);
+			options.fs.stat(getLockFile(file, options), (err, stat) => {
+				if (err) return err.code === "ENOENT" ? callback(null, false) : callback(err);
+				return callback(null, !isLockStale(stat, options));
+			});
+		});
+	}
+	function getLocks() {
+		return locks;
+	}
+	/* istanbul ignore next */
+	onExit(() => {
+		for (const file in locks) {
+			const options = locks[file].options;
+			try {
+				options.fs.rmdirSync(getLockFile(file, options));
+			} catch (e) {}
+		}
+	});
+	module.exports.lock = lock;
+	module.exports.unlock = unlock;
+	module.exports.check = check;
+	module.exports.getLocks = getLocks;
+}));
+//#endregion
+//#region ../../node_modules/proper-lockfile/lib/adapter.js
+var require_adapter = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var fs = require_graceful_fs();
+	function createSyncFs(fs) {
+		const methods = [
+			"mkdir",
+			"realpath",
+			"stat",
+			"rmdir",
+			"utimes"
+		];
+		const newFs = { ...fs };
+		methods.forEach((method) => {
+			newFs[method] = (...args) => {
+				const callback = args.pop();
+				let ret;
+				try {
+					ret = fs[`${method}Sync`](...args);
+				} catch (err) {
+					return callback(err);
+				}
+				callback(null, ret);
+			};
+		});
+		return newFs;
+	}
+	function toPromise(method) {
+		return (...args) => new Promise((resolve, reject) => {
+			args.push((err, result) => {
+				if (err) reject(err);
+				else resolve(result);
+			});
+			method(...args);
+		});
+	}
+	function toSync(method) {
+		return (...args) => {
+			let err;
+			let result;
+			args.push((_err, _result) => {
+				err = _err;
+				result = _result;
+			});
+			method(...args);
+			if (err) throw err;
+			return result;
+		};
+	}
+	function toSyncOptions(options) {
+		options = { ...options };
+		options.fs = createSyncFs(options.fs || fs);
+		if (typeof options.retries === "number" && options.retries > 0 || options.retries && typeof options.retries.retries === "number" && options.retries.retries > 0) throw Object.assign(/* @__PURE__ */ new Error("Cannot use retries with the sync api"), { code: "ESYNC" });
+		return options;
+	}
+	module.exports = {
+		toPromise,
+		toSync,
+		toSyncOptions
+	};
+}));
+//#endregion
+//#region src/lock.ts
+var import_proper_lockfile = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var lockfile = require_lockfile();
+	var { toPromise, toSync, toSyncOptions } = require_adapter();
+	async function lock(file, options) {
+		return toPromise(await toPromise(lockfile.lock)(file, options));
+	}
+	function lockSync(file, options) {
+		return toSync(toSync(lockfile.lock)(file, toSyncOptions(options)));
+	}
+	function unlock(file, options) {
+		return toPromise(lockfile.unlock)(file, options);
+	}
+	function unlockSync(file, options) {
+		return toSync(lockfile.unlock)(file, toSyncOptions(options));
+	}
+	function check(file, options) {
+		return toPromise(lockfile.check)(file, options);
+	}
+	function checkSync(file, options) {
+		return toSync(lockfile.check)(file, toSyncOptions(options));
+	}
+	module.exports = lock;
+	module.exports.lock = lock;
+	module.exports.unlock = unlock;
+	module.exports.lockSync = lockSync;
+	module.exports.unlockSync = unlockSync;
+	module.exports.check = check;
+	module.exports.checkSync = checkSync;
+})))(), 1);
+var LOCKFILE_NAME = "lock";
+var READERS_DIR_NAME = "readers";
+var READER_POLL_INTERVAL_MS = 100;
+function lockfilePath(dir) {
+	return join(dir, LOCKFILE_NAME);
+}
+function readersDir(dir) {
+	return join(dir, READERS_DIR_NAME);
+}
+function ensureDir(dir) {
+	mkdirSync(dir, { recursive: true });
+}
+function retriesForTimeout(timeoutMs) {
+	return {
+		retries: Math.max(1, Math.floor(timeoutMs / 200)),
+		minTimeout: 100,
+		maxTimeout: 500,
+		factor: 1.5
+	};
+}
+function errorCode(err) {
+	if (err instanceof Error && "code" in err) {
+		const { code } = err;
+		if (typeof code === "string") return code;
+	}
+}
+function isLockedError(err) {
+	return errorCode(err) === "ELOCKED";
+}
+function lockedMessage(timeoutMs) {
+	return `Another CLI process is holding the budget (waited ${Math.round(timeoutMs / 1e3)}s). Retry, or use a different --data-dir.`;
+}
+function pidIsAlive(pid) {
+	if (pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (err) {
+		return errorCode(err) === "EPERM";
+	}
+}
+function readReaderNames(readers) {
+	try {
+		return readdirSync(readers);
+	} catch (err) {
+		if (errorCode(err) === "ENOENT") return [];
+		throw err;
+	}
+}
+function sweepStaleReaders(dir) {
+	const readers = readersDir(dir);
+	for (const name of readReaderNames(readers)) {
+		const pid = Number(name.split("-")[0]);
+		if (!Number.isFinite(pid) || !pidIsAlive(pid)) rmSync(join(readers, name), { force: true });
+	}
+}
+async function waitForReadersEmpty(dir, timeoutMs) {
+	const readers = readersDir(dir);
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		sweepStaleReaders(dir);
+		if (readReaderNames(readers).length === 0) return;
+		await new Promise((resolve) => setTimeout(resolve, READER_POLL_INTERVAL_MS));
+	}
+	throw new Error(lockedMessage(timeoutMs));
+}
+async function acquireGate(dir, timeoutMs) {
+	ensureDir(dir);
+	try {
+		return await import_proper_lockfile.default.lock(dir, {
+			lockfilePath: lockfilePath(dir),
+			retries: retriesForTimeout(timeoutMs),
+			stale: 3e4
+		});
+	} catch (err) {
+		if (isLockedError(err)) throw new Error(lockedMessage(timeoutMs));
+		throw err;
+	}
+}
+async function acquireExclusive(dir, { timeoutMs }) {
+	const start = Date.now();
+	const release = await acquireGate(dir, timeoutMs);
+	try {
+		await waitForReadersEmpty(dir, Math.max(0, timeoutMs - (Date.now() - start)));
+	} catch (err) {
+		await release();
+		throw err;
+	}
+	return () => release();
+}
+async function acquireShared(dir, { timeoutMs }) {
+	const gate = await acquireGate(dir, timeoutMs);
+	let markerPath;
+	try {
+		const readers = readersDir(dir);
+		ensureDir(readers);
+		markerPath = join(readers, `${process.pid}-${randomBytes(6).toString("hex")}`);
+		writeFileSync(markerPath, "");
+	} catch (err) {
+		await gate();
+		throw err;
+	}
+	await gate();
+	return async () => {
+		rmSync(markerPath, { force: true });
 	};
 }
 //#endregion
@@ -158153,10 +159704,13 @@ async function resolveConfig(cliOpts) {
 function info(message, verbose) {
 	if (verbose) process.stderr.write(message + "\n");
 }
-async function withConnection(globalOpts, fn, options = {}) {
-	const { loadBudget = true } = options;
+async function resolveBudgetIdForSyncId(syncId) {
+	const match = (await api.getBudgets()).find((b) => typeof b.id === "string" && (b.groupId === syncId || b.cloudFileId === syncId));
+	if (!match?.id) throw new Error(`Could not resolve on-disk budget id for syncId ${syncId} after download.`);
+	return match.id;
+}
+async function withConnection(globalOpts, fn, { mutates, skipBudget = false }) {
 	const config = await resolveConfig(globalOpts);
-	mkdirSync(config.dataDir, { recursive: true });
 	info(`Connecting to ${config.serverUrl}...`, globalOpts.verbose);
 	if (config.sessionToken) await api.init({
 		serverURL: config.serverUrl,
@@ -158172,11 +159726,68 @@ async function withConnection(globalOpts, fn, options = {}) {
 	});
 	else throw new Error("Authentication required. Provide --password or --session-token, or set ACTUAL_PASSWORD / ACTUAL_SESSION_TOKEN.");
 	try {
-		if (loadBudget && config.syncId) {
-			info(`Downloading budget ${config.syncId}...`, globalOpts.verbose);
-			await api.downloadBudget(config.syncId, { password: config.encryptionPassword });
-		} else if (loadBudget && !config.syncId) throw new Error("Sync ID is required for this command. Set --sync-id or ACTUAL_SYNC_ID.");
-		return await fn();
+		if (skipBudget) return await fn(config);
+		if (!config.syncId) throw new Error("Sync ID is required for this command. Set --sync-id or ACTUAL_SYNC_ID.");
+		const meta = getMetaDir(config.dataDir, config.syncId);
+		let release = null;
+		if (!config.noLock) release = mutates ? await acquireExclusive(meta, { timeoutMs: config.lockTimeout * 1e3 }) : await acquireShared(meta, { timeoutMs: config.lockTimeout * 1e3 });
+		try {
+			const cachedState = readCacheState(meta);
+			const decision = decideSyncAction({
+				state: cachedState,
+				config: {
+					syncId: config.syncId,
+					serverUrl: config.serverUrl
+				},
+				now: Date.now(),
+				ttlMs: config.cacheTtl * 1e3,
+				mutates,
+				refresh: config.refresh,
+				encrypted: Boolean(config.encryptionPassword)
+			});
+			let state;
+			if (decision.action === "download") {
+				info(cachedState === null ? `Downloading budget ${config.syncId} for the first time...` : `Re-downloading budget ${config.syncId} (cache invalidated)...`, globalOpts.verbose);
+				await api.downloadBudget(config.syncId, { password: config.encryptionPassword });
+				const budgetId = await resolveBudgetIdForSyncId(config.syncId);
+				const now = Date.now();
+				state = {
+					version: 1,
+					syncId: config.syncId,
+					budgetId,
+					serverUrl: config.serverUrl,
+					lastSyncedAt: now,
+					lastDownloadedAt: now
+				};
+				writeCacheState(meta, state);
+			} else if (decision.action === "skip") {
+				info(`Using cached budget (synced ${Math.round((Date.now() - decision.state.lastSyncedAt) / 1e3)}s ago)...`, globalOpts.verbose);
+				await api.loadBudget(decision.state.budgetId);
+				state = decision.state;
+			} else {
+				info(`Syncing budget ${config.syncId}...`, globalOpts.verbose);
+				await api.loadBudget(decision.state.budgetId);
+				await api.sync();
+				state = {
+					...decision.state,
+					lastSyncedAt: Date.now()
+				};
+				writeCacheState(meta, state);
+			}
+			const result = await fn(config);
+			if (mutates) {
+				info(`Pushing changes for ${config.syncId}...`, globalOpts.verbose);
+				await api.sync();
+				state = {
+					...state,
+					lastSyncedAt: Date.now()
+				};
+				writeCacheState(meta, state);
+			}
+			return result;
+		} finally {
+			if (release) await release();
+		}
 	} finally {
 		await api.shutdown();
 	}
@@ -159901,7 +161512,7 @@ function registerAccountsCommand(program) {
 				closed: a.closed,
 				balance: balances[i]
 			})), opts.format);
-		});
+		}, { mutates: false });
 	});
 	accounts.command("create").description("Create a new account").requiredOption("--name <name>", "Account name").option("--offbudget", "Create as off-budget account", false).option("--balance <amount>", "Initial balance in cents (e.g. 50000 = 500.00)", "0").action(async (cmdOpts) => {
 		const balance = parseIntFlag(cmdOpts.balance, "--balance");
@@ -159911,7 +161522,7 @@ function registerAccountsCommand(program) {
 				name: cmdOpts.name,
 				offbudget: cmdOpts.offbudget
 			}, balance) }, opts.format);
-		});
+		}, { mutates: true });
 	});
 	accounts.command("update <id>").description("Update an account").option("--name <name>", "New account name").option("--offbudget <bool>", "Set off-budget status").action(async (id, cmdOpts) => {
 		const opts = program.opts();
@@ -159929,7 +161540,7 @@ function registerAccountsCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 	accounts.command("close <id>").description("Close an account").option("--transfer-account <id>", "Transfer remaining balance to this account").option("--transfer-category <id>", "Transfer remaining balance to this category").action(async (id, cmdOpts) => {
 		const opts = program.opts();
@@ -159939,7 +161550,7 @@ function registerAccountsCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 	accounts.command("reopen <id>").description("Reopen a closed account").action(async (id) => {
 		const opts = program.opts();
@@ -159949,7 +161560,7 @@ function registerAccountsCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 	accounts.command("delete <id>").description("Delete an account").action(async (id) => {
 		const opts = program.opts();
@@ -159959,7 +161570,7 @@ function registerAccountsCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 	accounts.command("balance <id>").description("Get account balance").option("--cutoff <date>", "Cutoff date (YYYY-MM-DD)").action(async (id, cmdOpts) => {
 		let cutoff;
@@ -159974,7 +161585,7 @@ function registerAccountsCommand(program) {
 				id,
 				balance: await api.getAccountBalance(id, cutoff)
 			}, opts.format);
-		});
+		}, { mutates: false });
 	});
 }
 //#endregion
@@ -159985,37 +161596,36 @@ function registerBudgetsCommand(program) {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			printOutput(await api.getBudgets(), opts.format);
-		}, { loadBudget: false });
+		}, {
+			mutates: false,
+			skipBudget: true
+		});
 	});
 	budgets.command("download <syncId>").description("Download a budget by sync ID").option("--encryption-password <password>", "Encryption password").action(async (syncId, cmdOpts) => {
 		const opts = program.opts();
-		const password = (await resolveConfig(opts)).encryptionPassword ?? cmdOpts.encryptionPassword;
-		await withConnection(opts, async () => {
+		await withConnection(opts, async (config) => {
+			const password = cmdOpts.encryptionPassword ?? config.encryptionPassword;
 			await api.downloadBudget(syncId, { password });
 			printOutput({
 				success: true,
 				syncId
 			}, opts.format);
-		}, { loadBudget: false });
-	});
-	budgets.command("sync").description("Sync the current budget").action(async () => {
-		const opts = program.opts();
-		await withConnection(opts, async () => {
-			await api.sync();
-			printOutput({ success: true }, opts.format);
+		}, {
+			mutates: false,
+			skipBudget: true
 		});
 	});
 	budgets.command("months").description("List available budget months").action(async () => {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			printOutput(await api.getBudgetMonths(), opts.format);
-		});
+		}, { mutates: false });
 	});
 	budgets.command("month <month>").description("Get budget data for a specific month (YYYY-MM)").action(async (month) => {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			printOutput(await api.getBudgetMonth(month), opts.format);
-		});
+		}, { mutates: false });
 	});
 	budgets.command("set-amount").description("Set budget amount for a category in a month").requiredOption("--month <month>", "Budget month (YYYY-MM)").requiredOption("--category <id>", "Category ID").requiredOption("--amount <amount>", "Amount in cents (e.g. 50000 = 500.00)").action(async (cmdOpts) => {
 		const amount = parseIntFlag(cmdOpts.amount, "--amount");
@@ -160023,7 +161633,7 @@ function registerBudgetsCommand(program) {
 		await withConnection(opts, async () => {
 			await api.setBudgetAmount(cmdOpts.month, cmdOpts.category, amount);
 			printOutput({ success: true }, opts.format);
-		});
+		}, { mutates: true });
 	});
 	budgets.command("set-carryover").description("Enable/disable carryover for a category").requiredOption("--month <month>", "Budget month (YYYY-MM)").requiredOption("--category <id>", "Category ID").requiredOption("--flag <bool>", "Enable (true) or disable (false)").action(async (cmdOpts) => {
 		const flag = parseBoolFlag(cmdOpts.flag, "--flag");
@@ -160031,7 +161641,7 @@ function registerBudgetsCommand(program) {
 		await withConnection(opts, async () => {
 			await api.setBudgetCarryover(cmdOpts.month, cmdOpts.category, flag);
 			printOutput({ success: true }, opts.format);
-		});
+		}, { mutates: true });
 	});
 	budgets.command("hold-next-month").description("Hold budget amount for next month").requiredOption("--month <month>", "Budget month (YYYY-MM)").requiredOption("--amount <amount>", "Amount in cents (e.g. 50000 = 500.00)").action(async (cmdOpts) => {
 		const parsedAmount = parseIntFlag(cmdOpts.amount, "--amount");
@@ -160039,14 +161649,14 @@ function registerBudgetsCommand(program) {
 		await withConnection(opts, async () => {
 			await api.holdBudgetForNextMonth(cmdOpts.month, parsedAmount);
 			printOutput({ success: true }, opts.format);
-		});
+		}, { mutates: true });
 	});
 	budgets.command("reset-hold").description("Reset budget hold for a month").requiredOption("--month <month>", "Budget month (YYYY-MM)").action(async (cmdOpts) => {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			await api.resetBudgetHold(cmdOpts.month);
 			printOutput({ success: true }, opts.format);
-		});
+		}, { mutates: true });
 	});
 }
 //#endregion
@@ -160057,7 +161667,7 @@ function registerCategoriesCommand(program) {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			printOutput(await api.getCategories(), opts.format);
-		});
+		}, { mutates: false });
 	});
 	categories.command("create").description("Create a new category").requiredOption("--name <name>", "Category name").requiredOption("--group-id <id>", "Category group ID").option("--is-income", "Mark as income category", false).action(async (cmdOpts) => {
 		const opts = program.opts();
@@ -160068,7 +161678,7 @@ function registerCategoriesCommand(program) {
 				is_income: cmdOpts.isIncome,
 				hidden: false
 			}) }, opts.format);
-		});
+		}, { mutates: true });
 	});
 	categories.command("update <id>").description("Update a category").option("--name <name>", "New category name").option("--hidden <bool>", "Set hidden status").action(async (id, cmdOpts) => {
 		const fields = {};
@@ -160082,7 +161692,7 @@ function registerCategoriesCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 	categories.command("delete <id>").description("Delete a category").option("--transfer-to <id>", "Transfer transactions to this category").action(async (id, cmdOpts) => {
 		const opts = program.opts();
@@ -160092,7 +161702,7 @@ function registerCategoriesCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 }
 //#endregion
@@ -160103,7 +161713,7 @@ function registerCategoryGroupsCommand(program) {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			printOutput(await api.getCategoryGroups(), opts.format);
-		});
+		}, { mutates: false });
 	});
 	groups.command("create").description("Create a new category group").requiredOption("--name <name>", "Group name").option("--is-income", "Mark as income group", false).action(async (cmdOpts) => {
 		const opts = program.opts();
@@ -160113,7 +161723,7 @@ function registerCategoryGroupsCommand(program) {
 				is_income: cmdOpts.isIncome,
 				hidden: false
 			}) }, opts.format);
-		});
+		}, { mutates: true });
 	});
 	groups.command("update <id>").description("Update a category group").option("--name <name>", "New group name").option("--hidden <bool>", "Set hidden status").action(async (id, cmdOpts) => {
 		const fields = {};
@@ -160127,7 +161737,7 @@ function registerCategoryGroupsCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 	groups.command("delete <id>").description("Delete a category group").option("--transfer-to <id>", "Transfer transactions to this category ID").action(async (id, cmdOpts) => {
 		const opts = program.opts();
@@ -160137,7 +161747,7 @@ function registerCategoryGroupsCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 }
 //#endregion
@@ -160148,19 +161758,19 @@ function registerPayeesCommand(program) {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			printOutput(await api.getPayees(), opts.format);
-		});
+		}, { mutates: false });
 	});
 	payees.command("common").description("List frequently used payees").action(async () => {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			printOutput(await api.getCommonPayees(), opts.format);
-		});
+		}, { mutates: false });
 	});
 	payees.command("create").description("Create a new payee").requiredOption("--name <name>", "Payee name").action(async (cmdOpts) => {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			printOutput({ id: await api.createPayee({ name: cmdOpts.name }) }, opts.format);
-		});
+		}, { mutates: true });
 	});
 	payees.command("update <id>").description("Update a payee").option("--name <name>", "New payee name").action(async (id, cmdOpts) => {
 		const fields = {};
@@ -160173,7 +161783,7 @@ function registerPayeesCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 	payees.command("delete <id>").description("Delete a payee").action(async (id) => {
 		const opts = program.opts();
@@ -160183,7 +161793,7 @@ function registerPayeesCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 	payees.command("merge").description("Merge payees into a target payee").requiredOption("--target <id>", "Target payee ID").requiredOption("--ids <ids>", "Comma-separated payee IDs to merge").action(async (cmdOpts) => {
 		const mergeIds = cmdOpts.ids.split(",").map((id) => id.trim()).filter((id) => id.length > 0);
@@ -160192,7 +161802,7 @@ function registerPayeesCommand(program) {
 		await withConnection(opts, async () => {
 			await api.mergePayees(cmdOpts.target, mergeIds);
 			printOutput({ success: true }, opts.format);
-		});
+		}, { mutates: true });
 	});
 }
 //#endregion
@@ -160201,7 +161811,7 @@ function readJsonInput(cmdOpts) {
 	if (cmdOpts.data && cmdOpts.file) throw new Error("Cannot use both --data and --file");
 	if (cmdOpts.data) return JSON.parse(cmdOpts.data);
 	if (cmdOpts.file) {
-		const content = cmdOpts.file === "-" ? readFileSync(0, "utf-8") : readFileSync(cmdOpts.file, "utf-8");
+		const content = cmdOpts.file === "-" ? readFileSync$1(0, "utf-8") : readFileSync$1(cmdOpts.file, "utf-8");
 		return JSON.parse(content);
 	}
 	throw new Error("Either --data or --file is required");
@@ -160424,7 +162034,7 @@ function registerQueryCommand(program) {
 			if (!isRecord(result) || !("data" in result)) throw new Error("Query result missing data");
 			if (cmdOpts.count) printOutput({ count: result.data }, opts.format);
 			else printOutput(result.data, opts.format);
-		});
+		}, { mutates: false });
 	});
 	query.command("tables").description("List available tables for querying").action(() => {
 		const opts = program.opts();
@@ -160449,20 +162059,20 @@ function registerRulesCommand(program) {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			printOutput(await api.getRules(), opts.format);
-		});
+		}, { mutates: false });
 	});
 	rules.command("payee-rules <payeeId>").description("List rules for a specific payee").action(async (payeeId) => {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			printOutput(await api.getPayeeRules(payeeId), opts.format);
-		});
+		}, { mutates: false });
 	});
 	rules.command("create").description("Create a new rule").option("--data <json>", "Rule definition as JSON").option("--file <path>", "Read rule from JSON file (use - for stdin)").action(async (cmdOpts) => {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			const rule = readJsonInput(cmdOpts);
 			printOutput({ id: await api.createRule(rule) }, opts.format);
-		});
+		}, { mutates: true });
 	});
 	rules.command("update").description("Update a rule").option("--data <json>", "Rule data as JSON (must include id)").option("--file <path>", "Read rule from JSON file (use - for stdin)").action(async (cmdOpts) => {
 		const opts = program.opts();
@@ -160470,7 +162080,7 @@ function registerRulesCommand(program) {
 			const rule = readJsonInput(cmdOpts);
 			await api.updateRule(rule);
 			printOutput({ success: true }, opts.format);
-		});
+		}, { mutates: true });
 	});
 	rules.command("delete <id>").description("Delete a rule").action(async (id) => {
 		const opts = program.opts();
@@ -160480,7 +162090,7 @@ function registerRulesCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 }
 //#endregion
@@ -160491,14 +162101,14 @@ function registerSchedulesCommand(program) {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			printOutput(await api.getSchedules(), opts.format);
-		});
+		}, { mutates: false });
 	});
 	schedules.command("create").description("Create a new schedule").option("--data <json>", "Schedule definition as JSON").option("--file <path>", "Read schedule from JSON file (use - for stdin)").action(async (cmdOpts) => {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			const schedule = readJsonInput(cmdOpts);
 			printOutput({ id: await api.createSchedule(schedule) }, opts.format);
-		});
+		}, { mutates: true });
 	});
 	schedules.command("update <id>").description("Update a schedule").option("--data <json>", "Fields to update as JSON").option("--file <path>", "Read fields from JSON file (use - for stdin)").option("--reset-next-date", "Reset next occurrence date", false).action(async (id, cmdOpts) => {
 		const opts = program.opts();
@@ -160509,7 +162119,7 @@ function registerSchedulesCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 	schedules.command("delete <id>").description("Delete a schedule").action(async (id) => {
 		const opts = program.opts();
@@ -160519,7 +162129,7 @@ function registerSchedulesCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 }
 //#endregion
@@ -160530,7 +162140,10 @@ function registerServerCommand(program) {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			printOutput({ version: await api.getServerVersion() }, opts.format);
-		}, { loadBudget: false });
+		}, {
+			mutates: false,
+			skipBudget: true
+		});
 	});
 	server.command("get-id").description("Get entity ID by name").addOption(new Option("--type <type>", "Entity type").choices([
 		"accounts",
@@ -160545,7 +162158,7 @@ function registerServerCommand(program) {
 				type: cmdOpts.type,
 				name: cmdOpts.name
 			}, opts.format);
-		});
+		}, { mutates: false });
 	});
 	server.command("bank-sync").description("Run bank synchronization").option("--account <id>", "Specific account ID to sync").action(async (cmdOpts) => {
 		const opts = program.opts();
@@ -160553,7 +162166,69 @@ function registerServerCommand(program) {
 			const args = cmdOpts.account ? { accountId: cmdOpts.account } : void 0;
 			await api.runBankSync(args);
 			printOutput({ success: true }, opts.format);
-		});
+		}, { mutates: true });
+	});
+}
+//#endregion
+//#region src/commands/sync.ts
+async function requireSyncIdAndMeta(opts, flag) {
+	const config = await resolveConfig(opts);
+	if (!config.syncId) throw new Error(`Sync ID is required for sync ${flag}. Set --sync-id or ACTUAL_SYNC_ID.`);
+	return {
+		config,
+		meta: getMetaDir(config.dataDir, config.syncId)
+	};
+}
+function registerSyncCommand(program) {
+	program.command("sync").description("Sync the local cached budget with the server, print cache status, or clear the cache").option("--status", "Print cache status without syncing", false).option("--clear", "Delete the local cache; next command re-downloads", false).action(async (cmdOpts) => {
+		const opts = program.opts();
+		if (cmdOpts.status) {
+			const { config, meta } = await requireSyncIdAndMeta(opts, "--status");
+			const state = readCacheState(meta);
+			if (state === null) {
+				printOutput({
+					neverSynced: true,
+					syncId: config.syncId,
+					ttlSeconds: config.cacheTtl
+				}, opts.format);
+				return;
+			}
+			const rawAgeSeconds = Math.round((Date.now() - state.lastSyncedAt) / 1e3);
+			const ageSeconds = Math.max(0, rawAgeSeconds);
+			printOutput({
+				neverSynced: false,
+				syncId: state.syncId,
+				budgetId: state.budgetId,
+				syncedAt: new Date(state.lastSyncedAt).toISOString(),
+				lastDownloadedAt: new Date(state.lastDownloadedAt).toISOString(),
+				ageSeconds,
+				ttlSeconds: config.cacheTtl,
+				stale: rawAgeSeconds < 0 || rawAgeSeconds > config.cacheTtl
+			}, opts.format);
+			return;
+		}
+		if (cmdOpts.clear) {
+			const { config, meta } = await requireSyncIdAndMeta(opts, "--clear");
+			const release = config.noLock ? null : await acquireExclusive(meta, { timeoutMs: config.lockTimeout * 1e3 });
+			try {
+				rmSync(join(meta, CACHE_FILE_NAME), { force: true });
+			} finally {
+				await release?.();
+			}
+			printOutput({
+				cleared: true,
+				syncId: config.syncId
+			}, opts.format);
+			return;
+		}
+		await withConnection(opts, async (config) => {
+			const state = config.syncId ? readCacheState(getMetaDir(config.dataDir, config.syncId)) : null;
+			printOutput({
+				syncedAt: new Date(state?.lastSyncedAt ?? Date.now()).toISOString(),
+				syncId: config.syncId,
+				budgetId: state?.budgetId ?? config.syncId
+			}, opts.format);
+		}, { mutates: true });
 	});
 }
 //#endregion
@@ -160564,7 +162239,7 @@ function registerTagsCommand(program) {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			printOutput(await api.getTags(), opts.format);
-		});
+		}, { mutates: false });
 	});
 	tags.command("create").description("Create a new tag").requiredOption("--tag <tag>", "Tag name").option("--color <color>", "Tag color").option("--description <description>", "Tag description").action(async (cmdOpts) => {
 		const opts = program.opts();
@@ -160574,7 +162249,7 @@ function registerTagsCommand(program) {
 				color: cmdOpts.color,
 				description: cmdOpts.description
 			}) }, opts.format);
-		});
+		}, { mutates: true });
 	});
 	tags.command("update <id>").description("Update a tag").option("--tag <tag>", "New tag name").option("--color <color>", "New tag color").option("--description <description>", "New tag description").action(async (id, cmdOpts) => {
 		const fields = {};
@@ -160589,7 +162264,7 @@ function registerTagsCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 	tags.command("delete <id>").description("Delete a tag").action(async (id) => {
 		const opts = program.opts();
@@ -160599,7 +162274,7 @@ function registerTagsCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 }
 //#endregion
@@ -160610,7 +162285,7 @@ function registerTransactionsCommand(program) {
 		const opts = program.opts();
 		await withConnection(opts, async () => {
 			printOutput(await api.getTransactions(cmdOpts.account, cmdOpts.start, cmdOpts.end), opts.format);
-		});
+		}, { mutates: false });
 	});
 	transactions.command("add").description("Add transactions to an account").requiredOption("--account <id>", "Account ID").option("--data <json>", "Transaction data as JSON array").option("--file <path>", "Read transaction data from JSON file (use - for stdin)").option("--learn-categories", "Learn category assignments", false).option("--run-transfers", "Process transfers", false).action(async (cmdOpts) => {
 		const opts = program.opts();
@@ -160620,7 +162295,7 @@ function registerTransactionsCommand(program) {
 				learnCategories: cmdOpts.learnCategories,
 				runTransfers: cmdOpts.runTransfers
 			}), opts.format);
-		});
+		}, { mutates: true });
 	});
 	transactions.command("import").description("Import transactions to an account").requiredOption("--account <id>", "Account ID").option("--data <json>", "Transaction data as JSON array").option("--file <path>", "Read transaction data from JSON file (use - for stdin)").option("--dry-run", "Preview without importing", false).action(async (cmdOpts) => {
 		const opts = program.opts();
@@ -160630,7 +162305,7 @@ function registerTransactionsCommand(program) {
 				defaultCleared: true,
 				dryRun: cmdOpts.dryRun
 			}), opts.format);
-		});
+		}, { mutates: true });
 	});
 	transactions.command("update <id>").description("Update a transaction").option("--data <json>", "Fields to update as JSON").option("--file <path>", "Read fields from JSON file (use - for stdin)").action(async (id, cmdOpts) => {
 		const opts = program.opts();
@@ -160641,7 +162316,7 @@ function registerTransactionsCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 	transactions.command("delete <id>").description("Delete a transaction").action(async (id) => {
 		const opts = program.opts();
@@ -160651,13 +162326,13 @@ function registerTransactionsCommand(program) {
 				success: true,
 				id
 			}, opts.format);
-		});
+		}, { mutates: true });
 	});
 }
 //#endregion
 //#region src/index.ts
 var program = new Command();
-program.name("actual").description("CLI for Actual Budget").version("26.5.0").option("--server-url <url>", "Actual server URL (env: ACTUAL_SERVER_URL)").option("--password <password>", "Server password (env: ACTUAL_PASSWORD)").option("--session-token <token>", "Session token (env: ACTUAL_SESSION_TOKEN)").option("--sync-id <id>", "Budget sync ID (env: ACTUAL_SYNC_ID)").option("--data-dir <path>", "Data directory (env: ACTUAL_DATA_DIR)").option("--encryption-password <password>", "E2E encryption password (env: ACTUAL_ENCRYPTION_PASSWORD)").addOption(new Option("--format <format>", "Output format: json, table, csv").choices([
+program.name("actual").description("CLI for Actual Budget").version("26.6.0-nightly.20260504").option("--server-url <url>", "Actual server URL (env: ACTUAL_SERVER_URL)").option("--password <password>", "Server password (env: ACTUAL_PASSWORD)").option("--session-token <token>", "Session token (env: ACTUAL_SESSION_TOKEN)").option("--sync-id <id>", "Budget sync ID (env: ACTUAL_SYNC_ID)").option("--data-dir <path>", "Data directory (env: ACTUAL_DATA_DIR)").option("--encryption-password <password>", "E2E encryption password (env: ACTUAL_ENCRYPTION_PASSWORD)").option("--cache-ttl <seconds>", "Cache TTL in seconds (env: ACTUAL_CACHE_TTL; default: 60)", (value) => parseNonNegativeIntFlag(value, "--cache-ttl")).option("--refresh", "Force a sync on this call, ignoring the cache", false).option("--no-cache", "Alias for --refresh").option("--lock-timeout <seconds>", "How long to wait for another CLI process to release the lock (env: ACTUAL_LOCK_TIMEOUT; default: 10)", (value) => parseNonNegativeIntFlag(value, "--lock-timeout")).option("--no-lock", "Disable the budget directory lock (use with care, env: ACTUAL_NO_LOCK)").addOption(new Option("--format <format>", "Output format: json, table, csv").choices([
 	"json",
 	"table",
 	"csv"
@@ -160673,6 +162348,7 @@ registerRulesCommand(program);
 registerSchedulesCommand(program);
 registerQueryCommand(program);
 registerServerCommand(program);
+registerSyncCommand(program);
 function normalizeThrownMessage(err) {
 	if (err instanceof Error) return err.message;
 	if (typeof err === "object" && err !== null) try {