obsidian-e2e 0.4.0 → 0.6.0

package/dist/{sandbox--mUbNsh7.mjs → test-context-Bl-e-83H.mjs}

@@ -1,8 +1,9 @@
+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 os from "node:os";
 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];
@@ -94,6 +95,133 @@ function isMissingFileError(error) {
 	return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
 }
 //#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/dev/eval-json.ts
+async function runEvalJson(dev, code, execOptions = {}) {
+	return parseEvalJsonEnvelope(await dev.evalRaw(buildEvalJsonCode(code), execOptions));
+}
+function buildEvalJsonCode(code) {
+	return [
+		"(()=>{",
+		`const __obsidianE2ECode=${JSON.stringify(code)};`,
+		"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;",
+		"};",
+		"try{",
+		"return JSON.stringify({ok:true,value:__obsidianE2ESerialize((0,eval)(__obsidianE2ECode))});",
+		"}catch(error){",
+		"return JSON.stringify({ok:false,error:{message:error instanceof Error?error.message:String(error),name:error instanceof Error?error.name:'Error',stack:error instanceof Error?error.stack:undefined}});",
+		"}",
+		"})()"
+	].join("");
+}
+function parseDevEvalOutput(raw) {
+	const normalized = normalizeEvalOutput(raw);
+	try {
+		return JSON.parse(normalized);
+	} catch {
+		return normalized;
+	}
+}
+function parseEvalJsonEnvelope(raw) {
+	const envelope = JSON.parse(normalizeEvalOutput(raw));
+	if (!envelope.ok) throw new DevEvalError(`Failed to evaluate Obsidian code: ${envelope.error.message}`, { ...envelope.error });
+	return decodeEvalJsonValue(envelope.value);
+}
+function normalizeEvalOutput(raw) {
+	return raw.startsWith("=> ") ? raw.slice(3) : raw;
+}
+function decodeEvalJsonValue(value) {
+	if (Array.isArray(value)) return value.map((entry) => decodeEvalJsonValue(entry));
+	if (!value || typeof value !== "object") return value;
+	if (isUndefinedSentinel(value)) return;
+	return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, decodeEvalJsonValue(entry)]));
+}
+function isUndefinedSentinel(value) {
+	return "__obsidianE2EType" in value && value.__obsidianE2EType === "undefined";
+}
+//#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 runEvalJson(client.dev, buildMetadataReadCode(method, path), execOptions);
+}
+function buildMetadataReadCode(method, path) {
+	return [
+		"(()=>{",
+		`const __obsidianE2EPath=${JSON.stringify(path)};`,
+		"const __obsidianE2EFile=app?.vault?.getAbstractFileByPath?.(__obsidianE2EPath);",
+		"if(!__obsidianE2EFile){return null;}",
+		method === "frontmatter" ? "return app?.metadataCache?.getFileCache?.(__obsidianE2EFile)?.frontmatter ?? null;" : "return app?.metadataCache?.getFileCache?.(__obsidianE2EFile) ?? null;",
+		"})()"
+	].join("");
+}
+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 {
@@ -125,17 +253,17 @@ function createPluginHandle(client, id) {
 	}
 	async function isLoadedInApp() {
 		try {
-			return await client.dev.eval(`(() => {
-        const plugins = app?.plugins;
-        return Boolean(
-          plugins?.enabledPlugins?.has?.(${JSON.stringify(id)}) &&
-          plugins?.plugins?.[${JSON.stringify(id)}],
-        );
-      })()`);
+			return await runEvalJson(client.dev, buildPluginLoadedCode(id));
 		} catch {
 			return false;
 		}
 	}
+	function withDefaultReadyReloadOptions(options = {}) {
+		return {
+			...options,
+			waitUntilReady: options.waitUntilReady ?? true
+		};
+	}
 	return {
 		data() {
 			return {
@@ -180,6 +308,37 @@ function createPluginHandle(client, id) {
 		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 {
@@ -202,24 +361,14 @@ function createPluginHandle(client, id) {
 		}
 	};
 }
-//#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;
-	}
-};
+function buildPluginLoadedCode(id) {
+	return [
+		"(()=>{",
+		"const __obsidianE2EPlugins=app?.plugins;",
+		`return Boolean(__obsidianE2EPlugins?.enabledPlugins?.has?.(${JSON.stringify(id)})&&__obsidianE2EPlugins?.plugins?.[${JSON.stringify(id)}]);`,
+		"})()"
+	].join("");
+}
 //#endregion
 //#region src/core/transport.ts
 const DEFAULT_TIMEOUT_MS$2 = 3e4;
@@ -266,6 +415,39 @@ const executeCommand = async ({ allowNonZeroExit = false, argv, bin, cwd, env, t
 	return result;
 };
 //#endregion
+//#region src/dev/diagnostics.ts
+const DIAGNOSTICS_NAMESPACE = "__obsidianE2EDiagnostics";
+function buildDiagnosticsCode(method) {
+	return [
+		"(()=>{",
+		`const __obsidianE2EMethod=${JSON.stringify(method)};`,
+		`const __obsidianE2ENamespace=${JSON.stringify(DIAGNOSTICS_NAMESPACE)};`,
+		"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 __obsidianE2EClone=(value)=>{try{return JSON.parse(JSON.stringify(value));}catch{return __obsidianE2EFormat(value);}};",
+		"const __obsidianE2EPushRuntimeError=(source,errorLike,state)=>{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 root=globalThis;",
+		"const state=root[__obsidianE2ENamespace]??(root[__obsidianE2ENamespace]={consoleMessages:[],notices:[],runtimeErrors:[],consolePatched:false,noticePatched:false,runtimePatched:false});",
+		"if(!state.consolePatched&&root.console){for(const level of ['debug','error','info','log','warn']){const original=root.console?.[level];if(typeof original!=='function'){continue;}root.console[level]=(...args)=>{__obsidianE2EPush(state.consoleMessages,{args:args.map(__obsidianE2EClone),at:Date.now(),level,text:args.map(__obsidianE2EFormat).join(' ')});return original.apply(root.console,args);};}state.consolePatched=true;}",
+		"if(!state.runtimePatched&&typeof root.addEventListener==='function'){root.addEventListener('error',(event)=>{__obsidianE2EPushRuntimeError('error',event?.error??event?.message??'Unknown error',state);});root.addEventListener('unhandledrejection',(event)=>{__obsidianE2EPushRuntimeError('unhandledrejection',event?.reason??'Unhandled rejection',state);});state.runtimePatched=true;}",
+		"if(!state.noticePatched&&typeof root.Notice==='function'){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);}});state.noticePatched=true;}",
+		"if(__obsidianE2EMethod==='reset'){state.consoleMessages.splice(0);state.notices.splice(0);state.runtimeErrors.splice(0);return true;}",
+		"if(__obsidianE2EMethod==='consoleMessages'){return state.consoleMessages;}",
+		"if(__obsidianE2EMethod==='notices'){return state.notices;}",
+		"if(__obsidianE2EMethod==='runtimeErrors'){return state.runtimeErrors;}",
+		"return {consoleMessages:state.consoleMessages,notices:state.notices,runtimeErrors:state.runtimeErrors};",
+		"})()"
+	].join("");
+}
+function createDevDiagnostics(value) {
+	return {
+		consoleMessages: value?.consoleMessages ?? [],
+		notices: value?.notices ?? [],
+		runtimeErrors: value?.runtimeErrors ?? []
+	};
+}
+//#endregion
 //#region src/core/wait.ts
 const DEFAULT_INTERVAL_MS = 100;
 const DEFAULT_TIMEOUT_MS$1 = 5e3;
@@ -303,6 +485,7 @@ function createObsidianClient(options) {
 	});
 	let cachedVaultPath;
 	const client = {};
+	const metadata = createObsidianMetadataHandle(client);
 	const app = {
 		async reload(execOptions = {}) {
 			await client.exec("reload", {}, execOptions);
@@ -326,32 +509,61 @@ function createObsidianClient(options) {
 			}, waitOptions);
 		}
 	};
+	const dev = {
+		async activeFilePath(execOptions = {}) {
+			return this.eval("app.workspace.getActiveFile()?.path ?? null", execOptions);
+		},
+		async consoleMessages(execOptions = {}) {
+			return readDiagnosticsValue(this, "consoleMessages", execOptions);
+		},
+		async diagnostics(execOptions = {}) {
+			return createDevDiagnostics(await readDiagnosticsValue(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 = {}) {
+			return parseDevEvalOutput(await this.evalRaw(code, execOptions));
+		},
+		async evalJson(code, execOptions = {}) {
+			return runEvalJson(this, code, execOptions);
+		},
+		async evalRaw(code, execOptions = {}) {
+			return client.execText("eval", { code }, execOptions);
+		},
+		async editorText(execOptions = {}) {
+			return this.eval("app.workspace.activeLeaf?.view?.editor?.getValue?.() ?? null", execOptions);
+		},
+		async notices(execOptions = {}) {
+			return readDiagnosticsValue(this, "notices", execOptions);
+		},
+		async resetDiagnostics(execOptions = {}) {
+			await readDiagnosticsValue(this, "reset", execOptions);
+		},
+		async runtimeErrors(execOptions = {}) {
+			return readDiagnosticsValue(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: {
-			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;
-			}
-		},
+		dev,
+		metadata,
 		command(id) {
 			return {
 				async exists(commandOptions = {}) {
@@ -419,6 +631,24 @@ function createObsidianClient(options) {
 			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,
@@ -435,14 +665,6 @@ function createObsidianClient(options) {
 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);
 }
@@ -478,6 +700,19 @@ function parseWorkspace(output) {
 	}
 	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 readDiagnosticsValue(dev, method, execOptions) {
+	return runEvalJson(dev, buildDiagnosticsCode(method), execOptions);
+}
 function getWorkspaceDepth(line) {
 	let depth = 0;
 	let remainder = line;
@@ -518,51 +753,188 @@ function parseWorkspaceNode(line) {
 	};
 }
 //#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: {
-			activeFile: true,
-			dom: true,
-			editorText: true,
-			screenshot: true,
-			tabs: true,
-			workspace: true
-		},
+		capture: { ...DEFAULT_FAILURE_ARTIFACT_CAPTURE },
 		enabled: false
 	};
 	const overrides = options.captureOnFailure === true ? {} : options.captureOnFailure;
 	return {
 		artifactsDir: path.resolve(options.artifactsDir ?? ".obsidian-e2e-artifacts"),
 		capture: {
-			activeFile: overrides.activeFile ?? true,
-			dom: overrides.dom ?? true,
-			editorText: overrides.editorText ?? true,
-			screenshot: overrides.screenshot ?? true,
-			tabs: overrides.tabs ?? true,
-			workspace: overrides.workspace ?? true
+			...DEFAULT_FAILURE_ARTIFACT_CAPTURE,
+			...overrides
 		},
 		enabled: true
 	};
 }
 function getFailureArtifactDirectory(artifactsDir, task) {
 	const suffix = task.id.split("_").at(-1) ?? "test";
-	return path.join(artifactsDir, `${sanitizeForPath(task.name)}-${suffix}`);
+	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 obsidian.dev.eval("app.workspace.getActiveFile()?.path ?? null") })),
+		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.eval("app.workspace.activeLeaf?.view?.editor?.getValue?.() ?? null") })),
+		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()),
@@ -570,14 +942,6 @@ async function captureFailureArtifacts(task, obsidian, options) {
 	]);
 	return artifactDirectory;
 }
