obsidian-integration-testing 12.1.2 → 12.3.0

package/README.md

@@ -1,10 +1,6 @@
 # obsidian-integration-testing
 
-[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-ffdd00?logo=buy-me-a-coffee&logoColor=black)](https://www.buymeacoffee.com/mnaoumov)
-[![npm version](https://img.shields.io/npm/v/obsidian-integration-testing)](https://www.npmjs.com/package/obsidian-integration-testing)
-[![npm downloads](https://img.shields.io/npm/dm/obsidian-integration-testing)](https://www.npmjs.com/package/obsidian-integration-testing)
-[![GitHub release](https://img.shields.io/github/v/release/mnaoumov/obsidian-integration-testing)](https://github.com/mnaoumov/obsidian-integration-testing/releases)
-[![Coverage: 100%](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/mnaoumov/obsidian-integration-testing)
+[![Buy Me a Coffee](https://img.shields.io/badge/Buy%20Me%20a%20Coffee-ffdd00?logo=buy-me-a-coffee&logoColor=black)](https://www.buymeacoffee.com/mnaoumov) [![npm version](https://img.shields.io/npm/v/obsidian-integration-testing)](https://www.npmjs.com/package/obsidian-integration-testing) [![npm downloads](https://img.shields.io/npm/dm/obsidian-integration-testing)](https://www.npmjs.com/package/obsidian-integration-testing) [![GitHub release](https://img.shields.io/github/v/release/mnaoumov/obsidian-integration-testing)](https://github.com/mnaoumov/obsidian-integration-testing/releases) [![Coverage: 100%](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/mnaoumov/obsidian-integration-testing)
 
 A set of helpers that simplify integration testing of [Obsidian](https://obsidian.md/) plugins against a running Obsidian instance.
 

package/dist/lib/cjs/app-config.cjs

@@ -0,0 +1,137 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var app_config_exports = {};
+__export(app_config_exports, {
+  getAppConfig: () => getAppConfig,
+  restoreAppConfig: () => restoreAppConfig,
+  setAppConfig: () => setAppConfig,
+  withAppConfig: () => withAppConfig
+});
+module.exports = __toCommonJS(app_config_exports);
+var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
+var import_normalize_optional_properties = require("./normalize-optional-properties.cjs");
+async function getAppConfig(params) {
+  const {
+    configKey,
+    transport,
+    vaultPath
+  } = params;
+  return await (0, import_eval_in_obsidian.evalInObsidian)((0, import_normalize_optional_properties.normalizeOptionalProperties)({
+    callback({ app, configKey: key }) {
+      const getConfig = app.vault.getConfig.bind(app.vault);
+      return getConfig(key);
+    },
+    input: { configKey },
+    transport,
+    vaultPath
+  }));
+}
+async function restoreAppConfig(restore) {
+  const {
+    configKey,
+    isPresent,
+    transport,
+    value,
+    vaultPath
+  } = restore;
+  await (0, import_eval_in_obsidian.evalInObsidian)((0, import_normalize_optional_properties.normalizeOptionalProperties)({
+    callback({
+      app,
+      configKey: key,
+      isPresent: wasPresent,
+      value: previousValue
+    }) {
+      const setConfig = app.vault.setConfig.bind(app.vault);
+      setConfig(key, wasPresent ? previousValue : void 0);
+    },
+    input: {
+      configKey,
+      isPresent,
+      value
+    },
+    transport,
+    vaultPath
+  }));
+}
+async function setAppConfig(params) {
+  const {
+    configKey,
+    transport,
+    value,
+    vaultPath
+  } = params;
+  const captured = await (0, import_eval_in_obsidian.evalInObsidian)((0, import_normalize_optional_properties.normalizeOptionalProperties)({
+    callback({
+      app,
+      configKey: key,
+      value: newValue
+    }) {
+      const isPresent = Object.hasOwn(app.vault.config, key);
+      const getConfig = app.vault.getConfig.bind(app.vault);
+      const previousValue = isPresent ? getConfig(key) : void 0;
+      const setConfig = app.vault.setConfig.bind(app.vault);
+      setConfig(key, newValue);
+      return {
+        isPresent,
+        value: previousValue
+      };
+    },
+    input: {
+      configKey,
+      value
+    },
+    transport,
+    vaultPath
+  }));
+  return (0, import_normalize_optional_properties.normalizeOptionalProperties)({
+    configKey,
+    isPresent: captured.isPresent,
+    transport,
+    value: captured.value,
+    vaultPath
+  });
+}
+async function withAppConfig(params) {
+  const {
+    callback,
+    configKey,
+    transport,
+    value,
+    vaultPath
+  } = params;
+  const restore = await setAppConfig((0, import_normalize_optional_properties.normalizeOptionalProperties)({
+    configKey,
+    transport,
+    value,
+    vaultPath
+  }));
+  try {
+    return await callback();
+  } finally {
+    await restoreAppConfig(restore);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAppConfig,
+  restoreAppConfig,
+  setAppConfig,
+  withAppConfig
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/app-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Node-side read/write/restore seam for one of Obsidian's **vault config** keys,\n * for the few tests that need a different value than the harness's headless\n * default.\n *\n * `ensureHeadlessVaultConfig` writes `alwaysUpdateLinks: true` and\n * `settingsPopoutWindow: false` into every vault the harness provisions, before\n * that vault is ever opened, and neither is a knob a consumer configures \u2014 see\n * the project `AGENTS.md` (**L48**). That is right for almost every test, and\n * wrong for the few whose **subject is** the second Electron window the popout\n * creates: a test that waits on `activeWindow !== window`, or reads\n * `app.setting.popout`, never observes the thing it asserts and simply times out.\n *\n * Those tests opt back in through here rather than by hand, which buys three\n * things over an inline `setConfig` inside an `evalInObsidian` closure:\n *\n * - **The value is restored**, including deleting a key that had never been\n *   written. An inline setter writes into a vault shared with the rest of the\n *   run, so every later test in that instance inherits the change \u2014 the\n *   cross-test contamination the unconditional default exists to end.\n * - **The cast lives in one place.** `obsidian-typings`' `ConfigItem` union omits\n *   `settingsPopoutWindow`, so the key cannot be passed to `getConfig` /\n *   `setConfig` without widening them; every consumer that wrote the setter\n *   inline repeated that cast.\n * - **Per-test granularity.** A parameter on the provisioning write would be\n *   per-vault, and a project whose tests share one vault \u2014 the usual shape \u2014\n *   cannot have it both ways.\n *\n * Everything here runs on the **Node** side. An `evalInObsidian` callback is\n * serialized into the driven Obsidian and can import nothing, so a helper\n * callable from inside one is not expressible; each function below is its own\n * short eval instead.\n *\n * ### Why presence is read off `app.vault.config`, not from `getConfig`\n *\n * Both facts were verified in the shipped 1.14.1 bundle rather than assumed:\n *\n * - `Vault.setConfig(key, value)` **deletes** the key when `value` is\n *   `undefined`, and does nothing at all when the value is unchanged (no save,\n *   no `config-changed` event). So an exact restore of a key that was never\n *   written is expressible.\n * - `Vault.getConfig(key)` falls back to Obsidian's defaults table when the key\n *   is absent, so it cannot tell *unset* from *set to the shipped default* \u2014\n *   restoring from it would leave the key written where it had not been.\n *   `app.vault.config` holds only the keys changed from their default, so\n *   `Object.hasOwn` on it is the signal a restore needs.\n */\n\n/* v8 ignore start -- Integration-time code (drives a live Obsidian via evalInObsidian) covered by integration tests, not unit tests. */\n\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.cjs';\n\n/**\n * Parameters for {@link getAppConfig}, and the shared shape of the writers below.\n */\nexport interface AppConfigParams {\n  /**\n   * The vault config key, e.g. `settingsPopoutWindow`. Not narrowed to\n   * `obsidian-typings`' `ConfigItem`: that union omits keys Obsidian really\n   * reads, `settingsPopoutWindow` among them, which is the whole reason a\n   * consumer had to widen the setter by hand.\n   */\n  readonly configKey: string;\n\n  /**\n   * Override the transport. When omitted, the transport the current test\n   * context is driving is used.\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The vault whose Obsidian instance to read or write. When omitted, the\n   * current test context's vault is used.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * What {@link setAppConfig} captured before it wrote, and all\n * {@link restoreAppConfig} needs to put the key back exactly as it was \u2014\n * including putting it back to *absent*.\n */\nexport interface AppConfigRestore {\n  /**\n   * The key that was written.\n   */\n  readonly configKey: string;\n\n  /**\n   * Whether the vault's config carried the key at all before the write. `false`\n   * means the vault was running on Obsidian's own default, and restoring is a\n   * delete rather than a write.\n   */\n  readonly isPresent: boolean;\n\n  /**\n   * The transport the capture was made against, so the restore lands in the\n   * same instance.\n   */\n  readonly transport?: ObsidianTransport;\n\n  /**\n   * The value the key held, or `undefined` when {@link isPresent} is `false`.\n   */\n  readonly value: unknown;\n\n  /**\n   * The vault the capture was made against, so the restore lands in the same\n   * instance.\n   */\n  readonly vaultPath?: string;\n}\n\n/**\n * Parameters for {@link setAppConfig}.\n */\nexport interface SetAppConfigParams extends AppConfigParams {\n  /**\n   * The value to write. `undefined` deletes the key, leaving Obsidian's own\n   * default in force.\n   */\n  readonly value: unknown;\n}\n\n/**\n * Parameters for {@link withAppConfig}.\n *\n * @typeParam T - What the wrapped work returns.\n */\nexport interface WithAppConfigParams<T> extends SetAppConfigParams {\n  /**\n   * The work to run while the key holds {@link SetAppConfigParams.value}.\n   */\n  readonly callback: (this: void) => Promise<T>;\n}\n\n/**\n * What a write captured about the key's state before it wrote.\n */\ninterface CapturedValue {\n  isPresent: boolean;\n  value: unknown;\n}\n\n/**\n * The serialized payload of a read.\n */\ninterface ReadInput extends GenericObject {\n  configKey: string;\n}\n\n/**\n * The serialized payload of a restore.\n */\ninterface RestoreInput extends GenericObject {\n  configKey: string;\n  isPresent: boolean;\n  value: unknown;\n}\n\n/**\n * The serialized payload of a write.\n */\ninterface WriteInput extends GenericObject {\n  configKey: string;\n  value: unknown;\n}\n\n/**\n * Reads a vault config key, resolving the transport and vault from the current\n * test context.\n *\n * This is Obsidian's own `Vault.getConfig`, so an absent key reads back as\n * Obsidian's **default** for it rather than as `undefined` \u2014 see this file's\n * header. Use {@link setAppConfig}'s {@link AppConfigRestore.isPresent} when the\n * difference matters.\n *\n * @param params - The key to read, and transport / vault overrides.\n * @returns A {@link Promise} resolving to the key's effective value.\n */\nexport async function getAppConfig(params: AppConfigParams): Promise<unknown> {\n  const {\n    configKey,\n    transport,\n    vaultPath\n  } = params;\n\n  return await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<ReadInput, unknown>>({\n    callback({ app, configKey: key }): unknown {\n      const getConfig = app.vault.getConfig.bind(app.vault) as (configKey: string) => unknown;\n      return getConfig(key);\n    },\n    input: { configKey },\n    transport,\n    vaultPath\n  }));\n}\n\n/**\n * Puts a key back exactly as {@link setAppConfig} found it \u2014 writing the captured\n * value back, or **deleting** the key when the vault had never carried it.\n *\n * The `beforeAll` / `afterAll` half of the seam. A test that scopes the change\n * to one callback wants {@link withAppConfig} instead, which cannot forget the\n * restore.\n *\n * @param restore - The token {@link setAppConfig} returned.\n * @returns A {@link Promise} that resolves once the key is back as it was.\n */\nexport async function restoreAppConfig(restore: AppConfigRestore): Promise<void> {\n  const {\n    configKey,\n    isPresent,\n    transport,\n    value,\n    vaultPath\n  } = restore;\n\n  await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<RestoreInput, undefined>>({\n    callback({\n      app,\n      configKey: key,\n      isPresent: wasPresent,\n      value: previousValue\n    }): undefined {\n      const setConfig = app.vault.setConfig.bind(app.vault) as (configKey: string, value: unknown) => void;\n\n      // `undefined` is not a no-op here: `setConfig` deletes the key for it,\n      // Which is the only way to restore one the vault never carried.\n      setConfig(key, wasPresent ? previousValue : undefined);\n    },\n    input: {\n      configKey,\n      isPresent,\n      value\n    },\n    transport,\n    vaultPath\n  }));\n}\n\n/**\n * Writes a vault config key, capturing what it held first so the write can be\n * undone exactly.\n *\n * Obsidian persists the change (`requestSaveConfig`) and fires its\n * `config-changed` event, both of which the app's own settings UI does too \u2014 so\n * anything listening reacts as it would to a user flipping the toggle. A write\n * of the value the key already holds is a no-op in Obsidian itself, and the\n * returned token still describes the state that preceded it.\n *\n * @param params - The key, the value, and transport / vault overrides.\n * @returns A {@link Promise} resolving to the {@link AppConfigRestore} token to\n *   hand {@link restoreAppConfig}.\n */\nexport async function setAppConfig(params: SetAppConfigParams): Promise<AppConfigRestore> {\n  const {\n    configKey,\n    transport,\n    value,\n    vaultPath\n  } = params;\n\n  const captured = await evalInObsidian(normalizeOptionalProperties<EvalInObsidianParams<WriteInput, CapturedValue>>({\n    callback({\n      app,\n      configKey: key,\n      value: newValue\n    }): CapturedValue {\n      // `config` carries ONLY the keys changed from their default, which is what\n      // Makes it the presence signal; `getConfig` substitutes the default and so\n      // Cannot tell an unset key from one set to that default. The value itself\n      // Still comes from `getConfig`, which returns the stored one whenever\n      // There is one \u2014 so the read needs no cast of the config object.\n      const isPresent = Object.hasOwn(app.vault.config, key);\n\n      const getConfig = app.vault.getConfig.bind(app.vault) as (configKey: string) => unknown;\n      const previousValue = isPresent ? getConfig(key) : undefined;\n\n      const setConfig = app.vault.setConfig.bind(app.vault) as (configKey: string, value: unknown) => void;\n      setConfig(key, newValue);\n\n      return {\n        isPresent,\n        value: previousValue\n      };\n    },\n    input: {\n      configKey,\n      value\n    },\n    transport,\n    vaultPath\n  }));\n\n  return normalizeOptionalProperties<AppConfigRestore>({\n    configKey,\n    isPresent: captured.isPresent,\n    transport,\n    value: captured.value,\n    vaultPath\n  });\n}\n\n/**\n * Runs work with a vault config key temporarily set, and puts the key back\n * afterwards \u2014 on a throw as much as on a return.\n *\n * The shape a popout-subject test wants:\n *\n * ```ts\n * await withAppConfig({\n *   async callback() {\n *     await evalInObsidian({ ... }); // the settings window is a popout in here\n *   },\n *   configKey: 'settingsPopoutWindow',\n *   value: true,\n *   vaultPath\n * });\n * ```\n *\n * The callback runs on the **Node** side, so it is free to make several evals,\n * take a screenshot, or assert between them.\n *\n * @typeParam T - What the wrapped work returns.\n * @param params - The key, the value to hold it at, the work, and transport /\n *   vault overrides.\n * @returns A {@link Promise} resolving to whatever the callback returned.\n */\nexport async function withAppConfig<T>(params: WithAppConfigParams<T>): Promise<T> {\n  const {\n    callback,\n    configKey,\n    transport,\n    value,\n    vaultPath\n  } = params;\n\n  const restore = await setAppConfig(normalizeOptionalProperties<SetAppConfigParams>({\n    configKey,\n    transport,\n    value,\n    vaultPath\n  }));\n\n  try {\n    return await callback();\n  } finally {\n    await restoreAppConfig(restore);\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA0DA,8BAA+B;AAC/B,2CAA4C;AAkI5C,eAAsB,aAAa,QAA2C;AAC5E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,SAAO,UAAM,4CAAe,kEAAsE;AAAA,IAChG,SAAS,EAAE,KAAK,WAAW,IAAI,GAAY;AACzC,YAAM,YAAY,IAAI,MAAM,UAAU,KAAK,IAAI,KAAK;AACpD,aAAO,UAAU,GAAG;AAAA,IACtB;AAAA,IACA,OAAO,EAAE,UAAU;AAAA,IACnB;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AACJ;AAaA,eAAsB,iBAAiB,SAA0C;AAC/E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,YAAM,4CAAe,kEAA2E;AAAA,IAC9F,SAAS;AAAA,MACP;AAAA,MACA,WAAW;AAAA,MACX,WAAW;AAAA,MACX,OAAO;AAAA,IACT,GAAc;AACZ,YAAM,YAAY,IAAI,MAAM,UAAU,KAAK,IAAI,KAAK;AAIpD,gBAAU,KAAK,aAAa,gBAAgB,MAAS;AAAA,IACvD;AAAA,IACA,OAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AACJ;AAgBA,eAAsB,aAAa,QAAuD;AACxF,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,WAAW,UAAM,4CAAe,kEAA6E;AAAA,IACjH,SAAS;AAAA,MACP;AAAA,MACA,WAAW;AAAA,MACX,OAAO;AAAA,IACT,GAAkB;AAMhB,YAAM,YAAY,OAAO,OAAO,IAAI,MAAM,QAAQ,GAAG;AAErD,YAAM,YAAY,IAAI,MAAM,UAAU,KAAK,IAAI,KAAK;AACpD,YAAM,gBAAgB,YAAY,UAAU,GAAG,IAAI;AAEnD,YAAM,YAAY,IAAI,MAAM,UAAU,KAAK,IAAI,KAAK;AACpD,gBAAU,KAAK,QAAQ;AAEvB,aAAO;AAAA,QACL;AAAA,QACA,OAAO;AAAA,MACT;AAAA,IACF;AAAA,IACA,OAAO;AAAA,MACL;AAAA,MACA;AAAA,IACF;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AAEF,aAAO,kEAA8C;AAAA,IACnD;AAAA,IACA,WAAW,SAAS;AAAA,IACpB;AAAA,IACA,OAAO,SAAS;AAAA,IAChB;AAAA,EACF,CAAC;AACH;AA2BA,eAAsB,cAAiB,QAA4C;AACjF,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,UAAU,MAAM,iBAAa,kEAAgD;AAAA,IACjF;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC,CAAC;AAEF,MAAI;AACF,WAAO,MAAM,SAAS;AAAA,EACxB,UAAE;AACA,UAAM,iBAAiB,OAAO;AAAA,EAChC;AACF;",
  "names": []
}


package/dist/lib/cjs/app-config.d.cts

@@ -0,0 +1,190 @@
+/**
+ * @file
+ *
+ * Node-side read/write/restore seam for one of Obsidian's **vault config** keys,
+ * for the few tests that need a different value than the harness's headless
+ * default.
+ *
+ * `ensureHeadlessVaultConfig` writes `alwaysUpdateLinks: true` and
+ * `settingsPopoutWindow: false` into every vault the harness provisions, before
+ * that vault is ever opened, and neither is a knob a consumer configures — see
+ * the project `AGENTS.md` (**L48**). That is right for almost every test, and
+ * wrong for the few whose **subject is** the second Electron window the popout
+ * creates: a test that waits on `activeWindow !== window`, or reads
+ * `app.setting.popout`, never observes the thing it asserts and simply times out.
+ *
+ * Those tests opt back in through here rather than by hand, which buys three
+ * things over an inline `setConfig` inside an `evalInObsidian` closure:
+ *
+ * - **The value is restored**, including deleting a key that had never been
+ *   written. An inline setter writes into a vault shared with the rest of the
+ *   run, so every later test in that instance inherits the change — the
+ *   cross-test contamination the unconditional default exists to end.
+ * - **The cast lives in one place.** `obsidian-typings`' `ConfigItem` union omits
+ *   `settingsPopoutWindow`, so the key cannot be passed to `getConfig` /
+ *   `setConfig` without widening them; every consumer that wrote the setter
+ *   inline repeated that cast.
+ * - **Per-test granularity.** A parameter on the provisioning write would be
+ *   per-vault, and a project whose tests share one vault — the usual shape —
+ *   cannot have it both ways.
+ *
+ * Everything here runs on the **Node** side. An `evalInObsidian` callback is
+ * serialized into the driven Obsidian and can import nothing, so a helper
+ * callable from inside one is not expressible; each function below is its own
+ * short eval instead.
+ *
+ * ### Why presence is read off `app.vault.config`, not from `getConfig`
+ *
+ * Both facts were verified in the shipped 1.14.1 bundle rather than assumed:
+ *
+ * - `Vault.setConfig(key, value)` **deletes** the key when `value` is
+ *   `undefined`, and does nothing at all when the value is unchanged (no save,
+ *   no `config-changed` event). So an exact restore of a key that was never
+ *   written is expressible.
+ * - `Vault.getConfig(key)` falls back to Obsidian's defaults table when the key
+ *   is absent, so it cannot tell *unset* from *set to the shipped default* —
+ *   restoring from it would leave the key written where it had not been.
+ *   `app.vault.config` holds only the keys changed from their default, so
+ *   `Object.hasOwn` on it is the signal a restore needs.
+ */
+import type { ObsidianTransport } from './transport.cjs';
+/**
+ * Parameters for {@link getAppConfig}, and the shared shape of the writers below.
+ */
+export interface AppConfigParams {
+    /**
+     * The vault config key, e.g. `settingsPopoutWindow`. Not narrowed to
+     * `obsidian-typings`' `ConfigItem`: that union omits keys Obsidian really
+     * reads, `settingsPopoutWindow` among them, which is the whole reason a
+     * consumer had to widen the setter by hand.
+     */
+    readonly configKey: string;
+    /**
+     * Override the transport. When omitted, the transport the current test
+     * context is driving is used.
+     */
+    readonly transport?: ObsidianTransport;
+    /**
+     * The vault whose Obsidian instance to read or write. When omitted, the
+     * current test context's vault is used.
+     */
+    readonly vaultPath?: string;
+}
+/**
+ * What {@link setAppConfig} captured before it wrote, and all
+ * {@link restoreAppConfig} needs to put the key back exactly as it was —
+ * including putting it back to *absent*.
+ */
+export interface AppConfigRestore {
+    /**
+     * The key that was written.
+     */
+    readonly configKey: string;
+    /**
+     * Whether the vault's config carried the key at all before the write. `false`
+     * means the vault was running on Obsidian's own default, and restoring is a
+     * delete rather than a write.
+     */
+    readonly isPresent: boolean;
+    /**
+     * The transport the capture was made against, so the restore lands in the
+     * same instance.
+     */
+    readonly transport?: ObsidianTransport;
+    /**
+     * The value the key held, or `undefined` when {@link isPresent} is `false`.
+     */
+    readonly value: unknown;
+    /**
+     * The vault the capture was made against, so the restore lands in the same
+     * instance.
+     */
+    readonly vaultPath?: string;
+}
+/**
+ * Parameters for {@link setAppConfig}.
+ */
+export interface SetAppConfigParams extends AppConfigParams {
+    /**
+     * The value to write. `undefined` deletes the key, leaving Obsidian's own
+     * default in force.
+     */
+    readonly value: unknown;
+}
+/**
+ * Parameters for {@link withAppConfig}.
+ *
+ * @typeParam T - What the wrapped work returns.
+ */
+export interface WithAppConfigParams<T> extends SetAppConfigParams {
+    /**
+     * The work to run while the key holds {@link SetAppConfigParams.value}.
+     */
+    readonly callback: (this: void) => Promise<T>;
+}
+/**
+ * Reads a vault config key, resolving the transport and vault from the current
+ * test context.
+ *
+ * This is Obsidian's own `Vault.getConfig`, so an absent key reads back as
+ * Obsidian's **default** for it rather than as `undefined` — see this file's
+ * header. Use {@link setAppConfig}'s {@link AppConfigRestore.isPresent} when the
+ * difference matters.
+ *
+ * @param params - The key to read, and transport / vault overrides.
+ * @returns A {@link Promise} resolving to the key's effective value.
+ */
+export declare function getAppConfig(params: AppConfigParams): Promise<unknown>;
+/**
+ * Puts a key back exactly as {@link setAppConfig} found it — writing the captured
+ * value back, or **deleting** the key when the vault had never carried it.
+ *
+ * The `beforeAll` / `afterAll` half of the seam. A test that scopes the change
+ * to one callback wants {@link withAppConfig} instead, which cannot forget the
+ * restore.
+ *
+ * @param restore - The token {@link setAppConfig} returned.
+ * @returns A {@link Promise} that resolves once the key is back as it was.
+ */
+export declare function restoreAppConfig(restore: AppConfigRestore): Promise<void>;
+/**
+ * Writes a vault config key, capturing what it held first so the write can be
+ * undone exactly.
+ *
+ * Obsidian persists the change (`requestSaveConfig`) and fires its
+ * `config-changed` event, both of which the app's own settings UI does too — so
+ * anything listening reacts as it would to a user flipping the toggle. A write
+ * of the value the key already holds is a no-op in Obsidian itself, and the
+ * returned token still describes the state that preceded it.
+ *
+ * @param params - The key, the value, and transport / vault overrides.
+ * @returns A {@link Promise} resolving to the {@link AppConfigRestore} token to
+ *   hand {@link restoreAppConfig}.
+ */
+export declare function setAppConfig(params: SetAppConfigParams): Promise<AppConfigRestore>;
+/**
+ * Runs work with a vault config key temporarily set, and puts the key back
+ * afterwards — on a throw as much as on a return.
+ *
+ * The shape a popout-subject test wants:
+ *
+ * ```ts
+ * await withAppConfig({
+ *   async callback() {
+ *     await evalInObsidian({ ... }); // the settings window is a popout in here
+ *   },
+ *   configKey: 'settingsPopoutWindow',
+ *   value: true,
+ *   vaultPath
+ * });
+ * ```
+ *
+ * The callback runs on the **Node** side, so it is free to make several evals,
+ * take a screenshot, or assert between them.
+ *
+ * @typeParam T - What the wrapped work returns.
+ * @param params - The key, the value to hold it at, the work, and transport /
+ *   vault overrides.
+ * @returns A {@link Promise} resolving to whatever the callback returned.
+ */
+export declare function withAppConfig<T>(params: WithAppConfigParams<T>): Promise<T>;

package/dist/lib/cjs/appium-session-config.cjs

@@ -21,14 +21,19 @@ __export(appium_session_config_exports, {
   DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS: () => DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS,
   DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS: () => DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,
   resolveAppiumStartTimeoutInMilliseconds: () => resolveAppiumStartTimeoutInMilliseconds,
+  resolveScriptTimeoutInMilliseconds: () => resolveScriptTimeoutInMilliseconds,
   resolveSessionConnectionRetryTimeoutInMilliseconds: () => resolveSessionConnectionRetryTimeoutInMilliseconds
 });
 module.exports = __toCommonJS(appium_session_config_exports);
+var import_eval_cap = require("./eval-cap.cjs");
 const DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS = 18e4;
 const DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS = 18e4;
 function resolveAppiumStartTimeoutInMilliseconds(options) {
   return options.appiumStartTimeoutInMilliseconds ?? DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS;
 }
+function resolveScriptTimeoutInMilliseconds(options) {
+  return options.scriptTimeoutInMilliseconds ?? import_eval_cap.DEFAULT_EVAL_CAP_IN_MILLISECONDS;
+}
 function resolveSessionConnectionRetryTimeoutInMilliseconds(options) {
   return options.sessionConnectionRetryTimeoutInMilliseconds ?? DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS;
 }
@@ -37,6 +42,7 @@ function resolveSessionConnectionRetryTimeoutInMilliseconds(options) {
   DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS,
   DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS,
   resolveAppiumStartTimeoutInMilliseconds,
+  resolveScriptTimeoutInMilliseconds,
   resolveSessionConnectionRetryTimeoutInMilliseconds
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/appium-session-config.d.cts

@@ -29,6 +29,26 @@ export declare const DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS =
  * @returns The timeout in milliseconds.
  */
 export declare function resolveAppiumStartTimeoutInMilliseconds(options: ObsidianAndroidAppiumTransportOptions): number;
+/**
+ * Resolves the per-script (per-`evalInObsidian`) timeout, applying the default
+ * when the option is omitted.
+ *
+ * This is what `AppiumTransport.evaluate` enforces on the Node side; it is also
+ * sent as the W3C `timeouts.script` capability, which was measured to be
+ * accepted and never acted on. It is deliberately NOT the knob to reach for when
+ * a closure times out: the closure is what should get shorter, with the waiting
+ * moved to Node via `pollInObsidian`.
+ *
+ * The default is {@link DEFAULT_EVAL_CAP_IN_MILLISECONDS}, the shared per-eval
+ * cap, rather than an Android-specific number: the protocol default WebDriver
+ * would nominally apply was measured not to be applied at all on this driver, so
+ * this is the only number that actually bounds an Android eval — which makes it
+ * the same policy the desktop transport enforces, not a coincidence.
+ *
+ * @param options - The Android Appium transport options.
+ * @returns The timeout in milliseconds.
+ */
+export declare function resolveScriptTimeoutInMilliseconds(options: ObsidianAndroidAppiumTransportOptions): number;
 /**
  * Resolves the Appium session connection retry timeout, applying the default
  * when the option is omitted.

package/dist/lib/cjs/cdp-command-timeout-error.cjs

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cdp_command_timeout_error_exports = {};
+__export(cdp_command_timeout_error_exports, {
+  CdpCommandTimeoutError: () => CdpCommandTimeoutError
+});
+module.exports = __toCommonJS(cdp_command_timeout_error_exports);
+class CdpCommandTimeoutError extends Error {
+  /**
+  The CDP method that got no response.
+   */
+  method;
+  /**
+  The per-command budget that elapsed, in milliseconds.
+   */
+  timeoutInMilliseconds;
+  /**
+   * Creates the error from the method and the elapsed budget.
+   *
+   * @param params - The CDP method and the per-command timeout.
+   */
+  constructor(params) {
+    const { method, timeoutInMilliseconds } = params;
+    super(`CDP command timed out after ${String(timeoutInMilliseconds)}ms: ${method}`);
+    this.name = "CdpCommandTimeoutError";
+    this.method = method;
+    this.timeoutInMilliseconds = timeoutInMilliseconds;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CdpCommandTimeoutError
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/cdp-command-timeout-error.d.cts

@@ -0,0 +1,48 @@
+/**
+ * @file
+ *
+ * The distinct error the desktop CDP transport raises when a single CDP command
+ * gets no response within `commandTimeoutInMilliseconds`.
+ *
+ * It exists as a type rather than a bare `Error` so ONE caller can tell it apart:
+ * `evaluate()`, which is the only `Runtime.evaluate` carrying a test's own
+ * closure, re-reports it as `EvalCapExceededError`. The harness's other
+ * `Runtime.evaluate` calls — the trust dialog, the parent-liveness watchdog, the
+ * boot probes — time out for reasons that have nothing to do with a test waiting
+ * too long, and matching them on the method name would produce exactly the
+ * misdiagnosis this work removes, pointing the other way.
+ */
+/**
+ * Parameters for the {@link CdpCommandTimeoutError} constructor.
+ */
+export interface CdpCommandTimeoutErrorConstructorParams {
+    /**
+    The CDP method that got no response, e.g. `'Runtime.evaluate'`.
+     */
+    readonly method: string;
+    /**
+    The per-command budget that elapsed, in milliseconds.
+     */
+    readonly timeoutInMilliseconds: number;
+}
+/**
+ * Thrown when a CDP command gets no response within the transport's per-command
+ * timeout. Carries the method and the budget so a caller can `instanceof`-match
+ * and re-report it in its own terms.
+ */
+export declare class CdpCommandTimeoutError extends Error {
+    /**
+    The CDP method that got no response.
+     */
+    readonly method: string;
+    /**
+    The per-command budget that elapsed, in milliseconds.
+     */
+    readonly timeoutInMilliseconds: number;
+    /**
+     * Creates the error from the method and the elapsed budget.
+     *
+     * @param params - The CDP method and the per-command timeout.
+     */
+    constructor(params: CdpCommandTimeoutErrorConstructorParams);
+}