obsidian-integration-testing 8.3.0 → 8.4.0

package/dist/lib/cjs/asar-fallback-detection.cjs

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var asar_fallback_detection_exports = {};
+__export(asar_fallback_detection_exports, {
+  checkAsarFallback: () => checkAsarFallback
+});
+module.exports = __toCommonJS(asar_fallback_detection_exports);
+var import_obsidian_version = require("./obsidian-version.cjs");
+function checkAsarFallback(params) {
+  const { requestedVersion, runningApiVersion } = params;
+  if (requestedVersion === void 0 || runningApiVersion === void 0) {
+    return {
+      requestedVersion: requestedVersion ?? null,
+      runningApiVersion: runningApiVersion ?? null,
+      tier: "unknown"
+    };
+  }
+  if ((0, import_obsidian_version.compareVersions)(runningApiVersion, requestedVersion) === 0) {
+    return { requestedVersion, runningApiVersion, tier: "match" };
+  }
+  return {
+    message: `Obsidian was pinned to app version ${requestedVersion} but is actually running ${runningApiVersion} \u2014 the installer silently fell back to its own bundled asar instead of running the pinned version. Pin an obsidianInstallerVersion at or above ${requestedVersion}'s run floor so the pin actually runs.`,
+    requestedVersion,
+    runningApiVersion,
+    tier: "fallback"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkAsarFallback
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/asar-fallback-detection.d.cts

@@ -0,0 +1,75 @@
+/**
+ * @file
+ *
+ * Pure verdict on whether a booted owned Obsidian instance is actually running
+ * the pinned app (asar) version, or **silently fell back** to the installer's own
+ * bundled asar. Kept separate from the integration-only `transport-desktop-cdp`
+ * (which reads the live version over CDP and is excluded from unit tests) so the
+ * tier logic stays unit-testable — mirroring the `installer-compatibility` /
+ * `electron-compatibility` / `renderer-boot-detection` split.
+ *
+ * When an asar is swapped onto an installer shell below its real boot floor, the
+ * renderer does not always dead-boot (the black screen `renderer-boot-detection`
+ * catches). Some app versions instead **silently revert to the installer's own
+ * bundled asar** and render a perfectly healthy UI of the *wrong (older)* version.
+ * The dead-boot detector reads that healthy UI as a false-positive "runnable" —
+ * exactly how Obsidian `1.13.0` on installer `1.1.9` was first mis-measured (it
+ * reports `apiVersion` `1.1.9`, not `1.13.0`).
+ *
+ * The discriminator is the **running** app version, read live post-boot
+ * (`ipcRenderer.sendSync('version')` / `obsidianModule.apiVersion`, which both
+ * track the asar actually running). This verdict compares it to the pinned
+ * version: equal ⇒ `'match'`, different ⇒ `'fallback'` (the pin was not honored),
+ * and `'unknown'` when either version is unavailable (no asar was swapped, or the
+ * live version could not be read) — in which case nothing is thrown or warned.
+ */
+/**
+ * The silent-asar-fallback verdict for a booted owned instance, carried as data
+ * on the transport / connection result so consumers can assert on it.
+ */
+export interface AsarFallback {
+    /** A human-readable explanation, present for the `'fallback'` tier. */
+    readonly message?: string;
+    /** The pinned app (asar) version that was requested, or `null` when none. */
+    readonly requestedVersion: null | string;
+    /** The app (asar) version actually running, or `null` when unreadable. */
+    readonly runningApiVersion: null | string;
+    /** The resolved fallback tier. */
+    readonly tier: AsarFallbackTier;
+}
+/**
+ * The silent-asar-fallback tier for a booted owned instance.
+ *
+ * - `'match'` — the running app version equals the pinned version; the pin was
+ *   honored.
+ * - `'fallback'` — the running app version differs from the pinned version; the
+ *   installer silently ran a different (its own bundled) asar instead of the pin.
+ * - `'unknown'` — cannot be determined (no asar was swapped, so there is no pin to
+ *   verify, or the live running version could not be read).
+ */
+export type AsarFallbackTier = 'fallback' | 'match' | 'unknown';
+/**
+ * Parameters for {@link checkAsarFallback}.
+ */
+export interface CheckAsarFallbackParams {
+    /**
+     * The pinned Obsidian app (asar) version the owned instance was asked to run,
+     * or `undefined` when no asar was swapped (so there is nothing to verify).
+     */
+    readonly requestedVersion: string | undefined;
+    /**
+     * The Obsidian app (asar) version the instance is actually running, read live
+     * post-boot, or `undefined` when it could not be read.
+     */
+    readonly runningApiVersion: string | undefined;
+}
+/**
+ * Computes the silent-asar-fallback verdict for a booted owned instance.
+ *
+ * Only `'fallback'` warrants action (a throw / warning); `'match'` and `'unknown'`
+ * are silent. Comparison is a pure `x.y.z` version compare — no I/O.
+ *
+ * @param params - The pinned version and the live running version.
+ * @returns The fallback verdict.
+ */
+export declare function checkAsarFallback(params: CheckAsarFallbackParams): AsarFallback;

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

@@ -18,11 +18,23 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var compatibility_options_exports = {};
 __export(compatibility_options_exports, {
+  resolveAsarFallbackAction: () => resolveAsarFallbackAction,
   resolveInstallerCompatibilityAction: () => resolveInstallerCompatibilityAction,
   resolveShouldThrowOnIncompatibleInstaller: () => resolveShouldThrowOnIncompatibleInstaller,
+  resolveShouldThrowOnSilentAsarFallback: () => resolveShouldThrowOnSilentAsarFallback,
   resolveShouldWarnOnCompatibilityIssues: () => resolveShouldWarnOnCompatibilityIssues
 });
 module.exports = __toCommonJS(compatibility_options_exports);
+function resolveAsarFallbackAction(params) {
+  const { shouldThrowOnSilentAsarFallback, shouldWarnOnCompatibilityIssues, tier } = params;
+  if (tier !== "fallback") {
+    return "silent";
+  }
+  if (shouldThrowOnSilentAsarFallback) {
+    return "throw";
+  }
+  return shouldWarnOnCompatibilityIssues ? "warn" : "silent";
+}
 function resolveInstallerCompatibilityAction(params) {
   const { shouldThrowOnIncompatibleInstaller, shouldWarnOnCompatibilityIssues, tier } = params;
   if (tier === "unrunnable") {
@@ -39,13 +51,18 @@ function resolveInstallerCompatibilityAction(params) {
 function resolveShouldThrowOnIncompatibleInstaller(shouldThrowOnIncompatibleInstaller) {
   return shouldThrowOnIncompatibleInstaller ?? true;
 }
+function resolveShouldThrowOnSilentAsarFallback(shouldThrowOnSilentAsarFallback) {
+  return shouldThrowOnSilentAsarFallback ?? true;
+}
 function resolveShouldWarnOnCompatibilityIssues(shouldWarnOnCompatibilityIssues) {
   return shouldWarnOnCompatibilityIssues ?? true;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  resolveAsarFallbackAction,
   resolveInstallerCompatibilityAction,
   resolveShouldThrowOnIncompatibleInstaller,
+  resolveShouldThrowOnSilentAsarFallback,
   resolveShouldWarnOnCompatibilityIssues
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# 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": []
}


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

@@ -18,7 +18,20 @@
  * resolution stays unit-testable — mirroring the `visibility.ts` /
  * `appium-session-config.ts` pure-resolver split.
  */
+import type { AsarFallbackTier } from './asar-fallback-detection.cjs';
 import type { InstallerCompatibilityTier } from './installer-compatibility.cjs';
+/**
+ * The action to take for a resolved silent-asar-fallback verdict, given the
+ * throw/warn knobs.
+ *
+ * - `'throw'` — the verdict is `'fallback'` and the throw is enabled; the caller
+ *   throws `SilentAsarFallbackError`.
+ * - `'warn'` — the verdict is `'fallback'` but the throw is disabled and warnings
+ *   are on; the caller logs the fallback warning and lets the boot proceed (the
+ *   verdict is still surfaced as data).
+ * - `'silent'` — nothing to do (`'match'` / `'unknown'`, or a suppressed fallback).
+ */
+export type AsarFallbackAction = 'silent' | 'throw' | 'warn';
 /**
  * The action to take for a resolved installer↔app compatibility verdict, given
  * the throw/warn knobs.
@@ -33,6 +46,17 @@ import type { InstallerCompatibilityTier } from './installer-compatibility.cjs';
  * - `'silent'` — nothing to do (`'ok'` / `'unknown'`, or warnings disabled).
  */
 export type InstallerCompatibilityAction = 'silent' | 'throw' | 'warn-nagged' | 'warn-unrunnable';
+/**
+ * Parameters for {@link resolveAsarFallbackAction}.
+ */
+export interface ResolveAsarFallbackActionParams {
+    /** Whether a `'fallback'` verdict throws (vs. proceeds with a warning). */
+    readonly shouldThrowOnSilentAsarFallback: boolean;
+    /** Whether a non-throwing fallback verdict is logged. */
+    readonly shouldWarnOnCompatibilityIssues: boolean;
+    /** The resolved silent-asar-fallback tier. */
+    readonly tier: AsarFallbackTier;
+}
 /**
  * Parameters for {@link resolveInstallerCompatibilityAction}.
  */
@@ -44,6 +68,14 @@ export interface ResolveInstallerCompatibilityActionParams {
     /** The resolved installer↔app compatibility tier. */
     readonly tier: InstallerCompatibilityTier;
 }
+/**
+ * Resolves what to do for a silent-asar-fallback verdict, given the throw/warn
+ * knobs. Pure — the caller performs the throw/log side effects.
+ *
+ * @param params - The verdict tier and the resolved throw/warn knobs.
+ * @returns The action the caller should take.
+ */
+export declare function resolveAsarFallbackAction(params: ResolveAsarFallbackActionParams): AsarFallbackAction;
 /**
  * Resolves what to do for an installer↔app compatibility verdict, given the
  * throw/warn knobs. Pure — the caller performs the throw/log side effects.
@@ -60,6 +92,15 @@ export declare function resolveInstallerCompatibilityAction(params: ResolveInsta
  * @returns `true` when an unrunnable pin should throw (the default).
  */
 export declare function resolveShouldThrowOnIncompatibleInstaller(shouldThrowOnIncompatibleInstaller?: 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).
+ * @returns `true` when a silent fallback should throw (the default).
+ */
+export declare function resolveShouldThrowOnSilentAsarFallback(shouldThrowOnSilentAsarFallback?: boolean): boolean;
 /**
  * Whether the owned-instance compatibility nag warnings should be emitted (both
  * the installer↔app `'nagged'` warning and the runtime-Electron `'nagged'`

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

@@ -22,6 +22,7 @@ __export(connect_to_cdp_exports, {
 });
 module.exports = __toCommonJS(connect_to_cdp_exports);
 var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
+var import_normalize_optional_properties = require("./normalize-optional-properties.cjs");
 var import_temp_vault = require("./temp-vault.cjs");
 var import_transport_desktop_cdp = require("./transport-desktop-cdp.cjs");
 var import_transport_factory = require("./transport-factory.cjs");
@@ -33,10 +34,12 @@ async function connectToCdp(options) {
   await vault.register(transport);
   const { host, port } = resolveEndpoint(transport, options);
   const cdpUrl = `http://${host}:${String(port)}`;
+  const asarFallback = transport instanceof import_transport_desktop_cdp.DesktopCdpTransport ? transport.getAsarFallback() : void 0;
   const compatibility = transport instanceof import_transport_desktop_cdp.DesktopCdpTransport ? transport.getCompatibility() : void 0;
   const electronCompatibility = transport instanceof import_transport_desktop_cdp.DesktopCdpTransport ? transport.getElectronCompatibility() : void 0;
   const connection = {
     cdpUrl,
+    ...asarFallback && { asarFallback },
     ...compatibility && { compatibility },
     ...electronCompatibility && { electronCompatibility },
     async dispose() {
@@ -65,24 +68,20 @@ async function connectToCdp(options) {
   return connection;
 }
 function buildCdpTransportOptions(options) {
-  return {
+  return (0, import_normalize_optional_properties.normalizeOptionalProperties)({
+    commandTimeoutInMilliseconds: options?.commandTimeoutInMilliseconds,
+    deadBootGraceInMilliseconds: options?.deadBootGraceInMilliseconds,
+    host: options?.host,
     isObsidianAppVisible: options?.isObsidianAppVisible ?? true,
-    type: "obsidian-cdp",
-    ...options?.commandTimeoutInMilliseconds !== void 0 && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds },
-    ...options?.deadBootGraceInMilliseconds !== void 0 && { deadBootGraceInMilliseconds: options.deadBootGraceInMilliseconds },
-    ...options?.host !== void 0 && { host: options.host },
-    ...options?.obsidianInstallerVersion !== void 0 && { obsidianInstallerVersion: options.obsidianInstallerVersion },
-    ...options?.obsidianVersion !== void 0 && { obsidianVersion: options.obsidianVersion },
-    ...options?.port !== void 0 && { port: options.port },
-    ...options?.shouldDisableSandbox !== void 0 && { shouldDisableSandbox: options.shouldDisableSandbox },
-    ...buildCompatibilityTransportOptions(options)
-  };
-}
-function buildCompatibilityTransportOptions(options) {
-  return {
-    ...options?.shouldThrowOnIncompatibleInstaller !== void 0 && { shouldThrowOnIncompatibleInstaller: options.shouldThrowOnIncompatibleInstaller },
-    ...options?.shouldWarnOnCompatibilityIssues !== void 0 && { shouldWarnOnCompatibilityIssues: options.shouldWarnOnCompatibilityIssues }
-  };
+    obsidianInstallerVersion: options?.obsidianInstallerVersion,
+    obsidianVersion: options?.obsidianVersion,
+    port: options?.port,
+    shouldDisableSandbox: options?.shouldDisableSandbox,
+    shouldThrowOnIncompatibleInstaller: options?.shouldThrowOnIncompatibleInstaller,
+    shouldThrowOnSilentAsarFallback: options?.shouldThrowOnSilentAsarFallback,
+    shouldWarnOnCompatibilityIssues: options?.shouldWarnOnCompatibilityIssues,
+    type: "obsidian-cdp"
+  });
 }
 function resolveEndpoint(transport, options) {
   if (transport instanceof import_transport_desktop_cdp.DesktopCdpTransport) {
@@ -100,4 +99,4 @@ function resolveEndpoint(transport, options) {
 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 { 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 { 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 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 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 transport = await createTransportFromOptions(buildCdpTransportOptions(options));\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 compatibility = transport instanceof DesktopCdpTransport ? transport.getCompatibility() : undefined;\n  const electronCompatibility = transport instanceof DesktopCdpTransport ? transport.getElectronCompatibility() : undefined;\n\n  const connection: CdpConnection = {\n    cdpUrl,\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).\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 {\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    type: 'obsidian-cdp',\n    ...(options?.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n    ...(options?.deadBootGraceInMilliseconds !== undefined && { deadBootGraceInMilliseconds: options.deadBootGraceInMilliseconds }),\n    ...(options?.host !== undefined && { host: options.host }),\n    ...(options?.obsidianInstallerVersion !== undefined && { obsidianInstallerVersion: options.obsidianInstallerVersion }),\n    ...(options?.obsidianVersion !== undefined && { obsidianVersion: options.obsidianVersion }),\n    ...(options?.port !== undefined && { port: options.port }),\n    ...(options?.shouldDisableSandbox !== undefined && { shouldDisableSandbox: options.shouldDisableSandbox }),\n    ...buildCompatibilityTransportOptions(options)\n  };\n}\n\n/**\n * Builds the compatibility-knob passthrough options ({@link ObsidianCdpTransportOptions.shouldThrowOnIncompatibleInstaller}\n * / {@link ObsidianCdpTransportOptions.shouldWarnOnCompatibilityIssues}) for a\n * connection, split out of {@link buildCdpTransportOptions} to keep its\n * complexity in bounds. Only forwards knobs the caller actually set.\n *\n * @param options - The connection options.\n * @returns The compatibility passthrough options (possibly empty).\n */\nfunction buildCompatibilityTransportOptions(options?: ConnectToCdpOptions): Partial<ObsidianCdpTransportOptions> {\n  return {\n    ...(options?.shouldThrowOnIncompatibleInstaller !== undefined && { shouldThrowOnIncompatibleInstaller: options.shouldThrowOnIncompatibleInstaller }),\n    ...(options?.shouldWarnOnCompatibilityIssues !== undefined && { shouldWarnOnCompatibilityIssues: options.shouldWarnOnCompatibilityIssues })\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/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA0BA,8BAA+B;AAC/B,wBAA0B;AAC1B,mCAAoC;AACpC,+BAA2C;AAE3C,MAAM,mBAAmB;AA8NzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,YAAY,UAAM,qDAA2B,yBAAyB,OAAO,CAAC;AACpF,QAAM,QAAQ,IAAI,4BAAU,SAAS,KAAK;AAC1C,QAAM,6BAA6B,SAAS,8BAA+B,SAAS,UAAU;AAK9F,QAAM,MAAM,SAAS,SAAS;AAE9B,QAAM,EAAE,MAAM,KAAK,IAAI,gBAAgB,WAAW,OAAO;AACzD,QAAM,SAAS,UAAU,IAAI,IAAI,OAAO,IAAI,CAAC;AAC7C,QAAM,gBAAgB,qBAAqB,mDAAsB,UAAU,iBAAiB,IAAI;AAChG,QAAM,wBAAwB,qBAAqB,mDAAsB,UAAU,yBAAyB,IAAI;AAEhH,QAAM,aAA4B;AAAA,IAChC;AAAA,IACA,GAAI,iBAAiB,EAAE,cAAc;AAAA,IACrC,GAAI,yBAAyB,EAAE,sBAAsB;AAAA,IAErD,MAAM,UAAyB;AAC7B,UAAI;AACF,YAAI,4BAA4B;AAC9B,gBAAM,MAAM,QAAQ,SAAS;AAAA,QAC/B,OAAO;AACL,gBAAM,UAAU,gBAAgB,MAAM,IAAI;AAAA,QAC5C;AAAA,MACF,UAAE;AACA,cAAM,UAAU,UAAU;AAAA,MAC5B;AAAA,IACF;AAAA,IAEA,MAAM,eACJ,QACiB;AACjB,iBAAO,wCAAyC,EAAE,GAAG,QAAQ,WAAW,WAAW,MAAM,KAAK,CAAC;AAAA,IACjG;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;AAUA,SAAS,yBAAyB,SAA4D;AAC5F,SAAO;AAAA,IACL,sBAAsB,SAAS,wBAAwB;AAAA,IACvD,MAAM;AAAA,IACN,GAAI,SAAS,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IAChI,GAAI,SAAS,gCAAgC,UAAa,EAAE,6BAA6B,QAAQ,4BAA4B;AAAA,IAC7H,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,IACxD,GAAI,SAAS,6BAA6B,UAAa,EAAE,0BAA0B,QAAQ,yBAAyB;AAAA,IACpH,GAAI,SAAS,oBAAoB,UAAa,EAAE,iBAAiB,QAAQ,gBAAgB;AAAA,IACzF,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,IACxD,GAAI,SAAS,yBAAyB,UAAa,EAAE,sBAAsB,QAAQ,qBAAqB;AAAA,IACxG,GAAG,mCAAmC,OAAO;AAAA,EAC/C;AACF;AAWA,SAAS,mCAAmC,SAAqE;AAC/G,SAAO;AAAA,IACL,GAAI,SAAS,uCAAuC,UAAa,EAAE,oCAAoC,QAAQ,mCAAmC;AAAA,IAClJ,GAAI,SAAS,oCAAoC,UAAa,EAAE,iCAAiC,QAAQ,gCAAgC;AAAA,EAC3I;AACF;AAWA,SAAS,gBAAgB,WAAoB,SAA4D;AACvG,MAAI,qBAAqB,kDAAqB;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;",
  "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 { 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 transport = await createTransportFromOptions(buildCdpTransportOptions(options));\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/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA2BA,8BAA+B;AAC/B,2CAA4C;AAC5C,wBAA0B;AAC1B,mCAAoC;AACpC,+BAA2C;AAE3C,MAAM,mBAAmB;AAwPzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,YAAY,UAAM,qDAA2B,yBAAyB,OAAO,CAAC;AACpF,QAAM,QAAQ,IAAI,4BAAU,SAAS,KAAK;AAC1C,QAAM,6BAA6B,SAAS,8BAA+B,SAAS,UAAU;AAK9F,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,mDAAsB,UAAU,gBAAgB,IAAI;AAC9F,QAAM,gBAAgB,qBAAqB,mDAAsB,UAAU,iBAAiB,IAAI;AAChG,QAAM,wBAAwB,qBAAqB,mDAAsB,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,UAAyB;AAC7B,UAAI;AACF,YAAI,4BAA4B;AAC9B,gBAAM,MAAM,QAAQ,SAAS;AAAA,QAC/B,OAAO;AACL,gBAAM,UAAU,gBAAgB,MAAM,IAAI;AAAA,QAC5C;AAAA,MACF,UAAE;AACA,cAAM,UAAU,UAAU;AAAA,MAC5B;AAAA,IACF;AAAA,IAEA,MAAM,eACJ,QACiB;AACjB,iBAAO,wCAAyC,EAAE,GAAG,QAAQ,WAAW,WAAW,MAAM,KAAK,CAAC;AAAA,IACjG;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,aAAO,kEAAyD;AAAA,IAC9D,8BAA8B,SAAS;AAAA,IACvC,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,kDAAqB;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;",
  "names": []
}


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

@@ -11,6 +11,7 @@
  * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.
  */
 import type { Except } from 'type-fest';
+import type { AsarFallback } from './asar-fallback-detection.cjs';
 import type { ContextId } from './context-id.cjs';
 import type { ElectronCompatibility } from './electron-compatibility.cjs';
 import type { EvalInObsidianParams, GenericObject } from './eval-in-obsidian.cjs';
@@ -25,6 +26,16 @@ import { TempVault } from './temp-vault.cjs';
  * removing its directory) automatically.
  */
 export interface CdpConnection extends AsyncDisposable {
+    /**
+     * The silent-asar-fallback verdict for an owned instance, read live after boot:
+     * whether the app version it is actually running matches the swapped-in pin, or
+     * the installer silently reverted to its own bundled asar. `undefined` in attach
+     * mode, when no asar was swapped, or when the running version was unreadable. A
+     * `'fallback'` verdict reaches here only when the throw is disabled
+     * ({@link ConnectToCdpOptions.shouldThrowOnSilentAsarFallback} `false`);
+     * otherwise it throws `SilentAsarFallbackError` before the connection is created.
+     */
+    readonly asarFallback?: AsarFallback | undefined;
     /**
      * The base CDP URL, e.g. `http://localhost:51888`.
      */
@@ -178,6 +189,20 @@ export interface ConnectToCdpOptions {
      * @default `true`
      */
     readonly shouldThrowOnIncompatibleInstaller?: boolean;
+    /**
+     * Whether a post-boot **silent asar fallback** fails fast.
+     *
+     * When an asar is swapped onto an installer shell too old for it, the instance
+     * may silently revert to the installer's own bundled asar and run the **wrong
+     * (older)** version behind a healthy UI. When `true` (the default), the running
+     * app version is verified against the pin post-boot and a mismatch throws
+     * `SilentAsarFallbackError`. Set `false` to let the boot proceed — the mismatch
+     * is then surfaced on {@link CdpConnection.asarFallback} rather than thrown.
+     * Ignored in attach mode ({@link port} set) and when no asar is swapped.
+     *
+     * @default `true`
+     */
+    readonly shouldThrowOnSilentAsarFallback?: boolean;
     /**
      * Whether the owned-instance compatibility **nag warnings** are emitted.
      *

package/dist/lib/cjs/ecmascript-version.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ecmascript_version_exports = {};
+__export(ecmascript_version_exports, {
+  deriveEcmaScriptVersion: () => deriveEcmaScriptVersion
+});
+module.exports = __toCommonJS(ecmascript_version_exports);
+const CHROME_MAJOR_FOR_ES2015 = 51;
+const CHROME_MAJOR_FOR_ES2016 = 52;
+const CHROME_MAJOR_FOR_ES2017 = 58;
+const CHROME_MAJOR_FOR_ES2018 = 64;
+const CHROME_MAJOR_FOR_ES2019 = 73;
+const CHROME_MAJOR_FOR_ES2020 = 80;
+const CHROME_MAJOR_FOR_ES2021 = 85;
+const CHROME_MAJOR_FOR_ES2022 = 94;
+const CHROME_MAJOR_FOR_ES2023 = 110;
+const CHROME_MAJOR_FOR_ES2024 = 122;
+const ECMA_SCRIPT_BREAKPOINTS = [
+  { ecmaScriptVersion: "ES2024", minChromeMajor: CHROME_MAJOR_FOR_ES2024 },
+  { ecmaScriptVersion: "ES2023", minChromeMajor: CHROME_MAJOR_FOR_ES2023 },
+  { ecmaScriptVersion: "ES2022", minChromeMajor: CHROME_MAJOR_FOR_ES2022 },
+  { ecmaScriptVersion: "ES2021", minChromeMajor: CHROME_MAJOR_FOR_ES2021 },
+  { ecmaScriptVersion: "ES2020", minChromeMajor: CHROME_MAJOR_FOR_ES2020 },
+  { ecmaScriptVersion: "ES2019", minChromeMajor: CHROME_MAJOR_FOR_ES2019 },
+  { ecmaScriptVersion: "ES2018", minChromeMajor: CHROME_MAJOR_FOR_ES2018 },
+  { ecmaScriptVersion: "ES2017", minChromeMajor: CHROME_MAJOR_FOR_ES2017 },
+  { ecmaScriptVersion: "ES2016", minChromeMajor: CHROME_MAJOR_FOR_ES2016 },
+  { ecmaScriptVersion: "ES2015", minChromeMajor: CHROME_MAJOR_FOR_ES2015 }
+];
+const DECIMAL_RADIX = 10;
+function deriveEcmaScriptVersion(chromeVersion) {
+  const chromeMajor = Number.parseInt(chromeVersion, DECIMAL_RADIX);
+  if (Number.isNaN(chromeMajor)) {
+    return void 0;
+  }
+  for (const breakpoint of ECMA_SCRIPT_BREAKPOINTS) {
+    if (chromeMajor >= breakpoint.minChromeMajor) {
+      return breakpoint.ecmaScriptVersion;
+    }
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deriveEcmaScriptVersion
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/ecmascript-version.d.cts

@@ -0,0 +1,28 @@
+/**
+ * @file
+ *
+ * Pure derivation of the ECMAScript language level supported by a given
+ * Chromium (V8) version, expressed as an ECMAScript-edition string (e.g. `'ES2022'`).
+ *
+ * A serialized `evalInObsidian` closure runs in Obsidian's Chromium renderer, so
+ * the ES features it may safely use are bounded by that shell's Chromium version.
+ * The empirically-collected `runtimeVersions.chrome` (see
+ * {@link ObsidianRuntimeVersions} and `scripts/collect-runtime-versions.ts`) is
+ * fed through {@link deriveEcmaScriptVersion} to bake a per-version
+ * `ecmaScriptVersion` into `metadata.json`, so a consumer pinning an installer can
+ * tell offline which ES level is safe.
+ *
+ * The Chromium-major → ES-year breakpoints below are the Chromium releases at
+ * which each yearly ECMAScript edition became fully supported, per MDN /
+ * caniuse / the ECMAScript compatibility tables. They are a curated table, not
+ * derived from anything else, so this module is pure and unit-tested to the 100% gate.
+ */
+/**
+ * Derives the highest fully-supported ECMAScript edition for a Chromium version.
+ *
+ * @param chromeVersion - A Chromium version string (e.g. `'114.0.5735.289'`);
+ *   only the leading major segment is significant.
+ * @returns The ECMAScript-edition label (e.g. `'ES2022'`), or `undefined` when the
+ *   version cannot be parsed or its Chromium major predates the earliest tracked edition.
+ */
+export declare function deriveEcmaScriptVersion(chromeVersion: string): string | undefined;