obsidian-integration-testing 9.2.2 → 10.0.0

package/dist/lib/cjs/compatibility-options.cjs

@@ -20,9 +20,9 @@ var compatibility_options_exports = {};
 __export(compatibility_options_exports, {
   resolveAsarFallbackAction: () => resolveAsarFallbackAction,
   resolveInstallerCompatibilityAction: () => resolveInstallerCompatibilityAction,
-  resolveShouldThrowOnIncompatibleInstaller: () => resolveShouldThrowOnIncompatibleInstaller,
-  resolveShouldThrowOnSilentAsarFallback: () => resolveShouldThrowOnSilentAsarFallback,
-  resolveShouldWarnOnCompatibilityIssues: () => resolveShouldWarnOnCompatibilityIssues
+  willThrowOnIncompatibleInstaller: () => willThrowOnIncompatibleInstaller,
+  willThrowOnSilentAsarFallback: () => willThrowOnSilentAsarFallback,
+  willWarnOnCompatibilityIssues: () => willWarnOnCompatibilityIssues
 });
 module.exports = __toCommonJS(compatibility_options_exports);
 function resolveAsarFallbackAction(params) {
@@ -48,21 +48,21 @@ function resolveInstallerCompatibilityAction(params) {
   }
   return "silent";
 }
-function resolveShouldThrowOnIncompatibleInstaller(shouldThrowOnIncompatibleInstaller) {
-  return shouldThrowOnIncompatibleInstaller ?? true;
+function willThrowOnIncompatibleInstaller(shouldThrow) {
+  return shouldThrow ?? true;
 }
-function resolveShouldThrowOnSilentAsarFallback(shouldThrowOnSilentAsarFallback) {
-  return shouldThrowOnSilentAsarFallback ?? true;
+function willThrowOnSilentAsarFallback(shouldThrow) {
+  return shouldThrow ?? true;
 }
-function resolveShouldWarnOnCompatibilityIssues(shouldWarnOnCompatibilityIssues) {
-  return shouldWarnOnCompatibilityIssues ?? true;
+function willWarnOnCompatibilityIssues(shouldWarn) {
+  return shouldWarn ?? true;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   resolveAsarFallbackAction,
   resolveInstallerCompatibilityAction,
-  resolveShouldThrowOnIncompatibleInstaller,
-  resolveShouldThrowOnSilentAsarFallback,
-  resolveShouldWarnOnCompatibilityIssues
+  willThrowOnIncompatibleInstaller,
+  willThrowOnSilentAsarFallback,
+  willWarnOnCompatibilityIssues
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/compatibility-options.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure resolution of the two owned-instance compatibility knobs \u2014 whether the\n * installer\u2194app / runtime-Electron nag warnings are emitted, and whether an\n * `'unrunnable'` installer\u2194app pair fails fast with\n * {@link IncompatibleInstallerVersionError} before launch.\n *\n * Both default to today's behavior (`true`): warnings on, and an unrunnable pin\n * throws proactively. Setting `shouldWarnOnCompatibilityIssues` to `false`\n * silences both nags (the verdicts are still computed and surfaced as data);\n * setting `shouldThrowOnIncompatibleInstaller` to `false` lets an unrunnable pin\n * proceed to launch, where the reactive dead-boot fast-fail\n * (`RendererFailedToInitializeError`) still catches it.\n *\n * Kept separate from the integration-only launch code (`transport-factory`,\n * `transport-desktop-cdp`, both excluded from unit tests) so the default\n * resolution stays unit-testable \u2014 mirroring the `visibility.ts` /\n * `appium-session-config.ts` pure-resolver split.\n */\n\nimport type { AsarFallbackTier } from './asar-fallback-detection.cjs';\nimport type { InstallerCompatibilityTier } from './installer-compatibility.cjs';\n\n/**\n * The action to take for a resolved silent-asar-fallback verdict, given the\n * throw/warn knobs.\n *\n * - `'throw'` \u2014 the verdict is `'fallback'` and the throw is enabled; the caller\n *   throws `SilentAsarFallbackError`.\n * - `'warn'` \u2014 the verdict is `'fallback'` but the throw is disabled and warnings\n *   are on; the caller logs the fallback warning and lets the boot proceed (the\n *   verdict is still surfaced as data).\n * - `'silent'` \u2014 nothing to do (`'match'` / `'unknown'`, or a suppressed fallback).\n */\nexport type AsarFallbackAction = 'silent' | 'throw' | 'warn';\n\n/**\n * The action to take for a resolved installer\u2194app compatibility verdict, given\n * the throw/warn knobs.\n *\n * - `'throw'` \u2014 the verdict is `'unrunnable'` and the proactive throw is enabled;\n *   the caller throws `IncompatibleInstallerVersionError` before launch.\n * - `'warn-unrunnable'` \u2014 the verdict is `'unrunnable'` but the throw is disabled\n *   and warnings are on; the caller logs a \"proceeding to launch\" warning and\n *   lets the boot proceed (where the reactive dead-boot fast-fail catches it).\n * - `'warn-nagged'` \u2014 the verdict is `'nagged'` and warnings are on; the caller\n *   logs the recommended-installer warning.\n * - `'silent'` \u2014 nothing to do (`'ok'` / `'unknown'`, or warnings disabled).\n */\nexport type InstallerCompatibilityAction = 'silent' | 'throw' | 'warn-nagged' | 'warn-unrunnable';\n\n/**\n * Parameters for {@link resolveAsarFallbackAction}.\n */\nexport interface ResolveAsarFallbackActionParams {\n  /** Whether a `'fallback'` verdict throws (vs. proceeds with a warning). */\n  readonly shouldThrowOnSilentAsarFallback: boolean;\n\n  /** Whether a non-throwing fallback verdict is logged. */\n  readonly shouldWarnOnCompatibilityIssues: boolean;\n\n  /** The resolved silent-asar-fallback tier. */\n  readonly tier: AsarFallbackTier;\n}\n\n/**\n * Parameters for {@link resolveInstallerCompatibilityAction}.\n */\nexport interface ResolveInstallerCompatibilityActionParams {\n  /** Whether an `'unrunnable'` verdict throws (vs. proceeds to launch). */\n  readonly shouldThrowOnIncompatibleInstaller: boolean;\n\n  /** Whether a nag / proceeding-unrunnable verdict is logged. */\n  readonly shouldWarnOnCompatibilityIssues: boolean;\n\n  /** The resolved installer\u2194app compatibility tier. */\n  readonly tier: InstallerCompatibilityTier;\n}\n\n/**\n * Resolves what to do for a silent-asar-fallback verdict, given the throw/warn\n * knobs. Pure \u2014 the caller performs the throw/log side effects.\n *\n * @param params - The verdict tier and the resolved throw/warn knobs.\n * @returns The action the caller should take.\n */\nexport function resolveAsarFallbackAction(params: ResolveAsarFallbackActionParams): AsarFallbackAction {\n  const { shouldThrowOnSilentAsarFallback, shouldWarnOnCompatibilityIssues, tier } = params;\n\n  if (tier !== 'fallback') {\n    return 'silent';\n  }\n\n  if (shouldThrowOnSilentAsarFallback) {\n    return 'throw';\n  }\n\n  return shouldWarnOnCompatibilityIssues ? 'warn' : 'silent';\n}\n\n/**\n * Resolves what to do for an installer\u2194app compatibility verdict, given the\n * throw/warn knobs. Pure \u2014 the caller performs the throw/log side effects.\n *\n * @param params - The verdict tier and the resolved throw/warn knobs.\n * @returns The action the caller should take.\n */\nexport function resolveInstallerCompatibilityAction(params: ResolveInstallerCompatibilityActionParams): InstallerCompatibilityAction {\n  const { shouldThrowOnIncompatibleInstaller, shouldWarnOnCompatibilityIssues, tier } = params;\n\n  if (tier === 'unrunnable') {\n    if (shouldThrowOnIncompatibleInstaller) {\n      return 'throw';\n    }\n\n    return shouldWarnOnCompatibilityIssues ? 'warn-unrunnable' : 'silent';\n  }\n\n  if (tier === 'nagged') {\n    return shouldWarnOnCompatibilityIssues ? 'warn-nagged' : 'silent';\n  }\n\n  return 'silent';\n}\n\n/**\n * Whether an `'unrunnable'` installer\u2194app pair should fail fast with\n * {@link IncompatibleInstallerVersionError} before launch.\n *\n * @param shouldThrowOnIncompatibleInstaller - The resolved option value (omitted \u2192 throw).\n * @returns `true` when an unrunnable pin should throw (the default).\n */\nexport function resolveShouldThrowOnIncompatibleInstaller(shouldThrowOnIncompatibleInstaller?: boolean): boolean {\n  return shouldThrowOnIncompatibleInstaller ?? true;\n}\n\n/**\n * Whether a booted owned instance running a different app (asar) version than the\n * pin \u2014 a silent fallback to the installer's own bundled asar \u2014 should fail fast\n * with {@link SilentAsarFallbackError}.\n *\n * @param shouldThrowOnSilentAsarFallback - The resolved option value (omitted \u2192 throw).\n * @returns `true` when a silent fallback should throw (the default).\n */\nexport function resolveShouldThrowOnSilentAsarFallback(shouldThrowOnSilentAsarFallback?: boolean): boolean {\n  return shouldThrowOnSilentAsarFallback ?? true;\n}\n\n/**\n * Whether the owned-instance compatibility nag warnings should be emitted (both\n * the installer\u2194app `'nagged'` warning and the runtime-Electron `'nagged'`\n * warning).\n *\n * @param shouldWarnOnCompatibilityIssues - The resolved option value (omitted \u2192 warn).\n * @returns `true` when the warnings should be emitted (the default).\n */\nexport function resolveShouldWarnOnCompatibilityIssues(shouldWarnOnCompatibilityIssues?: boolean): boolean {\n  return shouldWarnOnCompatibilityIssues ?? true;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuFO,SAAS,0BAA0B,QAA6D;AACrG,QAAM,EAAE,iCAAiC,iCAAiC,KAAK,IAAI;AAEnF,MAAI,SAAS,YAAY;AACvB,WAAO;AAAA,EACT;AAEA,MAAI,iCAAiC;AACnC,WAAO;AAAA,EACT;AAEA,SAAO,kCAAkC,SAAS;AACpD;AASO,SAAS,oCAAoC,QAAiF;AACnI,QAAM,EAAE,oCAAoC,iCAAiC,KAAK,IAAI;AAEtF,MAAI,SAAS,cAAc;AACzB,QAAI,oCAAoC;AACtC,aAAO;AAAA,IACT;AAEA,WAAO,kCAAkC,oBAAoB;AAAA,EAC/D;AAEA,MAAI,SAAS,UAAU;AACrB,WAAO,kCAAkC,gBAAgB;AAAA,EAC3D;AAEA,SAAO;AACT;AASO,SAAS,0CAA0C,oCAAuD;AAC/G,SAAO,sCAAsC;AAC/C;AAUO,SAAS,uCAAuC,iCAAoD;AACzG,SAAO,mCAAmC;AAC5C;AAUO,SAAS,uCAAuC,iCAAoD;AACzG,SAAO,mCAAmC;AAC5C;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/compatibility-options.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure resolution of the two owned-instance compatibility knobs \u2014 whether the\n * installer\u2194app / runtime-Electron nag warnings are emitted, and whether an\n * `'unrunnable'` installer\u2194app pair fails fast with\n * {@link IncompatibleInstallerVersionError} before launch.\n *\n * Both default to today's behavior (`true`): warnings on, and an unrunnable pin\n * throws proactively. Setting `shouldWarnOnCompatibilityIssues` to `false`\n * silences both nags (the verdicts are still computed and surfaced as data);\n * setting `shouldThrowOnIncompatibleInstaller` to `false` lets an unrunnable pin\n * proceed to launch, where the reactive dead-boot fast-fail\n * (`RendererFailedToInitializeError`) still catches it.\n *\n * Kept separate from the integration-only launch code (`transport-factory`,\n * `transport-desktop-cdp`, both excluded from unit tests) so the default\n * resolution stays unit-testable \u2014 mirroring the `visibility.ts` /\n * `appium-session-config.ts` pure-resolver split.\n */\n\nimport type { AsarFallbackTier } from './asar-fallback-detection.cjs';\nimport type { InstallerCompatibilityTier } from './installer-compatibility.cjs';\n\n/**\n * The action to take for a resolved silent-asar-fallback verdict, given the\n * throw/warn knobs.\n *\n * - `'throw'` \u2014 the verdict is `'fallback'` and the throw is enabled; the caller\n *   throws `SilentAsarFallbackError`.\n * - `'warn'` \u2014 the verdict is `'fallback'` but the throw is disabled and warnings\n *   are on; the caller logs the fallback warning and lets the boot proceed (the\n *   verdict is still surfaced as data).\n * - `'silent'` \u2014 nothing to do (`'match'` / `'unknown'`, or a suppressed fallback).\n */\nexport type AsarFallbackAction = 'silent' | 'throw' | 'warn';\n\n/**\n * The action to take for a resolved installer\u2194app compatibility verdict, given\n * the throw/warn knobs.\n *\n * - `'throw'` \u2014 the verdict is `'unrunnable'` and the proactive throw is enabled;\n *   the caller throws `IncompatibleInstallerVersionError` before launch.\n * - `'warn-unrunnable'` \u2014 the verdict is `'unrunnable'` but the throw is disabled\n *   and warnings are on; the caller logs a \"proceeding to launch\" warning and\n *   lets the boot proceed (where the reactive dead-boot fast-fail catches it).\n * - `'warn-nagged'` \u2014 the verdict is `'nagged'` and warnings are on; the caller\n *   logs the recommended-installer warning.\n * - `'silent'` \u2014 nothing to do (`'ok'` / `'unknown'`, or warnings disabled).\n */\nexport type InstallerCompatibilityAction = 'silent' | 'throw' | 'warn-nagged' | 'warn-unrunnable';\n\n/**\n * Parameters for {@link resolveAsarFallbackAction}.\n */\nexport interface ResolveAsarFallbackActionParams {\n  /**\n  Whether a `'fallback'` verdict throws (vs. proceeds with a warning).\n   */\n  readonly shouldThrowOnSilentAsarFallback: boolean;\n\n  /**\n  Whether a non-throwing fallback verdict is logged.\n   */\n  readonly shouldWarnOnCompatibilityIssues: boolean;\n\n  /**\n  The resolved silent-asar-fallback tier.\n   */\n  readonly tier: AsarFallbackTier;\n}\n\n/**\n * Parameters for {@link resolveInstallerCompatibilityAction}.\n */\nexport interface ResolveInstallerCompatibilityActionParams {\n  /**\n  Whether an `'unrunnable'` verdict throws (vs. proceeds to launch).\n   */\n  readonly shouldThrowOnIncompatibleInstaller: boolean;\n\n  /**\n  Whether a nag / proceeding-unrunnable verdict is logged.\n   */\n  readonly shouldWarnOnCompatibilityIssues: boolean;\n\n  /**\n  The resolved installer\u2194app compatibility tier.\n   */\n  readonly tier: InstallerCompatibilityTier;\n}\n\n/**\n * Resolves what to do for a silent-asar-fallback verdict, given the throw/warn\n * knobs. Pure \u2014 the caller performs the throw/log side effects.\n *\n * @param params - The verdict tier and the resolved throw/warn knobs.\n * @returns The action the caller should take.\n */\nexport function resolveAsarFallbackAction(params: ResolveAsarFallbackActionParams): AsarFallbackAction {\n  const { shouldThrowOnSilentAsarFallback, shouldWarnOnCompatibilityIssues, tier } = params;\n\n  if (tier !== 'fallback') {\n    return 'silent';\n  }\n\n  if (shouldThrowOnSilentAsarFallback) {\n    return 'throw';\n  }\n\n  return shouldWarnOnCompatibilityIssues ? 'warn' : 'silent';\n}\n\n/**\n * Resolves what to do for an installer\u2194app compatibility verdict, given the\n * throw/warn knobs. Pure \u2014 the caller performs the throw/log side effects.\n *\n * @param params - The verdict tier and the resolved throw/warn knobs.\n * @returns The action the caller should take.\n */\nexport function resolveInstallerCompatibilityAction(params: ResolveInstallerCompatibilityActionParams): InstallerCompatibilityAction {\n  const { shouldThrowOnIncompatibleInstaller, shouldWarnOnCompatibilityIssues, tier } = params;\n\n  if (tier === 'unrunnable') {\n    if (shouldThrowOnIncompatibleInstaller) {\n      return 'throw';\n    }\n\n    return shouldWarnOnCompatibilityIssues ? 'warn-unrunnable' : 'silent';\n  }\n\n  if (tier === 'nagged') {\n    return shouldWarnOnCompatibilityIssues ? 'warn-nagged' : 'silent';\n  }\n\n  return 'silent';\n}\n\n/**\n * Whether an `'unrunnable'` installer\u2194app pair should fail fast with\n * {@link IncompatibleInstallerVersionError} before launch.\n *\n * @param shouldThrow - The configured option value (omitted \u2192 throw).\n * @returns `true` when an unrunnable pin should throw (the default).\n */\nexport function willThrowOnIncompatibleInstaller(shouldThrow?: boolean): boolean {\n  return shouldThrow ?? true;\n}\n\n/**\n * Whether a booted owned instance running a different app (asar) version than the\n * pin \u2014 a silent fallback to the installer's own bundled asar \u2014 should fail fast\n * with {@link SilentAsarFallbackError}.\n *\n * @param shouldThrow - The configured option value (omitted \u2192 throw).\n * @returns `true` when a silent fallback should throw (the default).\n */\nexport function willThrowOnSilentAsarFallback(shouldThrow?: boolean): boolean {\n  return shouldThrow ?? true;\n}\n\n/**\n * Whether the owned-instance compatibility nag warnings should be emitted (both\n * the installer\u2194app `'nagged'` warning and the runtime-Electron `'nagged'`\n * warning).\n *\n * @param shouldWarn - The configured option value (omitted \u2192 warn).\n * @returns `true` when the warnings should be emitted (the default).\n */\nexport function willWarnOnCompatibilityIssues(shouldWarn?: boolean): boolean {\n  return shouldWarn ?? true;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmGO,SAAS,0BAA0B,QAA6D;AACrG,QAAM,EAAE,iCAAiC,iCAAiC,KAAK,IAAI;AAEnF,MAAI,SAAS,YAAY;AACvB,WAAO;AAAA,EACT;AAEA,MAAI,iCAAiC;AACnC,WAAO;AAAA,EACT;AAEA,SAAO,kCAAkC,SAAS;AACpD;AASO,SAAS,oCAAoC,QAAiF;AACnI,QAAM,EAAE,oCAAoC,iCAAiC,KAAK,IAAI;AAEtF,MAAI,SAAS,cAAc;AACzB,QAAI,oCAAoC;AACtC,aAAO;AAAA,IACT;AAEA,WAAO,kCAAkC,oBAAoB;AAAA,EAC/D;AAEA,MAAI,SAAS,UAAU;AACrB,WAAO,kCAAkC,gBAAgB;AAAA,EAC3D;AAEA,SAAO;AACT;AASO,SAAS,iCAAiC,aAAgC;AAC/E,SAAO,eAAe;AACxB;AAUO,SAAS,8BAA8B,aAAgC;AAC5E,SAAO,eAAe;AACxB;AAUO,SAAS,8BAA8B,YAA+B;AAC3E,SAAO,cAAc;AACvB;",
  "names": []
}


package/dist/lib/cjs/compatibility-options.d.cts

@@ -50,22 +50,34 @@ export type InstallerCompatibilityAction = 'silent' | 'throw' | 'warn-nagged' |
  * Parameters for {@link resolveAsarFallbackAction}.
  */
 export interface ResolveAsarFallbackActionParams {
-    /** Whether a `'fallback'` verdict throws (vs. proceeds with a warning). */
+    /**
+    Whether a `'fallback'` verdict throws (vs. proceeds with a warning).
+     */
     readonly shouldThrowOnSilentAsarFallback: boolean;
-    /** Whether a non-throwing fallback verdict is logged. */
+    /**
+    Whether a non-throwing fallback verdict is logged.
+     */
     readonly shouldWarnOnCompatibilityIssues: boolean;
-    /** The resolved silent-asar-fallback tier. */
+    /**
+    The resolved silent-asar-fallback tier.
+     */
     readonly tier: AsarFallbackTier;
 }
 /**
  * Parameters for {@link resolveInstallerCompatibilityAction}.
  */
 export interface ResolveInstallerCompatibilityActionParams {
-    /** Whether an `'unrunnable'` verdict throws (vs. proceeds to launch). */
+    /**
+    Whether an `'unrunnable'` verdict throws (vs. proceeds to launch).
+     */
     readonly shouldThrowOnIncompatibleInstaller: boolean;
-    /** Whether a nag / proceeding-unrunnable verdict is logged. */
+    /**
+    Whether a nag / proceeding-unrunnable verdict is logged.
+     */
     readonly shouldWarnOnCompatibilityIssues: boolean;
-    /** The resolved installer↔app compatibility tier. */
+    /**
+    The resolved installer↔app compatibility tier.
+     */
     readonly tier: InstallerCompatibilityTier;
 }
 /**
@@ -88,25 +100,25 @@ export declare function resolveInstallerCompatibilityAction(params: ResolveInsta
  * Whether an `'unrunnable'` installer↔app pair should fail fast with
  * {@link IncompatibleInstallerVersionError} before launch.
  *
- * @param shouldThrowOnIncompatibleInstaller - The resolved option value (omitted → throw).
+ * @param shouldThrow - The configured option value (omitted → throw).
  * @returns `true` when an unrunnable pin should throw (the default).
  */
-export declare function resolveShouldThrowOnIncompatibleInstaller(shouldThrowOnIncompatibleInstaller?: boolean): boolean;
+export declare function willThrowOnIncompatibleInstaller(shouldThrow?: boolean): boolean;
 /**
  * Whether a booted owned instance running a different app (asar) version than the
  * pin — a silent fallback to the installer's own bundled asar — should fail fast
  * with {@link SilentAsarFallbackError}.
  *
- * @param shouldThrowOnSilentAsarFallback - The resolved option value (omitted → throw).
+ * @param shouldThrow - The configured option value (omitted → throw).
  * @returns `true` when a silent fallback should throw (the default).
  */
-export declare function resolveShouldThrowOnSilentAsarFallback(shouldThrowOnSilentAsarFallback?: boolean): boolean;
+export declare function willThrowOnSilentAsarFallback(shouldThrow?: boolean): boolean;
 /**
  * Whether the owned-instance compatibility nag warnings should be emitted (both
  * the installer↔app `'nagged'` warning and the runtime-Electron `'nagged'`
  * warning).
  *
- * @param shouldWarnOnCompatibilityIssues - The resolved option value (omitted → warn).
+ * @param shouldWarn - The configured option value (omitted → warn).
  * @returns `true` when the warnings should be emitted (the default).
  */
-export declare function resolveShouldWarnOnCompatibilityIssues(shouldWarnOnCompatibilityIssues?: boolean): boolean;
+export declare function willWarnOnCompatibilityIssues(shouldWarn?: boolean): boolean;

package/dist/lib/cjs/connect-to-cdp.cjs

@@ -25,7 +25,7 @@ var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
 var import_leftover_cleanup = require("./leftover-cleanup.cjs");
 var import_log = require("./log.cjs");
 var import_normalize_optional_properties = require("./normalize-optional-properties.cjs");
-var import_temp_vault = require("./temp-vault.cjs");
+var import_temporary_vault = require("./temporary-vault.cjs");
 var import_transport_desktop_cdp = require("./transport-desktop-cdp.cjs");
 var import_transport_factory = require("./transport-factory.cjs");
 const DEFAULT_CDP_HOST = "localhost";
@@ -33,7 +33,7 @@ async function connectToCdp(options) {
   const transportOptions = buildCdpTransportOptions(options);
   await sweepLeftovers(transportOptions);
   const transport = await (0, import_transport_factory.createTransportFromOptions)(transportOptions);
-  const vault = new import_temp_vault.TempVault(options?.vault);
+  const vault = new import_temporary_vault.TemporaryVault(options?.vault);
   const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? options?.vault === void 0;
   await vault.register(transport);
   const { host, port } = resolveEndpoint(transport, options);
@@ -100,7 +100,7 @@ function resolveEndpoint(transport, options) {
   throw new Error("connectToCdp: could not determine the CDP port.");
 }
 async function sweepLeftovers(transportOptions) {
-  if (!(0, import_leftover_cleanup.resolveShouldSweepLeftovers)(transportOptions)) {
+  if (!(0, import_leftover_cleanup.willSweepLeftovers)(transportOptions)) {
     return;
   }
   try {
@@ -120,4 +120,4 @@ async function sweepLeftovers(transportOptions) {
 0 && (module.exports = {
   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.cjs';\nimport type { ContextId } from './context-id.cjs';\nimport type { ElectronCompatibility } from './electron-compatibility.cjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.cjs';\nimport type { InstallerCompatibility } from './installer-compatibility.cjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.cjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport {\n  resolveLeftoverMaxAgeInMilliseconds,\n  resolveShouldSweepLeftovers,\n  sweepHostLeftovers\n} from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.cjs';\nimport { TempVault } from './temp-vault.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { createTransportFromOptions } from './transport-factory.cjs';\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   * 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 `args`\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 (`fn`, optional `args`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `fn`.\n   */\n  evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Args, 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: TempVault;\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   * 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 vault = new TempVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\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 dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Args, 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    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 (!resolveShouldSweepLeftovers(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.cjs';\nimport type { ContextId } from './context-id.cjs';\nimport type { ElectronCompatibility } from './electron-compatibility.cjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.cjs';\nimport type { InstallerCompatibility } from './installer-compatibility.cjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.cjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport {\n  resolveLeftoverMaxAgeInMilliseconds,\n  sweepHostLeftovers,\n  willSweepLeftovers\n} from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.cjs';\nimport { TemporaryVault } from './temporary-vault.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { createTransportFromOptions } from './transport-factory.cjs';\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   * 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   * 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 vault = new TemporaryVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\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 dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\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    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": []
}


package/dist/lib/cjs/connect-to-cdp.d.cts

@@ -16,7 +16,7 @@ import type { ContextId } from './context-id.cjs';
 import type { ElectronCompatibility } from './electron-compatibility.cjs';
 import type { EvalInObsidianParams, GenericObject } from './eval-in-obsidian.cjs';
 import type { InstallerCompatibility } from './installer-compatibility.cjs';
-import { TempVault } from './temp-vault.cjs';
+import { TemporaryVault } from './temporary-vault.cjs';
 /**
  * A live connection to a CDP-enabled Obsidian instance with the runtime helper
  * namespace bootstrapped.
@@ -70,15 +70,15 @@ export interface CdpConnection extends AsyncDisposable {
     readonly electronCompatibility?: ElectronCompatibility | undefined;
     /**
      * Evaluates a self-contained function inside Obsidian via the rich helper
-     * path, receiving `{ app, lib, obsidianModule, context }` plus any `args`
+     * path, receiving `{ app, lib, obsidianModule, context }` plus any `input`
      * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). Mirrors
      * the top-level `evalInObsidian`, with the transport and vault path pre-bound
      * to this connection.
      *
-     * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).
-     * @returns A {@link Promise} that resolves to the return value of `fn`.
+     * @param params - The evaluation parameters (`callback`, optional `input`/`contextId`).
+     * @returns A {@link Promise} that resolves to the return value of `callback`.
      */
-    evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>): Promise<Result>;
+    evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(params: Except<EvalInObsidianParams<Input, Result, TContextId>, 'transport' | 'vaultPath'>): Promise<Result>;
     /**
      * Evaluates a raw JavaScript expression inside Obsidian and returns the
      * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).
@@ -95,7 +95,7 @@ export interface CdpConnection extends AsyncDisposable {
     /**
      * The opened vault. Exposes `path` and `populate(...)` for seeding files.
      */
-    readonly vault: TempVault;
+    readonly vault: TemporaryVault;
 }
 /**
  * Options for {@link connectToCdp}.

package/dist/lib/cjs/context-id.cjs

@@ -38,17 +38,17 @@ class ContextId {
    */
   async dispose(vaultPath) {
     await (0, import_eval_in_obsidian.evalInObsidian)({
-      args: { id: this.id },
       /* v8 ignore start -- Serialized via toString() and executed inside the Obsidian process. Covered by integration tests. */
-      fn({ id }) {
-        const holder = window;
+      callback({ id }) {
+        const holder = globalThis;
         if (holder.__obsidianIntegrationTesting?.contexts) {
           delete holder.__obsidianIntegrationTesting.contexts[id];
         }
       },
+      input: { id: this.id },
       /* v8 ignore stop */
       shouldSkipPreflightChecks: true,
-      ...vaultPath === void 0 ? {} : { vaultPath }
+      ...vaultPath !== void 0 && { vaultPath }
     });
   }
   /**
@@ -80,4 +80,4 @@ class ContextId {
 0 && (module.exports = {
   ContextId
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/context-id.d.cts

@@ -7,7 +7,7 @@
 /**
  * Wraps a {@link ContextOf} extraction into an object with a `context` property.
  */
-export interface ContextArgs<TContextId extends ContextId<unknown> | undefined = undefined> {
+export interface ContextArguments<TContextId extends ContextId<unknown> | undefined = undefined> {
     context: ContextOf<TContextId>;
 }
 /**

package/dist/lib/cjs/context-provider.cjs

@@ -32,11 +32,11 @@ function getTransportOptions() {
 function getVaultPath() {
   return vaultPathResolver?.();
 }
-function setTransportOptionsResolver(fn) {
-  transportOptionsResolver = fn;
+function setTransportOptionsResolver(callback) {
+  transportOptionsResolver = callback;
 }
-function setVaultPathResolver(fn) {
-  vaultPathResolver = fn;
+function setVaultPathResolver(callback) {
+  vaultPathResolver = callback;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -45,4 +45,4 @@ function setVaultPathResolver(fn) {
   setTransportOptionsResolver,
   setVaultPathResolver
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/context-provider.d.cts

@@ -33,13 +33,13 @@ export declare function getVaultPath(): string | undefined;
  * Registers a resolver function for transport options. Called by framework
  * adapters at module load time to bridge their native injection mechanisms.
  *
- * @param fn - The resolver function.
+ * @param callback - The resolver function.
  */
-export declare function setTransportOptionsResolver(fn: TransportOptionsResolver): void;
+export declare function setTransportOptionsResolver(callback: TransportOptionsResolver): void;
 /**
  * Registers a resolver function for the vault path. Called by framework
  * adapters at module load time to bridge their native injection mechanisms.
  *
- * @param fn - The resolver function.
+ * @param callback - The resolver function.
  */
-export declare function setVaultPathResolver(fn: VaultPathResolver): void;
+export declare function setVaultPathResolver(callback: VaultPathResolver): void;

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

@@ -48,13 +48,13 @@ function buildDemoVaultPopulate(params) {
 }
 function seedPlugin(demoVaultPath, plugin, map) {
   const { data, pluginId } = plugin;
-  const sourceDir = plugin.sourceDir ?? (0, import_node_path.join)(demoVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);
+  const sourceDirectory = plugin.sourceDirectory ?? (0, import_node_path.join)(demoVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);
   const pluginPrefix = `${OBSIDIAN_CONFIG_DIR}/${PLUGINS_DIR}/${pluginId}`;
-  const fileNames = (0, import_node_fs.existsSync)(sourceDir) ? (0, import_node_fs.readdirSync)(sourceDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name) : [];
+  const fileNames = (0, import_node_fs.existsSync)(sourceDirectory) ? (0, import_node_fs.readdirSync)(sourceDirectory, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name) : [];
   for (const requiredFile of [MAIN_JS, MANIFEST_JSON]) {
     if (!fileNames.includes(requiredFile)) {
       throw new Error(
-        `Community plugin "${pluginId}" is not installed in the demo vault (${(0, import_node_path.join)(sourceDir, requiredFile)} missing). Open demo-vault/ in Obsidian once so demo-vault-helper installs it, then re-run.`
+        `Community plugin "${pluginId}" is not installed in the demo vault (${(0, import_node_path.join)(sourceDirectory, requiredFile)} missing). Open demo-vault/ in Obsidian once so demo-vault-helper installs it, then re-run.`
       );
     }
   }
@@ -62,7 +62,7 @@ function seedPlugin(demoVaultPath, plugin, map) {
     if (fileName === DATA_JSON && data !== void 0) {
       continue;
     }
-    map[`${pluginPrefix}/${fileName}`] = (0, import_node_fs.readFileSync)((0, import_node_path.join)(sourceDir, fileName));
+    map[`${pluginPrefix}/${fileName}`] = (0, import_node_fs.readFileSync)((0, import_node_path.join)(sourceDirectory, fileName));
   }
   if (data !== void 0) {
     const dataJson = (0, import_type_guards.ensureNonNullable)(JSON.stringify(data, null, DATA_JSON_INDENT));
@@ -74,4 +74,4 @@ function seedPlugin(demoVaultPath, plugin, map) {
 0 && (module.exports = {
   buildDemoVaultPopulate
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/demo-vault-populate.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Builds a complete {@link PopulateFilesParams} map for a plugin's in-repo `demo-vault/`, ready to seed into\n * the temp vault before Obsidian opens it. Composes {@link readDemoVaultTree} (the note tree) with the two\n * pieces it deliberately omits: selected `.obsidian/*` config files, and the built binaries (+ `data.json`)\n * of any extra community plugins the demo vault depends on (e.g. CodeScript Toolkit, `demo-vault-helper`).\n *\n * Pairs with the `enableCommunityPlugins` option of the global-setup `createSetup`: this seeds the binaries,\n * that turns them on. It intentionally does NOT write `community-plugins.json` \u2014 the harness owns that file\n * (it lists the plugin-under-test), and enabling the extras persists them.\n */\n\nimport {\n  existsSync,\n  readdirSync,\n  readFileSync\n} from 'node:fs';\nimport { join } from 'node:path';\n\nimport type { PopulateFilesParams } from './temp-vault.cjs';\n\nimport { readDemoVaultTree } from './demo-vault-tree.cjs';\nimport { ensureNonNullable } from './type-guards.cjs';\n\nconst OBSIDIAN_CONFIG_DIR = '.obsidian';\nconst PLUGINS_DIR = 'plugins';\nconst DATA_JSON = 'data.json';\nconst MANIFEST_JSON = 'manifest.json';\nconst MAIN_JS = 'main.js';\nconst DATA_JSON_INDENT = 2;\n\nconst DEFAULT_OBSIDIAN_CONFIG_FILES = ['app.json', 'appearance.json', 'core-plugins.json'];\n\n/**\n * Parameters for {@link buildDemoVaultPopulate}.\n */\nexport interface BuildDemoVaultPopulateParams {\n  /**\n   * Absolute path to the plugin repo's `demo-vault/` directory.\n   */\n  readonly demoVaultPath: string;\n\n  /**\n   * Names (of files or directories, matched at any depth) to skip while reading the note tree \u2014 forwarded to\n   * {@link readDemoVaultTree}.\n   *\n   * @default `['.git', '.obsidian']`\n   */\n  readonly excludedNames?: Iterable<string>;\n\n  /**\n   * Community plugins to seed into `.obsidian/plugins/<pluginId>/` (binaries + optional `data.json`). Turn\n   * them on with the global-setup `createSetup({ enableCommunityPlugins })` option.\n   */\n  readonly injectPlugins?: readonly InjectPluginParams[];\n\n  /**\n   * `.obsidian/*` config files to carry over from the demo vault. {@link readDemoVaultTree} excludes the whole\n   * `.obsidian` directory, so config the vault relies on (preview-mode default, core plugins, appearance) must\n   * be re-added explicitly. Files that do not exist are skipped.\n   *\n   * @default `['app.json', 'appearance.json', 'core-plugins.json']`\n   */\n  readonly obsidianConfigFiles?: readonly string[];\n}\n\n/**\n * A community plugin to seed into the demo vault alongside the note tree.\n */\nexport interface InjectPluginParams {\n  /**\n   * Overlay written as `.obsidian/plugins/<pluginId>/data.json` (JSON, 2-space indent). Omit to keep whatever\n   * `data.json` (if any) already lives in {@link InjectPluginParams.sourceDir}.\n   */\n  readonly data?: unknown;\n\n  /**\n   * The community plugin's id (its `.obsidian/plugins/<pluginId>` folder name).\n   */\n  readonly pluginId: string;\n\n  /**\n   * Directory to read the plugin's built files from. Every file directly inside it is copied into\n   * `.obsidian/plugins/<pluginId>/`; `main.js` and `manifest.json` are required.\n   *\n   * @default `<demoVaultPath>/.obsidian/plugins/<pluginId>`\n   */\n  readonly sourceDir?: string;\n}\n\n/**\n * Builds the full populate map for a plugin's `demo-vault/`: the note tree, the selected `.obsidian/*` config\n * files, and every injected plugin's binaries (+ optional `data.json`).\n *\n * @param params - The {@link BuildDemoVaultPopulateParams}.\n * @returns The populate map, ready to hand to a global setup's `populate` or {@link TempVault.populate}.\n */\nexport function buildDemoVaultPopulate(params: BuildDemoVaultPopulateParams): PopulateFilesParams {\n  const { demoVaultPath, excludedNames, injectPlugins = [], obsidianConfigFiles = DEFAULT_OBSIDIAN_CONFIG_FILES } = params;\n\n  const map = readDemoVaultTree(excludedNames === undefined ? { demoVaultPath } : { demoVaultPath, excludedNames });\n\n  for (const configFile of obsidianConfigFiles) {\n    const configPath = join(demoVaultPath, OBSIDIAN_CONFIG_DIR, configFile);\n    if (existsSync(configPath)) {\n      map[`${OBSIDIAN_CONFIG_DIR}/${configFile}`] = readFileSync(configPath);\n    }\n  }\n\n  for (const plugin of injectPlugins) {\n    seedPlugin(demoVaultPath, plugin, map);\n  }\n\n  return map;\n}\n\n/**\n * Seeds one injected plugin's binaries (and optional `data.json`) into the populate map.\n *\n * @param demoVaultPath - The demo vault root, used to resolve the default source directory.\n * @param plugin - The plugin to seed.\n * @param map - The populate map to write into.\n */\nfunction seedPlugin(demoVaultPath: string, plugin: InjectPluginParams, map: PopulateFilesParams): void {\n  const { data, pluginId } = plugin;\n  const sourceDir = plugin.sourceDir ?? join(demoVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);\n  const pluginPrefix = `${OBSIDIAN_CONFIG_DIR}/${PLUGINS_DIR}/${pluginId}`;\n\n  const fileNames = existsSync(sourceDir)\n    ? readdirSync(sourceDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name)\n    : [];\n\n  for (const requiredFile of [MAIN_JS, MANIFEST_JSON]) {\n    if (!fileNames.includes(requiredFile)) {\n      throw new Error(\n        `Community plugin \"${pluginId}\" is not installed in the demo vault (${join(sourceDir, requiredFile)} missing). `\n          + 'Open demo-vault/ in Obsidian once so demo-vault-helper installs it, then re-run.'\n      );\n    }\n  }\n\n  for (const fileName of fileNames) {\n    // `data.json` is regenerated from `data` below (when provided); skip the on-disk copy to avoid seeding it twice.\n    if (fileName === DATA_JSON && data !== undefined) {\n      continue;\n    }\n    map[`${pluginPrefix}/${fileName}`] = readFileSync(join(sourceDir, fileName));\n  }\n\n  if (data !== undefined) {\n    const dataJson: string = ensureNonNullable(JSON.stringify(data, null, DATA_JSON_INDENT));\n    map[`${pluginPrefix}/${DATA_JSON}`] = `${dataJson}\\n`;\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,qBAIO;AACP,uBAAqB;AAIrB,6BAAkC;AAClC,yBAAkC;AAElC,MAAM,sBAAsB;AAC5B,MAAM,cAAc;AACpB,MAAM,YAAY;AAClB,MAAM,gBAAgB;AACtB,MAAM,UAAU;AAChB,MAAM,mBAAmB;AAEzB,MAAM,gCAAgC,CAAC,YAAY,mBAAmB,mBAAmB;AAkElF,SAAS,uBAAuB,QAA2D;AAChG,QAAM,EAAE,eAAe,eAAe,gBAAgB,CAAC,GAAG,sBAAsB,8BAA8B,IAAI;AAElH,QAAM,UAAM,0CAAkB,kBAAkB,SAAY,EAAE,cAAc,IAAI,EAAE,eAAe,cAAc,CAAC;AAEhH,aAAW,cAAc,qBAAqB;AAC5C,UAAM,iBAAa,uBAAK,eAAe,qBAAqB,UAAU;AACtE,YAAI,2BAAW,UAAU,GAAG;AAC1B,UAAI,GAAG,mBAAmB,IAAI,UAAU,EAAE,QAAI,6BAAa,UAAU;AAAA,IACvE;AAAA,EACF;AAEA,aAAW,UAAU,eAAe;AAClC,eAAW,eAAe,QAAQ,GAAG;AAAA,EACvC;AAEA,SAAO;AACT;AASA,SAAS,WAAW,eAAuB,QAA4B,KAAgC;AACrG,QAAM,EAAE,MAAM,SAAS,IAAI;AAC3B,QAAM,YAAY,OAAO,iBAAa,uBAAK,eAAe,qBAAqB,aAAa,QAAQ;AACpG,QAAM,eAAe,GAAG,mBAAmB,IAAI,WAAW,IAAI,QAAQ;AAEtE,QAAM,gBAAY,2BAAW,SAAS,QAClC,4BAAY,WAAW,EAAE,eAAe,KAAK,CAAC,EAAE,OAAO,CAAC,UAAU,MAAM,OAAO,CAAC,EAAE,IAAI,CAAC,UAAU,MAAM,IAAI,IAC3G,CAAC;AAEL,aAAW,gBAAgB,CAAC,SAAS,aAAa,GAAG;AACnD,QAAI,CAAC,UAAU,SAAS,YAAY,GAAG;AACrC,YAAM,IAAI;AAAA,QACR,qBAAqB,QAAQ,6CAAyC,uBAAK,WAAW,YAAY,CAAC;AAAA,MAErG;AAAA,IACF;AAAA,EACF;AAEA,aAAW,YAAY,WAAW;AAEhC,QAAI,aAAa,aAAa,SAAS,QAAW;AAChD;AAAA,IACF;AACA,QAAI,GAAG,YAAY,IAAI,QAAQ,EAAE,QAAI,iCAAa,uBAAK,WAAW,QAAQ,CAAC;AAAA,EAC7E;AAEA,MAAI,SAAS,QAAW;AACtB,UAAM,eAAmB,sCAAkB,KAAK,UAAU,MAAM,MAAM,gBAAgB,CAAC;AACvF,QAAI,GAAG,YAAY,IAAI,SAAS,EAAE,IAAI,GAAG,QAAQ;AAAA;AAAA,EACnD;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/demo-vault-populate.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Builds a complete {@link PopulateFilesParams} map for a plugin's in-repo `demo-vault/`, ready to seed into\n * the temp vault before Obsidian opens it. Composes {@link readDemoVaultTree} (the note tree) with the two\n * pieces it deliberately omits: selected `.obsidian/*` config files, and the built binaries (+ `data.json`)\n * of any extra community plugins the demo vault depends on (e.g. CodeScript Toolkit, `demo-vault-helper`).\n *\n * Pairs with the `enableCommunityPlugins` option of the global-setup `createSetup`: this seeds the binaries,\n * that turns them on. It intentionally does NOT write `community-plugins.json` \u2014 the harness owns that file\n * (it lists the plugin-under-test), and enabling the extras persists them.\n */\n\nimport {\n  existsSync,\n  readdirSync,\n  readFileSync\n} from 'node:fs';\nimport { join } from 'node:path';\n\nimport type { PopulateFilesParams } from './temporary-vault.cjs';\n\nimport { readDemoVaultTree } from './demo-vault-tree.cjs';\nimport { ensureNonNullable } from './type-guards.cjs';\n\nconst OBSIDIAN_CONFIG_DIR = '.obsidian';\nconst PLUGINS_DIR = 'plugins';\nconst DATA_JSON = 'data.json';\nconst MANIFEST_JSON = 'manifest.json';\nconst MAIN_JS = 'main.js';\nconst DATA_JSON_INDENT = 2;\n\nconst DEFAULT_OBSIDIAN_CONFIG_FILES = ['app.json', 'appearance.json', 'core-plugins.json'];\n\n/**\n * Parameters for {@link buildDemoVaultPopulate}.\n */\nexport interface BuildDemoVaultPopulateParams {\n  /**\n   * Absolute path to the plugin repo's `demo-vault/` directory.\n   */\n  readonly demoVaultPath: string;\n\n  /**\n   * Names (of files or directories, matched at any depth) to skip while reading the note tree \u2014 forwarded to\n   * {@link readDemoVaultTree}.\n   *\n   * @default `['.git', '.obsidian']`\n   */\n  readonly excludedNames?: Iterable<string>;\n\n  /**\n   * Community plugins to seed into `.obsidian/plugins/<pluginId>/` (binaries + optional `data.json`). Turn\n   * them on with the global-setup `createSetup({ enableCommunityPlugins })` option.\n   */\n  readonly injectPlugins?: readonly InjectPluginParams[];\n\n  /**\n   * `.obsidian/*` config files to carry over from the demo vault. {@link readDemoVaultTree} excludes the whole\n   * `.obsidian` directory, so config the vault relies on (preview-mode default, core plugins, appearance) must\n   * be re-added explicitly. Files that do not exist are skipped.\n   *\n   * @default `['app.json', 'appearance.json', 'core-plugins.json']`\n   */\n  readonly obsidianConfigFiles?: readonly string[];\n}\n\n/**\n * A community plugin to seed into the demo vault alongside the note tree.\n */\nexport interface InjectPluginParams {\n  /**\n   * Overlay written as `.obsidian/plugins/<pluginId>/data.json` (JSON, 2-space indent). Omit to keep whatever\n   * `data.json` (if any) already lives in {@link InjectPluginParams.sourceDirectory}.\n   */\n  readonly data?: unknown;\n\n  /**\n   * The community plugin's id (its `.obsidian/plugins/<pluginId>` folder name).\n   */\n  readonly pluginId: string;\n\n  /**\n   * Directory to read the plugin's built files from. Every file directly inside it is copied into\n   * `.obsidian/plugins/<pluginId>/`; `main.js` and `manifest.json` are required.\n   *\n   * @default `<demoVaultPath>/.obsidian/plugins/<pluginId>`\n   */\n\n  readonly sourceDirectory?: string;\n}\n\n/**\n * Builds the full populate map for a plugin's `demo-vault/`: the note tree, the selected `.obsidian/*` config\n * files, and every injected plugin's binaries (+ optional `data.json`).\n *\n * @param params - The {@link BuildDemoVaultPopulateParams}.\n * @returns The populate map, ready to hand to a global setup's `populate` or {@link TemporaryVault.populate}.\n */\nexport function buildDemoVaultPopulate(params: BuildDemoVaultPopulateParams): PopulateFilesParams {\n  const { demoVaultPath, excludedNames, injectPlugins = [], obsidianConfigFiles = DEFAULT_OBSIDIAN_CONFIG_FILES } = params;\n\n  const map = readDemoVaultTree(excludedNames === undefined ? { demoVaultPath } : { demoVaultPath, excludedNames });\n\n  for (const configFile of obsidianConfigFiles) {\n    const configPath = join(demoVaultPath, OBSIDIAN_CONFIG_DIR, configFile);\n    if (existsSync(configPath)) {\n      map[`${OBSIDIAN_CONFIG_DIR}/${configFile}`] = readFileSync(configPath);\n    }\n  }\n\n  for (const plugin of injectPlugins) {\n    seedPlugin(demoVaultPath, plugin, map);\n  }\n\n  return map;\n}\n\n/**\n * Seeds one injected plugin's binaries (and optional `data.json`) into the populate map.\n *\n * @param demoVaultPath - The demo vault root, used to resolve the default source directory.\n * @param plugin - The plugin to seed.\n * @param map - The populate map to write into.\n */\nfunction seedPlugin(demoVaultPath: string, plugin: InjectPluginParams, map: PopulateFilesParams): void {\n  const { data, pluginId } = plugin;\n  const sourceDirectory = plugin.sourceDirectory ?? join(demoVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);\n  const pluginPrefix = `${OBSIDIAN_CONFIG_DIR}/${PLUGINS_DIR}/${pluginId}`;\n\n  const fileNames = existsSync(sourceDirectory)\n    ? readdirSync(sourceDirectory, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name)\n    : [];\n\n  for (const requiredFile of [MAIN_JS, MANIFEST_JSON]) {\n    if (!fileNames.includes(requiredFile)) {\n      throw new Error(\n        `Community plugin \"${pluginId}\" is not installed in the demo vault (${join(sourceDirectory, requiredFile)} missing). `\n          + 'Open demo-vault/ in Obsidian once so demo-vault-helper installs it, then re-run.'\n      );\n    }\n  }\n\n  for (const fileName of fileNames) {\n    // `data.json` is regenerated from `data` below (when provided); skip the on-disk copy to avoid seeding it twice.\n    if (fileName === DATA_JSON && data !== undefined) {\n      continue;\n    }\n    map[`${pluginPrefix}/${fileName}`] = readFileSync(join(sourceDirectory, fileName));\n  }\n\n  if (data !== undefined) {\n    const dataJson: string = ensureNonNullable(JSON.stringify(data, null, DATA_JSON_INDENT));\n    map[`${pluginPrefix}/${DATA_JSON}`] = `${dataJson}\\n`;\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,qBAIO;AACP,uBAAqB;AAIrB,6BAAkC;AAClC,yBAAkC;AAElC,MAAM,sBAAsB;AAC5B,MAAM,cAAc;AACpB,MAAM,YAAY;AAClB,MAAM,gBAAgB;AACtB,MAAM,UAAU;AAChB,MAAM,mBAAmB;AAEzB,MAAM,gCAAgC,CAAC,YAAY,mBAAmB,mBAAmB;AAmElF,SAAS,uBAAuB,QAA2D;AAChG,QAAM,EAAE,eAAe,eAAe,gBAAgB,CAAC,GAAG,sBAAsB,8BAA8B,IAAI;AAElH,QAAM,UAAM,0CAAkB,kBAAkB,SAAY,EAAE,cAAc,IAAI,EAAE,eAAe,cAAc,CAAC;AAEhH,aAAW,cAAc,qBAAqB;AAC5C,UAAM,iBAAa,uBAAK,eAAe,qBAAqB,UAAU;AACtE,YAAI,2BAAW,UAAU,GAAG;AAC1B,UAAI,GAAG,mBAAmB,IAAI,UAAU,EAAE,QAAI,6BAAa,UAAU;AAAA,IACvE;AAAA,EACF;AAEA,aAAW,UAAU,eAAe;AAClC,eAAW,eAAe,QAAQ,GAAG;AAAA,EACvC;AAEA,SAAO;AACT;AASA,SAAS,WAAW,eAAuB,QAA4B,KAAgC;AACrG,QAAM,EAAE,MAAM,SAAS,IAAI;AAC3B,QAAM,kBAAkB,OAAO,uBAAmB,uBAAK,eAAe,qBAAqB,aAAa,QAAQ;AAChH,QAAM,eAAe,GAAG,mBAAmB,IAAI,WAAW,IAAI,QAAQ;AAEtE,QAAM,gBAAY,2BAAW,eAAe,QACxC,4BAAY,iBAAiB,EAAE,eAAe,KAAK,CAAC,EAAE,OAAO,CAAC,UAAU,MAAM,OAAO,CAAC,EAAE,IAAI,CAAC,UAAU,MAAM,IAAI,IACjH,CAAC;AAEL,aAAW,gBAAgB,CAAC,SAAS,aAAa,GAAG;AACnD,QAAI,CAAC,UAAU,SAAS,YAAY,GAAG;AACrC,YAAM,IAAI;AAAA,QACR,qBAAqB,QAAQ,6CAAyC,uBAAK,iBAAiB,YAAY,CAAC;AAAA,MAE3G;AAAA,IACF;AAAA,EACF;AAEA,aAAW,YAAY,WAAW;AAEhC,QAAI,aAAa,aAAa,SAAS,QAAW;AAChD;AAAA,IACF;AACA,QAAI,GAAG,YAAY,IAAI,QAAQ,EAAE,QAAI,iCAAa,uBAAK,iBAAiB,QAAQ,CAAC;AAAA,EACnF;AAEA,MAAI,SAAS,QAAW;AACtB,UAAM,eAAmB,sCAAkB,KAAK,UAAU,MAAM,MAAM,gBAAgB,CAAC;AACvF,QAAI,GAAG,YAAY,IAAI,SAAS,EAAE,IAAI,GAAG,QAAQ;AAAA;AAAA,EACnD;AACF;",
  "names": []
}


package/dist/lib/cjs/demo-vault-populate.d.cts

@@ -10,7 +10,7 @@
  * that turns them on. It intentionally does NOT write `community-plugins.json` — the harness owns that file
  * (it lists the plugin-under-test), and enabling the extras persists them.
  */
-import type { PopulateFilesParams } from './temp-vault.cjs';
+import type { PopulateFilesParams } from './temporary-vault.cjs';
 /**
  * Parameters for {@link buildDemoVaultPopulate}.
  */
@@ -46,7 +46,7 @@ export interface BuildDemoVaultPopulateParams {
 export interface InjectPluginParams {
     /**
      * Overlay written as `.obsidian/plugins/<pluginId>/data.json` (JSON, 2-space indent). Omit to keep whatever
-     * `data.json` (if any) already lives in {@link InjectPluginParams.sourceDir}.
+     * `data.json` (if any) already lives in {@link InjectPluginParams.sourceDirectory}.
      */
     readonly data?: unknown;
     /**
@@ -59,13 +59,13 @@ export interface InjectPluginParams {
      *
      * @default `<demoVaultPath>/.obsidian/plugins/<pluginId>`
      */
-    readonly sourceDir?: string;
+    readonly sourceDirectory?: string;
 }
 /**
  * Builds the full populate map for a plugin's `demo-vault/`: the note tree, the selected `.obsidian/*` config
  * files, and every injected plugin's binaries (+ optional `data.json`).
  *
  * @param params - The {@link BuildDemoVaultPopulateParams}.
- * @returns The populate map, ready to hand to a global setup's `populate` or {@link TempVault.populate}.
+ * @returns The populate map, ready to hand to a global setup's `populate` or {@link TemporaryVault.populate}.
  */
 export declare function buildDemoVaultPopulate(params: BuildDemoVaultPopulateParams): PopulateFilesParams;