obsidian-e2e 0.3.1 → 0.5.0

package/dist/test-context-BprSx6U1.mjs

@@ -0,0 +1,1558 @@
+import { n as parseNoteDocument, t as createNoteDocument } from "./document-DunL2Moz.mjs";
+import { access, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import path, { posix } from "node:path";
+import { spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import os from "node:os";
+//#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/dev/harness.ts
+const HARNESS_NAMESPACE = "__obsidianE2E";
+const HARNESS_VERSION = 1;
+function buildHarnessCallCode(method, ...args) {
+	return `(() => {
+    const __obsidianE2EMethod = ${JSON.stringify(method)};
+    const __obsidianE2EArgs = ${JSON.stringify(args)};
+    const __obsidianE2ENamespace = ${JSON.stringify(HARNESS_NAMESPACE)};
+    const __obsidianE2EVersion = ${HARNESS_VERSION};
+${HARNESS_RUNTIME}
+  })()`;
+}
+function parseHarnessEnvelope(raw) {
+	const envelope = JSON.parse(raw.startsWith("=> ") ? raw.slice(3) : raw);
+	if (!envelope.ok) throw envelope.error;
+	return decodeHarnessValue(envelope.value);
+}
+function decodeHarnessValue(value) {
+	if (Array.isArray(value)) return value.map((entry) => decodeHarnessValue(entry));
+	if (!value || typeof value !== "object") return value;
+	if ("__obsidianE2EType" in value && value.__obsidianE2EType === "undefined") return;
+	return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, decodeHarnessValue(entry)]));
+}
+function createDevDiagnostics(value) {
+	return {
+		consoleMessages: value?.consoleMessages ?? [],
+		notices: value?.notices ?? [],
+		runtimeErrors: value?.runtimeErrors ?? []
+	};
+}
+const HARNESS_RUNTIME = String.raw`
+    const __obsidianE2EMaxEntries = 100;
+
+    const __obsidianE2EPush = (entries, value) => {
+      if (entries.length >= __obsidianE2EMaxEntries) {
+        entries.shift();
+      }
+      entries.push(value);
+    };
+
+    const __obsidianE2EFormat = (value) => {
+      if (typeof value === "string") {
+        return value;
+      }
+
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return String(value);
+      }
+    };
+
+    const __obsidianE2ESerialize = (value, path = "$") => {
+      if (value === null) {
+        return null;
+      }
+
+      if (value === undefined) {
+        return { __obsidianE2EType: "undefined" };
+      }
+
+      const valueType = typeof value;
+
+      if (valueType === "string" || valueType === "boolean") {
+        return value;
+      }
+
+      if (valueType === "number") {
+        if (!Number.isFinite(value)) {
+          throw new Error(\`Cannot serialize non-finite number at \${path}.\`);
+        }
+
+        return value;
+      }
+
+      if (valueType === "bigint" || valueType === "function" || valueType === "symbol") {
+        throw new Error(\`Cannot serialize \${valueType} at \${path}.\`);
+      }
+
+      if (Array.isArray(value)) {
+        return value.map((item, index) => __obsidianE2ESerialize(item, \`\${path}[\${index}]\`));
+      }
+
+      const prototype = Object.getPrototypeOf(value);
+
+      if (prototype !== Object.prototype && prototype !== null) {
+        throw new Error(\`Cannot serialize non-plain object at \${path}.\`);
+      }
+
+      const next = {};
+
+      for (const [key, entry] of Object.entries(value)) {
+        next[key] = __obsidianE2ESerialize(entry, \`\${path}.\${key}\`);
+      }
+
+      return next;
+    };
+
+    const __obsidianE2EClone = (value) => JSON.parse(JSON.stringify(__obsidianE2ESerialize(value)));
+
+    const __obsidianE2ECreateHarness = () => {
+      const state = {
+        consoleMessages: [],
+        notices: [],
+        runtimeErrors: [],
+      };
+
+      const pushConsoleMessage = (level, args) => {
+        __obsidianE2EPush(state.consoleMessages, {
+          args: args.map((entry) => {
+            try {
+              return __obsidianE2EClone(entry);
+            } catch {
+              return __obsidianE2EFormat(entry);
+            }
+          }),
+          at: Date.now(),
+          level,
+          text: args.map(__obsidianE2EFormat).join(" "),
+        });
+      };
+
+      const pushRuntimeError = (source, errorLike) => {
+        const message =
+          errorLike && typeof errorLike === "object" && "message" in errorLike
+            ? String(errorLike.message)
+            : String(errorLike);
+        const stack =
+          errorLike && typeof errorLike === "object" && "stack" in errorLike
+            ? String(errorLike.stack)
+            : undefined;
+
+        __obsidianE2EPush(state.runtimeErrors, {
+          at: Date.now(),
+          message,
+          source,
+          stack,
+        });
+      };
+
+      const installConsolePatch = (root) => {
+        if (root.__obsidianE2EConsolePatched) {
+          return;
+        }
+
+        for (const level of ["debug", "error", "info", "log", "warn"]) {
+          const original = root.console?.[level];
+
+          if (typeof original !== "function") {
+            continue;
+          }
+
+          root.console[level] = (...args) => {
+            pushConsoleMessage(level, args);
+            return original.apply(root.console, args);
+          };
+        }
+
+        root.__obsidianE2EConsolePatched = true;
+      };
+
+      const installRuntimePatch = (root) => {
+        if (root.__obsidianE2ERuntimePatched || typeof root.addEventListener !== "function") {
+          return;
+        }
+
+        root.addEventListener("error", (event) => {
+          pushRuntimeError("error", event?.error ?? event?.message ?? "Unknown error");
+        });
+        root.addEventListener("unhandledrejection", (event) => {
+          pushRuntimeError("unhandledrejection", event?.reason ?? "Unhandled rejection");
+        });
+
+        root.__obsidianE2ERuntimePatched = true;
+      };
+
+      const installNoticePatch = (root) => {
+        if (root.__obsidianE2ENoticePatched || typeof root.Notice !== "function") {
+          return;
+        }
+
+        const OriginalNotice = root.Notice;
+        root.Notice = new Proxy(OriginalNotice, {
+          construct(target, ctorArgs, newTarget) {
+            __obsidianE2EPush(state.notices, {
+              at: Date.now(),
+              message: __obsidianE2EFormat(ctorArgs[0] ?? ""),
+              timeout:
+                typeof ctorArgs[1] === "number" && Number.isFinite(ctorArgs[1])
+                  ? ctorArgs[1]
+                  : undefined,
+            });
+
+            return Reflect.construct(target, ctorArgs, newTarget);
+          },
+        });
+        root.__obsidianE2ENoticePatched = true;
+      };
+
+      const ensureInstalled = () => {
+        const root = globalThis;
+        installConsolePatch(root);
+        installRuntimePatch(root);
+        installNoticePatch(root);
+      };
+
+      const getFileCache = (vaultPath) => {
+        const file = app?.vault?.getAbstractFileByPath?.(vaultPath);
+        if (!file) {
+          return null;
+        }
+
+        return app?.metadataCache?.getFileCache?.(file) ?? null;
+      };
+
+      return {
+        activeFilePath() {
+          ensureInstalled();
+          return app?.workspace?.getActiveFile?.()?.path ?? null;
+        },
+        consoleMessages() {
+          ensureInstalled();
+          return state.consoleMessages;
+        },
+        diagnostics() {
+          ensureInstalled();
+          return state;
+        },
+        editorText() {
+          ensureInstalled();
+          return app?.workspace?.activeLeaf?.view?.editor?.getValue?.() ?? null;
+        },
+        eval(code) {
+          ensureInstalled();
+          return (0, eval)(code);
+        },
+        frontmatter(vaultPath) {
+          ensureInstalled();
+          return getFileCache(vaultPath)?.frontmatter ?? null;
+        },
+        metadata(vaultPath) {
+          ensureInstalled();
+          return getFileCache(vaultPath);
+        },
+        notices() {
+          ensureInstalled();
+          return state.notices;
+        },
+        pluginLoaded(pluginId) {
+          ensureInstalled();
+          const plugins = app?.plugins;
+          return Boolean(
+            plugins?.enabledPlugins?.has?.(pluginId) &&
+              plugins?.plugins?.[pluginId],
+          );
+        },
+        resetDiagnostics() {
+          state.consoleMessages.splice(0);
+          state.notices.splice(0);
+          state.runtimeErrors.splice(0);
+          ensureInstalled();
+          return true;
+        },
+        runtimeErrors() {
+          ensureInstalled();
+          return state.runtimeErrors;
+        },
+      };
+    };
+
+    const root = globalThis;
+    const current = root[__obsidianE2ENamespace];
+    const harness =
+      current && current.version === __obsidianE2EVersion
+        ? current
+        : (root[__obsidianE2ENamespace] = {
+            api: __obsidianE2ECreateHarness(),
+            version: __obsidianE2EVersion,
+          });
+
+    try {
+      const result = harness.api[__obsidianE2EMethod](...__obsidianE2EArgs);
+      return JSON.stringify({
+        ok: true,
+        value: __obsidianE2ESerialize(result),
+      });
+    } catch (error) {
+      return JSON.stringify({
+        error: {
+          message: error instanceof Error ? error.message : String(error),
+          name: error instanceof Error ? error.name : "Error",
+          stack: error instanceof Error ? error.stack : undefined,
+        },
+        ok: false,
+      });
+    }`;
+//#endregion
+//#region src/core/exec-options.ts
+function mergeExecOptions(defaults, overrides) {
+	if (!defaults) return overrides ? { ...overrides } : {};
+	if (!overrides) return { ...defaults };
+	return {
+		...defaults,
+		...overrides,
+		env: mergeEnvironments(defaults.env, overrides.env)
+	};
+}
+function mergeEnvironments(defaults, overrides) {
+	if (!defaults) return overrides ? { ...overrides } : void 0;
+	if (!overrides) return { ...defaults };
+	return {
+		...defaults,
+		...overrides
+	};
+}
+//#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/metadata/metadata.ts
+function createObsidianMetadataHandle(client) {
+	return {
+		async fileCache(path, execOptions) {
+			return readMetadata(client, "metadata", path, execOptions);
+		},
+		async frontmatter(path, execOptions) {
+			return readMetadata(client, "frontmatter", path, execOptions);
+		},
+		async waitForFileCache(path, predicate, options) {
+			return waitForPresentValue(client, path, () => client.metadata.fileCache(path), predicate, "metadata cache", options);
+		},
+		async waitForFrontmatter(path, predicate, options) {
+			return waitForPresentValue(client, path, () => client.metadata.frontmatter(path), predicate, "frontmatter", options);
+		},
+		async waitForMetadata(path, predicate, options) {
+			return waitForPresentValue(client, path, () => client.metadata.fileCache(path), predicate, "metadata", options);
+		}
+	};
+}
+async function readMetadata(client, method, path, execOptions) {
+	return parseHarnessEnvelope(await client.dev.evalRaw(buildHarnessCallCode(method, path), execOptions));
+}
+async function waitForPresentValue(client, path, readValue, predicate, label, options = {}) {
+	return client.waitFor(async () => {
+		const value = await readValue();
+		if (value === null) return false;
+		return await (predicate?.(value) ?? true) ? value : false;
+	}, {
+		...options,
+		message: options.message ?? `vault path "${path}" to expose ${label}`
+	});
+}
+//#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");
+	}
+	async function isLoadedInApp() {
+		try {
+			return parseHarnessEnvelope(await client.dev.evalRaw(buildHarnessCallCode("pluginLoaded", id)));
+		} catch {
+			return false;
+		}
+	}
+	function withDefaultReadyReloadOptions(options = {}) {
+		return {
+			...options,
+			waitUntilReady: options.waitUntilReady ?? true
+		};
+	}
+	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(options = {}) {
+			const { readyOptions, waitUntilReady, ...execOptions } = options;
+			await client.exec("plugin:reload", { id }, execOptions);
+			if (waitUntilReady) await this.waitUntilReady(readyOptions);
+		},
+		async restoreData() {
+			await getClientInternals(client).restoreFile(await resolveDataPath());
+		},
+		async updateDataAndReload(updater, options = {}) {
+			const nextData = await this.data().patch(updater);
+			if (await this.isEnabled()) await this.reload(withDefaultReadyReloadOptions(options));
+			return nextData;
+		},
+		async withPatchedData(updater, run, options = {}) {
+			const pluginWasEnabled = await this.isEnabled();
+			const reloadOptions = withDefaultReadyReloadOptions(options);
+			let hasPatchedData = false;
+			let runResult;
+			let runError;
+			let restoreError;
+			try {
+				await this.data().patch(updater);
+				hasPatchedData = true;
+				if (pluginWasEnabled) await this.reload(reloadOptions);
+				runResult = await run(this);
+			} catch (error) {
+				runError = error;
+			}
+			if (hasPatchedData) try {
+				await this.restoreData();
+				if (pluginWasEnabled) await this.reload(reloadOptions);
+			} catch (error) {
+				restoreError = error;
+			}
+			if (runError && restoreError) throw new AggregateError([runError, restoreError], `Plugin "${id}" patch execution and restore both failed.`);
+			if (runError) throw runError;
+			if (restoreError) throw restoreError;
+			return runResult;
+		},
+		async waitForData(predicate, options = {}) {
+			return client.waitFor(async () => {
+				try {
+					const data = await this.data().read();
+					return await predicate(data) ? data : false;
+				} catch {
+					return false;
+				}
+			}, options);
+		},
+		async waitUntilReady(options = {}) {
+			await client.waitFor(async () => {
+				if (!await isLoadedInApp()) return false;
+				if (options.commandId) return await client.command(options.commandId).exists();
+				return true;
+			}, {
+				...options,
+				message: options.message ?? (options.commandId ? `plugin "${id}" to be ready with command "${options.commandId}"` : `plugin "${id}" to be ready`)
+			});
+		}
+	};
+}
+//#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;
+	}
+};
+var DevEvalError = class extends Error {
+	remote;
+	constructor(message, remote) {
+		super(message);
+		this.name = "DevEvalError";
+		this.remote = remote;
+		if (remote.stack) this.stack = `${this.name}: ${message}\nRemote stack:\n${remote.stack}`;
+	}
+};
+//#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 sleep$1(ms) {
+	await new Promise((resolve) => setTimeout(resolve, ms));
+}
+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 sleep$1(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 defaultExecOptions = options.defaultExecOptions;
+	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 metadata = createObsidianMetadataHandle(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);
+		}
+	};
+	const dev = {
+		async activeFilePath(execOptions = {}) {
+			return readHarnessValue(this, "activeFilePath", execOptions);
+		},
+		async consoleMessages(execOptions = {}) {
+			return readHarnessValue(this, "consoleMessages", execOptions);
+		},
+		async diagnostics(execOptions = {}) {
+			return createDevDiagnostics(await readHarnessValue(this, "diagnostics", execOptions));
+		},
+		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 = {}) {
+			try {
+				return parseHarnessEnvelope(await this.evalRaw(buildHarnessCallCode("eval", code), execOptions));
+			} catch (error) {
+				if (error && typeof error === "object" && "message" in error && "name" in error && typeof error.message === "string" && typeof error.name === "string") throw new DevEvalError(`Failed to evaluate Obsidian code: ${error.message}`, {
+					message: error.message,
+					name: error.name,
+					stack: "stack" in error && typeof error.stack === "string" ? error.stack : void 0
+				});
+				throw error;
+			}
+		},
+		async evalRaw(code, execOptions = {}) {
+			return client.execText("eval", { code }, execOptions);
+		},
+		async editorText(execOptions = {}) {
+			return readHarnessValue(this, "editorText", execOptions);
+		},
+		async notices(execOptions = {}) {
+			return readHarnessValue(this, "notices", execOptions);
+		},
+		async resetDiagnostics(execOptions = {}) {
+			await readHarnessValue(this, "resetDiagnostics", execOptions);
+		},
+		async runtimeErrors(execOptions = {}) {
+			return readHarnessValue(this, "runtimeErrors", execOptions);
+		},
+		async screenshot(targetPath, execOptions = {}) {
+			await client.exec("dev:screenshot", { path: targetPath }, execOptions);
+			return targetPath;
+		}
+	};
+	Object.assign(client, {
+		app,
+		bin: options.bin ?? "obsidian",
+		dev,
+		metadata,
+		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({
+				...mergeExecOptions(defaultExecOptions, 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);
+		},
+		sleep(ms) {
+			return sleep$1(ms);
+		},
+		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({
+				...mergeExecOptions(defaultExecOptions, void 0),
+				argv: ["--help"],
+				bin: this.bin
+			});
+			await this.vaultPath();
+		},
+		vaultName: options.vault,
+		async waitForActiveFile(path, options) {
+			return client.waitFor(async () => {
+				const activePath = await dev.activeFilePath();
+				return activePath === path ? activePath : false;
+			}, {
+				...options,
+				message: options?.message ?? `active file "${path}"`
+			});
+		},
+		async waitForConsoleMessage(predicate, options) {
+			return waitForDiagnosticEntry(client, () => client.dev.consoleMessages(), predicate, options?.message ?? "console message", options);
+		},
+		async waitForNotice(predicate, options) {
+			return waitForDiagnosticEntry(client, () => client.dev.notices(), typeof predicate === "string" ? (notice) => notice.message.includes(predicate) : predicate, options?.message ?? "notice", options);
+		},
+		async waitForRuntimeError(predicate, options) {
+			return waitForDiagnosticEntry(client, () => client.dev.runtimeErrors(), typeof predicate === "string" ? (error) => error.message.includes(predicate) : predicate, options?.message ?? "runtime error", options);
+		},
+		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 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;
+}
+async function waitForDiagnosticEntry(client, readEntries, predicate, label, options) {
+	return client.waitFor(async () => {
+		const entries = await readEntries();
+		for (const entry of entries) if (await predicate(entry)) return entry;
+		return false;
+	}, {
+		...options,
+		message: options?.message ?? label
+	});
+}
+async function readHarnessValue(dev, method, execOptions) {
+	return parseHarnessEnvelope(await dev.evalRaw(buildHarnessCallCode(method), execOptions));
+}
+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/core/path-slug.ts
+function sanitizePathSegment(value, options = {}) {
+	const fallback = options.fallback ?? "test";
+	const maxLength = options.maxLength ?? 80;
+	return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLength) || fallback;
+}
+//#endregion
+//#region src/vault/paths.ts
+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/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 waitForContent(targetPath, predicate, waitOptions = {}) {
+			const resolvedPath = await resolveFilesystemPath(options.obsidian, scopeRoot, targetPath);
+			return options.obsidian.waitFor(async () => {
+				try {
+					const content = await readFile(resolvedPath, "utf8");
+					return await predicate(content) ? content : false;
+				} catch {
+					return false;
+				}
+			}, {
+				message: `vault path "${resolveVaultPath(scopeRoot, targetPath)}" to match content`,
+				...waitOptions
+			});
+		},
+		async waitForExists(targetPath, waitOptions) {
+			const resolvedPath = await resolveFilesystemPath(options.obsidian, scopeRoot, targetPath);
+			await options.obsidian.waitFor(async () => {
+				try {
+					await access(resolvedPath);
+					return true;
+				} catch {
+					return false;
+				}
+			}, {
+				message: `vault path "${resolveVaultPath(scopeRoot, targetPath)}" to exist`,
+				...waitOptions
+			});
+		},
+		async waitForMissing(targetPath, waitOptions) {
+			const resolvedPath = await resolveFilesystemPath(options.obsidian, scopeRoot, targetPath);
+			await options.obsidian.waitFor(async () => {
+				try {
+					await access(resolvedPath);
+					return false;
+				} catch {
+					return true;
+				}
+			}, {
+				message: `vault path "${resolveVaultPath(scopeRoot, targetPath)}" to be removed`,
+				...waitOptions
+			});
+		},
+		async write(targetPath, content, writeOptions = {}) {
+			const resolvedPath = await resolveFilesystemPath(options.obsidian, scopeRoot, targetPath);
+			await mkdir(path.dirname(resolvedPath), { recursive: true });
+			await writeFile(resolvedPath, content, "utf8");
+			if (!writeOptions.waitForContent) return;
+			const predicate = typeof writeOptions.waitForContent === "function" ? writeOptions.waitForContent : (value) => value === content;
+			await this.waitForContent(targetPath, predicate, writeOptions.waitOptions);
+		}
+	};
+}
+//#endregion
+//#region src/artifacts/failure-artifacts.ts
+const DEFAULT_FAILURE_ARTIFACTS_DIR = ".obsidian-e2e-artifacts";
+const DEFAULT_FAILURE_ARTIFACT_CAPTURE = {
+	activeFile: true,
+	activeNote: true,
+	consoleMessages: true,
+	dom: true,
+	editorText: true,
+	notices: true,
+	parsedFrontmatter: true,
+	runtimeErrors: true,
+	screenshot: true,
+	tabs: true,
+	workspace: true
+};
+function getFailureArtifactConfig(options) {
+	if (!options.captureOnFailure) return {
+		artifactsDir: path.resolve(options.artifactsDir ?? ".obsidian-e2e-artifacts"),
+		capture: { ...DEFAULT_FAILURE_ARTIFACT_CAPTURE },
+		enabled: false
+	};
+	const overrides = options.captureOnFailure === true ? {} : options.captureOnFailure;
+	return {
+		artifactsDir: path.resolve(options.artifactsDir ?? ".obsidian-e2e-artifacts"),
+		capture: {
+			...DEFAULT_FAILURE_ARTIFACT_CAPTURE,
+			...overrides
+		},
+		enabled: true
+	};
+}
+function getFailureArtifactDirectory(artifactsDir, task) {
+	const suffix = task.id.split("_").at(-1) ?? "test";
+	return path.join(artifactsDir, `${sanitizePathSegment(task.name, { maxLength: 60 })}-${suffix}`);
+}
+async function captureFailureArtifacts(task, obsidian, options) {
+	const config = getFailureArtifactConfig(options);
+	if (!config.enabled) return;
+	const artifactDirectory = getFailureArtifactDirectory(config.artifactsDir, task);
+	await mkdir(artifactDirectory, { recursive: true });
+	const activeFile = readArtifactInput(() => readActiveFilePath(obsidian));
+	const activeNote = readArtifactInput(async () => {
+		const activeFilePath = await unwrapArtifactInput(activeFile);
+		return activeFilePath ? readActiveNoteSnapshot(obsidian, activeFilePath) : null;
+	});
+	const diagnostics = await obsidian.dev.diagnostics().catch(() => null);
+	await Promise.all([
+		captureJsonArtifact(artifactDirectory, "active-file.json", config.capture.activeFile, async () => ({ activeFile: await unwrapArtifactInput(activeFile) })),
+		captureTextArtifact(artifactDirectory, "active-note.md", config.capture.activeNote, async () => (await unwrapArtifactInput(activeNote))?.raw ?? ""),
+		captureJsonArtifact(artifactDirectory, "active-note-frontmatter.json", config.capture.parsedFrontmatter, async () => ({ frontmatter: (await unwrapArtifactInput(activeNote))?.frontmatter ?? null })),
+		captureTextArtifact(artifactDirectory, "dom.txt", config.capture.dom, async () => String(await obsidian.dev.dom({
+			inner: true,
+			selector: ".workspace"
+		}))),
+		captureJsonArtifact(artifactDirectory, "editor.json", config.capture.editorText, async () => ({ text: await obsidian.dev.editorText() })),
+		captureJsonArtifact(artifactDirectory, "console-messages.json", config.capture.consoleMessages, async () => diagnostics?.consoleMessages ?? []),
+		captureJsonArtifact(artifactDirectory, "runtime-errors.json", config.capture.runtimeErrors, async () => diagnostics?.runtimeErrors ?? []),
+		captureJsonArtifact(artifactDirectory, "notices.json", config.capture.notices, async () => diagnostics?.notices ?? []),
+		captureScreenshotArtifact(artifactDirectory, config.capture.screenshot, obsidian),
+		captureJsonArtifact(artifactDirectory, "tabs.json", config.capture.tabs, () => obsidian.tabs()),
+		captureJsonArtifact(artifactDirectory, "workspace.json", config.capture.workspace, () => obsidian.workspace()),
+		options.plugin ? captureJsonArtifact(artifactDirectory, `${options.plugin.id}-data.json`, true, () => options.plugin.data().read()) : Promise.resolve()
+	]);
+	return artifactDirectory;
+}
+async function captureJsonArtifact(artifactDirectory, filename, enabled, readValue) {
+	if (!enabled) return;
+	try {
+		const value = await readValue();
+		await writeFile(path.join(artifactDirectory, filename), `${JSON.stringify(value, null, 2)}\n`, "utf8");
+	} catch (error) {
+		await writeFile(path.join(artifactDirectory, `${filename}.error.txt`), formatArtifactError(error), "utf8");
+	}
+}
+async function captureScreenshotArtifact(artifactDirectory, enabled, obsidian) {
+	if (!enabled) return;
+	const screenshotPath = path.join(artifactDirectory, "screenshot.png");
+	try {
+		await obsidian.dev.screenshot(screenshotPath);
+	} catch (error) {
+		await writeFile(path.join(artifactDirectory, "screenshot.error.txt"), formatArtifactError(error), "utf8");
+	}
+}
+async function captureTextArtifact(artifactDirectory, filename, enabled, readValue) {
+	if (!enabled) return;
+	try {
+		await writeFile(path.join(artifactDirectory, filename), await readValue(), "utf8");
+	} catch (error) {
+		await writeFile(path.join(artifactDirectory, `${filename}.error.txt`), formatArtifactError(error), "utf8");
+	}
+}
+function formatArtifactError(error) {
+	return error instanceof Error ? `${error.name}: ${error.message}\n` : `${String(error)}\n`;
+}
+async function readActiveFilePath(obsidian) {
+	return obsidian.dev.activeFilePath();
+}
+async function readActiveNoteSnapshot(obsidian, activeFile) {
+	return parseNoteDocument(await createVaultApi({ obsidian }).read(activeFile));
+}
+function readArtifactInput(readValue) {
+	return { promise: readValue().then((value) => ({
+		ok: true,
+		value
+	}), (error) => ({
+		error,
+		ok: false
+	})) };
+}
+async function unwrapArtifactInput(result) {
+	const value = await result.promise;
+	if (!value.ok) throw value.error;
+	return value.value;
+}
+//#endregion
+//#region src/vault/sandbox.ts
+async function createSandboxApi(options) {
+	const root = posix.join(options.sandboxRoot, `${sanitizePathSegment(options.testName)}-${randomUUID().slice(0, 8)}`);
+	const sandboxPath = (...segments) => posix.join(root, ...segments);
+	const vault = createVaultApi({
+		obsidian: options.obsidian,
+		root
+	});
+	await vault.mkdir(".");
+	return {
+		...vault,
+		async cleanup() {
+			await vault.delete(".", { permanent: true });
+		},
+		async frontmatter(targetPath) {
+			return options.obsidian.metadata.frontmatter(sandboxPath(targetPath));
+		},
+		path(...segments) {
+			return sandboxPath(...segments);
+		},
+		async readNote(targetPath) {
+			return parseNoteDocument(await vault.read(targetPath));
+		},
+		root,
+		async waitForFrontmatter(targetPath, predicate, waitOptions) {
+			return options.obsidian.metadata.waitForFrontmatter(sandboxPath(targetPath), predicate, waitOptions);
+		},
+		async waitForMetadata(targetPath, predicate, waitOptions) {
+			return options.obsidian.metadata.waitForMetadata(sandboxPath(targetPath), predicate, waitOptions);
+		},
+		async writeNote(writeOptions) {
+			const { path, waitForMetadata = true, waitOptions, ...noteInput } = writeOptions;
+			const document = createNoteDocument(noteInput);
+			await vault.write(path, document.raw);
+			if (waitForMetadata) {
+				const predicate = typeof waitForMetadata === "function" ? waitForMetadata : void 0;
+				await options.obsidian.metadata.waitForMetadata(sandboxPath(path), predicate, waitOptions);
+			}
+			return document;
+		}
+	};
+}
+//#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");
+}
+function createBaseFixtures(options, fixtureOptions = {}) {
+	const createVault = fixtureOptions.createVault ?? ((obsidian) => createVaultApi({ obsidian }));
+	return {
+		_vaultLock: [async ({}, use) => {
+			if (!options.sharedVaultLock) {
+				await use(null);
+				return;
+			}
+			const lockClient = createObsidianClient(options);
+			await lockClient.verify();
+			const vaultLock = await acquireVaultRunLock({
+				...options.sharedVaultLock === true ? {} : options.sharedVaultLock,
+				vaultName: options.vault,
+				vaultPath: await lockClient.vaultPath()
+			});
+			await vaultLock.publishMarker(lockClient);
+			try {
+				await use(vaultLock);
+			} finally {
+				try {
+					await clearVaultRunLockMarker(lockClient);
+				} catch {}
+				await vaultLock.release();
+			}
+		}, { scope: "worker" }],
+		_testContext: async ({ _vaultLock, onTestFailed, task }, use) => {
+			let failedTask = false;
+			onTestFailed(() => {
+				failedTask = true;
+			});
+			const context = await createInternalTestContext({
+				...options,
+				createVault,
+				testName: task.name,
+				vaultLock: _vaultLock
+			});
+			try {
+				await use(context);
+			} finally {
+				await context.cleanup({ failedTask: failedTask ? task : void 0 });
+			}
+		},
+		obsidian: async ({ _testContext }, use) => {
+			await use(_testContext.obsidian);
+		},
+		sandbox: async ({ _testContext }, use) => {
+			await use(_testContext.sandbox);
+		},
+		vault: async ({ _testContext }, use) => {
+			await use(_testContext.vault);
+		}
+	};
+}
+//#endregion
+//#region src/fixtures/test-context.ts
+async function createTestContext(options) {
+	return createInternalTestContext(options);
+}
+async function withVaultSandbox(options, run) {
+	const context = await createInternalTestContext(options);
+	try {
+		return await run(context);
+	} finally {
+		await context.cleanup();
+	}
+}
+async function createInternalTestContext(options) {
+	const obsidian = createObsidianClient(options);
+	const trackedPlugins = /* @__PURE__ */ new Map();
+	let sandbox = null;
+	const vaultLock = options.vaultLock ?? await maybeAcquireVaultLock(options, obsidian);
+	const ownsVaultLock = options.vaultLock === void 0 && vaultLock !== null;
+	const vaultFactory = options.createVault ?? ((client) => createVaultApi({ obsidian: client }));
+	let disposed = false;
+	try {
+		await obsidian.verify();
+		if (vaultLock) await vaultLock.publishMarker(obsidian);
+		await obsidian.dev.resetDiagnostics().catch(() => {});
+		const vault = await vaultFactory(obsidian);
+		sandbox = await createSandboxApi({
+			obsidian,
+			sandboxRoot: options.sandboxRoot ?? "__obsidian_e2e__",
+			testName: options.testName ?? "test"
+		});
+		const captureArtifacts = async (task) => captureFailureArtifacts(task, obsidian, {
+			...options,
+			plugin: trackedPlugins.size === 1 ? [...trackedPlugins.values()][0].plugin : void 0
+		});
+		const cleanup = async (cleanupOptions = {}) => {
+			if (disposed) return;
+			disposed = true;
+			const cleanupErrors = [];
+			try {
+				if (cleanupOptions.failedTask && options.captureOnFailure) await captureArtifacts(cleanupOptions.failedTask);
+			} finally {
+				try {
+					await getClientInternals(obsidian).restoreAll();
+				} finally {
+					for (const session of [...trackedPlugins.values()].reverse()) if (!session.wasEnabled) await recordCleanupError(cleanupErrors, async () => session.plugin.disable({ filter: session.filter }));
+					try {
+						await clearVaultRunLockMarker(obsidian);
+					} catch {}
+					if (ownsVaultLock) await recordCleanupError(cleanupErrors, async () => vaultLock.release());
+					await recordCleanupError(cleanupErrors, async () => sandbox.cleanup());
+				}
+			}
+			if (cleanupErrors.length === 1) throw cleanupErrors[0];
+			if (cleanupErrors.length > 1) throw new AggregateError(cleanupErrors, "One or more test cleanup steps failed.");
+		};
+		return {
+			obsidian,
+			sandbox,
+			vault,
+			captureFailureArtifacts: captureArtifacts,
+			cleanup,
+			async plugin(id, sessionOptions = {}) {
+				const existing = trackedPlugins.get(id);
+				if (existing) return existing.plugin;
+				const plugin = obsidian.plugin(id);
+				const wasEnabled = await plugin.isEnabled();
+				if (!wasEnabled) await plugin.enable({ filter: sessionOptions.filter });
+				if (sessionOptions.seedData !== void 0) await plugin.data().write(sessionOptions.seedData);
+				trackedPlugins.set(id, {
+					filter: sessionOptions.filter,
+					plugin,
+					wasEnabled
+				});
+				return plugin;
+			},
+			async resetDiagnostics() {
+				await obsidian.dev.resetDiagnostics().catch(() => {});
+			}
+		};
+	} catch (error) {
+		try {
+			if (sandbox) await sandbox.cleanup();
+		} finally {
+			try {
+				await clearVaultRunLockMarker(obsidian);
+			} catch {}
+			if (ownsVaultLock) await vaultLock.release();
+		}
+		throw error;
+	}
+}
+async function recordCleanupError(cleanupErrors, run) {
+	try {
+		await run();
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+}
+async function maybeAcquireVaultLock(options, obsidian) {
+	if (!options.sharedVaultLock) return null;
+	return acquireVaultRunLock({
+		...options.sharedVaultLock === true ? {} : options.sharedVaultLock,
+		vaultName: options.vault,
+		vaultPath: await obsidian.vaultPath()
+	});
+}
+//#endregion
+export { clearVaultRunLockMarker as a, createSandboxApi as c, createVaultApi as d, resolveFilesystemPath as f, acquireVaultRunLock as i, DEFAULT_FAILURE_ARTIFACTS_DIR as l, getClientInternals as m, withVaultSandbox as n, inspectVaultRunLock as o, createObsidianClient as p, createBaseFixtures as r, readVaultRunLockMarker as s, createTestContext as t, captureFailureArtifacts as u };
+
+//# sourceMappingURL=test-context-BprSx6U1.mjs.map