-async function capturePluginFailureArtifacts(task, plugin, options) {
-	const config = getFailureArtifactConfig(options);
-	if (!config.enabled) return;
-	const artifactDirectory = getFailureArtifactDirectory(config.artifactsDir, task);
-	await mkdir(artifactDirectory, { recursive: true });
-	await captureJsonArtifact(artifactDirectory, `${plugin.id}-data.json`, true, () => plugin.data().read());
-	return artifactDirectory;
-}
 async function captureJsonArtifact(artifactDirectory, filename, enabled, readValue) {
 	if (!enabled) return;
 	try {
@@ -607,8 +971,59 @@ async function captureTextArtifact(artifactDirectory, filename, enabled, readVal
 function formatArtifactError(error) {
 	return error instanceof Error ? `${error.name}: ${error.message}\n` : `${String(error)}\n`;
 }
-function sanitizeForPath(value) {
-	return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "test";
+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 });
+		},
+		path(...segments) {
+			return sandboxPath(...segments);
+		},
+		async readNote(targetPath) {
+			return parseNoteDocument(await vault.read(targetPath));
+		},
+		root,
+		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
@@ -772,147 +1187,167 @@ async function sleep(durationMs) {
 async function writeMetadata(metadataPath, metadata) {
 	await writeFile(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
 }
-//#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);
+function createBaseFixtures(options, fixtureOptions = {}) {
+	const createVault = fixtureOptions.createVault ?? ((obsidian) => createVaultApi({ obsidian }));
 	return {
-		async delete(targetPath, deleteOptions = {}) {
-			await rm(await resolveFilesystemPath(options.obsidian, scopeRoot, targetPath), {
-				force: true,
-				recursive: true
+		_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()
 			});
-			if (deleteOptions.permanent === false) return;
-		},
-		async exists(targetPath) {
+			await vaultLock.publishMarker(lockClient);
 			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 () => {
+				await use(vaultLock);
+			} finally {
 				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
+					await clearVaultRunLockMarker(lockClient);
+				} catch {}
+				await vaultLock.release();
+			}
+		}, { scope: "worker" }],
+		_testContext: async ({ _vaultLock, onTestFailed, task }, use) => {
+			let failedTask = false;
+			onTestFailed(() => {
+				failedTask = true;
 			});
-		},
-		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
+			const context = await createInternalTestContext({
+				...options,
+				createVault,
+				testName: task.name,
+				vaultLock: _vaultLock
 			});
+			try {
+				await use(context);
+			} finally {
+				await context.cleanup({ failedTask: failedTask ? task : void 0 });
+			}
 		},
-		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
-			});
+		obsidian: async ({ _testContext }, use) => {
+			await use(_testContext.obsidian);
 		},
-		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);
+		sandbox: async ({ _testContext }, use) => {
+			await use(_testContext.sandbox);
+		},
+		vault: async ({ _testContext }, use) => {
+			await use(_testContext.vault);
 		}
 	};
 }
 //#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
-	};
+//#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;
+	}
 }
-function sanitizeSegment(value) {
-	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "test";
+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, DEFAULT_FAILURE_ARTIFACTS_DIR as c, createObsidianClient as d, getClientInternals as f, acquireVaultRunLock as i, captureFailureArtifacts as l, createVaultApi as n, inspectVaultRunLock as o, resolveFilesystemPath as r, readVaultRunLockMarker as s, createSandboxApi as t, capturePluginFailureArtifacts as u };
+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=sandbox--mUbNsh7.mjs.map
+//# sourceMappingURL=test-context-Bl-e-83H.mjs.map