obsidian-dev-utils 96.5.4 → 97.0.0

package/dist/lib/esm/obsidian/desktop-demo-vault-opener.d.mts

@@ -17,14 +17,17 @@
  * `<plugin-id>-<version>.demo-vault` so it reads nicely in Obsidian's vault switcher. Orphaned
  * extracted folders left over from earlier sessions are cleaned up (best-effort) on each open.
  *
- * **`adm-zip` is loaded lazily, and must stay that way.** The `node:` imports below are safe to merely
- * evaluate on mobile — `require` hands back `undefined` there and nothing reads it at load time — but
- * `adm-zip`'s zip-crypto method opens with a top-level `const { randomFillSync } = require('crypto')`,
- * which throws the moment the module is initialized. Because the generated barrels re-export this module,
- * a static `import AdmZip from 'adm-zip'` therefore killed the whole library's load on Android (see the
- * mobile-load check in `scripts/helpers/assert-mobile-loadable-bundle.ts`, which fails the build on
- * exactly that). Any future dependency that touches a platform-only API while initializing has to be
- * deferred the same way.
+ * **Nothing here may touch a platform-only API while the module INITIALIZES.** The `node:` imports below
+ * are safe to merely evaluate on mobile — `require` hands back `undefined` there and nothing reads it at
+ * load time — and because the generated barrels re-export this module, that is a load-bearing property of
+ * the whole library rather than a detail of this file. It was learned the hard way: this module once
+ * imported `adm-zip`, whose zip-crypto method opens with a top-level
+ * `const { randomFillSync } = require('crypto')`, and a static `import AdmZip from 'adm-zip'` therefore
+ * killed the library's load on Android (see the mobile-load check in
+ * `scripts/helpers/assert-mobile-loadable-bundle.ts`, which fails the build on exactly that). Extraction
+ * now goes through `desktop-zip-extractor.ts`, which needs no dependency at all — but any future
+ * dependency that initializes against a platform-only API still has to be deferred behind a call-time
+ * `import()`.
  */
 import type { App } from 'obsidian';
 import type { PluginNoticeComponent } from './components/plugin-notice-component.mjs';

package/dist/lib/esm/obsidian/desktop-demo-vault-opener.mjs

