@agimon-ai/po-git 0.0.0-alpha.45 → 0.0.0-alpha.46

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_worktreeOperations = require("./worktreeOperations-CU0iV2h-.cjs");
+const require_worktreeOperations = require("./worktreeOperations-C1ygq-Na.cjs");
 //#region src/services/extensionService/index.ts
 var DefaultGitExtensionService = class {
 	async execute() {

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":["_$___worktreeEvents0.WorktreeMessage"],"sources":["../src/services/worktreeEvents/index.ts","../src/types/worktreeRegistry.ts","../src/services/worktreeNaming/index.ts","../src/services/worktreeOperations/index.ts","../src/types/extension.ts","../src/services/extensionService/index.ts","../src/services/gitDependencies/index.ts"],"mappings":";;;cASa;KASD;UAEK;WACN,gBAAgB;WAChB;WACA;WACA,MAAM;WACN;WACA;;;;;;;;;;;KCRC;cAEC;UAEI;EACf,gBAAgB;;EAEhB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;EAKA;EACA,QAAQ;;EAER;;;;UC8De;;EAEf,QAAQ;;EAER,QAAQ;;EAER;;EAEA,WAAW;;;;;;;EAOX;;;;;;;;iBASc,UAAU;EACxB,kBAAkB;EAClB;EACA;EACA,aAAa;IACX;;;UCnFa;;EAEf;;;;;EAKA;;UAGe;EACf;EACA;EACA;EACA;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf,SAAS;;EAET,cAAc;;UAGC;EACf,MAAM,SAAS,iBAAiB,SAAS,sBAAsB,UAAU,eAAe,QAAQ;EAChG,MAAM,SAAS,iBAAiB,YAAY,iBAAiB,QAAQ;EACrE,KAAK,SAAS,kBAAkB,QAAQ;EACxC,OAAO,SAAS,iBAAiB,aAAa;IAAU,QAAQ;IAAgB;;EAChF,MAAM,SAAS,iBAAiB,YAAY,mBAAmB,QAAQ;EACvE,MAAM,SAAS,iBAAiB,kBAAkB,QAAQ,kBAAkB;EAC5E,KAAK,SAAS,iBAAiB,YAAY,kBAAkB;EAC7D,SAAS,SAAS,iBAAiB,aAAa,QAA9BA;;;;KCtFR;UAEK;EACf;EACA,OAAO;;UAGQ;EACf,WAAW,QAAQ;;UAGJ;EACf,SAAS;EACT,YAAY;;;;qBCbD,sCAAsC;EAC3C,WAAW,QAAQ;;;;wBCEX,sBAAsB,YAAW,QAAQ,4BAAiC"}
+{"version":3,"file":"index.d.mts","names":["_$___worktreeEvents0.WorktreeMessage"],"sources":["../src/services/worktreeEvents/index.ts","../src/types/worktreeRegistry.ts","../src/services/worktreeNaming/index.ts","../src/services/worktreeOperations/index.ts","../src/types/extension.ts","../src/services/extensionService/index.ts","../src/services/gitDependencies/index.ts"],"mappings":";;;cASa;KASD;UAEK;WACN,gBAAgB;WAChB;WACA;WACA,MAAM;WACN;WACA;;;;;;;;;;;KCRC;cAEC;UAEI;EACf,gBAAgB;;EAEhB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;EAKA;EACA,QAAQ;;EAER;;;;UCgEe;;EAEf,QAAQ;;EAER,QAAQ;;EAER;;EAEA,WAAW;;;;;;;EAOX;;;;;;;;iBASc,UAAU;EACxB,kBAAkB;EAClB;EACA;EACA,aAAa;IACX;;;UCrFa;;EAEf;;;;;EAKA;;UAGe;EACf;EACA;EACA;EACA;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf,SAAS;;EAET,cAAc;;UAGC;EACf,MAAM,SAAS,iBAAiB,SAAS,sBAAsB,UAAU,eAAe,QAAQ;EAChG,MAAM,SAAS,iBAAiB,YAAY,iBAAiB,QAAQ;EACrE,KAAK,SAAS,kBAAkB,QAAQ;EACxC,OAAO,SAAS,iBAAiB,aAAa;IAAU,QAAQ;IAAgB;;EAChF,MAAM,SAAS,iBAAiB,YAAY,mBAAmB,QAAQ;EACvE,MAAM,SAAS,iBAAiB,kBAAkB,QAAQ,kBAAkB;EAC5E,KAAK,SAAS,iBAAiB,YAAY,kBAAkB;EAC7D,SAAS,SAAS,iBAAiB,aAAa,QAA9BA;;;;KCtFR;UAEK;EACf;EACA,OAAO;;UAGQ;EACf,WAAW,QAAQ;;UAGJ;EACf,SAAS;EACT,YAAY;;;;qBCbD,sCAAsC;EAC3C,WAAW,QAAQ;;;;wBCEX,sBAAsB,YAAW,QAAQ,4BAAiC"}

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { T as createWorktreeGit, t as createWorktreeOperations } from "./worktreeOperations-BqLLypS5.mjs";
+import { T as createWorktreeGit, t as createWorktreeOperations } from "./worktreeOperations-CP2lYxrI.mjs";
 //#region src/services/extensionService/index.ts
 var DefaultGitExtensionService = class {
 	async execute() {

package/dist/{worktreeOperations-CU0iV2h-.cjs → worktreeOperations-C1ygq-Na.cjs}

@@ -21,8 +21,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 let node_child_process = require("node:child_process");
-let node_fs = require("node:fs");
-node_fs = __toESM(node_fs, 1);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises, 1);
 let node_crypto = require("node:crypto");
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
@@ -200,7 +200,7 @@ function createWorktreeGit() {
 				path
 			], REMOVE_TIMEOUT_MS);
 			if (result.code === 0) return;
-			if (missingWorktree(result.stderr) && !node_fs.default.existsSync(path)) {
+			if (missingWorktree(result.stderr) && !await node_fs_promises.default.access(path).then(() => true, () => false)) {
 				await prune(repositoryRoot);
 				return;
 			}
@@ -338,12 +338,12 @@ const OWNER_ONLY_FILE = 384;
 * record in it. Writing beside the target and renaming makes the swap atomic on
 * the same filesystem, so a reader sees either the old file or the new one.
 */
-function writeJsonAtomic(file, value) {
+async function writeJsonAtomic(file, value) {
 	const directory = node_path.default.dirname(file);
-	node_fs.default.mkdirSync(directory, { recursive: true });
-	const temporary = node_path.default.join(directory, `.${node_path.default.basename(file)}.${String(process.pid)}.tmp`);
-	node_fs.default.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: OWNER_ONLY_FILE });
-	node_fs.default.renameSync(temporary, file);
+	await node_fs_promises.default.mkdir(directory, { recursive: true });
+	const temporary = node_path.default.join(directory, `.${node_path.default.basename(file)}.${(0, node_crypto.randomUUID)()}.tmp`);
+	await node_fs_promises.default.writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: OWNER_ONLY_FILE });
+	await node_fs_promises.default.rename(temporary, file);
 }
 /**
 * Reads JSON, treating every failure as absent.
@@ -352,9 +352,9 @@ function writeJsonAtomic(file, value) {
 * here: there is nothing to act on. Distinguishing them would only offer a
 * choice no caller wants to make.
 */
