obsidian-integration-testing 12.1.2 → 12.3.0

package/dist/lib/esm/app-config.d.mts

@@ -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.mjs';
+/**
+ * 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/esm/app-config.mjs

@@ -0,0 +1,110 @@
+import { evalInObsidian } from "./eval-in-obsidian.mjs";
+import { normalizeOptionalProperties } from "./normalize-optional-properties.mjs";
+async function getAppConfig(params) {
+  const {
+    configKey,
+    transport,
+    vaultPath
+  } = params;
+  return await evalInObsidian(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 evalInObsidian(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 evalInObsidian(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 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(normalizeOptionalProperties({
+    configKey,
+    transport,
+    value,
+    vaultPath
+  }));
+  try {
+    return await callback();
+  } finally {
+    await restoreAppConfig(restore);
+  }
+}
+export {
+  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.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.mjs';\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": "AA0DA,SAAS,sBAAsB;AAC/B,SAAS,mCAAmC;AAkI5C,eAAsB,aAAa,QAA2C;AAC5E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,SAAO,MAAM,eAAe,4BAAsE;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,QAAM,eAAe,4BAA2E;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,MAAM,eAAe,4BAA6E;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,SAAO,4BAA8C;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,aAAa,4BAAgD;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/esm/appium-session-config.d.mts

@@ -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/esm/appium-session-config.mjs

@@ -1,8 +1,12 @@
+import { DEFAULT_EVAL_CAP_IN_MILLISECONDS } from "./eval-cap.mjs";
 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 ?? DEFAULT_EVAL_CAP_IN_MILLISECONDS;
+}
 function resolveSessionConnectionRetryTimeoutInMilliseconds(options) {
   return options.sessionConnectionRetryTimeoutInMilliseconds ?? DEFAULT_SESSION_CONNECTION_RETRY_TIMEOUT_IN_MILLISECONDS;
 }
@@ -10,6 +14,7 @@ export {
   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/esm/cdp-command-timeout-error.d.mts

@@ -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/esm/cdp-command-timeout-error.mjs

@@ -0,0 +1,26 @@
+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;
+  }
+}
+export {
+  CdpCommandTimeoutError
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/connect-to-cdp.d.mts

@@ -117,6 +117,11 @@ export interface ConnectToCdpOptions {
     /**
      * Timeout in milliseconds for individual CDP commands.
      *
+     * A test's closure travels as one `Runtime.evaluate` command, so this is also
+     * the desktop per-eval cap. The default is `DEFAULT_EVAL_CAP_IN_MILLISECONDS`,
+     * exported from the package root — import it rather than restating the number,
+     * so a closure sized against the cap follows it if it ever moves.
+     *
      * @default `30000`
      */
     readonly commandTimeoutInMilliseconds?: number;

package/dist/lib/esm/connect-to-cdp.mjs

