obsidian-e2e 0.3.1 → 0.5.0

package/dist/sandbox-Cz3rj_Rn.mjs

@@ -1,728 +0,0 @@
-import { access, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
-import path, { posix } from "node:path";
-import { spawn } from "node:child_process";
-import os from "node:os";
-import { createHash, randomUUID } from "node:crypto";
-//#region src/core/args.ts
-function buildCommandArgv(vaultName, command, args = {}) {
-	const argv = [`vault=${vaultName}`, command];
-	for (const [key, value] of Object.entries(args)) {
-		if (value === false || value === null || value === void 0) continue;
-		if (value === true) {
-			argv.push(key);
-			continue;
-		}
-		argv.push(`${key}=${String(value)}`);
-	}
-	return argv;
-}
-//#endregion
-//#region src/core/internals.ts
-const clientInternals = /* @__PURE__ */ new WeakMap();
-function attachClientInternals(client, internals) {
-	clientInternals.set(client, internals);
-}
-function getClientInternals(client) {
-	const internals = clientInternals.get(client);
-	if (!internals) throw new Error("Missing obsidian client internals.");
-	return internals;
-}
-function createRestoreManager(readFile) {
-	const snapshots = /* @__PURE__ */ new Map();
-	return {
-		async restoreAll() {
-			const entries = [...snapshots.entries()].reverse();
-			for (const [filePath, snapshot] of entries) await restoreSnapshot(filePath, snapshot);
-			snapshots.clear();
-		},
-		async restoreFile(filePath) {
-			const snapshot = snapshots.get(filePath);
-			if (!snapshot) return;
-			await restoreSnapshot(filePath, snapshot);
-			snapshots.delete(filePath);
-		},
-		async snapshotFileOnce(filePath) {
-			if (snapshots.has(filePath)) return;
-			try {
-				snapshots.set(filePath, {
-					exists: true,
-					value: await readFile(filePath)
-				});
-			} catch (error) {
-				if (isMissingFileError(error)) {
-					snapshots.set(filePath, {
-						exists: false,
-						value: ""
-					});
-					return;
-				}
-				throw error;
-			}
-		}
-	};
-}
-async function restoreSnapshot(filePath, snapshot) {
-	if (snapshot.exists) {
-		await writeFile(filePath, snapshot.value, "utf8");
-		return;
-	}
-	await rm(filePath, {
-		force: true,
-		recursive: true
-	});
-}
-function isMissingFileError(error) {
-	return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
-}
-//#endregion
-//#region src/vault/json-file.ts
-function createJsonFile(filePath, beforeMutate) {
-	return {
-		async patch(updater) {
-			await beforeMutate?.();
-			const currentValue = await this.read();
-			const draft = structuredClone(currentValue);
-			const nextValue = await updater(draft) ?? draft;
-			await this.write(nextValue);
-			return nextValue;
-		},
-		async read() {
-			const value = await readFile(filePath, "utf8");
-			return JSON.parse(value);
-		},
-		async write(value) {
-			await beforeMutate?.();
-			await mkdir(path.dirname(filePath), { recursive: true });
-			await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-		}
-	};
-}
-//#endregion
-//#region src/plugin/plugin.ts
-function createPluginHandle(client, id) {
-	async function resolveDataPath() {
-		const vaultPath = await client.vaultPath();
-		return path.join(vaultPath, ".obsidian", "plugins", id, "data.json");
-	}
-	return {
-		data() {
-			return {
-				async patch(updater) {
-					const dataPath = await resolveDataPath();
-					return createJsonFile(dataPath, () => getClientInternals(client).snapshotFileOnce(dataPath)).patch(updater);
-				},
-				async read() {
-					return createJsonFile(await resolveDataPath()).read();
-				},
-				async write(value) {
-					const dataPath = await resolveDataPath();
-					await createJsonFile(dataPath, () => getClientInternals(client).snapshotFileOnce(dataPath)).write(value);
-				}
-			};
-		},
-		async dataPath() {
-			return resolveDataPath();
-		},
-		async disable(options = {}) {
-			await client.exec("plugin:disable", {
-				filter: options.filter,
-				id
-			});
-		},
-		async enable(options = {}) {
-			await client.exec("plugin:enable", {
-				filter: options.filter,
-				id
-			});
-		},
-		id,
-		async isEnabled() {
-			const output = await client.execText("plugin", { id }, { allowNonZeroExit: true });
-			return /enabled\s+true/i.test(output);
-		},
-		async reload() {
-			await client.exec("plugin:reload", { id });
-		},
-		async restoreData() {
-			await getClientInternals(client).restoreFile(await resolveDataPath());
-		}
-	};
-}
-//#endregion
-//#region src/core/errors.ts
-var ObsidianCommandError = class extends Error {
-	result;
-	constructor(message, result) {
-		super(message);
-		this.name = "ObsidianCommandError";
-		this.result = result;
-	}
-};
-var WaitForTimeoutError = class extends Error {
-	causeError;
-	constructor(message, causeError) {
-		super(message);
-		this.name = "WaitForTimeoutError";
-		this.causeError = causeError;
-	}
-};
-//#endregion
-//#region src/core/transport.ts
-const DEFAULT_TIMEOUT_MS$2 = 3e4;
-const executeCommand = async ({ allowNonZeroExit = false, argv, bin, cwd, env, timeoutMs = DEFAULT_TIMEOUT_MS$2 }) => {
-	const child = spawn(bin, argv, {
-		cwd,
-		env,
-		stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		]
-	});
-	const stdoutChunks = [];
-	const stderrChunks = [];
-	child.stdout.on("data", (chunk) => {
-		stdoutChunks.push(Buffer.from(chunk));
-	});
-	child.stderr.on("data", (chunk) => {
-		stderrChunks.push(Buffer.from(chunk));
-	});
-	const exitCode = await new Promise((resolve, reject) => {
-		const timer = setTimeout(() => {
-			child.kill("SIGTERM");
-			reject(/* @__PURE__ */ new Error(`Command timed out after ${timeoutMs}ms: ${bin} ${argv.join(" ")}`));
-		}, timeoutMs);
-		child.on("error", (error) => {
-			clearTimeout(timer);
-			reject(error);
-		});
-		child.on("close", (code) => {
-			clearTimeout(timer);
-			resolve(code ?? 0);
-		});
-	});
-	const result = {
-		argv,
-		command: bin,
-		exitCode,
-		stderr: Buffer.concat(stderrChunks).toString("utf8"),
-		stdout: Buffer.concat(stdoutChunks).toString("utf8")
-	};
-	if (exitCode !== 0 && !allowNonZeroExit) throw new ObsidianCommandError(`Obsidian command failed with exit code ${exitCode}: ${bin} ${argv.join(" ")}`, result);
-	return result;
-};
-//#endregion
-//#region src/core/wait.ts
-const DEFAULT_INTERVAL_MS = 100;
-const DEFAULT_TIMEOUT_MS$1 = 5e3;
-async function waitForValue(fn, options = {}) {
-	const intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
-	const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS$1;
-	const startTime = Date.now();
-	let lastError;
-	while (Date.now() - startTime <= timeoutMs) {
-		try {
-			const result = await fn();
-			if (result !== false && result !== null && result !== void 0) return result;
-		} catch (error) {
-			lastError = error;
-		}
-		await new Promise((resolve) => setTimeout(resolve, intervalMs));
-	}
-	throw new WaitForTimeoutError(`Timed out waiting for ${options.message ?? "condition"} after ${timeoutMs}ms.`, lastError);
-}
-//#endregion
-//#region src/core/client.ts
-function createObsidianClient(options) {
-	const transport = options.transport ?? executeCommand;
-	const waitDefaults = {
-		intervalMs: options.intervalMs,
-		timeoutMs: options.timeoutMs
-	};
-	const restoreManager = createRestoreManager(async (filePath) => {
-		const { readFile } = await import("node:fs/promises");
-		return readFile(filePath, "utf8");
-	});
-	let cachedVaultPath;
-	const client = {};
-	const app = {
-		async reload(execOptions = {}) {
-			await client.exec("reload", {}, execOptions);
-		},
-		async restart({ readyOptions, waitUntilReady = true, ...execOptions } = {}) {
-			await client.exec("restart", {}, execOptions);
-			if (waitUntilReady) await app.waitUntilReady(readyOptions);
-		},
-		version(execOptions = {}) {
-			return client.execText("version", {}, execOptions);
-		},
-		async waitUntilReady(waitOptions) {
-			await client.waitFor(async () => {
-				try {
-					await client.vaultPath();
-					await client.commands();
-					return true;
-				} catch {
-					return false;
-				}
-			}, waitOptions);
-		}
-	};
-	Object.assign(client, {
-		app,
-		bin: options.bin ?? "obsidian",
-		dev: {
-			async dom(options, execOptions = {}) {
-				const output = await client.execText("dev:dom", {
-					all: options.all,
-					attr: options.attr,
-					css: options.css,
-					inner: options.inner,
-					selector: options.selector,
-					text: options.text,
-					total: options.total
-				}, execOptions);
-				if (options.total) return Number.parseInt(output, 10);
-				if (options.all) return output ? output.split(/\r?\n/u).filter(Boolean) : [];
-				return output;
-			},
-			async eval(code, execOptions = {}) {
-				return parseDevEvalOutput(await client.execText("eval", { code }, execOptions));
-			},
-			async screenshot(targetPath, execOptions = {}) {
-				await client.exec("dev:screenshot", { path: targetPath }, execOptions);
-				return targetPath;
-			}
-		},
-		command(id) {
-			return {
-				async exists(commandOptions = {}) {
-					return (await client.commands({
-						...commandOptions,
-						filter: commandOptions.filter ?? id
-					})).includes(id);
-				},
-				id,
-				async run(execOptions = {}) {
-					await client.exec("command", { id }, execOptions);
-				}
-			};
-		},
-		async commands(commandOptions = {}, execOptions = {}) {
-			return parseCommandIds(await client.execText("commands", { filter: commandOptions.filter }, execOptions));
-		},
-		exec(command, args = {}, execOptions = {}) {
-			return transport({
-				...execOptions,
-				argv: buildCommandArgv(options.vault, command, args),
-				bin: this.bin
-			});
-		},
-		async execJson(command, args = {}, execOptions = {}) {
-			const output = await this.execText(command, args, execOptions);
-			return JSON.parse(output);
-		},
-		async execText(command, args = {}, execOptions = {}) {
-			return (await this.exec(command, args, execOptions)).stdout.trimEnd();
-		},
-		async open(openOptions, execOptions = {}) {
-			await client.exec("open", {
-				file: openOptions.file,
-				newtab: openOptions.newTab,
-				path: openOptions.path
-			}, execOptions);
-		},
-		async openTab(tabOptions = {}, execOptions = {}) {
-			await client.exec("tab:open", {
-				file: tabOptions.file,
-				group: tabOptions.group,
-				view: tabOptions.view
-			}, execOptions);
-		},
-		plugin(id) {
-			return createPluginHandle(this, id);
-		},
-		async tabs(tabOptions = {}, execOptions = {}) {
-			return parseTabs(await client.execText("tabs", { ids: tabOptions.ids ?? true }, execOptions));
-		},
-		async vaultPath() {
-			if (!cachedVaultPath) cachedVaultPath = await this.execText("vault", { info: "path" });
-			return cachedVaultPath;
-		},
-		async verify() {
-			await transport({
-				argv: ["--help"],
-				bin: this.bin
-			});
-			await this.vaultPath();
-		},
-		vaultName: options.vault,
-		waitFor(fn, waitOptions) {
-			return waitForValue(fn, {
-				...waitDefaults,
-				...waitOptions
-			});
-		},
-		async workspace(workspaceOptions = {}, execOptions = {}) {
-			return parseWorkspace(await client.execText("workspace", { ids: workspaceOptions.ids ?? true }, execOptions));
-		}
-	});
-	attachClientInternals(client, restoreManager);
-	return client;
-}
-function parseCommandIds(output) {
-	return output.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).map((line) => line.split("	", 1)[0]?.trim() ?? "").filter(Boolean);
-}
-function parseDevEvalOutput(output) {
-	const normalized = output.startsWith("=> ") ? output.slice(3) : output;
-	try {
-		return JSON.parse(normalized);
-	} catch {
-		return normalized;
-	}
-}
-function parseTabs(output) {
-	return output.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).map(parseTabLine);
-}
-function parseTabLine(line) {
-	const [descriptor, id] = line.split("	");
-	const match = descriptor?.match(/^\[(.+?)\]\s+(.*)$/u);
-	if (!match) return {
-		id: id?.trim() || void 0,
-		title: descriptor?.trim() ?? "",
-		viewType: "unknown"
-	};
-	return {
-		id: id?.trim() || void 0,
-		title: match[2],
-		viewType: match[1]
-	};
-}
-function parseWorkspace(output) {
-	const roots = [];
-	const stack = [];
-	for (const rawLine of output.split(/\r?\n/u)) {
-		if (!rawLine.trim()) continue;
-		const depth = getWorkspaceDepth(rawLine);
-		const node = parseWorkspaceNode(rawLine);
-		while (stack.length > 0 && stack.at(-1).depth >= depth) stack.pop();
-		const parent = stack.at(-1)?.node;
-		if (parent) parent.children.push(node);
-		else roots.push(node);
-		stack.push({
-			depth,
-			node
-		});
-	}
-	return roots;
-}
-function getWorkspaceDepth(line) {
-	let depth = 0;
-	let remainder = line;
-	while (true) {
-		if (remainder.startsWith("│   ") || remainder.startsWith("    ") || remainder.startsWith("├── ") || remainder.startsWith("└── ")) {
-			depth += 1;
-			remainder = remainder.slice(4);
-			continue;
-		}
-		return depth;
-	}
-}
-function parseWorkspaceNode(line) {
-	let withoutTree = line;
-	while (true) {
-		if (withoutTree.startsWith("│   ") || withoutTree.startsWith("    ") || withoutTree.startsWith("├── ") || withoutTree.startsWith("└── ")) {
-			withoutTree = withoutTree.slice(4);
-			continue;
-		}
-		break;
-	}
-	withoutTree = withoutTree.trim();
-	const idMatch = withoutTree.match(/^(.*?)(?: \(([a-z0-9]+)\))?$/iu);
-	const content = idMatch?.[1]?.trim() ?? withoutTree;
-	const id = idMatch?.[2];
-	const leafMatch = content.match(/^\[(.+?)\]\s+(.*)$/u);
-	if (leafMatch) return {
-		children: [],
-		id,
-		label: leafMatch[2],
-		title: leafMatch[2],
-		viewType: leafMatch[1]
-	};
-	return {
-		children: [],
-		id,
-		label: content
-	};
-}
-//#endregion
-//#region src/fixtures/vault-lock.ts
-const DEFAULT_HEARTBEAT_MS = 2e3;
-const DEFAULT_STALE_MS = 15e3;
-const DEFAULT_TIMEOUT_MS = 6e4;
-const DEFAULT_WAIT_INTERVAL_MS = 500;
-const DEFAULT_LOCK_ROOT = path.join(os.tmpdir(), "obsidian-e2e-locks");
-const LOCK_METADATA_FILE = "lock.json";
-const APP_LOCK_KEY = "__obsidianE2ELock";
-const heldLocks = /* @__PURE__ */ new Map();
-async function acquireVaultRunLock({ heartbeatMs = DEFAULT_HEARTBEAT_MS, lockRoot = DEFAULT_LOCK_ROOT, onBusy = "wait", staleMs = DEFAULT_STALE_MS, timeoutMs = DEFAULT_TIMEOUT_MS, vaultName, vaultPath }) {
-	const lockDir = path.join(lockRoot, createVaultLockKey(vaultPath));
-	const heldLock = heldLocks.get(lockDir);
-	if (heldLock) {
-		heldLock.refs += 1;
-		return createVaultRunLockHandle(heldLock);
-	}
-	const ownerId = randomUUID();
-	const metadataPath = path.join(lockDir, LOCK_METADATA_FILE);
-	const metadata = {
-		acquiredAt: Date.now(),
-		cwd: process.cwd(),
-		heartbeatAt: Date.now(),
-		hostname: os.hostname(),
-		ownerId,
-		pid: process.pid,
-		staleMs,
-		vaultName,
-		vaultPath
-	};
-	await mkdir(lockRoot, { recursive: true });
-	const startedAt = Date.now();
-	while (true) try {
-		await mkdir(lockDir);
-		await writeMetadata(metadataPath, metadata);
-		break;
-	} catch (error) {
-		if (!isAlreadyExistsError(error)) throw error;
-		const currentLock = await inspectVaultRunLock({
-			lockRoot,
-			staleMs,
-			vaultPath
-		});
-		if (currentLock && !currentLock.isStale) {
-			if (onBusy === "fail") throw new Error(formatBusyLockMessage(vaultPath, currentLock));
-		} else {
-			await rm(lockDir, {
-				force: true,
-				recursive: true
-			});
-			continue;
-		}
-		if (Date.now() - startedAt >= timeoutMs) throw new Error(currentLock ? `Timed out waiting for shared vault lock: ${formatBusyLockMessage(vaultPath, currentLock)}` : `Timed out waiting for shared vault lock on ${vaultPath}`);
-		await sleep(Math.min(DEFAULT_WAIT_INTERVAL_MS, heartbeatMs));
-	}
-	const heartbeat = setInterval(() => {
-		metadata.heartbeatAt = Date.now();
-		writeMetadata(metadataPath, metadata).catch(() => {});
-	}, heartbeatMs);
-	heartbeat.unref();
-	const nextHeldLock = {
-		heartbeat,
-		lockDir,
-		metadata,
-		metadataPath,
-		refs: 1
-	};
-	heldLocks.set(lockDir, nextHeldLock);
-	return createVaultRunLockHandle(nextHeldLock);
-}
-async function clearVaultRunLockMarker(obsidian) {
-	await obsidian.dev.eval(`delete window.${APP_LOCK_KEY}; delete app.${APP_LOCK_KEY}; "cleared"`, { allowNonZeroExit: true });
-}
-async function inspectVaultRunLock({ lockRoot = DEFAULT_LOCK_ROOT, staleMs = DEFAULT_STALE_MS, vaultPath }) {
-	const lockDir = path.join(lockRoot, createVaultLockKey(vaultPath));
-	const metadata = await readLockState(lockDir);
-	if (!metadata) return null;
-	return {
-		heartbeatAgeMs: Date.now() - metadata.heartbeatAt,
-		isStale: isLockStale(metadata, staleMs),
-		lockDir,
-		metadata
-	};
-}
-async function readVaultRunLockMarker(obsidian) {
-	return obsidian.dev.eval(`window.${APP_LOCK_KEY} ?? app.${APP_LOCK_KEY} ?? null`, { allowNonZeroExit: true });
-}
-function createVaultLockKey(vaultPath) {
-	return createHash("sha256").update(path.resolve(vaultPath)).digest("hex");
-}
-function buildSetMarkerCode(metadata) {
-	return `(() => {
-    const lock = ${JSON.stringify(metadata)};
-    window.${APP_LOCK_KEY} = lock;
-    app.${APP_LOCK_KEY} = lock;
-    return lock;
-  })()`;
-}
-function createVaultRunLockHandle(heldLock) {
-	return {
-		get lockDir() {
-			return heldLock.lockDir;
-		},
-		get metadata() {
-			return heldLock.metadata;
-		},
-		async publishMarker(obsidian) {
-			await obsidian.dev.eval(buildSetMarkerCode(heldLock.metadata));
-		},
-		async release() {
-			if (heldLock.refs > 1) {
-				heldLock.refs -= 1;
-				return;
-			}
-			heldLocks.delete(heldLock.lockDir);
-			clearInterval(heldLock.heartbeat);
-			if ((await readLockState(heldLock.lockDir))?.ownerId !== heldLock.metadata.ownerId) return;
-			await rm(heldLock.lockDir, {
-				force: true,
-				recursive: true
-			});
-		}
-	};
-}
-async function readLockState(lockDir) {
-	const metadataPath = path.join(lockDir, LOCK_METADATA_FILE);
-	try {
-		return JSON.parse(await readFile(metadataPath, "utf8"));
-	} catch {
-		try {
-			const directoryStat = await stat(lockDir);
-			return {
-				acquiredAt: directoryStat.mtimeMs,
-				cwd: "",
-				heartbeatAt: directoryStat.mtimeMs,
-				hostname: "",
-				ownerId: "",
-				pid: 0,
-				staleMs: DEFAULT_STALE_MS,
-				vaultName: "",
-				vaultPath: ""
-			};
-		} catch {
-			return null;
-		}
-	}
-}
-function formatBusyLockMessage(vaultPath, state) {
-	return `vault ${vaultPath} is locked by ${state.metadata.ownerId ? `owner=${state.metadata.ownerId} pid=${state.metadata.pid} cwd=${state.metadata.cwd || "<unknown>"}` : "owner=<unknown>"} ${`heartbeatAgeMs=${state.heartbeatAgeMs} stale=${state.isStale}`}`;
-}
-function isAlreadyExistsError(error) {
-	return error instanceof Error && "code" in error && error.code === "EEXIST";
-}
-function isLockStale(metadata, staleMs) {
-	return Date.now() - metadata.heartbeatAt > staleMs;
-}
-async function sleep(durationMs) {
-	await new Promise((resolve) => setTimeout(resolve, durationMs));
-}
-async function writeMetadata(metadataPath, metadata) {
-	await writeFile(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
-}
-//#endregion
-//#region src/vault/vault.ts
-function createVaultApi(options) {
-	const scopeRoot = normalizeScope(options.root);
-	return {
-		async delete(targetPath, deleteOptions = {}) {
-			await rm(await resolveFilesystemPath(options.obsidian, scopeRoot, targetPath), {
-				force: true,
-				recursive: true
-			});
-			if (deleteOptions.permanent === false) return;
-		},
-		async exists(targetPath) {
-			try {
-				await access(await resolveFilesystemPath(options.obsidian, scopeRoot, targetPath));
-				return true;
-			} catch {
-				return false;
-			}
-		},
-		json(targetPath) {
-			const jsonFile = {
-				async patch(updater) {
-					const currentValue = await jsonFile.read();
-					const draft = structuredClone(currentValue);
-					const nextValue = await updater(draft) ?? draft;
-					await jsonFile.write(nextValue);
-					return nextValue;
-				},
-				async read() {
-					const rawValue = await readFile(await resolveFilesystemPath(options.obsidian, scopeRoot, targetPath), "utf8");
-					return JSON.parse(rawValue);
-				},
-				async write(value) {
-					const resolvedPath = await resolveFilesystemPath(options.obsidian, scopeRoot, targetPath);
-					await mkdir(path.dirname(resolvedPath), { recursive: true });
-					await writeFile(resolvedPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-				}
-			};
-			return jsonFile;
-		},
-		async mkdir(targetPath) {
-			await mkdir(await resolveFilesystemPath(options.obsidian, scopeRoot, targetPath), { recursive: true });
-		},
-		async read(targetPath) {
-			return readFile(await resolveFilesystemPath(options.obsidian, scopeRoot, targetPath), "utf8");
-		},
-		async waitForExists(targetPath, waitOptions) {
-			await options.obsidian.waitFor(async () => await this.exists(targetPath) ? true : false, {
-				message: `vault path "${resolveVaultPath(scopeRoot, targetPath)}" to exist`,
-				...waitOptions
-			});
-		},
-		async waitForMissing(targetPath, waitOptions) {
-			await options.obsidian.waitFor(async () => await this.exists(targetPath) ? false : true, {
-				message: `vault path "${resolveVaultPath(scopeRoot, targetPath)}" to be removed`,
-				...waitOptions
-			});
-		},
-		async write(targetPath, content) {
-			const resolvedPath = await resolveFilesystemPath(options.obsidian, scopeRoot, targetPath);
-			await mkdir(path.dirname(resolvedPath), { recursive: true });
-			await writeFile(resolvedPath, content, "utf8");
-		}
-	};
-}
-function normalizeScope(scope) {
-	if (!scope || scope === ".") return "";
-	return scope.replace(/^\/+|\/+$/g, "");
-}
-function resolveVaultPath(scopeRoot, targetPath) {
-	if (!targetPath || targetPath === ".") return scopeRoot;
-	return scopeRoot ? posix.join(scopeRoot, targetPath) : posix.normalize(targetPath);
-}
-async function resolveFilesystemPath(obsidian, scopeRoot, targetPath) {
-	const vaultPath = await obsidian.vaultPath();
-	const relativePath = resolveVaultPath(scopeRoot, targetPath).split("/").filter(Boolean);
-	const resolvedPath = path.resolve(vaultPath, ...relativePath);
-	const normalizedVaultPath = path.resolve(vaultPath);
-	if (resolvedPath !== normalizedVaultPath && !resolvedPath.startsWith(`${normalizedVaultPath}${path.sep}`)) throw new Error(`Resolved path escapes the vault root: ${targetPath}`);
-	return resolvedPath;
-}
-//#endregion
-//#region src/vault/sandbox.ts
-async function createSandboxApi(options) {
-	const root = posix.join(options.sandboxRoot, `${sanitizeSegment(options.testName)}-${randomUUID().slice(0, 8)}`);
-	const vault = createVaultApi({
-		obsidian: options.obsidian,
-		root
-	});
-	await vault.mkdir(".");
-	return {
-		...vault,
-		async cleanup() {
-			await vault.delete(".", { permanent: true });
-		},
-		path(...segments) {
-			return posix.join(root, ...segments);
-		},
-		root
-	};
-}
-function sanitizeSegment(value) {
-	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "test";
-}
-//#endregion
-export { inspectVaultRunLock as a, getClientInternals as c, clearVaultRunLockMarker as i, createVaultApi as n, readVaultRunLockMarker as o, acquireVaultRunLock as r, createObsidianClient as s, createSandboxApi as t };
-
-//# sourceMappingURL=sandbox-Cz3rj_Rn.mjs.map