-function readJson(file) {
+async function readJson(file) {
 	try {
-		return JSON.parse(node_fs.default.readFileSync(file, "utf8"));
+		return JSON.parse(await node_fs_promises.default.readFile(file, "utf8"));
 	} catch {
 		return;
 	}
@@ -373,12 +373,12 @@ const MAX_LABEL_LENGTH = 32;
 * the registry is per repository and must be found from inside a worktree too.
 * A session may run in a subdirectory, so the nearest enclosing checkout is used.
 */
-function gitCommonDirectory(directory) {
+async function gitCommonDirectory(directory) {
 	let root = node_path.default.resolve(directory);
 	let marker = node_path.default.join(root, ".git");
 	let stat;
 	for (;;) try {
-		stat = node_fs.default.statSync(marker);
+		stat = await node_fs_promises.default.stat(marker);
 		break;
 	} catch {
 		const parent = node_path.default.dirname(root);
@@ -389,14 +389,14 @@ function gitCommonDirectory(directory) {
 	if (stat.isDirectory()) return marker;
 	let pointer;
 	try {
-		pointer = node_fs.default.readFileSync(marker, "utf8").trim();
+		pointer = (await node_fs_promises.default.readFile(marker, "utf8")).trim();
 	} catch {
 		return;
 	}
 	if (!pointer.startsWith("gitdir:")) return void 0;
 	const gitDir = node_path.default.resolve(root, pointer.slice(7).trim());
 	try {
-		const common = node_fs.default.readFileSync(node_path.default.join(gitDir, "commondir"), "utf8").trim();
+		const common = (await node_fs_promises.default.readFile(node_path.default.join(gitDir, "commondir"), "utf8")).trim();
 		return node_path.default.resolve(gitDir, common);
 	} catch {
 		return gitDir;
@@ -415,8 +415,8 @@ function repositoryLabel(root) {
 * registry. Falling back to the path keeps a non-repository directory usable
 * instead of failing, though nothing here should reach that case.
 */
-function repositoryId(root) {
-	const common = gitCommonDirectory(root);
+async function repositoryId(root) {
+	const common = await gitCommonDirectory(root);
 	const token = common === void 0 ? `root:${node_path.default.resolve(root)}` : `git:${common}`;
 	return (0, node_crypto.createHash)("sha256").update(token).digest("hex").slice(0, ID_LENGTH);
 }
@@ -452,22 +452,26 @@ function credentialsFile(homeDir = node_os.default.homedir()) {
 	return node_path.default.join(poGitRoot(homeDir), "credentials.json");
 }
 /** One registry file per repository, keyed by the shared git directory. */
-function registryFile(repositoryRoot, homeDir = node_os.default.homedir()) {
-	const id = repositoryId(repositoryRoot);
+async function registryFile(repositoryRoot, homeDir = node_os.default.homedir()) {
+	const id = await repositoryId(repositoryRoot);
 	const root = node_path.default.join(poGitRoot(homeDir), "registry");
 	const canonical = node_path.default.join(root, id, "worktrees.json");
-	if (node_fs.default.existsSync(canonical)) return canonical;
+	if (await node_fs_promises.default.access(canonical).then(() => true, () => false)) return canonical;
 	let names;
 	try {
-		names = node_fs.default.readdirSync(root);
+		names = await node_fs_promises.default.readdir(root);
 	} catch {
 		return canonical;
 	}
-	const legacyFiles = names.filter((entry) => entry.endsWith(`--${id}`)).sort().map((entry) => node_path.default.join(root, entry, "worktrees.json")).filter((file) => node_fs.default.existsSync(file));
+	const legacyFiles = [];
+	for (const entry of names.filter((name) => name.endsWith(`--${id}`)).sort()) {
+		const file = node_path.default.join(root, entry, "worktrees.json");
+		if (await node_fs_promises.default.access(file).then(() => true, () => false)) legacyFiles.push(file);
+	}
 	if (legacyFiles.length === 0) return canonical;
 	const entries = /* @__PURE__ */ new Map();
 	for (const file of legacyFiles) {
-		const legacy = readJson(file);
+		const legacy = await readJson(file);
 		if (legacy?.version !== 1 || !Array.isArray(legacy.entries)) continue;
 		for (const value of legacy.entries) {
 			if (typeof value !== "object" || value === null || !("id" in value) || typeof value.id !== "string" || value.id === "") continue;
@@ -478,16 +482,16 @@ function registryFile(repositoryRoot, homeDir = node_os.default.homedir()) {
 		}
 	}
 	const temporary = `${canonical}.${(0, node_crypto.randomUUID)()}.migration`;
-	writeJsonAtomic(temporary, {
+	await writeJsonAtomic(temporary, {
 		version: 1,
 		entries: [...entries.values()]
 	});
 	try {
-		node_fs.default.linkSync(temporary, canonical);
+		await node_fs_promises.default.link(temporary, canonical);
 	} catch (error) {
 		if (error.code !== "EEXIST") throw error;
 	} finally {
-		node_fs.default.rmSync(temporary);
+		await node_fs_promises.default.rm(temporary);
 	}
 	return canonical;
 }
@@ -606,18 +610,22 @@ function refuseClose(input) {
 * uncommitted work, so losing the record would lose the only pointer to it.
 * Deletion is always a separate, named decision.
 */
-function reconcile(records, probe) {
+async function reconcile(records, probe) {
 	const changed = [];
+	const next = [];
+	for (const record of records) {
+		if (record.status === "orphaned" || await probe.exists(record.path) && probe.alive(record)) {
+			next.push(record);
+			continue;
+		}
+		changed.push(record.id);
+		next.push({
+			...record,
+			status: "orphaned"
+		});
+	}
 	return {
-		records: records.map((record) => {
-			if (record.status === "orphaned") return record;
-			if (!(!probe.exists(record.path) || !probe.alive(record))) return record;
-			changed.push(record.id);
-			return {
-				...record,
-				status: "orphaned"
-			};
-		}),
+		records: next,
 		changed
 	};
 }
@@ -677,25 +685,25 @@ function isRecord(value) {
 */
 function createWorktreeRegistry(file) {
 	return {
-		list() {
-			const parsed = readJson(file);
+		async list() {
+			const parsed = await readJson(file);
 			if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.entries)) return [];
 			return parsed.entries.filter(isRecord);
 		},
-		replace(entries) {
-			writeJsonAtomic(file, {
+		async replace(entries) {
+			await writeJsonAtomic(file, {
 				version: 1,
 				entries
 			});
 		},
 		async transaction(operation, signal) {
 			const lock = `${file}.lock`;
-			node_fs.default.mkdirSync(node_path.default.dirname(file), { recursive: true });
+			await node_fs_promises.default.mkdir(node_path.default.dirname(file), { recursive: true });
 			const deadline = Date.now() + LOCK_WAIT_MS;
 			for (;;) {
 				signal?.throwIfAborted();
 				try {
-					node_fs.default.mkdirSync(lock, { mode: 448 });
+					await node_fs_promises.default.mkdir(lock, { mode: 448 });
 					break;
 				} catch (error) {
 					if (error.code !== "EEXIST") throw error;
@@ -704,14 +712,14 @@ function createWorktreeRegistry(file) {
 				}
 			}
 			try {
-				node_fs.default.writeFileSync(node_path.default.join(lock, "owner.json"), JSON.stringify({
+				await node_fs_promises.default.writeFile(node_path.default.join(lock, "owner.json"), JSON.stringify({
 					pid: process.pid,
 					createdAt: (/* @__PURE__ */ new Date()).toISOString()
 				}), { mode: 384 });
 				signal?.throwIfAborted();
 				return await operation();
 			} finally {
-				node_fs.default.rmSync(lock, { recursive: true });
+				await node_fs_promises.default.rm(lock, { recursive: true });
 			}
 		}
 	};
@@ -725,13 +733,13 @@ const GIT_WORKTREE_REPORT_KIND = "git.worktree.report";
 * The repository's worktree setup as one shell command, or undefined when it asks for none.
 * Read from the checkout the spawn starts in, so an uncommitted edit applies at once.
 */
-function readWorktreeSetup(root) {
+async function readWorktreeSetup(root) {
 	const file = node_path.default.join(root, WORKTREE_CONFIG_FILE);
-	if (!node_fs.default.existsSync(file)) return void 0;
 	let setup;
 	try {
-		setup = (0, js_yaml.load)(node_fs.default.readFileSync(file, "utf8"))?.setup;
+		setup = (0, js_yaml.load)(await node_fs_promises.default.readFile(file, "utf8"))?.setup;
 	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
 		throw new PoGitExpectedError("invalid_request", `${WORKTREE_CONFIG_FILE} is not valid YAML (${error.message}).`, false, "Fix the file and try again.");
 	}
 	const commands = [setup ?? []].flat();
@@ -758,7 +766,7 @@ function createWorktreeOperations(deps) {
 	};
 	const probe = {
 		alive: (record) => requireSessionService().isLive(record.sessionId),
-		exists: (path) => node_fs.default.existsSync(path)
+		exists: (path) => node_fs_promises.default.access(path).then(() => true, () => false)
 	};
 	/**
 	* Everything an action needs about the repository it is acting on.
@@ -770,11 +778,11 @@ function createWorktreeOperations(deps) {
 	const resolve = async (context) => {
 		const root = await git.repositoryRoot(context.cwd);
 		if (root === void 0) throw new PoGitExpectedError("not_a_repository", `${context.cwd} is not inside a git repository.`, false, "Run this from a repository checkout.");
-		const store = createWorktreeRegistry(registryFile(root, deps.homeDir));
+		const store = createWorktreeRegistry(await registryFile(root, deps.homeDir));
 		return {
 			root,
 			store,
-			records: store.list()
+			records: await store.list()
 		};
 	};
 	const require$1 = (records, id) => {
@@ -825,11 +833,11 @@ function createWorktreeOperations(deps) {
 				const expectedPath = worktreeDirectory({
 					worktreesRoot: worktreesRoot(deps.homeDir),
 					repositoryLabel: repositoryLabel(root),
-					repositoryId: repositoryId(root),
+					repositoryId: await repositoryId(root),
 					branch: request.branch,
 					shortId: shortId(reserved.sessionId)
 				});
-				if (existing.parentSessionId !== parentSessionId || existing.repositoryRoot !== root || existing.branch !== request.branch || existing.path !== expectedPath || existing.path !== reserved?.cwd || request.baseRef !== void 0 && existing.baseRef !== request.baseRef || !node_fs.default.existsSync(existing.path) || !(await git.listWorktreePaths(root)).includes(existing.path) || await git.repositoryRoot(existing.path) !== existing.path || await git.currentBranch(existing.path) !== request.branch) throw new PoGitExpectedError("invalid_request", "The reserved checkout no longer matches this setup.", false, "Inspect the existing branch and checkout; they will not be replaced.");
+				if (existing.parentSessionId !== parentSessionId || existing.repositoryRoot !== root || existing.branch !== request.branch || existing.path !== expectedPath || existing.path !== reserved?.cwd || request.baseRef !== void 0 && existing.baseRef !== request.baseRef || !await probe.exists(existing.path) || !(await git.listWorktreePaths(root)).includes(existing.path) || await git.repositoryRoot(existing.path) !== existing.path || await git.currentBranch(existing.path) !== request.branch) throw new PoGitExpectedError("invalid_request", "The reserved checkout no longer matches this setup.", false, "Inspect the existing branch and checkout; they will not be replaced.");
 				if (!requireSessionService().isLive(existing.sessionId)) {
 					if ((await requireSessionService().create({
 						cwd: existing.path,
@@ -849,18 +857,18 @@ function createWorktreeOperations(deps) {
 			});
 			if (refusal !== void 0) throw new PoGitExpectedError("worktree_exists", refusal, false, "Pick another branch name, or close it.");
 			const taskDelivery = request.task === void 0 ? void 0 : requireSessionDelivery();
-			const setup = readWorktreeSetup(root);
+			const setup = await readWorktreeSetup(root);
 			const existingBranch = request.checkout === "existing";
 			const id = shortId(reserved?.sessionId ?? (0, node_crypto.randomUUID)());
 			let path = worktreeDirectory({
 				worktreesRoot: worktreesRoot(deps.homeDir),
 				repositoryLabel: repositoryLabel(root),
-				repositoryId: repositoryId(root),
+				repositoryId: await repositoryId(root),
 				branch: request.branch,
 				shortId: id
 			});
 			if (request.reservationId !== void 0) path = (await reservations.prepare(request.reservationId, parentSessionId, path)).cwd;
-			const recovering = reserved?.cwd !== void 0 && node_fs.default.existsSync(path);
+			const recovering = reserved?.cwd !== void 0 && await probe.exists(path);
 			if (recovering && (!(await git.listWorktreePaths(root)).includes(path) || await git.currentBranch(path) !== request.branch)) throw new PoGitExpectedError("invalid_request", "The reserved checkout no longer matches this setup.", false, "Inspect the existing directory; it will not be replaced.");
 			if (!recovering) {
 				if (existingBranch) {
@@ -932,7 +940,7 @@ function createWorktreeOperations(deps) {
 				createdAt: now().toISOString()
 			};
 			try {
-				store.replace([...records, record]);
+				await store.replace([...records, record]);
 			} catch (error) {
 				await requireSessionService().close(sessionId).catch(() => void 0);
 				const kept = await rollback();
@@ -974,7 +982,7 @@ function createWorktreeOperations(deps) {
 			requireOwner(context, record, "close");
 			const refusal = refuseClose({
 				record,
-				dirtyFiles: node_fs.default.existsSync(record.path) ? await git.dirtyFiles(record.path) : [],
+				dirtyFiles: await probe.exists(record.path) ? await git.dirtyFiles(record.path) : [],
 				force
 			});
 			if (refusal !== void 0) throw new PoGitExpectedError("worktree_dirty", refusal, false, "Commit the work, or pass force: true.");
@@ -984,13 +992,13 @@ function createWorktreeOperations(deps) {
 				path: record.path,
 				force
 			});
-			store.replace(records.filter((entry) => entry.id !== id));
+			await store.replace(records.filter((entry) => entry.id !== id));
 			return record;
 		},
 		async list(context) {
 			const { store, records } = await resolve(context);
-			const outcome = reconcile(records, probe);
-			if (outcome.changed.length > 0) store.replace(outcome.records);
+			const outcome = await reconcile(records, probe);
+			if (outcome.changed.length > 0) await store.replace(outcome.records);
 			return outcome.records;
 		},
 		async status(context, id) {
@@ -998,7 +1006,7 @@ function createWorktreeOperations(deps) {
 			const record = require$1(records, id);
 			return {
 				record,
-				dirtyFiles: node_fs.default.existsSync(record.path) ? await git.dirtyFiles(record.path) : []
+				dirtyFiles: await probe.exists(record.path) ? await git.dirtyFiles(record.path) : []
 			};
 		},
 		async merge(context, id, message) {
@@ -1071,10 +1079,10 @@ function createWorktreeOperations(deps) {
 		},
 		async prune(context, dryRun) {
 			const { root, store, records } = await resolve(context);
-			const reconciled = reconcile(records, probe);
+			const reconciled = await reconcile(records, probe);
 			const gitPaths = await git.listWorktreePaths(root);
 			const dirtyByPath = /* @__PURE__ */ new Map();
-			for (const record of reconciled.records) if (record.status === "orphaned" && node_fs.default.existsSync(record.path)) dirtyByPath.set(record.path, await git.dirtyFiles(record.path));
+			for (const record of reconciled.records) if (record.status === "orphaned" && await probe.exists(record.path)) dirtyByPath.set(record.path, await git.dirtyFiles(record.path));
 			const plan = planPrune({
 				records: reconciled.records,
 				gitPaths,
@@ -1082,7 +1090,7 @@ function createWorktreeOperations(deps) {
 				dirtyByPath
 			});
 			if (dryRun) {
-				store.replace(reconciled.records);
+				await store.replace(reconciled.records);
 				return plan;
 			}
 			for (const record of plan.remove) await git.removeWorktree({
@@ -1095,7 +1103,7 @@ function createWorktreeOperations(deps) {
 				branch: record.branch
 			}).catch(() => false)) plan.keptBranches.push(record.branch);
 			const dropped = new Set([...plan.remove, ...plan.forget].map((record) => record.id));
-			store.replace(reconciled.records.filter((record) => !dropped.has(record.id)));
+			await store.replace(reconciled.records.filter((record) => !dropped.has(record.id)));
 			return plan;
 		}
 	};
@@ -1292,4 +1300,4 @@ Object.defineProperty(exports, "writeJsonAtomic", {
 	}
 });
 
-//# sourceMappingURL=worktreeOperations-CU0iV2h-.cjs.map
+//# sourceMappingURL=worktreeOperations-C1ygq-Na.cjs.map