@mnaoumov/obsidian-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/cjs/demo-vault-buttons.cjs

@@ -0,0 +1,580 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip']
+  );
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var demo_vault_buttons_exports = {};
+__export(demo_vault_buttons_exports, {
+  CODE_SCRIPT_TOOLKIT_PLUGIN_ID: () => CODE_SCRIPT_TOOLKIT_PLUGIN_ID,
+  assertClickBudgetsFitTransportCap: () => assertClickBudgetsFitTransportCap,
+  countRenderedButtons: () => countRenderedButtons,
+  findDuplicateCaptions: () => findDuplicateCaptions,
+  formatFailures: () => formatFailures,
+  listNotesWithButtons: () => listNotesWithButtons,
+  listRenderedButtonCaptions: () => listRenderedButtonCaptions,
+  registerDemoVaultButtonSuite: () => registerDemoVaultButtonSuite,
+  selectUnexpectedFailures: () => selectUnexpectedFailures
+});
+module.exports = __toCommonJS(demo_vault_buttons_exports);
+var import_root = require('@mnaoumov/typescript-dev-toolkit/root');
+var import_node_fs = require('node:fs');
+var import_node_path = require('node:path');
+var import_node_process = __toESM(__extractDefault(require('node:process')), 1);
+var import_obsidian_integration_testing = require('obsidian-integration-testing');
+var import_vitest_global_setup_plugin = require('obsidian-integration-testing/vitest-global-setup-plugin');
+var import_vitest = require('vitest');
+const CODE_SCRIPT_TOOLKIT_PLUGIN_ID = "fix-require-modules";
+const DEFAULT_BUTTON_RESULT_TIMEOUT_IN_MILLISECONDS = 1e4;
+const DEFAULT_SETTLE_TIMEOUT_IN_MILLISECONDS = 12e3;
+const POLL_INTERVAL_IN_MILLISECONDS = 100;
+const OUTPUT_EXCERPT_LENGTH = 400;
+const DEFAULT_EXCLUDED_NOTES = ["README.md"];
+const FENCE_REG_EXP = /^(?<indent>\s*)(?<marker>`{3,}|~{3,})(?<info>.*)$/;
+const CODE_BUTTON_FENCE_INFO = "code-button";
+const FRONT_MATTER_DELIMITER = "---";
+const RAW_MODE_CONFIG_REG_EXP = /^isRaw:\s*true\s*$/m;
+const CAPTION_CONFIG_REG_EXP = /^caption:(?<value>.*)$/m;
+const PLAIN_SCALAR_COMMENT_REG_EXP = /\s+#.*$/;
+const SINGLE_QUOTED_SCALAR_REG_EXP = /^'(?<content>.*)'$/;
+const DOUBLE_QUOTED_SCALAR_REG_EXP = /^"(?<content>.*)"$/;
+const DEFAULT_CODE_BUTTON_CAPTION = "(no caption)";
+function assertClickBudgetsFitTransportCap(timeouts) {
+  const totalInMilliseconds = timeouts.settleTimeoutInMilliseconds + timeouts.buttonResultTimeoutInMilliseconds;
+  if (totalInMilliseconds < import_obsidian_integration_testing.DEFAULT_EVAL_CAP_IN_MILLISECONDS) {
+    return;
+  }
+  throw new Error(
+    `One demo-vault button click spends settleTimeoutInMilliseconds (${String(timeouts.settleTimeoutInMilliseconds)} ms) and buttonResultTimeoutInMilliseconds (${String(timeouts.buttonResultTimeoutInMilliseconds)} ms) inside a single transport call, so their sum of ${String(totalInMilliseconds)} ms is at or over the transport's ${String(import_obsidian_integration_testing.DEFAULT_EVAL_CAP_IN_MILLISECONDS)} ms script timeout and can never be honoured. Lower either budget in RegisterDemoVaultButtonSuiteOptions.`
+  );
+}
+function countRenderedButtons(source) {
+  return listRenderedButtonCaptions(source).length;
+}
+function findDuplicateCaptions(captions) {
+  const seenCaptions = /* @__PURE__ */ new Set();
+  const duplicateCaptions = /* @__PURE__ */ new Set();
+  for (const caption of captions) {
+    if (seenCaptions.has(caption)) {
+      duplicateCaptions.add(caption);
+    }
+    seenCaptions.add(caption);
+  }
+  return [...duplicateCaptions];
+}
+function formatFailures(noteName, failures) {
+  if (failures.length === 0) {
+    return "";
+  }
+  const details = failures.map((failure) => `  - "${failure.caption}" [${failure.status}]: ${failure.output.replaceAll(/\s+/g, " ").trim()}`).join("\n");
+  return `${String(failures.length)} button(s) in ${noteName} did not run cleanly:
+${details}`;
+}
+function listRenderedButtonCaptions(source) {
+  const captions = [];
+  let openMarker = "";
+  let isCodeButtonFence = false;
+  let fenceBody = [];
+  let fenceIndentLength = 0;
+  function closeFence() {
+    if (isCodeButtonFence && !isRawFence(fenceBody)) {
+      captions.push(readCaption(fenceBody));
+    }
+    openMarker = "";
+  }
+  for (const line of source.split(/\r?\n/)) {
+    const match = FENCE_REG_EXP.exec(line);
+    const indent = match?.groups?.["indent"] ?? "";
+    const marker = match?.groups?.["marker"] ?? "";
+    const info = (match?.groups?.["info"] ?? "").trim();
+    if (openMarker === "") {
+      if (match) {
+        openMarker = marker;
+        isCodeButtonFence = info === CODE_BUTTON_FENCE_INFO;
+        fenceBody = [];
+        fenceIndentLength = indent.length;
+      }
+      continue;
+    }
+    if (marker.startsWith(openMarker.charAt(0)) && marker.length >= openMarker.length && info === "") {
+      closeFence();
+      continue;
+    }
+    fenceBody.push(line.slice(Math.min(fenceIndentLength, line.length - line.trimStart().length)));
+  }
+  if (openMarker !== "") {
+    closeFence();
+  }
+  return captions;
+}
+function selectUnexpectedFailures(noteName, results, expectedNonOkButtons) {
+  return results.filter(
+    (result) => result.status !== "ok" && expectedNonOkButtons.every(
+      (expected) => !(expected.note === noteName && expected.status === result.status && result.caption.includes(expected.captionIncludes))
+    )
+  );
+}
+function isRawFence(fenceBody) {
+  const config = readConfigBlock(fenceBody);
+  return config !== null && RAW_MODE_CONFIG_REG_EXP.test(config);
+}
+function readCaption(fenceBody) {
+  const config = readConfigBlock(fenceBody);
+  const rawValue = config === null ? void 0 : CAPTION_CONFIG_REG_EXP.exec(config)?.groups?.["value"];
+  if (rawValue === void 0) {
+    return DEFAULT_CODE_BUTTON_CAPTION;
+  }
+  const value = rawValue.trim();
+  const singleQuotedContent = SINGLE_QUOTED_SCALAR_REG_EXP.exec(value)?.groups?.["content"];
+  if (singleQuotedContent !== void 0) {
+    return singleQuotedContent.replaceAll("''", "'");
+  }
+  const doubleQuotedContent = DOUBLE_QUOTED_SCALAR_REG_EXP.exec(value)?.groups?.["content"];
+  if (doubleQuotedContent !== void 0) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return doubleQuotedContent;
+    }
+  }
+  return value.replace(PLAIN_SCALAR_COMMENT_REG_EXP, "");
+}
+function readConfigBlock(fenceBody) {
+  if (fenceBody[0]?.trim() !== FRONT_MATTER_DELIMITER) {
+    return null;
+  }
+  const endIndex = fenceBody.findIndex((line, index) => index > 0 && line.trim() === FRONT_MATTER_DELIMITER);
+  return endIndex === -1 ? null : fenceBody.slice(1, endIndex).join("\n");
+}
+const NON_WALKTHROUGH_FOLDERS = /* @__PURE__ */ new Set(["Materials"]);
+function listNotesWithButtons(demoVaultPath, excludedNotes, excludedFolders = /* @__PURE__ */ new Set()) {
+  const notes = [];
+  function walk(folder, relativeFolder) {
+    for (const entry of (0, import_node_fs.readdirSync)(folder, { withFileTypes: true })) {
+      const relativePath = relativeFolder === "" ? entry.name : `${relativeFolder}/${entry.name}`;
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && !entry.name.startsWith("_") && !NON_WALKTHROUGH_FOLDERS.has(entry.name) && !excludedFolders.has(entry.name) && !excludedFolders.has(relativePath)) {
+          walk((0, import_node_path.join)(folder, entry.name), relativePath);
+        }
+        continue;
+      }
+      if (!entry.name.endsWith(".md") || excludedNotes.has(entry.name) || excludedNotes.has(relativePath)) {
+        continue;
+      }
+      const captions = listRenderedButtonCaptions((0, import_node_fs.readFileSync)((0, import_node_path.join)(folder, entry.name), "utf-8"));
+      if (captions.length > 0) {
+        notes.push({ buttonCount: captions.length, captions, name: relativePath });
+      }
+    }
+  }
+  walk(demoVaultPath, "");
+  return notes.sort((a, b) => a.name.localeCompare(b.name, "en"));
+}
+function registerDemoVaultButtonSuite(options = {}) {
+  const rootFolder = options.rootFolder ?? (0, import_root.getRootFolder)() ?? import_node_process.default.cwd();
+  const demoVaultPath = (0, import_node_path.join)(rootFolder, "demo-vault");
+  const excludedNotes = new Set(options.excludedNotes ?? DEFAULT_EXCLUDED_NOTES);
+  const excludedFolders = new Set(options.excludedFolders);
+  const expectedNonOkButtons = options.expectedNonOkButtons ?? [];
+  const shouldDismissModals = options.shouldDismissModals ?? false;
+  const settleTimeoutInMilliseconds = options.settleTimeoutInMilliseconds ?? DEFAULT_SETTLE_TIMEOUT_IN_MILLISECONDS;
+  const buttonResultTimeoutInMilliseconds = options.buttonResultTimeoutInMilliseconds ?? DEFAULT_BUTTON_RESULT_TIMEOUT_IN_MILLISECONDS;
+  const clickButtonTimeouts = {
+    buttonResultTimeoutInMilliseconds,
+    settleTimeoutInMilliseconds
+  };
+  assertClickBudgetsFitTransportCap(clickButtonTimeouts);
+  const notes = listNotesWithButtons(demoVaultPath, excludedNotes, excludedFolders);
+  (0, import_vitest.describe)("demo-vault buttons", () => {
+    (0, import_vitest.beforeAll)(async () => {
+      const isCodeScriptToolkitLoaded = await checkCodeScriptToolkitLoaded(settleTimeoutInMilliseconds);
+      (0, import_vitest.expect)(isCodeScriptToolkitLoaded, "CodeScript Toolkit did not load, so no button could render").toBe(true);
+    });
+    (0, import_vitest.it)("has at least one note with a code button", () => {
+      (0, import_vitest.expect)(notes.length).toBeGreaterThan(0);
+    });
+    for (const note of notes) {
+      (0, import_vitest.it)(`runs every code button in ${note.name}`, async () => {
+        const duplicateCaptions = findDuplicateCaptions(note.captions);
+        (0, import_vitest.expect)(
+          duplicateCaptions,
+          `${note.name} declares more than one button captioned ${duplicateCaptions.map((caption) => `"${caption}"`).join(", ")}. This suite addresses a button by its caption, so only the first of them could ever be clicked. Give each button a distinct caption.`
+        ).toEqual([]);
+        const captions = await openNoteAndListButtonCaptions(note, settleTimeoutInMilliseconds);
+        const missingCaptions = note.captions.filter((caption) => !captions.includes(caption));
+        (0, import_vitest.expect)(
+          captions.length,
+          `${note.name} declares ${String(note.buttonCount)} button(s) but only ${String(captions.length)} rendered; never seen: ${missingCaptions.map((caption) => `"${caption}"`).join(", ")}`
+        ).toBeGreaterThanOrEqual(note.buttonCount);
+        const results = [];
+        for (const caption of captions) {
+          results.push(await clickButton({ buttonCaption: caption, notePath: note.name, shouldDismissModals, timeouts: clickButtonTimeouts }));
+        }
+        const failures = selectUnexpectedFailures(note.name, results, expectedNonOkButtons);
+        (0, import_vitest.expect)(failures, formatFailures(note.name, failures)).toEqual([]);
+      });
+    }
+  });
+}
+async function checkCodeScriptToolkitLoaded(timeoutInMilliseconds) {
+  return (0, import_obsidian_integration_testing.evalInObsidian)({
+    async callback({ app, codeScriptToolkitPluginId, intervalInMilliseconds, lib: { waitUntil }, timeoutInMilliseconds: timeout }) {
+      if (typeof app.plugins.isEnabled === "function" && !app.plugins.isEnabled()) {
+        await app.plugins.setEnable(true);
+      }
+      if (!app.plugins.getPlugin(codeScriptToolkitPluginId)) {
+        await app.plugins.enablePlugin(codeScriptToolkitPluginId);
+      }
+      try {
+        await waitUntil({
+          intervalInMilliseconds,
+          message: "CodeScript Toolkit never loaded",
+          predicate: () => app.plugins.getPlugin(codeScriptToolkitPluginId) !== null,
+          timeoutInMilliseconds: timeout
+        });
+      } catch {
+        return false;
+      }
+      return true;
+    },
+    input: {
+      codeScriptToolkitPluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID,
+      intervalInMilliseconds: POLL_INTERVAL_IN_MILLISECONDS,
+      timeoutInMilliseconds
+    },
+    vaultPath: (0, import_vitest_global_setup_plugin.getTemporaryVault)().path
+  });
+}
+async function clickButton(params) {
+  return (0, import_obsidian_integration_testing.evalInObsidian)({
+    async callback({
+      app,
+      buttonResultTimeoutInMilliseconds,
+      caption,
+      intervalInMilliseconds,
+      lib: { pressKey, waitUntil },
+      notePath: notePathToOpen,
+      obsidianModule,
+      outputExcerptLength,
+      settleTimeoutInMilliseconds,
+      shouldDismissModals: shouldDismiss
+    }) {
+      function view() {
+        return app.workspace.getActiveViewOfType(obsidianModule.MarkdownView);
+      }
+      function previewEl() {
+        return view()?.containerEl.querySelector(":scope .markdown-preview-view") ?? null;
+      }
+      function buttons() {
+        return [...view()?.containerEl.querySelectorAll(":scope .block-language-code-button button.mod-cta") ?? []];
+      }
+      function findButton() {
+        return buttons().find((candidate) => candidate.textContent === caption);
+      }
+      const SCROLL_BOTTOM_TOLERANCE_IN_PIXELS = 4;
+      const SCROLL_STEP_RATIO = 0.8;
+      function advanceScroll() {
+        const scroller = previewEl();
+        if (!scroller) {
+          return;
+        }
+        const isAtBottom = scroller.scrollTop + scroller.clientHeight >= scroller.scrollHeight - SCROLL_BOTTOM_TOLERANCE_IN_PIXELS;
+        scroller.scrollTop = isAtBottom ? 0 : scroller.scrollTop + Math.floor(scroller.clientHeight * SCROLL_STEP_RATIO);
+      }
+      async function dismissModals() {
+        if (!shouldDismiss) {
+          return;
+        }
+        for (const closeButton of activeDocument.body.querySelectorAll(":scope .modal-container :is(.modal-close-button, .modal-header-button)")) {
+          closeButton.click();
+        }
+        if (activeDocument.querySelector(".modal-container, .prompt")) {
+          await pressKey({ key: "Escape" });
+        }
+      }
+      await app.workspace.openLinkText(notePathToOpen.replace(/\.md$/, ""), "", false);
+      await app.workspace.getLeaf(false).setViewState({ state: { file: notePathToOpen, mode: "preview" }, type: "markdown" });
+      let button;
+      try {
+        await waitUntil({
+          intervalInMilliseconds,
+          message: `code button "${caption}" never rendered`,
+          predicate: () => {
+            advanceScroll();
+            button = findButton();
+            return button !== void 0;
+          },
+          timeoutInMilliseconds: settleTimeoutInMilliseconds
+        });
+      } catch {
+        return { caption, output: "", status: "timeout" };
+      }
+      if (!button) {
+        return { caption, output: "", status: "timeout" };
+      }
+      const block = button.closest(".block-language-code-button") ?? button.parentElement;
+      button.scrollIntoView();
+      button.click();
+      let status;
+      try {
+        await waitUntil({
+          intervalInMilliseconds,
+          message: `button "${caption}" never reported a result`,
+          predicate: async () => {
+            await dismissModals();
+            return /Executed (?:successfully|with error)/.test(block?.textContent ?? "");
+          },
+          timeoutInMilliseconds: buttonResultTimeoutInMilliseconds
+        });
+        const text = block?.textContent ?? "";
+        if (text.includes("Executed with error")) {
+          status = "error";
+        } else if (text.includes("Executed successfully")) {
+          status = "ok";
+        } else {
+          status = "unknown";
+        }
+      } catch {
+        status = "timeout";
+      }
+      await dismissModals();
+      return { caption, output: (block?.textContent ?? "").slice(0, outputExcerptLength), status };
+    },
+    input: {
+      buttonResultTimeoutInMilliseconds: params.timeouts.buttonResultTimeoutInMilliseconds,
+      caption: params.buttonCaption,
+      intervalInMilliseconds: POLL_INTERVAL_IN_MILLISECONDS,
+      notePath: params.notePath,
+      outputExcerptLength: OUTPUT_EXCERPT_LENGTH,
+      settleTimeoutInMilliseconds: params.timeouts.settleTimeoutInMilliseconds,
+      shouldDismissModals: params.shouldDismissModals
+    },
+    vaultPath: (0, import_vitest_global_setup_plugin.getTemporaryVault)().path
+  });
+}
+async function openNoteAndListButtonCaptions(note, settleTimeoutInMilliseconds) {
+  return (0, import_obsidian_integration_testing.evalInObsidian)({
+    async callback({ app, expectedButtonCount, intervalInMilliseconds, lib: { waitUntil }, notePath, obsidianModule, timeoutInMilliseconds }) {
+      function view() {
+        return app.workspace.getActiveViewOfType(obsidianModule.MarkdownView);
+      }
+      function previewEl() {
+        return view()?.containerEl.querySelector(":scope .markdown-preview-view") ?? null;
+      }
+      const seenCaptions = /* @__PURE__ */ new Set();
+      function captions() {
+        for (const button of view()?.containerEl.querySelectorAll(":scope .block-language-code-button button.mod-cta") ?? []) {
+          if (button.textContent !== "") {
+            seenCaptions.add(button.textContent);
+          }
+        }
+        return [...seenCaptions];
+      }
+      const SCROLL_BOTTOM_TOLERANCE_IN_PIXELS = 4;
+      const SCROLL_STEP_RATIO = 0.8;
+      function advanceScroll() {
+        const scroller = previewEl();
+        if (!scroller) {
+          return;
+        }
+        const isAtBottom = scroller.scrollTop + scroller.clientHeight >= scroller.scrollHeight - SCROLL_BOTTOM_TOLERANCE_IN_PIXELS;
+        scroller.scrollTop = isAtBottom ? 0 : scroller.scrollTop + Math.floor(scroller.clientHeight * SCROLL_STEP_RATIO);
+      }
+      await app.workspace.openLinkText(notePath.replace(/\.md$/, ""), "", false);
+      await app.workspace.getLeaf(false).setViewState({ state: { file: notePath, mode: "preview" }, type: "markdown" });
+      try {
+        await waitUntil({
+          intervalInMilliseconds,
+          message: `"${notePath}" never mounted all ${String(expectedButtonCount)} of its buttons`,
+          predicate: () => {
+            advanceScroll();
+            return captions().length >= expectedButtonCount;
+          },
+          timeoutInMilliseconds
+        });
+      } catch {
+      }
+      return captions();
+    },
+    input: {
+      expectedButtonCount: note.buttonCount,
+      intervalInMilliseconds: POLL_INTERVAL_IN_MILLISECONDS,
+      notePath: note.name,
+      timeoutInMilliseconds: settleTimeoutInMilliseconds
+    },
+    vaultPath: (0, import_vitest_global_setup_plugin.getTemporaryVault)().path
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CODE_SCRIPT_TOOLKIT_PLUGIN_ID,
+  assertClickBudgetsFitTransportCap,
+  countRenderedButtons,
+  findDuplicateCaptions,
+  formatFailures,
+  listNotesWithButtons,
+  listRenderedButtonCaptions,
+  registerDemoVaultButtonSuite,
+  selectUnexpectedFailures
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/demo-vault-buttons.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A vitest suite that opens every note of a plugin's in-repo `demo-vault/`, clicks each `code-button`\n * in it against a real Obsidian, and fails on any button that errors or never reports a result.\n *\n * A demo vault's buttons are the one part of it no other gate can check. `lint:md` reads the markdown,\n * the coverage suite ({@link ./demo-vault-coverage.ts | `registerDemoVaultCoverageSuite`}) checks the\n * authoring conventions, and neither executes anything \u2014 a button whose `require('/demoSetup.ts')` path\n * is wrong, or that calls an API that has since changed shape, fails at click time and nowhere else.\n *\n * The companion half \u2014 seeding the temp vault with the demo-vault tree, its `.obsidian` config, and the\n * CodeScript Toolkit binary that turns ```` ```code-button ```` fences into buttons \u2014 is\n * `buildDemoVaultPopulate` in `obsidian-integration-testing`; hand its result to the project's\n * `globalSetup` and name CodeScript Toolkit in `enableCommunityPlugins`.\n */\n\nimport { getRootFolder } from '@mnaoumov/typescript-dev-toolkit/root';\nimport {\n  readdirSync,\n  readFileSync\n} from 'node:fs';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport {\n  DEFAULT_EVAL_CAP_IN_MILLISECONDS,\n  evalInObsidian\n} from 'obsidian-integration-testing';\nimport { getTemporaryVault } from 'obsidian-integration-testing/vitest-global-setup-plugin';\nimport {\n  beforeAll,\n  describe,\n  expect,\n  it\n} from 'vitest';\n\n/**\n * CodeScript Toolkit's manifest id. It is still the plugin's original `fix-require-modules` id, which\n * no longer matches its name \u2014 the id is published, so it cannot be changed.\n */\nexport const CODE_SCRIPT_TOOLKIT_PLUGIN_ID = 'fix-require-modules';\n\n/**\n * The waiting budgets a single button click is allowed.\n *\n * Both are spent inside ONE transport call, so it is their SUM that\n * {@link assertClickBudgetsFitTransportCap} bounds.\n */\nexport interface ClickButtonTimeouts {\n  /**\n   * How long to wait for the clicked button to report a result.\n   */\n  readonly buttonResultTimeoutInMilliseconds: number;\n\n  /**\n   * How long to wait for the button itself to mount.\n   */\n  readonly settleTimeoutInMilliseconds: number;\n}\n\n/**\n * The outcome of clicking one button.\n */\nexport interface DemoVaultButtonResult {\n  /**\n   * The button's caption, as rendered.\n   */\n  readonly caption: string;\n\n  /**\n   * The result line CodeScript Toolkit printed under the button, truncated.\n   */\n  readonly output: string;\n\n  /**\n   * Whether the button reported success, reported an error, or never reported at all.\n   */\n  readonly status: 'error' | 'ok' | 'timeout' | 'unknown';\n}\n\n/**\n * One demo-vault note and how many buttons its source declares.\n */\nexport interface DemoVaultNote {\n  /**\n   * How many buttons the note's source renders, as counted by {@link countRenderedButtons}.\n   */\n  readonly buttonCount: number;\n\n  /**\n   * The captions of those buttons, in source order, as read by {@link listRenderedButtonCaptions}.\n   */\n  readonly captions: readonly string[];\n\n  /**\n   * The note's file name, relative to the demo vault root.\n   */\n  readonly name: string;\n}\n\n/**\n * A button that is EXPECTED not to report success, so the suite does not fail on it.\n */\nexport interface ExpectedNonOkButton {\n  /**\n   * A substring of the button's rendered caption.\n   */\n  readonly captionIncludes: string;\n\n  /**\n   * The note holding the button, relative to the demo vault root.\n   */\n  readonly note: string;\n\n  /**\n   * The status the button is expected to end in. Any other status still fails, so an error demo that\n   * starts timing out instead is reported rather than waved through.\n   */\n  readonly status: Exclude<DemoVaultButtonResult['status'], 'ok'>;\n}\n\n/**\n * The options for {@link registerDemoVaultButtonSuite}.\n */\nexport interface RegisterDemoVaultButtonSuiteOptions {\n  /**\n   * How long, in milliseconds, to wait for a clicked button to report a result.\n   *\n   * Bounded by the same sum as {@link RegisterDemoVaultButtonSuiteOptions.settleTimeoutInMilliseconds},\n   * and refused by the same throw at registration.\n   *\n   * @default `10000`\n   */\n  readonly buttonResultTimeoutInMilliseconds?: number;\n\n  /**\n   * Folders to skip whole, matched against both the folder name and its path relative to the demo vault\n   * root \u2014 for a group whose notes cannot run unattended, such as ones that first install a third-party\n   * plugin from the community store.\n   *\n   * @default `[]`\n   */\n  readonly excludedFolders?: readonly string[];\n\n  /**\n   * Note file names (relative to the demo vault root) to skip.\n   *\n   * @default `['README.md']`\n   */\n  readonly excludedNotes?: readonly string[];\n\n  /**\n   * Buttons that legitimately do not report success: an error demo, or a button that turns system\n   * messages off and so never prints the result line the suite classifies.\n   *\n   * @default `[]`\n   */\n  readonly expectedNonOkButtons?: readonly ExpectedNonOkButton[];\n\n  /**\n   * The repository root holding `demo-vault/`.\n   *\n   * @default the resolved repo root, falling back to `process.cwd()`.\n   */\n  readonly rootFolder?: string;\n\n  /**\n   * How long, in milliseconds, to wait for a note's preview and its buttons to mount.\n   *\n   * Together with `buttonResultTimeoutInMilliseconds` this must stay under the transport's ~30 s script\n   * timeout: one button click spends both inside a SINGLE evaluation, so a sum at or over the cap cannot\n   * be honoured and turns a real timeout into a bare `script timeout` naming only the transport.\n   * {@link registerDemoVaultButtonSuite} throws on such a pair rather than registering it.\n   *\n   * @default `12000`\n   */\n  readonly settleTimeoutInMilliseconds?: number;\n\n  /**\n   * Whether to dismiss any open modal while waiting for a clicked button's result, and again once it is\n   * classified.\n   *\n   * A button that `await`s an `alert` / `confirm` / `prompt` cannot report a result until somebody closes\n   * the dialog, so without this it ends as `timeout` \u2014 and the dialog it left open then sits over every\n   * later button in the run. Off by default, so no suite changes behavior unasked.\n   *\n   * @default `false`\n   */\n  readonly shouldDismissModals?: boolean;\n}\n\n/*\n * These two are spent INSIDE ONE `evalInObsidian` closure by `clickButton`, which waits for the button to\n * mount and then for its result, so it is their SUM that has to stay under the transport's ~30 s script\n * timeout \u2014 not either one alone. The former 20 000 + 15 000 asked for 35 s, which the transport can never\n * grant: a slow button did not report \"never reported a result\", it died as a bare `script timeout` naming\n * only the transport. `no-over-cap-wait-in-eval-in-obsidian` cannot catch this one, because the budgets\n * reach the closure from a caller two levels up rather than being written at the wait \u2014 which is why\n * `assertClickBudgetsFitTransportCap` below enforces at runtime what the rule cannot see. Overriding\n * either default via `RegisterDemoVaultButtonSuiteOptions` is subject to the same sum.\n */\nconst DEFAULT_BUTTON_RESULT_TIMEOUT_IN_MILLISECONDS = 10_000;\nconst DEFAULT_SETTLE_TIMEOUT_IN_MILLISECONDS = 12_000;\n\ninterface ClickButtonParams {\n  /**\n   * The button's rendered caption, which is how it is addressed.\n   */\n  readonly buttonCaption: string;\n\n  /**\n   * The note holding the button.\n   */\n  readonly notePath: string;\n\n  /**\n   * Whether to dismiss the modals the button opens.\n   */\n  readonly shouldDismissModals: boolean;\n\n  /**\n   * The render and result budgets.\n   */\n  readonly timeouts: ClickButtonTimeouts;\n}\n\nconst POLL_INTERVAL_IN_MILLISECONDS = 100;\nconst OUTPUT_EXCERPT_LENGTH = 400;\n\n// `README.md` is the repo-facing page GitHub renders, not a walkthrough. `00 Start.md` is deliberately\n// NOT excluded: the landing notes carry buttons of their own.\nconst DEFAULT_EXCLUDED_NOTES = ['README.md'];\n\n// A fence line: its marker run (three or more backticks or tildes) and whatever follows it.\nconst FENCE_REG_EXP = /^(?<indent>\\s*)(?<marker>`{3,}|~{3,})(?<info>.*)$/;\nconst CODE_BUTTON_FENCE_INFO = 'code-button';\nconst FRONT_MATTER_DELIMITER = '---';\nconst RAW_MODE_CONFIG_REG_EXP = /^isRaw:\\s*true\\s*$/m;\nconst CAPTION_CONFIG_REG_EXP = /^caption:(?<value>.*)$/m;\nconst PLAIN_SCALAR_COMMENT_REG_EXP = /\\s+#.*$/;\nconst SINGLE_QUOTED_SCALAR_REG_EXP = /^'(?<content>.*)'$/;\nconst DOUBLE_QUOTED_SCALAR_REG_EXP = /^\"(?<content>.*)\"$/;\n// CodeScript Toolkit's own default, which a fence naming no caption renders.\nconst DEFAULT_CODE_BUTTON_CAPTION = '(no caption)';\n\n// The rendered-button selector is `:scope .block-language-code-button button.mod-cta`. It is written\n// out at each use site rather than held in a constant here: every closure below is serialized with\n// `toString()` and evaluated inside Obsidian, where nothing from this module's scope exists.\n\n/**\n * Refuses a settle/result budget pair that a single transport call could never honour.\n *\n * `clickButton` waits for the button to mount and then for its result INSIDE ONE `evalInObsidian`\n * closure, so the transport's script timeout bounds their sum rather than either one alone \u2014 and\n * `RegisterDemoVaultButtonSuiteOptions` lets a consumer raise each independently, with nothing summing\n * them. Raising `settleTimeoutInMilliseconds` to 20 000 for one slow note is an ordinary thing to do and\n * silently puts the pair at the cap.\n *\n * Throwing here, at suite registration, is the whole value: the failure it replaces is a\n * `WebDriverError: script timeout` raised mid-run against whichever button happened to be slowest,\n * naming the transport and neither budget.\n *\n * @param timeouts - The {@link ClickButtonTimeouts} to bound.\n */\nexport function assertClickBudgetsFitTransportCap(timeouts: ClickButtonTimeouts): void {\n  const totalInMilliseconds = timeouts.settleTimeoutInMilliseconds + timeouts.buttonResultTimeoutInMilliseconds;\n\n  /*\n   * The comparison is `<` rather than `<=` because a sum that merely REACHES the cap can already never\n   * be honoured: `no-over-cap-wait-in-eval-in-obsidian` reports at the cap as well as over it, and a\n   * closure handed exactly the transport's budget has nothing left for the dispatch itself.\n   */\n  if (totalInMilliseconds < DEFAULT_EVAL_CAP_IN_MILLISECONDS) {\n    return;\n  }\n\n  throw new Error(\n    `One demo-vault button click spends settleTimeoutInMilliseconds (${String(timeouts.settleTimeoutInMilliseconds)} ms) and `\n      + `buttonResultTimeoutInMilliseconds (${String(timeouts.buttonResultTimeoutInMilliseconds)} ms) inside a single transport call, `\n      + `so their sum of ${String(totalInMilliseconds)} ms is at or over the transport's `\n      + `${String(DEFAULT_EVAL_CAP_IN_MILLISECONDS)} ms script timeout and can never be honoured. `\n      + 'Lower either budget in RegisterDemoVaultButtonSuiteOptions.'\n  );\n}\n\n/**\n * Counts the buttons a note's source will actually render.\n *\n * Three kinds of ` ```code-button ` fence render no clickable button, and a vault that DOCUMENTS code\n * buttons is full of the first two:\n *\n * - A fence nested inside a longer or different fence (a ```` ````markdown ```` or `~~~` block) is a\n *   markdown SAMPLE shown to the reader; the renderer never sees it as a block.\n * - An `isRaw: true` fence renders its output directly and no button element at all.\n * - A fence whose info string carries anything after `code-button` uses the legacy argument syntax, which\n *   renders an error banner asking to update the config rather than the button.\n *\n * Counting any of them makes the suite's shortfall assertion unsatisfiable \u2014 it demands more buttons\n * than the note can ever render \u2014 and an assertion that cannot pass gates nothing.\n *\n * The scan follows CommonMark's fence rules: a fence closes only on a run of the SAME character at least\n * as long as the opener, with no info string, and one left open runs to the end of the document, where it\n * still renders.\n *\n * @param source - The note's markdown.\n * @returns How many buttons it renders.\n */\nexport function countRenderedButtons(source: string): number {\n  return listRenderedButtonCaptions(source).length;\n}\n\n/**\n * Finds the captions declared by more than one button.\n *\n * The suite addresses a button by its caption \u2014 it collects the captions that mounted and clicks the\n * button carrying each one \u2014 so two buttons sharing a caption collapse into one: the second is never\n * clicked, and the note reads as declaring a button that never rendered.\n *\n * @param captions - A note's button captions.\n * @returns Each caption occurring more than once, listed once, in order of first repeat.\n */\nexport function findDuplicateCaptions(captions: readonly string[]): string[] {\n  const seenCaptions = new Set<string>();\n  const duplicateCaptions = new Set<string>();\n  for (const caption of captions) {\n    if (seenCaptions.has(caption)) {\n      duplicateCaptions.add(caption);\n    }\n    seenCaptions.add(caption);\n  }\n  return [...duplicateCaptions];\n}\n\n/**\n * Builds the assertion message for a note's failing buttons.\n *\n * The captured output is included because a button's failure is a runtime one \u2014 the stack CodeScript\n * Toolkit prints under it is the only diagnosis there is.\n *\n * @param noteName - The note the buttons belong to.\n * @param failures - The failing buttons.\n * @returns The message.\n */\nexport function formatFailures(noteName: string, failures: readonly DemoVaultButtonResult[]): string {\n  if (failures.length === 0) {\n    return '';\n  }\n\n  const details = failures\n    .map((failure) => `  - \"${failure.caption}\" [${failure.status}]: ${failure.output.replaceAll(/\\s+/g, ' ').trim()}`)\n    .join('\\n');\n  return `${String(failures.length)} button(s) in ${noteName} did not run cleanly:\\n${details}`;\n}\n\n/**\n * Lists the captions of the buttons a note's source will actually render, in source order.\n *\n * Which fences render a button is decided exactly as {@link countRenderedButtons} describes. A caption is\n * read from the fence's own config block; a fence naming none takes CodeScript Toolkit's default,\n * `(no caption)`, which is what its button then shows.\n *\n * @param source - The note's markdown.\n * @returns The captions, one per rendered button.\n */\nexport function listRenderedButtonCaptions(source: string): string[] {\n  const captions: string[] = [];\n  let openMarker = '';\n  let isCodeButtonFence = false;\n  let fenceBody: string[] = [];\n  let fenceIndentLength = 0;\n\n  function closeFence(): void {\n    if (isCodeButtonFence && !isRawFence(fenceBody)) {\n      captions.push(readCaption(fenceBody));\n    }\n    openMarker = '';\n  }\n\n  for (const line of source.split(/\\r?\\n/)) {\n    const match = FENCE_REG_EXP.exec(line);\n    const indent = match?.groups?.['indent'] ?? '';\n    const marker = match?.groups?.['marker'] ?? '';\n    const info = (match?.groups?.['info'] ?? '').trim();\n\n    if (openMarker === '') {\n      if (match) {\n        openMarker = marker;\n        isCodeButtonFence = info === CODE_BUTTON_FENCE_INFO;\n        fenceBody = [];\n        fenceIndentLength = indent.length;\n      }\n      continue;\n    }\n\n    // Anything else while a fence is open is its content \u2014 which is exactly how a ````markdown sample\n    // holds a ```code-button.\n    if (marker.startsWith(openMarker.charAt(0)) && marker.length >= openMarker.length && info === '') {\n      closeFence();\n      continue;\n    }\n\n    // CommonMark strips up to the opening fence's indentation from each content line, so a fence nested in\n    // a list item carries its `caption:` / `isRaw:` keys at column 0 like any other.\n    fenceBody.push(line.slice(Math.min(fenceIndentLength, line.length - line.trimStart().length)));\n  }\n\n  if (openMarker !== '') {\n    closeFence();\n  }\n\n  return captions;\n}\n\n/**\n * Picks the buttons that failed and were not expected to.\n *\n * @param noteName - The note the results belong to, relative to the demo vault root.\n * @param results - Every button's result in that note.\n * @param expectedNonOkButtons - The buttons allowed to end in a given non-`ok` status.\n * @returns The results that are not `ok` and match no {@link ExpectedNonOkButton}.\n */\nexport function selectUnexpectedFailures(\n  noteName: string,\n  results: readonly DemoVaultButtonResult[],\n  expectedNonOkButtons: readonly ExpectedNonOkButton[]\n): DemoVaultButtonResult[] {\n  return results.filter((result) =>\n    result.status !== 'ok'\n    && expectedNonOkButtons.every((expected) =>\n      !(expected.note === noteName\n        && expected.status === result.status\n        && result.caption.includes(expected.captionIncludes))\n    )\n  );\n}\n\n/**\n * Whether a `code-button` fence's own YAML config asks for raw mode.\n *\n * Read from the leading `---` block rather than from the whole body, so an `isRaw: true` written inside\n * a button's CODE \u2014 a button that demonstrates the key \u2014 is not mistaken for the button's own config.\n *\n * @param fenceBody - The fence's lines, without the fence markers.\n * @returns Whether the fence renders no button.\n */\nfunction isRawFence(fenceBody: readonly string[]): boolean {\n  const config = readConfigBlock(fenceBody);\n  return config !== null && RAW_MODE_CONFIG_REG_EXP.test(config);\n}\n\n/**\n * Reads the caption a `code-button` fence's own config block gives its button.\n *\n * A deliberately small reading of YAML \u2014 a plain, single-quoted or double-quoted scalar on the `caption:`\n * line \u2014 since the value only ever names a button. A value it cannot read exactly, such as a block\n * scalar, is returned as written: that can make one caption read wrong, but it cannot make two\n * different ones compare equal.\n *\n * @param fenceBody - The fence's lines, without the fence markers.\n * @returns The caption.\n */\nfunction readCaption(fenceBody: readonly string[]): string {\n  const config = readConfigBlock(fenceBody);\n  const rawValue = config === null ? undefined : CAPTION_CONFIG_REG_EXP.exec(config)?.groups?.['value'];\n  if (rawValue === undefined) {\n    return DEFAULT_CODE_BUTTON_CAPTION;\n  }\n\n  const value = rawValue.trim();\n  const singleQuotedContent = SINGLE_QUOTED_SCALAR_REG_EXP.exec(value)?.groups?.['content'];\n  if (singleQuotedContent !== undefined) {\n    return singleQuotedContent.replaceAll('\\'\\'', '\\'');\n  }\n  const doubleQuotedContent = DOUBLE_QUOTED_SCALAR_REG_EXP.exec(value)?.groups?.['content'];\n  if (doubleQuotedContent !== undefined) {\n    try {\n      return JSON.parse(value) as string;\n    } catch {\n      return doubleQuotedContent;\n    }\n  }\n  return value.replace(PLAIN_SCALAR_COMMENT_REG_EXP, '');\n}\n\n/**\n * Reads a `code-button` fence's leading `---` config block.\n *\n * Only the leading block counts, so a `---` block written inside a button's CODE is not mistaken for the\n * button's own config.\n *\n * @param fenceBody - The fence's lines, without the fence markers.\n * @returns The block's content, or `null` when the fence opens with no terminated block.\n */\nfunction readConfigBlock(fenceBody: readonly string[]): null | string {\n  if (fenceBody[0]?.trim() !== FRONT_MATTER_DELIMITER) {\n    return null;\n  }\n\n  const endIndex = fenceBody.findIndex((line, index) => index > 0 && line.trim() === FRONT_MATTER_DELIMITER);\n  return endIndex === -1 ? null : fenceBody.slice(1, endIndex).join('\\n');\n}\n\n/**\n * Folders that never hold a walkthrough. `Materials/` holds the fixtures the walkthroughs act on;\n * `_assets/` holds the demo scripts; `.obsidian/` is vault config. A folder starting with `.` or `_`\n * is skipped on the same reasoning, without having to be listed.\n */\nconst NON_WALKTHROUGH_FOLDERS = new Set(['Materials']);\n\n/**\n * Lists the demo vault's notes that declare at least one `code-button`, walking group folders too.\n *\n * A vault big enough to need grouping puts its walkthroughs in numbered folders \u2014 and a root-only walk\n * finds NONE of them, which is worse than it sounds: a vault whose notes are all grouped reports zero\n * notes, and one that is partly grouped silently gates only the ungrouped part. Fixture and asset\n * folders are still skipped, so what is walked is walkthroughs and nothing else.\n *\n * @param demoVaultPath - The demo vault root.\n * @param excludedNotes - Note names to skip, matched against both the file name and the path relative\n * to the vault root.\n * @param excludedFolders - Folders to skip whole, matched the same way.\n * @returns The notes, sorted by path.\n */\nexport function listNotesWithButtons(\n  demoVaultPath: string,\n  excludedNotes: ReadonlySet<string>,\n  excludedFolders: ReadonlySet<string> = new Set()\n): DemoVaultNote[] {\n  const notes: DemoVaultNote[] = [];\n\n  function walk(folder: string, relativeFolder: string): void {\n    for (const entry of readdirSync(folder, { withFileTypes: true })) {\n      const relativePath = relativeFolder === '' ? entry.name : `${relativeFolder}/${entry.name}`;\n\n      if (entry.isDirectory()) {\n        if (\n          !entry.name.startsWith('.') && !entry.name.startsWith('_') && !NON_WALKTHROUGH_FOLDERS.has(entry.name)\n          && !excludedFolders.has(entry.name) && !excludedFolders.has(relativePath)\n        ) {\n          walk(join(folder, entry.name), relativePath);\n        }\n        continue;\n      }\n\n      if (!entry.name.endsWith('.md') || excludedNotes.has(entry.name) || excludedNotes.has(relativePath)) {\n        continue;\n      }\n\n      const captions = listRenderedButtonCaptions(readFileSync(join(folder, entry.name), 'utf-8'));\n      if (captions.length > 0) {\n        notes.push({ buttonCount: captions.length, captions, name: relativePath });\n      }\n    }\n  }\n\n  walk(demoVaultPath, '');\n  return notes.sort((a, b) => a.name.localeCompare(b.name, 'en'));\n}\n\n/* v8 ignore start -- Every assertion below runs against a real Obsidian over CDP, driven by closures this process serializes and another executes. The testable parts are listNotesWithButtons and formatFailures, which have their own unit tests. */\n/**\n * Registers a vitest suite that clicks every `code-button` in the repo's demo vault.\n *\n * One `it` per note, and one `evalInObsidian` per button: a single closure runs as one CDP\n * `Runtime.evaluate`, which the harness caps at 30 s, so a note with a dozen buttons would otherwise\n * time out as a whole rather than reporting which button failed.\n *\n * @param options - The {@link RegisterDemoVaultButtonSuiteOptions}.\n */\nexport function registerDemoVaultButtonSuite(options: RegisterDemoVaultButtonSuiteOptions = {}): void {\n  const rootFolder = options.rootFolder ?? getRootFolder() ?? process.cwd();\n  const demoVaultPath = join(rootFolder, 'demo-vault');\n  const excludedNotes = new Set(options.excludedNotes ?? DEFAULT_EXCLUDED_NOTES);\n  const excludedFolders = new Set(options.excludedFolders);\n  const expectedNonOkButtons = options.expectedNonOkButtons ?? [];\n  const shouldDismissModals = options.shouldDismissModals ?? false;\n  const settleTimeoutInMilliseconds = options.settleTimeoutInMilliseconds ?? DEFAULT_SETTLE_TIMEOUT_IN_MILLISECONDS;\n  const buttonResultTimeoutInMilliseconds = options.buttonResultTimeoutInMilliseconds ?? DEFAULT_BUTTON_RESULT_TIMEOUT_IN_MILLISECONDS;\n\n  // Resolved ONCE and handed to both the bound and the click, so the pair that is asserted and the pair\n  // that is spent cannot drift apart.\n  const clickButtonTimeouts: ClickButtonTimeouts = {\n    buttonResultTimeoutInMilliseconds,\n    settleTimeoutInMilliseconds\n  };\n  assertClickBudgetsFitTransportCap(clickButtonTimeouts);\n\n  const notes = listNotesWithButtons(demoVaultPath, excludedNotes, excludedFolders);\n\n  describe('demo-vault buttons', () => {\n    beforeAll(async () => {\n      const isCodeScriptToolkitLoaded = await checkCodeScriptToolkitLoaded(settleTimeoutInMilliseconds);\n      // Without it every `code-button` fence stays a plain code block, so every note below would report\n      // zero buttons and pass vacuously. Fail here instead, once, with the reason.\n      expect(isCodeScriptToolkitLoaded, 'CodeScript Toolkit did not load, so no button could render').toBe(true);\n    });\n\n    // A demo vault has to demonstrate every headline feature, so a vault whose notes declare no buttons\n    // is a real failure of its interactive half, not a reason to register nothing and report green.\n    it('has at least one note with a code button', () => {\n      expect(notes.length).toBeGreaterThan(0);\n    });\n\n    for (const note of notes) {\n      it(`runs every code button in ${note.name}`, async () => {\n        // Checked from the source, before anything is opened: buttons are addressed by caption, so a\n        // shared one would otherwise surface below as a button that \"never rendered\".\n        const duplicateCaptions = findDuplicateCaptions(note.captions);\n        expect(\n          duplicateCaptions,\n          `${note.name} declares more than one button captioned ${duplicateCaptions.map((caption) => `\"${caption}\"`).join(', ')}. `\n            + 'This suite addresses a button by its caption, so only the first of them could ever be clicked. Give each button a distinct caption.'\n        ).toEqual([]);\n\n        const captions = await openNoteAndListButtonCaptions(note, settleTimeoutInMilliseconds);\n        // Reading view mounts a note's leading sections more than once while it settles, so the DOM can\n        // hold several elements per fence. The captions are deduplicated, and the assertion is that at\n        // least as many DISTINCT buttons rendered as the source declares \u2014 a fence that silently stayed\n        // A plain code block is the failure this catches.\n        const missingCaptions = note.captions.filter((caption) => !captions.includes(caption));\n        expect(\n          captions.length,\n          `${note.name} declares ${String(note.buttonCount)} button(s) but only ${String(captions.length)} rendered; `\n            + `never seen: ${missingCaptions.map((caption) => `\"${caption}\"`).join(', ')}`\n        )\n          .toBeGreaterThanOrEqual(note.buttonCount);\n\n        const results: DemoVaultButtonResult[] = [];\n        for (const caption of captions) {\n          results.push(await clickButton({ buttonCaption: caption, notePath: note.name, shouldDismissModals, timeouts: clickButtonTimeouts }));\n        }\n\n        const failures = selectUnexpectedFailures(note.name, results, expectedNonOkButtons);\n\n        expect(failures, formatFailures(note.name, failures)).toEqual([]);\n      });\n    }\n  });\n}\n\n/* v8 ignore stop */\n\n/* v8 ignore start -- Drives a real Obsidian over CDP: the closure is serialized here and executed in another process, so it cannot be exercised by a unit test. */\n/**\n * Turns restricted mode off and enables CodeScript Toolkit, whose binary the global setup seeded.\n *\n * @param timeoutInMilliseconds - How long to wait for it to load.\n * @returns Whether CodeScript Toolkit is loaded.\n */\nasync function checkCodeScriptToolkitLoaded(timeoutInMilliseconds: number): Promise<boolean> {\n  return evalInObsidian({\n    async callback({ app, codeScriptToolkitPluginId, intervalInMilliseconds, lib: { waitUntil }, timeoutInMilliseconds: timeout }): Promise<boolean> {\n      if (typeof app.plugins.isEnabled === 'function' && !app.plugins.isEnabled()) {\n        await app.plugins.setEnable(true);\n      }\n      if (!app.plugins.getPlugin(codeScriptToolkitPluginId)) {\n        await app.plugins.enablePlugin(codeScriptToolkitPluginId);\n      }\n      try {\n        await waitUntil({\n          intervalInMilliseconds,\n          message: 'CodeScript Toolkit never loaded',\n          predicate: (): boolean => app.plugins.getPlugin(codeScriptToolkitPluginId) !== null,\n          timeoutInMilliseconds: timeout\n        });\n      } catch {\n        return false;\n      }\n      return true;\n    },\n    input: {\n      codeScriptToolkitPluginId: CODE_SCRIPT_TOOLKIT_PLUGIN_ID,\n      intervalInMilliseconds: POLL_INTERVAL_IN_MILLISECONDS,\n      timeoutInMilliseconds\n    },\n    vaultPath: getTemporaryVault().path\n  });\n}\n\n/* v8 ignore stop */\n\n/* v8 ignore start -- Drives a real Obsidian over CDP: the closure is serialized here and executed in another process, so it cannot be exercised by a unit test. */\n/**\n * Clicks one button and reads the result line CodeScript Toolkit writes under it.\n *\n * A button that re-renders its own note (a settings change, a reload) detaches the block it lives in,\n * so the block element is captured BEFORE the click and read afterwards \u2014 CodeScript Toolkit writes the\n * result into that same element even once it is detached.\n *\n * @param params - The {@link ClickButtonParams}.\n * @returns The {@link DemoVaultButtonResult}.\n */\nasync function clickButton(params: ClickButtonParams): Promise<DemoVaultButtonResult> {\n  return evalInObsidian({\n    async callback({\n      app,\n      buttonResultTimeoutInMilliseconds,\n      caption,\n      intervalInMilliseconds,\n      lib: { pressKey, waitUntil },\n      notePath: notePathToOpen,\n      obsidianModule,\n      outputExcerptLength,\n      settleTimeoutInMilliseconds,\n      shouldDismissModals: shouldDismiss\n    }): Promise<DemoVaultButtonResult> {\n      function view(): InstanceType<typeof obsidianModule.MarkdownView> | null {\n        return app.workspace.getActiveViewOfType(obsidianModule.MarkdownView);\n      }\n      function previewEl(): HTMLElement | null {\n        return view()?.containerEl.querySelector<HTMLElement>(':scope .markdown-preview-view') ?? null;\n      }\n      function buttons(): HTMLButtonElement[] {\n        return [...view()?.containerEl.querySelectorAll<HTMLButtonElement>(':scope .block-language-code-button button.mod-cta') ?? []];\n      }\n\n      function findButton(): HTMLButtonElement | undefined {\n        return buttons().find((candidate) => candidate.textContent === caption);\n      }\n\n      // Reading view mounts lazily and unmounts sections far off-screen, so NO single scroll position\n      // holds a whole note's buttons. Advance a viewport at a time and wrap back to the top, remounting\n      // every section in turn until the one being looked for appears. Pinning to the BOTTOM instead \u2014\n      // what this did until 94.4.1 \u2014 only ever mounts the note's tail, so a button anywhere but at the\n      // end of its note was reported as never rendered (`status: 'timeout'`, empty output) however\n      // healthy it was.\n      const SCROLL_BOTTOM_TOLERANCE_IN_PIXELS = 4;\n      const SCROLL_STEP_RATIO = 0.8;\n      function advanceScroll(): void {\n        const scroller = previewEl();\n        if (!scroller) {\n          return;\n        }\n        const isAtBottom = scroller.scrollTop + scroller.clientHeight >= scroller.scrollHeight - SCROLL_BOTTOM_TOLERANCE_IN_PIXELS;\n        scroller.scrollTop = isAtBottom ? 0 : scroller.scrollTop + Math.floor(scroller.clientHeight * SCROLL_STEP_RATIO);\n      }\n\n      // Both the pre-1.13 and the 1.13 name of a modal's X: the old one alone matches nothing on a current\n      // Obsidian, and clicking nothing is a silent no-op rather than an error.\n      async function dismissModals(): Promise<void> {\n        if (!shouldDismiss) {\n          return;\n        }\n        for (const closeButton of activeDocument.body.querySelectorAll<HTMLElement>(':scope .modal-container :is(.modal-close-button, .modal-header-button)')) {\n          closeButton.click();\n        }\n        // A trusted Escape \u2014 what a user presses \u2014 but only while something is still open: this runs on\n        // every poll, and an unconditional key press would land in whatever the next button is doing.\n        if (activeDocument.querySelector('.modal-container, .prompt')) {\n          await pressKey({ key: 'Escape' });\n        }\n      }\n\n      // Re-open the note before every click instead of assuming the previous button left the workspace\n      // where it was found. Every helper above reads the ACTIVE view, and opening a note is one of the\n      // most ordinary things a demo button does \u2014 so the first such button would otherwise send each\n      // later button in its note to `status: 'timeout'` with an empty output, which is the shape of a\n      // button that never rendered rather than one that was looked for in the wrong view.\n      await app.workspace.openLinkText(notePathToOpen.replace(/\\.md$/, ''), '', false);\n      await app.workspace.getLeaf(false).setViewState({ state: { file: notePathToOpen, mode: 'preview' }, type: 'markdown' });\n\n      // Held from the predicate rather than re-queried after it: the walk above keeps moving the\n      // viewport, so a button found on one poll can be unmounted again by the next.\n      let button: HTMLButtonElement | undefined;\n      try {\n        await waitUntil({\n          intervalInMilliseconds,\n          message: `code button \"${caption}\" never rendered`,\n          predicate: (): boolean => {\n            advanceScroll();\n            button = findButton();\n            return button !== undefined;\n          },\n          timeoutInMilliseconds: settleTimeoutInMilliseconds\n        });\n      } catch {\n        return { caption, output: '', status: 'timeout' };\n      }\n\n      if (!button) {\n        return { caption, output: '', status: 'timeout' };\n      }\n\n      const block = button.closest<HTMLElement>('.block-language-code-button') ?? button.parentElement;\n      button.scrollIntoView();\n      button.click();\n\n      let status: DemoVaultButtonResult['status'];\n      try {\n        await waitUntil({\n          intervalInMilliseconds,\n          message: `button \"${caption}\" never reported a result`,\n          predicate: async (): Promise<boolean> => {\n            // A button that awaits an alert / confirm / prompt reports nothing until the dialog closes.\n            await dismissModals();\n            return /Executed (?:successfully|with error)/.test(block?.textContent ?? '');\n          },\n          timeoutInMilliseconds: buttonResultTimeoutInMilliseconds\n        });\n        const text = block?.textContent ?? '';\n        if (text.includes('Executed with error')) {\n          status = 'error';\n        } else if (text.includes('Executed successfully')) {\n          status = 'ok';\n        } else {\n          status = 'unknown';\n        }\n      } catch {\n        status = 'timeout';\n      }\n\n      // Whatever this button left open would otherwise sit over the next one.\n      await dismissModals();\n\n      return { caption, output: (block?.textContent ?? '').slice(0, outputExcerptLength), status };\n    },\n    input: {\n      buttonResultTimeoutInMilliseconds: params.timeouts.buttonResultTimeoutInMilliseconds,\n      caption: params.buttonCaption,\n      intervalInMilliseconds: POLL_INTERVAL_IN_MILLISECONDS,\n      notePath: params.notePath,\n      outputExcerptLength: OUTPUT_EXCERPT_LENGTH,\n      settleTimeoutInMilliseconds: params.timeouts.settleTimeoutInMilliseconds,\n      shouldDismissModals: params.shouldDismissModals\n    },\n    vaultPath: getTemporaryVault().path\n  });\n}\n\n/**\n * Opens a note in reading view and lists the captions of the buttons that mounted, deduplicated and in\n * document order.\n *\n * Two quirks of reading view shape this. It renders lazily and unmounts sections far off-screen, so no\n * single scroll position holds a whole note's buttons \u2014 the preview is walked top to bottom and back\n * while waiting, and the captions seen along the way are ACCUMULATED rather than read once at the end.\n * And while it settles it can hold SEVERAL elements per fence \u2014 the same button was observed rendered\n * twice \u2014 so the captions are deduplicated; clicking by caption then addresses each button once however\n * many copies of it the DOM is holding.\n *\n * @param note - The note to open.\n * @param settleTimeoutInMilliseconds - How long to wait for the buttons to mount.\n * @returns The distinct button captions.\n */\nasync function openNoteAndListButtonCaptions(note: DemoVaultNote, settleTimeoutInMilliseconds: number): Promise<string[]> {\n  return evalInObsidian({\n    async callback({ app, expectedButtonCount, intervalInMilliseconds, lib: { waitUntil }, notePath, obsidianModule, timeoutInMilliseconds }): Promise<string[]> {\n      function view(): InstanceType<typeof obsidianModule.MarkdownView> | null {\n        return app.workspace.getActiveViewOfType(obsidianModule.MarkdownView);\n      }\n      function previewEl(): HTMLElement | null {\n        return view()?.containerEl.querySelector<HTMLElement>(':scope .markdown-preview-view') ?? null;\n      }\n      // Accumulated across the walk below, never read from one snapshot: with the viewport moving, any\n      // single reading holds only the sections currently mounted.\n      const seenCaptions = new Set<string>();\n      function captions(): string[] {\n        for (const button of view()?.containerEl.querySelectorAll<HTMLButtonElement>(':scope .block-language-code-button button.mod-cta') ?? []) {\n          if (button.textContent !== '') {\n            seenCaptions.add(button.textContent);\n          }\n        }\n        return [...seenCaptions];\n      }\n\n      // Same walk as `clickButton`, and for the same reason: a note whose buttons are in the MIDDLE\n      // never mounts them if the preview is pinned to the bottom.\n      const SCROLL_BOTTOM_TOLERANCE_IN_PIXELS = 4;\n      const SCROLL_STEP_RATIO = 0.8;\n      function advanceScroll(): void {\n        const scroller = previewEl();\n        if (!scroller) {\n          return;\n        }\n        const isAtBottom = scroller.scrollTop + scroller.clientHeight >= scroller.scrollHeight - SCROLL_BOTTOM_TOLERANCE_IN_PIXELS;\n        scroller.scrollTop = isAtBottom ? 0 : scroller.scrollTop + Math.floor(scroller.clientHeight * SCROLL_STEP_RATIO);\n      }\n\n      await app.workspace.openLinkText(notePath.replace(/\\.md$/, ''), '', false);\n      await app.workspace.getLeaf(false).setViewState({ state: { file: notePath, mode: 'preview' }, type: 'markdown' });\n\n      try {\n        await waitUntil({\n          intervalInMilliseconds,\n          message: `\"${notePath}\" never mounted all ${String(expectedButtonCount)} of its buttons`,\n          predicate: (): boolean => {\n            advanceScroll();\n            return captions().length >= expectedButtonCount;\n          },\n          timeoutInMilliseconds\n        });\n      } catch {\n        // The captions are returned either way; the caller asserts on them and reports the shortfall.\n      }\n\n      return captions();\n    },\n    input: {\n      expectedButtonCount: note.buttonCount,\n      intervalInMilliseconds: POLL_INTERVAL_IN_MILLISECONDS,\n      notePath: note.name,\n      timeoutInMilliseconds: settleTimeoutInMilliseconds\n    },\n    vaultPath: getTemporaryVault().path\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["process"]
}
