obsidian-integration-testing 12.1.1 → 12.2.0

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

@@ -19,24 +19,32 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var appium_session_config_exports = {};
 __export(appium_session_config_exports, {
   DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS: () => DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS,
+  DEFAULT_SCRIPT_TIMEOUT_IN_MILLISECONDS: () => DEFAULT_SCRIPT_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);
 const DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS = 18e4;
+const DEFAULT_SCRIPT_TIMEOUT_IN_MILLISECONDS = 3e4;
 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 ?? DEFAULT_SCRIPT_TIMEOUT_IN_MILLISECONDS;
+}
 function resolveSessionConnectionRetryTimeoutInMilliseconds(options) {
   return options.sessionConnectionRetryTimeoutInMilliseconds ?? DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS,
+  DEFAULT_SCRIPT_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

@@ -12,6 +12,15 @@ import type { ObsidianAndroidAppiumTransportOptions } from './transport-options.
  * Default for {@link ObsidianAndroidAppiumTransportOptions.appiumStartTimeoutInMilliseconds}.
  */
 export declare const DEFAULT_APPIUM_START_TIMEOUT_IN_MILLISECONDS = 180000;
+/**
+ * Default for {@link ObsidianAndroidAppiumTransportOptions.scriptTimeoutInMilliseconds}.
+ *
+ * The same 30s WebDriver would nominally apply, stated here so the cap is a
+ * declared number rather than an invisible protocol default — and, since the
+ * protocol default was measured not to be applied at all on this driver, the
+ * only number that actually bounds an Android eval.
+ */
+export declare const DEFAULT_SCRIPT_TIMEOUT_IN_MILLISECONDS = 30000;
 /**
  * Default for {@link ObsidianAndroidAppiumTransportOptions.sessionConnectionRetryTimeoutInMilliseconds}.
  */
@@ -29,6 +38,20 @@ 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`.
+ *
+ * @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);
+}

package/dist/lib/cjs/emulator-arguments.cjs

@@ -18,10 +18,14 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var emulator_arguments_exports = {};
 __export(emulator_arguments_exports, {
-  buildEmulatorArguments: () => buildEmulatorArguments
+  NETSIM_LOG_FILTER: () => NETSIM_LOG_FILTER,
+  buildEmulatorArguments: () => buildEmulatorArguments,
+  buildEmulatorEnvironment: () => buildEmulatorEnvironment
 });
 module.exports = __toCommonJS(emulator_arguments_exports);
 const DNS_SERVER = "8.8.8.8";
+const NETSIM_LOG_FILTER = "error";
+const RUST_LOG_VARIABLE_NAME = "RUST_LOG";
 function buildEmulatorArguments(params) {
   const emulatorArguments = ["-avd", params.avdName];
   if (!params.shouldReuseSnapshot) {
@@ -33,8 +37,20 @@ function buildEmulatorArguments(params) {
   }
   return emulatorArguments;
 }
+function buildEmulatorEnvironment(baseEnvironment) {
+  const existingFilter = baseEnvironment[RUST_LOG_VARIABLE_NAME];
+  if (existingFilter !== void 0 && existingFilter !== "") {
+    return { environment: { ...baseEnvironment }, isNetsimLogGuarded: false };
+  }
+  return {
+    environment: { ...baseEnvironment, [RUST_LOG_VARIABLE_NAME]: NETSIM_LOG_FILTER },
+    isNetsimLogGuarded: true
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  buildEmulatorArguments
+  NETSIM_LOG_FILTER,
+  buildEmulatorArguments,
+  buildEmulatorEnvironment
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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