obsidian-e2e 0.4.0 → 0.5.0

package/dist/{sandbox--mUbNsh7.mjs → test-context-BprSx6U1.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];
@@ -17,6 +18,303 @@ function buildCommandArgv(vaultName, command, args = {}) {
 	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 } : {};
@@ -94,6 +392,40 @@ 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 {
@@ -125,17 +457,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 parseHarnessEnvelope(await client.dev.evalRaw(buildHarnessCallCode("pluginLoaded", id)));
 		} catch {
 			return false;
 		}
 	}
+	function withDefaultReadyReloadOptions(options = {}) {
+		return {
+			...options,
+			waitUntilReady: options.waitUntilReady ?? true
+		};
+	}
 	return {
 		data() {
 			return {
@@ -180,6 +512,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 {
@@ -220,6 +583,15 @@ var WaitForTimeoutError = class extends Error {
 		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;
@@ -303,6 +675,7 @@ function createObsidianClient(options) {
 	});
 	let cachedVaultPath;
 	const client = {};
+	const metadata = createObsidianMetadataHandle(client);
 	const app = {
 		async reload(execOptions = {}) {
 			await client.exec("reload", {}, execOptions);
@@ -326,32 +699,67 @@ function createObsidianClient(options) {
 			}, 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: {
-			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 +827,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 +861,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 +896,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 readHarnessValue(dev, method, execOptions) {
+	return parseHarnessEnvelope(await dev.evalRaw(buildHarnessCallCode(method), execOptions));
+}
 function getWorkspaceDepth(line) {
 	let depth = 0;
 	let remainder = line;
@@ -518,51 +949,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 +1138,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 +1167,68 @@ 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 });
+		},
+		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
@@ -772,147 +1392,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-BprSx6U1.mjs.map