@@ -100,6 +100,7 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { requestUrl } from "obsidian";
+import { extractZipArchive } from "../desktop-zip-extractor.mjs";
 import { join } from "../path.mjs";
 import {
   getCommunityPluginRepo,
@@ -176,7 +177,7 @@ async function openDemoVault(params) {
     }
     progressNotice.setContent(`Extracting demo vault for ${pluginName} v${versionToOpen}\u2026`);
     cleanupOrphanedExtractedVaults();
-    const vaultDirectory = await extractDemoVaultToFreshFolder({
+    const vaultDirectory = extractDemoVaultToFreshFolder({
       archive,
       pluginId,
       version: versionToOpen
@@ -206,19 +207,21 @@ function cleanupOrphanedExtractedVaults() {
     }
   }
 }
-async function extractDemoVaultArchive(archive, targetDirectory) {
-  const { default: AdmZip } = await import("adm-zip");
+function extractDemoVaultArchive(archive, targetDirectory) {
   const originalFs = window.require('node:original-fs');
-  const zip = new AdmZip(archive, { fs: originalFs });
-  zip.extractAllTo(targetDirectory, true);
+  extractZipArchive({
+    archive,
+    fileSystem: originalFs,
+    targetDirectory
+  });
 }
-async function extractDemoVaultToFreshFolder(params) {
+function extractDemoVaultToFreshFolder(params) {
   const { archive, pluginId, version } = params;
   const extractedVaultsRoot = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);
   mkdirSync(extractedVaultsRoot, { recursive: true });
   const uniqueParentDirectory = mkdtempSync(join(extractedVaultsRoot, `${pluginId}-${version}-`));
   const vaultDirectory = join(uniqueParentDirectory, `${pluginId}-${version}.demo-vault`);
-  await extractDemoVaultArchive(archive, vaultDirectory);
+  extractDemoVaultArchive(archive, vaultDirectory);
   return vaultDirectory;
 }
 async function resolveDemoVaultArchive(params) {
@@ -253,4 +256,4 @@ async function resolveDemoVaultArchive(params) {
 export {
   openDemoVault
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/desktop-demo-vault-opener.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Downloads and opens a plugin's shipped demo vault in a new Obsidian window (desktop only).\n *\n * A plugin can attach a `<plugin-id>-demo-vault-<version>.zip` archive to each GitHub release (see\n * `archivePluginDemoVault` in `script-utils/demo-vault.ts`). This resolves the plugin's repository\n * from Obsidian's community registry, downloads the archive for the chosen version, and opens it as a\n * vault in a new window. When the installed plugin version is behind the latest release, the user is\n * offered a choice between the two versions.\n *\n * A progress notice is shown immediately (download + extraction can take a while, so the user must see\n * something is happening right away). Only the downloaded ARCHIVE is cached (under the OS temp\n * directory); every invocation extracts a FRESH copy into its own temporary folder and opens that, so a\n * previous session's edits never leak into a new one. The extracted vault folder is named\n * `<plugin-id>-<version>.demo-vault` so it reads nicely in Obsidian's vault switcher. Orphaned\n * extracted folders left over from earlier sessions are cleaned up (best-effort) on each open.\n *\n * **`adm-zip` is loaded lazily, and must stay that way.** The `node:` imports below are safe to merely\n * evaluate on mobile \u2014 `require` hands back `undefined` there and nothing reads it at load time \u2014 but\n * `adm-zip`'s zip-crypto method opens with a top-level `const { randomFillSync } = require('crypto')`,\n * which throws the moment the module is initialized. Because the generated barrels re-export this module,\n * a static `import AdmZip from 'adm-zip'` therefore killed the whole library's load on Android (see the\n * mobile-load check in `scripts/helpers/assert-mobile-loadable-bundle.ts`, which fails the build on\n * exactly that). Any future dependency that touches a platform-only API while initializing has to be\n * deferred the same way.\n */\n\nimport type { App } from 'obsidian';\n\nimport { compareVersions } from 'compare-versions';\n/* eslint-disable import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so these Node APIs are never reached there. */\nimport { Buffer } from 'node:buffer';\nimport {\n  existsSync,\n  mkdirSync,\n  mkdtempSync,\n  readdirSync,\n  readFileSync,\n  rmSync,\n  statSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\n/* eslint-enable import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so these Node APIs are never reached there. */\nimport { requestUrl } from 'obsidian';\n\nimport type {\n  PluginNoticeComponent,\n  PluginNoticeComponentDelayedNotice\n} from './components/plugin-notice-component.ts';\n\nimport { join } from '../path.ts';\nimport {\n  getCommunityPluginRepo,\n  getLatestReleaseVersion\n} from './community-plugins.ts';\nimport { PluginNoticeMode } from './components/plugin-notice-component.ts';\nimport { selectOption } from './modals/select-option.ts';\n\n/**\n * Parameters for {@link openDemoVault}.\n */\nexport interface OpenDemoVaultParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The plugin id, used to locate the GitHub repository, to name the archive asset, and to name the\n   * cached archive and the extracted vault folder.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The plugin display name, used to label the notices and the version-choice dialog.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The notice component used to report progress and problems (plugin not in the registry, missing\n   * archive).\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * The currently installed plugin version, offered as one of the version choices.\n   */\n  readonly pluginVersion: string;\n}\n\ninterface ExtractDemoVaultToFreshFolderParams {\n  readonly archive: Buffer;\n  readonly pluginId: string;\n  readonly version: string;\n}\n\ninterface ResolveDemoVaultArchiveParams {\n  readonly pluginId: string;\n  readonly pluginName: string;\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n  readonly progressNotice: PluginNoticeComponentDelayedNotice;\n  readonly repo: string;\n  readonly version: string;\n}\n\nconst DEMO_VAULTS_CACHE_FOLDER = 'obsidian-demo-vaults';\nconst ARCHIVES_SUBFOLDER = 'archives';\nconst EXTRACTED_VAULTS_SUBFOLDER = 'extracted';\nconst HTTP_STATUS_OK = 200;\n// One day in milliseconds (24 * 60 * 60 * 1000).\nconst ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS = 86_400_000;\n\n/**\n * Downloads and opens the plugin's demo vault in a new Obsidian window. Desktop only.\n *\n * If the installed plugin version is the latest (or newer), its demo vault opens directly; otherwise\n * the user chooses between the latest and the currently-installed version. A progress notice is shown\n * immediately. The chosen version's archive is downloaded once (then reused from the archive cache),\n * but a fresh copy is extracted into its own temporary folder on every open \u2014 the vault is never reused\n * across sessions.\n *\n * @param params - The {@link OpenDemoVaultParams}.\n * @returns A {@link Promise} that resolves once the vault has been opened, or once the operation has\n * been reported as not possible (notice shown) or cancelled by the user.\n */\nexport async function openDemoVault(params: OpenDemoVaultParams): Promise<void> {\n  const {\n    app,\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    pluginVersion\n  } = params;\n\n  // Shown immediately (`delayInMilliseconds: 0`): resolving the release, downloading and extracting can\n  // Each take a while, so the user must see progress the moment the command is invoked.\n  //\n  // Kept out of the shared slot (`Separate`), because this very function raises ordinary notices while\n  // The operation is still running \u2014 \"not in the registry\", \"no demo vault for this version\" \u2014 and a\n  // Slot notice would hide the progress notice rather than appear beside it.\n  using progressNotice = pluginNoticeComponent.showNoticeAfterDelay({\n    content: `Opening demo vault for ${pluginName}\u2026`,\n    delayInMilliseconds: 0,\n    mode: PluginNoticeMode.Separate\n  });\n\n  const repo = await getCommunityPluginRepo(pluginId);\n  if (!repo) {\n    pluginNoticeComponent.showNotice(`Could not find plugin ${pluginName} in the community plugins registry.`);\n    return;\n  }\n\n  const currentVersion = pluginVersion;\n  const latestVersion = await getLatestReleaseVersion(repo);\n\n  let versionToOpen: string;\n  if (compareVersions(currentVersion, latestVersion) >= 0) {\n    versionToOpen = currentVersion;\n  } else {\n    const chosenVersion = await selectOption<null | string>({\n      app,\n      message: `Current version of plugin ${pluginName} v${currentVersion} is not the latest (v${latestVersion})`,\n      options: [\n        {\n          isCta: true,\n          text: `Open demo vault for latest version (v${latestVersion})`,\n          value: latestVersion\n        },\n        {\n          text: `Open demo vault for current version (v${currentVersion})`,\n          value: currentVersion\n        },\n        {\n          text: 'Cancel',\n          value: null\n        }\n      ],\n      title: pluginName\n    });\n    if (chosenVersion === null) {\n      return;\n    }\n    versionToOpen = chosenVersion;\n  }\n\n  const archive = await resolveDemoVaultArchive({\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    progressNotice,\n    repo,\n    version: versionToOpen\n  });\n  if (!archive) {\n    return;\n  }\n\n  progressNotice.setContent(`Extracting demo vault for ${pluginName} v${versionToOpen}\u2026`);\n  cleanupOrphanedExtractedVaults();\n  const vaultDirectory = await extractDemoVaultToFreshFolder({\n    archive,\n    pluginId,\n    version: versionToOpen\n  });\n\n  window.electron.ipcRenderer.sendSync('vault-open', vaultDirectory, false);\n}\n\n/**\n * Removes extracted demo-vault folders left over from earlier sessions (best-effort).\n *\n * Every open extracts a fresh copy into its own folder and never deletes it afterwards (the vault stays\n * open in its window), so these accumulate. This drops folders older than\n * {@link ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS}. A folder whose vault is still open in another\n * window is locked on Windows and cannot be removed \u2014 the removal is wrapped so such a folder is simply\n * skipped and retried on a later open.\n */\nfunction cleanupOrphanedExtractedVaults(): void {\n  const extractedVaultsRoot = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);\n  if (!existsSync(extractedVaultsRoot)) {\n    return;\n  }\n\n  const now = Date.now();\n  for (const entryName of readdirSync(extractedVaultsRoot)) {\n    const entryPath = join(extractedVaultsRoot, entryName);\n    try {\n      const stats = statSync(entryPath);\n      if (now - stats.mtimeMs < ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS) {\n        continue;\n      }\n      rmSync(entryPath, { force: true, recursive: true });\n    } catch {\n      // Best-effort cleanup: an orphan whose vault is still open (locked on Windows) cannot be removed; skip it and retry on a later open.\n    }\n  }\n}\n\n/**\n * Extracts a downloaded demo-vault archive to disk.\n *\n * Electron's asar layer intercepts `fs` operations on any path containing `.asar` and throws `ENOENT`\n * when `chmod`-ing an `.asar` file (it treats it as an archive root rather than a plain file). A demo\n * vault may ship such a file (e.g. `_assets/CodeScriptToolkit/module.asar` demonstrating the ASAR\n * require feature), and adm-zip `chmod`s every extracted file, so extraction would otherwise crash.\n * Hand adm-zip Electron's `original-fs` \u2014 the real `fs` with asar interception disabled \u2014 so the\n * `.asar` file is treated as a plain file and `chmod` succeeds. It is a desktop-only Electron module\n * with no bundled types, so it is loaded via `window.require` and typed as `node:fs`'s shape.\n *\n * `adm-zip` is imported here rather than at the top of the module: it initializes a Node-only dependency\n * (`require('crypto')`), so a static import would break the library's load on mobile even though this\n * function only ever runs on desktop. See the module's `@file` note.\n *\n * @param archive - The raw zip archive bytes.\n * @param targetDirectory - The directory to extract into.\n * @returns A {@link Promise} that resolves once the archive has been extracted.\n */\nasync function extractDemoVaultArchive(archive: Buffer, targetDirectory: string): Promise<void> {\n  const { default: AdmZip } = await import('adm-zip');\n  const originalFs = window.require('node:original-fs') as typeof import('node:fs');\n  const zip = new AdmZip(archive, { fs: originalFs });\n  zip.extractAllTo(targetDirectory, true);\n}\n\n/**\n * Extracts the archive into a fresh, uniquely-named temporary folder and returns the vault path.\n *\n * A unique parent folder (`mkdtempSync`) guarantees a brand-new extraction every time \u2014 the demo vault\n * is never reused across opens, so a previous session's edits never leak in. Inside it, the vault folder\n * is named `<plugin-id>-<version>.demo-vault` so Obsidian's vault switcher shows a friendly name (its\n * basename) rather than the random temp id.\n *\n * @param params - The {@link ExtractDemoVaultToFreshFolderParams}.\n * @returns A {@link Promise} resolving to the absolute path of the freshly extracted vault folder.\n */\nasync function extractDemoVaultToFreshFolder(params: ExtractDemoVaultToFreshFolderParams): Promise<string> {\n  const { archive, pluginId, version } = params;\n  const extractedVaultsRoot = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);\n  mkdirSync(extractedVaultsRoot, { recursive: true });\n  const uniqueParentDirectory = mkdtempSync(join(extractedVaultsRoot, `${pluginId}-${version}-`));\n  const vaultDirectory = join(uniqueParentDirectory, `${pluginId}-${version}.demo-vault`);\n  await extractDemoVaultArchive(archive, vaultDirectory);\n  return vaultDirectory;\n}\n\n/**\n * Resolves the demo-vault archive bytes for a version, downloading and caching them on first use.\n *\n * Only the archive is cached (keyed by plugin id + version); the extracted vault is not. A cache hit is\n * returned without any network request; a miss downloads the release asset, writes it to the archive\n * cache, and returns the freshly downloaded bytes.\n *\n * @param params - The {@link ResolveDemoVaultArchiveParams}.\n * @returns A {@link Promise} resolving to the archive bytes, or `null` when no archive is available for\n * the version (a notice has been shown).\n */\nasync function resolveDemoVaultArchive(params: ResolveDemoVaultArchiveParams): Promise<Buffer | null> {\n  const {\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    progressNotice,\n    repo,\n    version\n  } = params;\n\n  const archivesDirectory = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, ARCHIVES_SUBFOLDER);\n  const archivePath = join(archivesDirectory, `${pluginId}-${version}.zip`);\n  if (existsSync(archivePath)) {\n    return readFileSync(archivePath);\n  }\n\n  progressNotice.setContent(`Downloading demo vault for ${pluginName} v${version}\u2026`);\n  const assetUrl = `https://github.com/${repo}/releases/download/${version}/${pluginId}-demo-vault-${version}.zip`;\n  const response = await requestUrl({\n    throw: false,\n    url: assetUrl\n  });\n  if (response.status !== HTTP_STATUS_OK) {\n    pluginNoticeComponent.showNotice(`No demo vault is available for plugin ${pluginName} v${version}.`);\n    return null;\n  }\n\n  const archive = Buffer.from(response.arrayBuffer);\n  mkdirSync(archivesDirectory, { recursive: true });\n  writeFileSync(archivePath, archive);\n  return archive;\n}\n"],
  "mappings": "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",
  "names": ["Buffer", "Buffer"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/desktop-demo-vault-opener.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Downloads and opens a plugin's shipped demo vault in a new Obsidian window (desktop only).\n *\n * A plugin can attach a `<plugin-id>-demo-vault-<version>.zip` archive to each GitHub release (see\n * `archivePluginDemoVault` in `script-utils/demo-vault.ts`). This resolves the plugin's repository\n * from Obsidian's community registry, downloads the archive for the chosen version, and opens it as a\n * vault in a new window. When the installed plugin version is behind the latest release, the user is\n * offered a choice between the two versions.\n *\n * A progress notice is shown immediately (download + extraction can take a while, so the user must see\n * something is happening right away). Only the downloaded ARCHIVE is cached (under the OS temp\n * directory); every invocation extracts a FRESH copy into its own temporary folder and opens that, so a\n * previous session's edits never leak into a new one. The extracted vault folder is named\n * `<plugin-id>-<version>.demo-vault` so it reads nicely in Obsidian's vault switcher. Orphaned\n * extracted folders left over from earlier sessions are cleaned up (best-effort) on each open.\n *\n * **Nothing here may touch a platform-only API while the module INITIALIZES.** The `node:` imports below\n * are safe to merely evaluate on mobile \u2014 `require` hands back `undefined` there and nothing reads it at\n * load time \u2014 and because the generated barrels re-export this module, that is a load-bearing property of\n * the whole library rather than a detail of this file. It was learned the hard way: this module once\n * imported `adm-zip`, whose zip-crypto method opens with a top-level\n * `const { randomFillSync } = require('crypto')`, and a static `import AdmZip from 'adm-zip'` therefore\n * killed the library's load on Android (see the mobile-load check in\n * `scripts/helpers/assert-mobile-loadable-bundle.ts`, which fails the build on exactly that). Extraction\n * now goes through `desktop-zip-extractor.ts`, which needs no dependency at all \u2014 but any future\n * dependency that initializes against a platform-only API still has to be deferred behind a call-time\n * `import()`.\n */\n\nimport type { App } from 'obsidian';\n\nimport { compareVersions } from 'compare-versions';\n/* eslint-disable import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so these Node APIs are never reached there. */\nimport { Buffer } from 'node:buffer';\nimport {\n  existsSync,\n  mkdirSync,\n  mkdtempSync,\n  readdirSync,\n  readFileSync,\n  rmSync,\n  statSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\n/* eslint-enable import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so these Node APIs are never reached there. */\nimport { requestUrl } from 'obsidian';\n\nimport type {\n  PluginNoticeComponent,\n  PluginNoticeComponentDelayedNotice\n} from './components/plugin-notice-component.ts';\n\nimport { extractZipArchive } from '../desktop-zip-extractor.ts';\nimport { join } from '../path.ts';\nimport {\n  getCommunityPluginRepo,\n  getLatestReleaseVersion\n} from './community-plugins.ts';\nimport { PluginNoticeMode } from './components/plugin-notice-component.ts';\nimport { selectOption } from './modals/select-option.ts';\n\n/**\n * Parameters for {@link openDemoVault}.\n */\nexport interface OpenDemoVaultParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The plugin id, used to locate the GitHub repository, to name the archive asset, and to name the\n   * cached archive and the extracted vault folder.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The plugin display name, used to label the notices and the version-choice dialog.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The notice component used to report progress and problems (plugin not in the registry, missing\n   * archive).\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * The currently installed plugin version, offered as one of the version choices.\n   */\n  readonly pluginVersion: string;\n}\n\ninterface ExtractDemoVaultToFreshFolderParams {\n  readonly archive: Buffer;\n  readonly pluginId: string;\n  readonly version: string;\n}\n\ninterface ResolveDemoVaultArchiveParams {\n  readonly pluginId: string;\n  readonly pluginName: string;\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n  readonly progressNotice: PluginNoticeComponentDelayedNotice;\n  readonly repo: string;\n  readonly version: string;\n}\n\nconst DEMO_VAULTS_CACHE_FOLDER = 'obsidian-demo-vaults';\nconst ARCHIVES_SUBFOLDER = 'archives';\nconst EXTRACTED_VAULTS_SUBFOLDER = 'extracted';\nconst HTTP_STATUS_OK = 200;\n// One day in milliseconds (24 * 60 * 60 * 1000).\nconst ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS = 86_400_000;\n\n/**\n * Downloads and opens the plugin's demo vault in a new Obsidian window. Desktop only.\n *\n * If the installed plugin version is the latest (or newer), its demo vault opens directly; otherwise\n * the user chooses between the latest and the currently-installed version. A progress notice is shown\n * immediately. The chosen version's archive is downloaded once (then reused from the archive cache),\n * but a fresh copy is extracted into its own temporary folder on every open \u2014 the vault is never reused\n * across sessions.\n *\n * @param params - The {@link OpenDemoVaultParams}.\n * @returns A {@link Promise} that resolves once the vault has been opened, or once the operation has\n * been reported as not possible (notice shown) or cancelled by the user.\n */\nexport async function openDemoVault(params: OpenDemoVaultParams): Promise<void> {\n  const {\n    app,\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    pluginVersion\n  } = params;\n\n  // Shown immediately (`delayInMilliseconds: 0`): resolving the release, downloading and extracting can\n  // Each take a while, so the user must see progress the moment the command is invoked.\n  //\n  // Kept out of the shared slot (`Separate`), because this very function raises ordinary notices while\n  // The operation is still running \u2014 \"not in the registry\", \"no demo vault for this version\" \u2014 and a\n  // Slot notice would hide the progress notice rather than appear beside it.\n  using progressNotice = pluginNoticeComponent.showNoticeAfterDelay({\n    content: `Opening demo vault for ${pluginName}\u2026`,\n    delayInMilliseconds: 0,\n    mode: PluginNoticeMode.Separate\n  });\n\n  const repo = await getCommunityPluginRepo(pluginId);\n  if (!repo) {\n    pluginNoticeComponent.showNotice(`Could not find plugin ${pluginName} in the community plugins registry.`);\n    return;\n  }\n\n  const currentVersion = pluginVersion;\n  const latestVersion = await getLatestReleaseVersion(repo);\n\n  let versionToOpen: string;\n  if (compareVersions(currentVersion, latestVersion) >= 0) {\n    versionToOpen = currentVersion;\n  } else {\n    const chosenVersion = await selectOption<null | string>({\n      app,\n      message: `Current version of plugin ${pluginName} v${currentVersion} is not the latest (v${latestVersion})`,\n      options: [\n        {\n          isCta: true,\n          text: `Open demo vault for latest version (v${latestVersion})`,\n          value: latestVersion\n        },\n        {\n          text: `Open demo vault for current version (v${currentVersion})`,\n          value: currentVersion\n        },\n        {\n          text: 'Cancel',\n          value: null\n        }\n      ],\n      title: pluginName\n    });\n    if (chosenVersion === null) {\n      return;\n    }\n    versionToOpen = chosenVersion;\n  }\n\n  const archive = await resolveDemoVaultArchive({\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    progressNotice,\n    repo,\n    version: versionToOpen\n  });\n  if (!archive) {\n    return;\n  }\n\n  progressNotice.setContent(`Extracting demo vault for ${pluginName} v${versionToOpen}\u2026`);\n  cleanupOrphanedExtractedVaults();\n  const vaultDirectory = extractDemoVaultToFreshFolder({\n    archive,\n    pluginId,\n    version: versionToOpen\n  });\n\n  window.electron.ipcRenderer.sendSync('vault-open', vaultDirectory, false);\n}\n\n/**\n * Removes extracted demo-vault folders left over from earlier sessions (best-effort).\n *\n * Every open extracts a fresh copy into its own folder and never deletes it afterwards (the vault stays\n * open in its window), so these accumulate. This drops folders older than\n * {@link ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS}. A folder whose vault is still open in another\n * window is locked on Windows and cannot be removed \u2014 the removal is wrapped so such a folder is simply\n * skipped and retried on a later open.\n */\nfunction cleanupOrphanedExtractedVaults(): void {\n  const extractedVaultsRoot = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);\n  if (!existsSync(extractedVaultsRoot)) {\n    return;\n  }\n\n  const now = Date.now();\n  for (const entryName of readdirSync(extractedVaultsRoot)) {\n    const entryPath = join(extractedVaultsRoot, entryName);\n    try {\n      const stats = statSync(entryPath);\n      if (now - stats.mtimeMs < ORPHANED_EXTRACTED_VAULT_MAX_AGE_IN_MILLISECONDS) {\n        continue;\n      }\n      rmSync(entryPath, { force: true, recursive: true });\n    } catch {\n      // Best-effort cleanup: an orphan whose vault is still open (locked on Windows) cannot be removed; skip it and retry on a later open.\n    }\n  }\n}\n\n/**\n * Extracts a downloaded demo-vault archive to disk.\n *\n * Extraction is written with Electron's `original-fs` \u2014 the real `fs` with asar interception disabled \u2014\n * rather than with `node:fs`. A demo vault may ship a file that merely LOOKS like an Electron archive\n * (e.g. `_assets/CodeScriptToolkit/module.asar` demonstrating the ASAR require feature), and Electron's\n * asar layer intercepts `fs` operations on any path containing `.asar`, treating it as an archive root\n * rather than a plain file. That already cost one production bug when the extractor `chmod`-ed such a\n * file and got `ENOENT`; nothing `chmod`s any more, but writing those bytes through the copy that has no\n * asar layer costs nothing and keeps the whole class of failure off this path. `original-fs` is a desktop-only\n * Electron module with no bundled types, so it is loaded via `window.require` and typed as `node:fs`'s\n * shape.\n *\n * @param archive - The raw zip archive bytes.\n * @param targetDirectory - The directory to extract into.\n */\nfunction extractDemoVaultArchive(archive: Buffer, targetDirectory: string): void {\n  const originalFs = window.require('node:original-fs') as typeof import('node:fs');\n  extractZipArchive({\n    archive,\n    fileSystem: originalFs,\n    targetDirectory\n  });\n}\n\n/**\n * Extracts the archive into a fresh, uniquely-named temporary folder and returns the vault path.\n *\n * A unique parent folder (`mkdtempSync`) guarantees a brand-new extraction every time \u2014 the demo vault\n * is never reused across opens, so a previous session's edits never leak in. Inside it, the vault folder\n * is named `<plugin-id>-<version>.demo-vault` so Obsidian's vault switcher shows a friendly name (its\n * basename) rather than the random temp id.\n *\n * @param params - The {@link ExtractDemoVaultToFreshFolderParams}.\n * @returns The absolute path of the freshly extracted vault folder.\n */\nfunction extractDemoVaultToFreshFolder(params: ExtractDemoVaultToFreshFolderParams): string {\n  const { archive, pluginId, version } = params;\n  const extractedVaultsRoot = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, EXTRACTED_VAULTS_SUBFOLDER);\n  mkdirSync(extractedVaultsRoot, { recursive: true });\n  const uniqueParentDirectory = mkdtempSync(join(extractedVaultsRoot, `${pluginId}-${version}-`));\n  const vaultDirectory = join(uniqueParentDirectory, `${pluginId}-${version}.demo-vault`);\n  extractDemoVaultArchive(archive, vaultDirectory);\n  return vaultDirectory;\n}\n\n/**\n * Resolves the demo-vault archive bytes for a version, downloading and caching them on first use.\n *\n * Only the archive is cached (keyed by plugin id + version); the extracted vault is not. A cache hit is\n * returned without any network request; a miss downloads the release asset, writes it to the archive\n * cache, and returns the freshly downloaded bytes.\n *\n * @param params - The {@link ResolveDemoVaultArchiveParams}.\n * @returns A {@link Promise} resolving to the archive bytes, or `null` when no archive is available for\n * the version (a notice has been shown).\n */\nasync function resolveDemoVaultArchive(params: ResolveDemoVaultArchiveParams): Promise<Buffer | null> {\n  const {\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    progressNotice,\n    repo,\n    version\n  } = params;\n\n  const archivesDirectory = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, ARCHIVES_SUBFOLDER);\n  const archivePath = join(archivesDirectory, `${pluginId}-${version}.zip`);\n  if (existsSync(archivePath)) {\n    return readFileSync(archivePath);\n  }\n\n  progressNotice.setContent(`Downloading demo vault for ${pluginName} v${version}\u2026`);\n  const assetUrl = `https://github.com/${repo}/releases/download/${version}/${pluginId}-demo-vault-${version}.zip`;\n  const response = await requestUrl({\n    throw: false,\n    url: assetUrl\n  });\n  if (response.status !== HTTP_STATUS_OK) {\n    pluginNoticeComponent.showNotice(`No demo vault is available for plugin ${pluginName} v${version}.`);\n    return null;\n  }\n\n  const archive = Buffer.from(response.arrayBuffer);\n  mkdirSync(archivesDirectory, { recursive: true });\n  writeFileSync(archivePath, archive);\n  return archive;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAS,uBAAuB;AAEhC,SAAS,UAAAA,eAAc;AACvB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,cAAc;AAEvB,SAAS,kBAAkB;AAO3B,SAAS,yBAAyB;AAClC,SAAS,YAAY;AACrB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,wBAAwB;AACjC,SAAS,oBAAoB;AAiD7B,MAAM,2BAA2B;AACjC,MAAM,qBAAqB;AAC3B,MAAM,6BAA6B;AACnC,MAAM,iBAAiB;AAEvB,MAAM,mDAAmD;AAezD,eAAsB,cAAc,QAA4C;AAe9E;AAAA;AAdA,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,IAAI;AAQJ,UAAM,iBAAiB,sCAAsB,qBAAqB;AAAA,MAChE,SAAS,0BAA0B,UAAU;AAAA,MAC7C,qBAAqB;AAAA,MACrB,MAAM,iBAAiB;AAAA,IACzB,CAAC;AAED,UAAM,OAAO,MAAM,uBAAuB,QAAQ;AAClD,QAAI,CAAC,MAAM;AACT,4BAAsB,WAAW,yBAAyB,UAAU,qCAAqC;AACzG;AAAA,IACF;AAEA,UAAM,iBAAiB;AACvB,UAAM,gBAAgB,MAAM,wBAAwB,IAAI;AAExD,QAAI;AACJ,QAAI,gBAAgB,gBAAgB,aAAa,KAAK,GAAG;AACvD,sBAAgB;AAAA,IAClB,OAAO;AACL,YAAM,gBAAgB,MAAM,aAA4B;AAAA,QACtD;AAAA,QACA,SAAS,6BAA6B,UAAU,KAAK,cAAc,wBAAwB,aAAa;AAAA,QACxG,SAAS;AAAA,UACP;AAAA,YACE,OAAO;AAAA,YACP,MAAM,wCAAwC,aAAa;AAAA,YAC3D,OAAO;AAAA,UACT;AAAA,UACA;AAAA,YACE,MAAM,yCAAyC,cAAc;AAAA,YAC7D,OAAO;AAAA,UACT;AAAA,UACA;AAAA,YACE,MAAM;AAAA,YACN,OAAO;AAAA,UACT;AAAA,QACF;AAAA,QACA,OAAO;AAAA,MACT,CAAC;AACD,UAAI,kBAAkB,MAAM;AAC1B;AAAA,MACF;AACA,sBAAgB;AAAA,IAClB;AAEA,UAAM,UAAU,MAAM,wBAAwB;AAAA,MAC5C;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS;AAAA,IACX,CAAC;AACD,QAAI,CAAC,SAAS;AACZ;AAAA,IACF;AAEA,mBAAe,WAAW,6BAA6B,UAAU,KAAK,aAAa,QAAG;AACtF,mCAA+B;AAC/B,UAAM,iBAAiB,8BAA8B;AAAA,MACnD;AAAA,MACA;AAAA,MACA,SAAS;AAAA,IACX,CAAC;AAED,WAAO,SAAS,YAAY,SAAS,cAAc,gBAAgB,KAAK;AAAA,WAjExE;AAAA;AAAA;AAAA;AAAA;AAkEF;AAWA,SAAS,iCAAuC;AAC9C,QAAM,sBAAsB,KAAK,OAAO,GAAG,0BAA0B,0BAA0B;AAC/F,MAAI,CAAC,WAAW,mBAAmB,GAAG;AACpC;AAAA,EACF;AAEA,QAAM,MAAM,KAAK,IAAI;AACrB,aAAW,aAAa,YAAY,mBAAmB,GAAG;AACxD,UAAM,YAAY,KAAK,qBAAqB,SAAS;AACrD,QAAI;AACF,YAAM,QAAQ,SAAS,SAAS;AAChC,UAAI,MAAM,MAAM,UAAU,kDAAkD;AAC1E;AAAA,MACF;AACA,aAAO,WAAW,EAAE,OAAO,MAAM,WAAW,KAAK,CAAC;AAAA,IACpD,QAAQ;AAAA,IAER;AAAA,EACF;AACF;AAkBA,SAAS,wBAAwB,SAAiB,iBAA+B;AAC/E,QAAM,aAAa,OAAO,QAAQ,kBAAkB;AACpD,oBAAkB;AAAA,IAChB;AAAA,IACA,YAAY;AAAA,IACZ;AAAA,EACF,CAAC;AACH;AAaA,SAAS,8BAA8B,QAAqD;AAC1F,QAAM,EAAE,SAAS,UAAU,QAAQ,IAAI;AACvC,QAAM,sBAAsB,KAAK,OAAO,GAAG,0BAA0B,0BAA0B;AAC/F,YAAU,qBAAqB,EAAE,WAAW,KAAK,CAAC;AAClD,QAAM,wBAAwB,YAAY,KAAK,qBAAqB,GAAG,QAAQ,IAAI,OAAO,GAAG,CAAC;AAC9F,QAAM,iBAAiB,KAAK,uBAAuB,GAAG,QAAQ,IAAI,OAAO,aAAa;AACtF,0BAAwB,SAAS,cAAc;AAC/C,SAAO;AACT;AAaA,eAAe,wBAAwB,QAA+D;AACpG,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,oBAAoB,KAAK,OAAO,GAAG,0BAA0B,kBAAkB;AACrF,QAAM,cAAc,KAAK,mBAAmB,GAAG,QAAQ,IAAI,OAAO,MAAM;AACxE,MAAI,WAAW,WAAW,GAAG;AAC3B,WAAO,aAAa,WAAW;AAAA,EACjC;AAEA,iBAAe,WAAW,8BAA8B,UAAU,KAAK,OAAO,QAAG;AACjF,QAAM,WAAW,sBAAsB,IAAI,sBAAsB,OAAO,IAAI,QAAQ,eAAe,OAAO;AAC1G,QAAM,WAAW,MAAM,WAAW;AAAA,IAChC,OAAO;AAAA,IACP,KAAK;AAAA,EACP,CAAC;AACD,MAAI,SAAS,WAAW,gBAAgB;AACtC,0BAAsB,WAAW,yCAAyC,UAAU,KAAK,OAAO,GAAG;AACnG,WAAO;AAAA,EACT;AAEA,QAAM,UAAUC,QAAO,KAAK,SAAS,WAAW;AAChD,YAAU,mBAAmB,EAAE,WAAW,KAAK,CAAC;AAChD,gBAAc,aAAa,OAAO;AAClC,SAAO;AACT;",
  "names": ["Buffer", "Buffer"]
}


package/dist/lib/esm/obsidian/modals/index.d.mts

@@ -2,6 +2,7 @@
 export * as 'alert' from './alert.mjs';
 export * as 'confirm' from './confirm.mjs';
 export * as 'minimizable-modal' from './minimizable-modal.mjs';
+export * as 'modal-command-builder' from './modal-command-builder.mjs';
 export * as 'modal' from './modal.mjs';
 export * as 'prompt' from './prompt.mjs';
 export * as 'select-item' from './select-item.mjs';

package/dist/lib/esm/obsidian/modals/index.mjs

@@ -44,6 +44,7 @@ function ensureBrowserProcess() {
 import * as alert from "./alert.mjs";
 import * as confirm from "./confirm.mjs";
 import * as minimizable_modal from "./minimizable-modal.mjs";
+import * as modal_command_builder from "./modal-command-builder.mjs";
 import * as modal from "./modal.mjs";
 import * as prompt from "./prompt.mjs";
 import * as select_item from "./select-item.mjs";
@@ -54,9 +55,10 @@ export {
   confirm,
   minimizable_modal as "minimizable-modal",
   modal,
+  modal_command_builder as "modal-command-builder",
   prompt,
   select_item as "select-item",
   select_option as "select-option",
   suggest_modal_command_builder as "suggest-modal-command-builder"
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL21vZGFscy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdhbGVydCcgZnJvbSAnLi9hbGVydC50cyc7XG5leHBvcnQgKiBhcyAnY29uZmlybScgZnJvbSAnLi9jb25maXJtLnRzJztcbmV4cG9ydCAqIGFzICdtaW5pbWl6YWJsZS1tb2RhbCcgZnJvbSAnLi9taW5pbWl6YWJsZS1tb2RhbC50cyc7XG5leHBvcnQgKiBhcyAnbW9kYWwnIGZyb20gJy4vbW9kYWwudHMnO1xuZXhwb3J0ICogYXMgJ3Byb21wdCcgZnJvbSAnLi9wcm9tcHQudHMnO1xuZXhwb3J0ICogYXMgJ3NlbGVjdC1pdGVtJyBmcm9tICcuL3NlbGVjdC1pdGVtLnRzJztcbmV4cG9ydCAqIGFzICdzZWxlY3Qtb3B0aW9uJyBmcm9tICcuL3NlbGVjdC1vcHRpb24udHMnO1xuZXhwb3J0ICogYXMgJ3N1Z2dlc3QtbW9kYWwtY29tbWFuZC1idWlsZGVyJyBmcm9tICcuL3N1Z2dlc3QtbW9kYWwtY29tbWFuZC1idWlsZGVyLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFQSxZQUFZLFdBQWE7QUFDekIsWUFBWSxhQUFlO0FBQzNCLFlBQVlBLHVCQUF5QjtBQUNyQyxZQUFZLFdBQWE7QUFDekIsWUFBWSxZQUFjO0FBQzFCLFlBQVlDLGlCQUFtQjtBQUMvQixZQUFZQyxtQkFBcUI7QUFDakMsWUFBWUMsbUNBQXFDOyIsCiAgIm5hbWVzIjogWyJtaW5pbWl6YWJsZS1tb2RhbCIsICJzZWxlY3QtaXRlbSIsICJzZWxlY3Qtb3B0aW9uIiwgInN1Z2dlc3QtbW9kYWwtY29tbWFuZC1idWlsZGVyIl0KfQo=
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL21vZGFscy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdhbGVydCcgZnJvbSAnLi9hbGVydC50cyc7XG5leHBvcnQgKiBhcyAnY29uZmlybScgZnJvbSAnLi9jb25maXJtLnRzJztcbmV4cG9ydCAqIGFzICdtaW5pbWl6YWJsZS1tb2RhbCcgZnJvbSAnLi9taW5pbWl6YWJsZS1tb2RhbC50cyc7XG5leHBvcnQgKiBhcyAnbW9kYWwtY29tbWFuZC1idWlsZGVyJyBmcm9tICcuL21vZGFsLWNvbW1hbmQtYnVpbGRlci50cyc7XG5leHBvcnQgKiBhcyAnbW9kYWwnIGZyb20gJy4vbW9kYWwudHMnO1xuZXhwb3J0ICogYXMgJ3Byb21wdCcgZnJvbSAnLi9wcm9tcHQudHMnO1xuZXhwb3J0ICogYXMgJ3NlbGVjdC1pdGVtJyBmcm9tICcuL3NlbGVjdC1pdGVtLnRzJztcbmV4cG9ydCAqIGFzICdzZWxlY3Qtb3B0aW9uJyBmcm9tICcuL3NlbGVjdC1vcHRpb24udHMnO1xuZXhwb3J0ICogYXMgJ3N1Z2dlc3QtbW9kYWwtY29tbWFuZC1idWlsZGVyJyBmcm9tICcuL3N1Z2dlc3QtbW9kYWwtY29tbWFuZC1idWlsZGVyLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFQSxZQUFZLFdBQWE7QUFDekIsWUFBWSxhQUFlO0FBQzNCLFlBQVlBLHVCQUF5QjtBQUNyQyxZQUFZQywyQkFBNkI7QUFDekMsWUFBWSxXQUFhO0FBQ3pCLFlBQVksWUFBYztBQUMxQixZQUFZQyxpQkFBbUI7QUFDL0IsWUFBWUMsbUJBQXFCO0FBQ2pDLFlBQVlDLG1DQUFxQzsiLAogICJuYW1lcyI6IFsibWluaW1pemFibGUtbW9kYWwiLCAibW9kYWwtY29tbWFuZC1idWlsZGVyIiwgInNlbGVjdC1pdGVtIiwgInNlbGVjdC1vcHRpb24iLCAic3VnZ2VzdC1tb2RhbC1jb21tYW5kLWJ1aWxkZXIiXQp9Cg==

package/dist/lib/esm/obsidian/modals/modal-command-builder.d.mts

@@ -0,0 +1,281 @@
+/// <reference path="../../library.d.mts" />
+/**
+ * @file
+ *
+ * A builder for a modal's control strip.
+ *
+ * {@link ModalCommandBuilder} assembles the strip of controls shown at the bottom of a modal:
+ * keyboard-command hints ({@link ModalCommandBuilder.addKeyboardCommand}), interactive checkboxes bound to
+ * a modifier+key shortcut ({@link ModalCommandBuilder.addCheckbox}), and dropdowns bound to a modifier+key
+ * shortcut ({@link ModalCommandBuilder.addDropDown}). Chain the `add*` calls, then apply everything to a
+ * modal with {@link ModalCommandBuilder.build}:
+ *
+ * ```ts
+ * new ModalCommandBuilder()
+ *   .addKeyboardCommand({ key: 'Enter', modifiers: ['Mod'], onKey, purpose: 'to create' })
+ *   .addCheckbox({ key: '1', modifiers: ['Alt'], onChange, onInit, purpose: 'Fix footnotes' })
+ *   .build(modal);
+ * ```
+ *
+ * The strip is described by two independent axes:
+ *
+ * - **Where it is hosted.** A {@link SuggestModal} in {@link ModalCommandsRenderMode.Instructions} mode
+ *   keeps Obsidian's own instruction bar (`setInstructions` + `instructionsEl`). Every other target — a
+ *   plain {@link Modal}, or a bare {@link ModalCommandsHost} of an element plus a `Scope` — gets a strip
+ *   element the builder creates itself.
+ * - **How each control looks.** {@link ModalCommandsRenderMode.Instructions} renders the purpose text with
+ *   an inline checkbox or dropdown; {@link ModalCommandsRenderMode.Buttons} renders one clickable button
+ *   per control, carrying its pressed and disabled state.
+ *
+ * The axes are independent because a button strip inside a {@link SuggestModal} is a real combination.
+ *
+ * {@link ModalCommandBuilder.build} always registers the essential navigation/action key handlers, but
+ * only renders the control UI and registers the option-toggle shortcuts when
+ * {@link ModalCommandBuilderBuildOptions.shouldShowInstructions} is `true` (the default).
+ */
+import type { KeymapContext, Modal, Modifier, Scope, SuggestModal } from 'obsidian';
+import { DropdownComponent } from 'obsidian';
+/**
+ * The way {@link ModalCommandBuilder.build} renders each control.
+ */
+export declare enum ModalCommandsRenderMode {
+    /**
+     * One clickable button per control, carrying its pressed (`aria-pressed`) and disabled state.
+     *
+     * Only controls reachable by pointer are rendered — checkboxes, and keyboard commands that supply
+     * {@link KeyboardCommand.onActivate}. A hint-only or keyboard-only command still registers its handler
+     * but renders no button, because a button nobody can press is worse than no button. A dropdown throws:
+     * a control that CYCLES has no button form.
+     */
+    Buttons = "buttons",
+    /**
+     * Obsidian's instruction-bar look: the shortcut, then the purpose text with an inline checkbox or
+     * dropdown.
+     */
+    Instructions = "instructions"
+}
+/**
+ * A checkbox command shown in a modal's control strip and bound to a modifier+key shortcut that toggles
+ * it.
+ */
+export interface CheckboxCommand extends CommandBase {
+    /**
+     * Called when the checkbox value changes.
+     *
+     * @param isChecked - The new checked state.
+     */
+    onChange(isChecked: boolean): void;
+    /**
+     * Called once with the created checkbox element, to initialize its state.
+     *
+     * In {@link ModalCommandsRenderMode.Buttons} mode the element is created but never appended — the
+     * button is a view of it — so the same initialization code serves both render modes.
+     *
+     * @param checkboxEl - The created checkbox element.
+     */
+    onInit(checkboxEl: HTMLInputElement): void;
+}
+/**
+ * The members every command shares.
+ */
+export interface CommandBase {
+    /**
+     * Whether the control can be used right now. When it returns `false` the control is rendered
+     * **disabled rather than removed**, so the strip does not reflow under the pointer as modes change —
+     * which on a phone means a mis-tap.
+     *
+     * Re-read by {@link ModalCommands.refresh}. When omitted, the builder never touches the control's
+     * disabled state, leaving whatever {@link CheckboxCommand.onInit} / {@link DropDownCommand.onInit} set.
+     *
+     * @returns Whether the control can be used right now.
+     */
+    checkIsAvailable?(this: void): boolean;
+    /**
+     * The key that activates the command.
+     */
+    key: string;
+    /**
+     * The modifiers combined with {@link CommandBase.key}. When omitted, no modifiers are required.
+     */
+    modifiers?: Modifier[];
+    /**
+     * The human-readable description shown next to the control.
+     */
+    purpose: string;
+}
+/**
+ * A dropdown command shown in a modal's control strip and bound to a modifier+key shortcut that cycles
+ * through its options.
+ *
+ * Supported in {@link ModalCommandsRenderMode.Instructions} mode only.
+ */
+export interface DropDownCommand extends CommandBase {
+    /**
+     * Called when the dropdown value changes.
+     *
+     * @param value - The newly selected value.
+     */
+    onChange(value: string): void;
+    /**
+     * Called once with the created dropdown component, to initialize its options and state.
+     *
+     * @param dropdownComponent - The created dropdown component.
+     */
+    onInit(dropdownComponent: DropdownComponent): void;
+}
+/**
+ * A keyboard command shown in a modal's control strip and optionally bound to a modifier+key handler.
+ */
+export interface KeyboardCommand extends CommandBase {
+    /**
+     * Whether the command reads as ON. Supply it for a toggle whose state lives outside the strip; omit it
+     * for an action, which does something and is done. A {@link CheckboxCommand} needs no equivalent — its
+     * checkbox element is the state.
+     *
+     * Re-read by {@link ModalCommands.refresh}.
+     *
+     * @returns Whether the command reads as ON.
+     */
+    checkIsOn?(this: void): boolean;
+    /**
+     * The pointer route into the same handler the shortcut runs. Required for the command to render a
+     * button in {@link ModalCommandsRenderMode.Buttons} mode — on a phone there is no modifier key to
+     * press, so this is the only way in.
+     *
+     * @param $event - The click event, so a command that picks something has one to hand on.
+     */
+    onActivate?(this: void, $event: MouseEvent): void;
+    /**
+     * The handler invoked when the shortcut is pressed. When omitted, the command is a hint only and no
+     * scope handler is registered.
+     *
+     * @param $event - The keyboard event.
+     * @param context - The keymap context.
+     * @returns `false` to prevent Obsidian's default handling, or `void`/`true` otherwise.
+     */
+    onKey?($event: KeyboardEvent, context: KeymapContext): boolean;
+}
+/**
+ * Options for {@link ModalCommandBuilder.build}.
+ */
+export interface ModalCommandBuilderBuildOptions {
+    /**
+     * The way each control is rendered.
+     *
+     * @default {@link ModalCommandsRenderMode.Instructions}
+     */
+    readonly renderMode?: ModalCommandsRenderMode;
+    /**
+     * Whether to render the control strip (checkboxes, dropdowns, keyboard hints) and register the
+     * option-toggle keyboard shortcuts. When `false`, no control UI is shown and the option-toggle
+     * shortcuts are not registered; only the essential navigation key handlers remain active.
+     *
+     * @default `true`
+     */
+    readonly shouldShowInstructions?: boolean;
+}
+/**
+ * The handle returned by {@link ModalCommandBuilder.build}.
+ */
+export interface ModalCommands {
+    /**
+     * Brings every rendered control's disabled and pressed state up to date, by re-reading
+     * {@link CommandBase.checkIsAvailable} and {@link KeyboardCommand.checkIsOn}.
+     *
+     * The strip is built once and only re-stated afterwards, because rebuilding it would replace an element
+     * the pointer may be about to click.
+     */
+    refresh(): void;
+}
+/**
+ * A bare host for a control strip: the element to render into, plus the scope to register shortcuts with.
+ */
+export interface ModalCommandsHost {
+    /**
+     * The element the control strip is appended to.
+     */
+    readonly containerEl: HTMLElement;
+    /**
+     * The scope the shortcuts are registered with.
+     */
+    readonly scope: Scope;
+}
+/**
+ * Every target {@link ModalCommandBuilder.build} accepts.
+ */
+export type ModalCommandsTarget = Modal | ModalCommandsHost | SuggestModal<unknown>;
+/**
+ * Builds a modal's control strip from keyboard commands, interactive checkboxes, and dropdowns, then
+ * applies them to a modal via {@link ModalCommandBuilder.build}.
+ */
+export declare class ModalCommandBuilder {
+    private readonly entries;
+    /**
+     * Adds an interactive checkbox to the control strip, bound to a modifier+key shortcut that toggles it.
+     *
+     * @param command - The checkbox command to add.
+     * @returns The builder instance for chaining.
+     */
+    addCheckbox(command: CheckboxCommand): this;
+    /**
+     * Adds a dropdown to the control strip, bound to a modifier+key shortcut that cycles through its
+     * options.
+     *
+     * @param command - The dropdown command to add.
+     * @returns The builder instance for chaining.
+     */
+    addDropDown(command: DropDownCommand): this;
+    /**
+     * Adds a keyboard command to the control strip. When {@link KeyboardCommand.onKey} is provided, its
+     * handler is registered with the modal scope; otherwise the command is a hint only.
+     *
+     * @param command - The keyboard command to add.
+     * @returns The builder instance for chaining.
+     */
+    addKeyboardCommand(command: KeyboardCommand): this;
+    /**
+     * Applies the accumulated commands to a modal. Always registers the essential navigation/action key
+     * handlers; only renders the control strip and registers the option-toggle shortcuts when
+     * {@link ModalCommandBuilderBuildOptions.shouldShowInstructions} is `true`.
+     *
+     * @param target - The modal, or the bare element + scope, to apply the commands to.
+     * @param options - The build options.
+     * @returns A handle whose {@link ModalCommands.refresh} re-states every rendered control.
+     */
+    build(target: ModalCommandsTarget, options?: ModalCommandBuilderBuildOptions): ModalCommands;
+    private buildCommandText;
+    private getModifierString;
+    /**
+     * Resolves the element a self-created strip is appended to.
+     *
+     * A {@link Modal} carries both `modalEl` and a `containerEl` that is the OUTER `.modal-container`, so
+     * `modalEl` has to win — otherwise the strip lands outside the modal frame. Discriminated with `in`
+     * rather than a property read, because tests hand `build` a `strictProxy` mock whose `get` trap throws
+     * on unmocked members.
+     *
+     * @param target - The build target.
+     * @returns The element to append the strip to.
+     */
+    private getStripContainerEl;
+    private renderButtons;
+    private renderInstructions;
+    /**
+     * Renders through Obsidian's own instruction bar, the way every {@link SuggestModal} consumer has always
+     * had it.
+     *
+     * @param modal - The suggest modal.
+     * @param instructions - The instructions to render.
+     * @returns The purpose element of each rendered instruction.
+     */
+    private renderNativeInstructions;
+    /**
+     * Renders an instruction bar of the builder's own, for a host that has none.
+     *
+     * The markup mirrors what `setInstructions` produces, so Obsidian's own styling applies unchanged.
+     *
+     * @param containerEl - The element to append the bar to.
+     * @param instructions - The instructions to render.
+     * @returns The purpose element of each rendered instruction.
+     */
+    private renderOwnInstructions;
+}