@@ -112,4 +112,4 @@ async function sweepLeftovers(transportOptions) {
 export {
   connectToCdp
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * the base `lib` helpers, `errorToString`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { AsarFallback } from './asar-fallback-detection.mjs';\nimport type { CaptureScreenshotParams } from './capture-screenshot.mjs';\nimport type { ContextId } from './context-id.mjs';\nimport type { ElectronCompatibility } from './electron-compatibility.mjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { InstallerCompatibility } from './installer-compatibility.mjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { ensureHeadlessVaultConfig } from './headless-vault-config.mjs';\nimport {\n  resolveLeftoverMaxAgeInMilliseconds,\n  sweepHostLeftovers,\n  willSweepLeftovers\n} from './leftover-cleanup.mjs';\nimport { log } from './log.mjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.mjs';\nimport { TemporaryVault } from './temporary-vault.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\nimport { resolveOwnedConfigDirectory } from './transport-options.mjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The silent-asar-fallback verdict for an owned instance, read live after boot:\n   * whether the app version it is actually running matches the swapped-in pin, or\n   * the installer silently reverted to its own bundled asar. `undefined` in attach\n   * mode, when no asar was swapped, or when the running version was unreadable. A\n   * `'fallback'` verdict reaches here only when the throw is disabled\n   * ({@link ConnectToCdpOptions.shouldThrowOnSilentAsarFallback} `false`);\n   * otherwise it throws `SilentAsarFallbackError` before the connection is created.\n   */\n  readonly asarFallback?: AsarFallback | undefined;\n\n  /**\n   * Captures a PNG screenshot of this connection's Obsidian window, with the\n   * vault path pre-bound.\n   *\n   * Pass `widthInPixels` + `heightInPixels` to pin the viewport for the duration\n   * of the capture, so the emitted PNG is exactly that size whatever size the\n   * window happens to be.\n   *\n   * @param params - The exact size to capture at. Omit to capture the window at its natural size.\n   * @returns A {@link Promise} that resolves to the raw PNG bytes.\n   */\n  captureScreenshot(params?: Except<CaptureScreenshotParams, 'cwd'>): Promise<Uint8Array>;\n\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * The resolved installer\u2194app compatibility verdict for an owned instance, when\n   * it could be determined. `undefined` in attach mode, or when the verdict is\n   * unknown (undetectable shell version, or the app version is absent from the\n   * table). An `'unrunnable'` verdict reaches here only when the proactive throw\n   * is disabled ({@link ConnectToCdpOptions.shouldThrowOnIncompatibleInstaller}\n   * `false`); otherwise it throws `IncompatibleInstallerVersionError` before the\n   * connection is created.\n   */\n  readonly compatibility?: InstallerCompatibility | undefined;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * The runtime Electron compatibility verdict for an owned instance, read live\n   * after boot: whether the Electron version it is actually running is new enough\n   * for the running app version. `undefined` in attach mode, or when the verdict\n   * is unknown (the live version was unreadable, or the app version carries no\n   * recommended Electron version). An old Electron never blocks \u2014 it only warns \u2014\n   * so unlike {@link compatibility} there is no throwing tier.\n   */\n  readonly electronCompatibility?: ElectronCompatibility | undefined;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, lib, obsidianModule, context }` plus any `input`\n   * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). Mirrors\n   * the top-level `evalInObsidian`, with the transport and vault path pre-bound\n   * to this connection.\n   *\n   * @param params - The evaluation parameters (`callback`, optional `input`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `callback`.\n   */\n  evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Input, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TemporaryVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * The vault's **config folder** \u2014 Obsidian's per-vault *Override config\n   * folder* setting, e.g. `'.obsidian-desktop'`. Set it to open a vault that\n   * keeps its settings somewhere other than `.obsidian`; without it such a vault\n   * opens against `.obsidian`, which for a vault that has a stale one beside the\n   * real folder means opening successfully against the wrong settings.\n   *\n   * Must start with a dot, must not be the bare dot, and must not contain a path\n   * separator \u2014 anything else throws before Obsidian launches, since Obsidian\n   * would silently substitute `.obsidian`. After the vault opens, its actual\n   * `app.vault.configDir` is read back and a mismatch throws\n   * `ConfigDirectoryFallbackError`.\n   *\n   * Ignored in attach mode ({@link ConnectToCdpOptions.port} set), where the\n   * vault is opened by the user's own Obsidian under its own config.\n   *\n   * @default `undefined` (Obsidian's own default, `.obsidian`)\n   */\n  readonly configDirectory?: string;\n\n  /**\n   * Grace window in milliseconds for fast-failing a dead boot of the owned\n   * instance \u2014 the renderer loaded but the app never bootstrapped (empty\n   * `<body>`, no `window.app`), the terminal state when the asar cannot run on\n   * the launched Electron shell. Once it has held this long a\n   * `RendererFailedToInitializeError` is thrown instead of waiting out the full\n   * readiness timeout. Ignored in attach mode ({@link port} set). Set `0` to\n   * disable fast-fail.\n   *\n   * @default `10000`\n   */\n  readonly deadBootGraceInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Whether the Obsidian window is shown on screen. Defaults to `true`; set\n   * `false` to launch it off-screen.\n   * Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to launch the owned instance with Chromium's sandbox disabled\n   * (`--no-sandbox`).\n   *\n   * Needed to boot on Linux without a correctly-configured setuid\n   * `chrome-sandbox` helper (e.g. an installer-extracted portable shell, or CI\n   * running as a non-root user); harmless on Windows/macOS. Ignored in attach\n   * mode ({@link port} set).\n   *\n   * @default `false`\n   */\n  readonly shouldDisableSandbox?: boolean;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Whether an **unrunnable** installer\u2194app version pair fails fast before launch.\n   *\n   * When `true` (the default), an installer below the app's run floor throws\n   * `IncompatibleInstallerVersionError` from version resolution before anything is\n   * downloaded or launched. Set `false` to let the pin proceed to launch \u2014 where\n   * the reactive dead-boot fast-fail still catches the black-screen boot, and the\n   * `'unrunnable'` verdict is surfaced on {@link CdpConnection.compatibility}\n   * rather than thrown. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnIncompatibleInstaller?: boolean;\n\n  /**\n   * Whether a post-boot **silent asar fallback** fails fast.\n   *\n   * When an asar is swapped onto an installer shell too old for it, the instance\n   * may silently revert to the installer's own bundled asar and run the **wrong\n   * (older)** version behind a healthy UI. When `true` (the default), the running\n   * app version is verified against the pin post-boot and a mismatch throws\n   * `SilentAsarFallbackError`. Set `false` to let the boot proceed \u2014 the mismatch\n   * is then surfaced on {@link CdpConnection.asarFallback} rather than thrown.\n   * Ignored in attach mode ({@link port} set) and when no asar is swapped.\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnSilentAsarFallback?: boolean;\n\n  /**\n   * Whether the owned-instance compatibility **nag warnings** are emitted.\n   *\n   * Covers both the offline installer\u2194app warning and the post-boot\n   * runtime-Electron warning. When `true` (the default) each fires via the harness\n   * log; set `false` to silence both \u2014 the verdicts are still surfaced on\n   * {@link CdpConnection.compatibility} / {@link CdpConnection.electronCompatibility},\n   * only the log is suppressed. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldWarnOnCompatibilityIssues?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transportOptions = buildCdpTransportOptions(options);\n  await sweepLeftovers(transportOptions);\n  const transport = await createTransportFromOptions(transportOptions);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n  const vault = new TemporaryVault(options?.vault, { shouldRemoveDirectoryOnDispose: shouldRemoveVaultOnDispose });\n\n  // The headless defaults go only into a vault the harness made \u2014 the same\n  // `options.vault === undefined` discriminator the disposal above turns on. A\n  // Caller-supplied vault is a real one the user keeps, and a debugging session\n  // Has no business rewriting its settings.\n  if (options?.vault === undefined) {\n    await ensureHeadlessVaultConfig({\n      configDirectory: resolveOwnedConfigDirectory(transportOptions),\n      label: transportOptions.type,\n      vaultPath: vault.path\n    });\n  }\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n  const asarFallback = transport instanceof DesktopCdpTransport ? transport.getAsarFallback() : undefined;\n  const compatibility = transport instanceof DesktopCdpTransport ? transport.getCompatibility() : undefined;\n  const electronCompatibility = transport instanceof DesktopCdpTransport ? transport.getElectronCompatibility() : undefined;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n    ...(asarFallback && { asarFallback }),\n    ...(compatibility && { compatibility }),\n    ...(electronCompatibility && { electronCompatibility }),\n\n    async captureScreenshot(params?: Except<CaptureScreenshotParams, 'cwd'>): Promise<Uint8Array> {\n      // Every transport `connectToCdp` builds is a DesktopCdpTransport, which\n      // Implements the optional method \u2014 but the interface still types it\n      // Optional, so the absence is reported rather than silently thrown at.\n      if (!transport.captureScreenshot) {\n        throw new Error('connectToCdp: this transport cannot capture screenshots.');\n      }\n\n      return transport.captureScreenshot({ ...params, cwd: vault.path });\n    },\n\n    async dispose(): Promise<void> {\n      try {\n        // The vault carries `shouldRemoveVaultOnDispose` itself (handed to its constructor above), so\n        // This is one call rather than a branch: it always unregisters, and removes the directory only\n        // When that flag says to.\n        await vault.dispose(transport);\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Input, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Input, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Builds the {@link ObsidianCdpTransportOptions} for a connection, threading only\n * the provided {@link ConnectToCdpOptions} through (owned-visible defaults to\n * `true`, unlike the hidden-by-default test transports). Unset knobs pass through\n * as `undefined` and are read with `?? default` / `!== undefined` guards\n * downstream, so an explicit `undefined` is indistinguishable from an absent key.\n *\n * @param options - The connection options.\n * @returns The transport options to create the connection's transport from.\n */\nfunction buildCdpTransportOptions(options?: ConnectToCdpOptions): ObsidianCdpTransportOptions {\n  return normalizeOptionalProperties<ObsidianCdpTransportOptions>({\n    commandTimeoutInMilliseconds: options?.commandTimeoutInMilliseconds,\n    configDirectory: options?.configDirectory,\n    deadBootGraceInMilliseconds: options?.deadBootGraceInMilliseconds,\n    host: options?.host,\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    obsidianInstallerVersion: options?.obsidianInstallerVersion,\n    obsidianVersion: options?.obsidianVersion,\n    port: options?.port,\n    shouldDisableSandbox: options?.shouldDisableSandbox,\n    shouldThrowOnIncompatibleInstaller: options?.shouldThrowOnIncompatibleInstaller,\n    shouldThrowOnSilentAsarFallback: options?.shouldThrowOnSilentAsarFallback,\n    shouldWarnOnCompatibilityIssues: options?.shouldWarnOnCompatibilityIssues,\n    type: 'obsidian-cdp'\n  });\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/**\n * Removes the host-side temp directories earlier runs leaked, before this\n * connection adds its own.\n *\n * `connectToCdp` mints the same `temp-vault-*` / owned `userdata-*` directories\n * the test global setup does, and an ad-hoc debugging session is exactly the\n * kind that gets killed with a leftover behind \u2014 so it sweeps too. Age-gated and\n * best-effort; see the core's `sweepLeftovers`.\n *\n * @param transportOptions - The resolved transport options (source of the sweep knobs).\n */\nasync function sweepLeftovers(transportOptions: ObsidianCdpTransportOptions): Promise<void> {\n  if (!willSweepLeftovers(transportOptions)) {\n    return;\n  }\n\n  try {\n    const result = await sweepHostLeftovers({\n      maxAgeInMilliseconds: resolveLeftoverMaxAgeInMilliseconds(transportOptions)\n    });\n    if (result.removedCount > 0 || result.failedCount > 0) {\n      log(\n        `[connect-to-cdp] Swept ${String(result.removedCount)} leftover temp director(ies) from earlier runs `\n          + `(${String(result.failedCount)} still in use).`\n      );\n    }\n  } catch (error: unknown) {\n    log(`[connect-to-cdp] Leftover sweep error (non-fatal): ${String(error)}`);\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * the base `lib` helpers, `errorToString`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { AsarFallback } from './asar-fallback-detection.mjs';\nimport type { CaptureScreenshotParams } from './capture-screenshot.mjs';\nimport type { ContextId } from './context-id.mjs';\nimport type { ElectronCompatibility } from './electron-compatibility.mjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { InstallerCompatibility } from './installer-compatibility.mjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { ensureHeadlessVaultConfig } from './headless-vault-config.mjs';\nimport {\n  resolveLeftoverMaxAgeInMilliseconds,\n  sweepHostLeftovers,\n  willSweepLeftovers\n} from './leftover-cleanup.mjs';\nimport { log } from './log.mjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.mjs';\nimport { TemporaryVault } from './temporary-vault.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\nimport { resolveOwnedConfigDirectory } from './transport-options.mjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The silent-asar-fallback verdict for an owned instance, read live after boot:\n   * whether the app version it is actually running matches the swapped-in pin, or\n   * the installer silently reverted to its own bundled asar. `undefined` in attach\n   * mode, when no asar was swapped, or when the running version was unreadable. A\n   * `'fallback'` verdict reaches here only when the throw is disabled\n   * ({@link ConnectToCdpOptions.shouldThrowOnSilentAsarFallback} `false`);\n   * otherwise it throws `SilentAsarFallbackError` before the connection is created.\n   */\n  readonly asarFallback?: AsarFallback | undefined;\n\n  /**\n   * Captures a PNG screenshot of this connection's Obsidian window, with the\n   * vault path pre-bound.\n   *\n   * Pass `widthInPixels` + `heightInPixels` to pin the viewport for the duration\n   * of the capture, so the emitted PNG is exactly that size whatever size the\n   * window happens to be.\n   *\n   * @param params - The exact size to capture at. Omit to capture the window at its natural size.\n   * @returns A {@link Promise} that resolves to the raw PNG bytes.\n   */\n  captureScreenshot(params?: Except<CaptureScreenshotParams, 'cwd'>): Promise<Uint8Array>;\n\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * The resolved installer\u2194app compatibility verdict for an owned instance, when\n   * it could be determined. `undefined` in attach mode, or when the verdict is\n   * unknown (undetectable shell version, or the app version is absent from the\n   * table). An `'unrunnable'` verdict reaches here only when the proactive throw\n   * is disabled ({@link ConnectToCdpOptions.shouldThrowOnIncompatibleInstaller}\n   * `false`); otherwise it throws `IncompatibleInstallerVersionError` before the\n   * connection is created.\n   */\n  readonly compatibility?: InstallerCompatibility | undefined;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * The runtime Electron compatibility verdict for an owned instance, read live\n   * after boot: whether the Electron version it is actually running is new enough\n   * for the running app version. `undefined` in attach mode, or when the verdict\n   * is unknown (the live version was unreadable, or the app version carries no\n   * recommended Electron version). An old Electron never blocks \u2014 it only warns \u2014\n   * so unlike {@link compatibility} there is no throwing tier.\n   */\n  readonly electronCompatibility?: ElectronCompatibility | undefined;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, lib, obsidianModule, context }` plus any `input`\n   * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). Mirrors\n   * the top-level `evalInObsidian`, with the transport and vault path pre-bound\n   * to this connection.\n   *\n   * @param params - The evaluation parameters (`callback`, optional `input`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `callback`.\n   */\n  evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Input, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TemporaryVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * A test's closure travels as one `Runtime.evaluate` command, so this is also\n   * the desktop per-eval cap. The default is `DEFAULT_EVAL_CAP_IN_MILLISECONDS`,\n   * exported from the package root \u2014 import it rather than restating the number,\n   * so a closure sized against the cap follows it if it ever moves.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * The vault's **config folder** \u2014 Obsidian's per-vault *Override config\n   * folder* setting, e.g. `'.obsidian-desktop'`. Set it to open a vault that\n   * keeps its settings somewhere other than `.obsidian`; without it such a vault\n   * opens against `.obsidian`, which for a vault that has a stale one beside the\n   * real folder means opening successfully against the wrong settings.\n   *\n   * Must start with a dot, must not be the bare dot, and must not contain a path\n   * separator \u2014 anything else throws before Obsidian launches, since Obsidian\n   * would silently substitute `.obsidian`. After the vault opens, its actual\n   * `app.vault.configDir` is read back and a mismatch throws\n   * `ConfigDirectoryFallbackError`.\n   *\n   * Ignored in attach mode ({@link ConnectToCdpOptions.port} set), where the\n   * vault is opened by the user's own Obsidian under its own config.\n   *\n   * @default `undefined` (Obsidian's own default, `.obsidian`)\n   */\n  readonly configDirectory?: string;\n\n  /**\n   * Grace window in milliseconds for fast-failing a dead boot of the owned\n   * instance \u2014 the renderer loaded but the app never bootstrapped (empty\n   * `<body>`, no `window.app`), the terminal state when the asar cannot run on\n   * the launched Electron shell. Once it has held this long a\n   * `RendererFailedToInitializeError` is thrown instead of waiting out the full\n   * readiness timeout. Ignored in attach mode ({@link port} set). Set `0` to\n   * disable fast-fail.\n   *\n   * @default `10000`\n   */\n  readonly deadBootGraceInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Whether the Obsidian window is shown on screen. Defaults to `true`; set\n   * `false` to launch it off-screen.\n   * Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to launch the owned instance with Chromium's sandbox disabled\n   * (`--no-sandbox`).\n   *\n   * Needed to boot on Linux without a correctly-configured setuid\n   * `chrome-sandbox` helper (e.g. an installer-extracted portable shell, or CI\n   * running as a non-root user); harmless on Windows/macOS. Ignored in attach\n   * mode ({@link port} set).\n   *\n   * @default `false`\n   */\n  readonly shouldDisableSandbox?: boolean;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Whether an **unrunnable** installer\u2194app version pair fails fast before launch.\n   *\n   * When `true` (the default), an installer below the app's run floor throws\n   * `IncompatibleInstallerVersionError` from version resolution before anything is\n   * downloaded or launched. Set `false` to let the pin proceed to launch \u2014 where\n   * the reactive dead-boot fast-fail still catches the black-screen boot, and the\n   * `'unrunnable'` verdict is surfaced on {@link CdpConnection.compatibility}\n   * rather than thrown. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnIncompatibleInstaller?: boolean;\n\n  /**\n   * Whether a post-boot **silent asar fallback** fails fast.\n   *\n   * When an asar is swapped onto an installer shell too old for it, the instance\n   * may silently revert to the installer's own bundled asar and run the **wrong\n   * (older)** version behind a healthy UI. When `true` (the default), the running\n   * app version is verified against the pin post-boot and a mismatch throws\n   * `SilentAsarFallbackError`. Set `false` to let the boot proceed \u2014 the mismatch\n   * is then surfaced on {@link CdpConnection.asarFallback} rather than thrown.\n   * Ignored in attach mode ({@link port} set) and when no asar is swapped.\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnSilentAsarFallback?: boolean;\n\n  /**\n   * Whether the owned-instance compatibility **nag warnings** are emitted.\n   *\n   * Covers both the offline installer\u2194app warning and the post-boot\n   * runtime-Electron warning. When `true` (the default) each fires via the harness\n   * log; set `false` to silence both \u2014 the verdicts are still surfaced on\n   * {@link CdpConnection.compatibility} / {@link CdpConnection.electronCompatibility},\n   * only the log is suppressed. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldWarnOnCompatibilityIssues?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transportOptions = buildCdpTransportOptions(options);\n  await sweepLeftovers(transportOptions);\n  const transport = await createTransportFromOptions(transportOptions);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n  const vault = new TemporaryVault(options?.vault, { shouldRemoveDirectoryOnDispose: shouldRemoveVaultOnDispose });\n\n  // The headless defaults go only into a vault the harness made \u2014 the same\n  // `options.vault === undefined` discriminator the disposal above turns on. A\n  // Caller-supplied vault is a real one the user keeps, and a debugging session\n  // Has no business rewriting its settings.\n  if (options?.vault === undefined) {\n    await ensureHeadlessVaultConfig({\n      configDirectory: resolveOwnedConfigDirectory(transportOptions),\n      label: transportOptions.type,\n      vaultPath: vault.path\n    });\n  }\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n  const asarFallback = transport instanceof DesktopCdpTransport ? transport.getAsarFallback() : undefined;\n  const compatibility = transport instanceof DesktopCdpTransport ? transport.getCompatibility() : undefined;\n  const electronCompatibility = transport instanceof DesktopCdpTransport ? transport.getElectronCompatibility() : undefined;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n    ...(asarFallback && { asarFallback }),\n    ...(compatibility && { compatibility }),\n    ...(electronCompatibility && { electronCompatibility }),\n\n    async captureScreenshot(params?: Except<CaptureScreenshotParams, 'cwd'>): Promise<Uint8Array> {\n      // Every transport `connectToCdp` builds is a DesktopCdpTransport, which\n      // Implements the optional method \u2014 but the interface still types it\n      // Optional, so the absence is reported rather than silently thrown at.\n      if (!transport.captureScreenshot) {\n        throw new Error('connectToCdp: this transport cannot capture screenshots.');\n      }\n\n      return transport.captureScreenshot({ ...params, cwd: vault.path });\n    },\n\n    async dispose(): Promise<void> {\n      try {\n        // The vault carries `shouldRemoveVaultOnDispose` itself (handed to its constructor above), so\n        // This is one call rather than a branch: it always unregisters, and removes the directory only\n        // When that flag says to.\n        await vault.dispose(transport);\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Input, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Input, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Builds the {@link ObsidianCdpTransportOptions} for a connection, threading only\n * the provided {@link ConnectToCdpOptions} through (owned-visible defaults to\n * `true`, unlike the hidden-by-default test transports). Unset knobs pass through\n * as `undefined` and are read with `?? default` / `!== undefined` guards\n * downstream, so an explicit `undefined` is indistinguishable from an absent key.\n *\n * @param options - The connection options.\n * @returns The transport options to create the connection's transport from.\n */\nfunction buildCdpTransportOptions(options?: ConnectToCdpOptions): ObsidianCdpTransportOptions {\n  return normalizeOptionalProperties<ObsidianCdpTransportOptions>({\n    commandTimeoutInMilliseconds: options?.commandTimeoutInMilliseconds,\n    configDirectory: options?.configDirectory,\n    deadBootGraceInMilliseconds: options?.deadBootGraceInMilliseconds,\n    host: options?.host,\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    obsidianInstallerVersion: options?.obsidianInstallerVersion,\n    obsidianVersion: options?.obsidianVersion,\n    port: options?.port,\n    shouldDisableSandbox: options?.shouldDisableSandbox,\n    shouldThrowOnIncompatibleInstaller: options?.shouldThrowOnIncompatibleInstaller,\n    shouldThrowOnSilentAsarFallback: options?.shouldThrowOnSilentAsarFallback,\n    shouldWarnOnCompatibilityIssues: options?.shouldWarnOnCompatibilityIssues,\n    type: 'obsidian-cdp'\n  });\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/**\n * Removes the host-side temp directories earlier runs leaked, before this\n * connection adds its own.\n *\n * `connectToCdp` mints the same `temp-vault-*` / owned `userdata-*` directories\n * the test global setup does, and an ad-hoc debugging session is exactly the\n * kind that gets killed with a leftover behind \u2014 so it sweeps too. Age-gated and\n * best-effort; see the core's `sweepLeftovers`.\n *\n * @param transportOptions - The resolved transport options (source of the sweep knobs).\n */\nasync function sweepLeftovers(transportOptions: ObsidianCdpTransportOptions): Promise<void> {\n  if (!willSweepLeftovers(transportOptions)) {\n    return;\n  }\n\n  try {\n    const result = await sweepHostLeftovers({\n      maxAgeInMilliseconds: resolveLeftoverMaxAgeInMilliseconds(transportOptions)\n    });\n    if (result.removedCount > 0 || result.failedCount > 0) {\n      log(\n        `[connect-to-cdp] Swept ${String(result.removedCount)} leftover temp director(ies) from earlier runs `\n          + `(${String(result.failedCount)} still in use).`\n      );\n    }\n  } catch (error: unknown) {\n    log(`[connect-to-cdp] Leftover sweep error (non-fatal): ${String(error)}`);\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AA4BA,SAAS,sBAAsB;AAC/B,SAAS,iCAAiC;AAC1C;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,WAAW;AACpB,SAAS,mCAAmC;AAC5C,SAAS,sBAAsB;AAC/B,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAC3C,SAAS,mCAAmC;AAE5C,MAAM,mBAAmB;AA8RzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,mBAAmB,yBAAyB,OAAO;AACzD,QAAM,eAAe,gBAAgB;AACrC,QAAM,YAAY,MAAM,2BAA2B,gBAAgB;AACnE,QAAM,6BAA6B,SAAS,8BAA+B,SAAS,UAAU;AAC9F,QAAM,QAAQ,IAAI,eAAe,SAAS,OAAO,EAAE,gCAAgC,2BAA2B,CAAC;AAM/G,MAAI,SAAS,UAAU,QAAW;AAChC,UAAM,0BAA0B;AAAA,MAC9B,iBAAiB,4BAA4B,gBAAgB;AAAA,MAC7D,OAAO,iBAAiB;AAAA,MACxB,WAAW,MAAM;AAAA,IACnB,CAAC;AAAA,EACH;AAKA,QAAM,MAAM,SAAS,SAAS;AAE9B,QAAM,EAAE,MAAM,KAAK,IAAI,gBAAgB,WAAW,OAAO;AACzD,QAAM,SAAS,UAAU,IAAI,IAAI,OAAO,IAAI,CAAC;AAC7C,QAAM,eAAe,qBAAqB,sBAAsB,UAAU,gBAAgB,IAAI;AAC9F,QAAM,gBAAgB,qBAAqB,sBAAsB,UAAU,iBAAiB,IAAI;AAChG,QAAM,wBAAwB,qBAAqB,sBAAsB,UAAU,yBAAyB,IAAI;AAEhH,QAAM,aAA4B;AAAA,IAChC;AAAA,IACA,GAAI,gBAAgB,EAAE,aAAa;AAAA,IACnC,GAAI,iBAAiB,EAAE,cAAc;AAAA,IACrC,GAAI,yBAAyB,EAAE,sBAAsB;AAAA,IAErD,MAAM,kBAAkB,QAAsE;AAI5F,UAAI,CAAC,UAAU,mBAAmB;AAChC,cAAM,IAAI,MAAM,0DAA0D;AAAA,MAC5E;AAEA,aAAO,UAAU,kBAAkB,EAAE,GAAG,QAAQ,KAAK,MAAM,KAAK,CAAC;AAAA,IACnE;AAAA,IAEA,MAAM,UAAyB;AAC7B,UAAI;AAIF,cAAM,MAAM,QAAQ,SAAS;AAAA,MAC/B,UAAE;AACA,cAAM,UAAU,UAAU;AAAA,MAC5B;AAAA,IACF;AAAA,IAEA,MAAM,eACJ,QACiB;AACjB,aAAO,eAA0C,EAAE,GAAG,QAAQ,WAAW,WAAW,MAAM,KAAK,CAAC;AAAA,IAClG;AAAA,IAEA,MAAM,OAAO,YAAqC;AAChD,aAAO,UAAU,SAAS,YAAY,EAAE,KAAK,MAAM,KAAK,CAAC;AAAA,IAC3D;AAAA,IAEA;AAAA,IAEA,OAAO,OAAO,YAAY,IAAmB;AAC3C,YAAM,WAAW,QAAQ;AAAA,IAC3B;AAAA,IAEA;AAAA,EACF;AAEA,SAAO;AACT;AAYA,SAAS,yBAAyB,SAA4D;AAC5F,SAAO,4BAAyD;AAAA,IAC9D,8BAA8B,SAAS;AAAA,IACvC,iBAAiB,SAAS;AAAA,IAC1B,6BAA6B,SAAS;AAAA,IACtC,MAAM,SAAS;AAAA,IACf,sBAAsB,SAAS,wBAAwB;AAAA,IACvD,0BAA0B,SAAS;AAAA,IACnC,iBAAiB,SAAS;AAAA,IAC1B,MAAM,SAAS;AAAA,IACf,sBAAsB,SAAS;AAAA,IAC/B,oCAAoC,SAAS;AAAA,IAC7C,iCAAiC,SAAS;AAAA,IAC1C,iCAAiC,SAAS;AAAA,IAC1C,MAAM;AAAA,EACR,CAAC;AACH;AAWA,SAAS,gBAAgB,WAAoB,SAA4D;AACvG,MAAI,qBAAqB,qBAAqB;AAC5C,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,aAAO,EAAE,MAAM,SAAS,MAAM,MAAM,SAAS,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,MAAI,SAAS,SAAS,QAAW;AAC/B,WAAO,EAAE,MAAM,QAAQ,QAAQ,kBAAkB,MAAM,QAAQ,KAAK;AAAA,EACtE;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;AAaA,eAAe,eAAe,kBAA8D;AAC1F,MAAI,CAAC,mBAAmB,gBAAgB,GAAG;AACzC;AAAA,EACF;AAEA,MAAI;AACF,UAAM,SAAS,MAAM,mBAAmB;AAAA,MACtC,sBAAsB,oCAAoC,gBAAgB;AAAA,IAC5E,CAAC;AACD,QAAI,OAAO,eAAe,KAAK,OAAO,cAAc,GAAG;AACrD;AAAA,QACE,0BAA0B,OAAO,OAAO,YAAY,CAAC,mDAC7C,OAAO,OAAO,WAAW,CAAC;AAAA,MACpC;AAAA,IACF;AAAA,EACF,SAAS,OAAgB;AACvB,QAAI,sDAAsD,OAAO,KAAK,CAAC,EAAE;AAAA,EAC3E;AACF;",
  "names": []
}
