obsidian-integration-testing 8.2.0 → 8.3.0

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

@@ -0,0 +1,51 @@
+"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 compatibility_options_exports = {};
+__export(compatibility_options_exports, {
+  resolveInstallerCompatibilityAction: () => resolveInstallerCompatibilityAction,
+  resolveShouldThrowOnIncompatibleInstaller: () => resolveShouldThrowOnIncompatibleInstaller,
+  resolveShouldWarnOnCompatibilityIssues: () => resolveShouldWarnOnCompatibilityIssues
+});
+module.exports = __toCommonJS(compatibility_options_exports);
+function resolveInstallerCompatibilityAction(params) {
+  const { shouldThrowOnIncompatibleInstaller, shouldWarnOnCompatibilityIssues, tier } = params;
+  if (tier === "unrunnable") {
+    if (shouldThrowOnIncompatibleInstaller) {
+      return "throw";
+    }
+    return shouldWarnOnCompatibilityIssues ? "warn-unrunnable" : "silent";
+  }
+  if (tier === "nagged") {
+    return shouldWarnOnCompatibilityIssues ? "warn-nagged" : "silent";
+  }
+  return "silent";
+}
+function resolveShouldThrowOnIncompatibleInstaller(shouldThrowOnIncompatibleInstaller) {
+  return shouldThrowOnIncompatibleInstaller ?? true;
+}
+function resolveShouldWarnOnCompatibilityIssues(shouldWarnOnCompatibilityIssues) {
+  return shouldWarnOnCompatibilityIssues ?? true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveInstallerCompatibilityAction,
+  resolveShouldThrowOnIncompatibleInstaller,
+  resolveShouldWarnOnCompatibilityIssues
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,71 @@
+/**
+ * @file
+ *
+ * Pure resolution of the two owned-instance compatibility knobs — whether the
+ * installer↔app / runtime-Electron nag warnings are emitted, and whether an
+ * `'unrunnable'` installer↔app pair fails fast with
+ * {@link IncompatibleInstallerVersionError} before launch.
+ *
+ * Both default to today's behavior (`true`): warnings on, and an unrunnable pin
+ * throws proactively. Setting `shouldWarnOnCompatibilityIssues` to `false`
+ * silences both nags (the verdicts are still computed and surfaced as data);
+ * setting `shouldThrowOnIncompatibleInstaller` to `false` lets an unrunnable pin
+ * proceed to launch, where the reactive dead-boot fast-fail
+ * (`RendererFailedToInitializeError`) still catches it.
+ *
+ * Kept separate from the integration-only launch code (`transport-factory`,
+ * `transport-desktop-cdp`, both excluded from unit tests) so the default
+ * resolution stays unit-testable — mirroring the `visibility.ts` /
+ * `appium-session-config.ts` pure-resolver split.
+ */
+import type { InstallerCompatibilityTier } from './installer-compatibility.cjs';
+/**
+ * The action to take for a resolved installer↔app compatibility verdict, given
+ * the throw/warn knobs.
+ *
+ * - `'throw'` — the verdict is `'unrunnable'` and the proactive throw is enabled;
+ *   the caller throws `IncompatibleInstallerVersionError` before launch.
+ * - `'warn-unrunnable'` — the verdict is `'unrunnable'` but the throw is disabled
+ *   and warnings are on; the caller logs a "proceeding to launch" warning and
+ *   lets the boot proceed (where the reactive dead-boot fast-fail catches it).
+ * - `'warn-nagged'` — the verdict is `'nagged'` and warnings are on; the caller
+ *   logs the recommended-installer warning.
+ * - `'silent'` — nothing to do (`'ok'` / `'unknown'`, or warnings disabled).
+ */
+export type InstallerCompatibilityAction = 'silent' | 'throw' | 'warn-nagged' | 'warn-unrunnable';
+/**
+ * Parameters for {@link resolveInstallerCompatibilityAction}.
+ */
+export interface ResolveInstallerCompatibilityActionParams {
+    /** Whether an `'unrunnable'` verdict throws (vs. proceeds to launch). */
+    readonly shouldThrowOnIncompatibleInstaller: boolean;
+    /** Whether a nag / proceeding-unrunnable verdict is logged. */
+    readonly shouldWarnOnCompatibilityIssues: boolean;
+    /** The resolved installer↔app compatibility tier. */
+    readonly tier: InstallerCompatibilityTier;
+}
+/**
+ * Resolves what to do for an installer↔app compatibility 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 resolveInstallerCompatibilityAction(params: ResolveInstallerCompatibilityActionParams): InstallerCompatibilityAction;
+/**
+ * Whether an `'unrunnable'` installer↔app pair should fail fast with
+ * {@link IncompatibleInstallerVersionError} before launch.
+ *
+ * @param shouldThrowOnIncompatibleInstaller - The resolved option value (omitted → throw).
+ * @returns `true` when an unrunnable pin should throw (the default).
+ */
+export declare function resolveShouldThrowOnIncompatibleInstaller(shouldThrowOnIncompatibleInstaller?: 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).
+ * @returns `true` when the warnings should be emitted (the default).
+ */
+export declare function resolveShouldWarnOnCompatibilityIssues(shouldWarnOnCompatibilityIssues?: boolean): boolean;

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

@@ -34,9 +34,11 @@ async function connectToCdp(options) {
   const { host, port } = resolveEndpoint(transport, options);
   const cdpUrl = `http://${host}:${String(port)}`;
   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,
     ...compatibility && { compatibility },
+    ...electronCompatibility && { electronCompatibility },
     async dispose() {
       try {
         if (shouldRemoveVaultOnDispose) {
@@ -72,7 +74,14 @@ function buildCdpTransportOptions(options) {
     ...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 }
+    ...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 }
   };
 }
 function resolveEndpoint(transport, options) {
@@ -91,4 +100,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 {\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 never reaches here \u2014 it throws\n   * `IncompatibleInstallerVersionError` before the 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   * 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   * 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\n  const connection: CdpConnection = {\n    cdpUrl,\n    ...(compatibility && { compatibility }),\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  };\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;AAyBA,8BAA+B;AAC/B,wBAA0B;AAC1B,mCAAoC;AACpC,+BAA2C;AAE3C,MAAM,mBAAmB;AAuLzB,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;AAEhG,QAAM,aAA4B;AAAA,IAChC;AAAA,IACA,GAAI,iBAAiB,EAAE,cAAc;AAAA,IAErC,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,EAC1G;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 { 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": []
}


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

@@ -12,6 +12,7 @@
  */
 import type { Except } from 'type-fest';
 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';
@@ -32,8 +33,10 @@ export interface CdpConnection extends AsyncDisposable {
      * The resolved installer↔app compatibility verdict for an owned instance, when
      * it could be determined. `undefined` in attach mode, or when the verdict is
      * unknown (undetectable shell version, or the app version is absent from the
-     * table). An `'unrunnable'` verdict never reaches here — it throws
-     * `IncompatibleInstallerVersionError` before the connection is created.
+     * table). An `'unrunnable'` verdict reaches here only when the proactive throw
+     * is disabled ({@link ConnectToCdpOptions.shouldThrowOnIncompatibleInstaller}
+     * `false`); otherwise it throws `IncompatibleInstallerVersionError` before the
+     * connection is created.
      */
     readonly compatibility?: InstallerCompatibility | undefined;
     /**
@@ -45,6 +48,15 @@ export interface CdpConnection extends AsyncDisposable {
      * @returns A {@link Promise} that resolves once disposal completes.
      */
     dispose(): Promise<void>;
+    /**
+     * The runtime Electron compatibility verdict for an owned instance, read live
+     * after boot: whether the Electron version it is actually running is new enough
+     * for the running app version. `undefined` in attach mode, or when the verdict
+     * is unknown (the live version was unreadable, or the app version carries no
+     * recommended Electron version). An old Electron never blocks — it only warns —
+     * so unlike {@link compatibility} there is no throwing tier.
+     */
+    readonly electronCompatibility?: ElectronCompatibility | undefined;
     /**
      * Evaluates a self-contained function inside Obsidian via the rich helper
      * path, receiving `{ app, lib, obsidianModule, context }` plus any `args`
@@ -153,6 +165,31 @@ export interface ConnectToCdpOptions {
      * a real vault is never deleted. Set explicitly to override.
      */
     readonly shouldRemoveVaultOnDispose?: boolean;
+    /**
+     * Whether an **unrunnable** installer↔app version pair fails fast before launch.
+     *
+     * When `true` (the default), an installer below the app's run floor throws
+     * `IncompatibleInstallerVersionError` from version resolution before anything is
+     * downloaded or launched. Set `false` to let the pin proceed to launch — where
+     * the reactive dead-boot fast-fail still catches the black-screen boot, and the
+     * `'unrunnable'` verdict is surfaced on {@link CdpConnection.compatibility}
+     * rather than thrown. Ignored in attach mode ({@link port} set).
+     *
+     * @default `true`
+     */
+    readonly shouldThrowOnIncompatibleInstaller?: boolean;
+    /**
+     * Whether the owned-instance compatibility **nag warnings** are emitted.
+     *
+     * Covers both the offline installer↔app warning and the post-boot
+     * runtime-Electron warning. When `true` (the default) each fires via the harness
+     * log; set `false` to silence both — the verdicts are still surfaced on
+     * {@link CdpConnection.compatibility} / {@link CdpConnection.electronCompatibility},
+     * only the log is suppressed. Ignored in attach mode ({@link port} set).
+     *
+     * @default `true`
+     */
+    readonly shouldWarnOnCompatibilityIssues?: boolean;
     /**
      * Absolute path to an existing vault to open. When omitted, an empty temporary
      * vault is created (and removed on dispose unless

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

@@ -0,0 +1,46 @@
+"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 electron_compatibility_exports = {};
+__export(electron_compatibility_exports, {
+  checkElectronCompatibility: () => checkElectronCompatibility
+});
+module.exports = __toCommonJS(electron_compatibility_exports);
+var import_obsidian_version = require("./obsidian-version.cjs");
+function checkElectronCompatibility(params) {
+  const { actualElectronVersion, appVersion, metadata } = params;
+  const minRecommendedElectronVersion = metadata?.minRecommendedElectronVersion;
+  if (actualElectronVersion === void 0 || minRecommendedElectronVersion === void 0) {
+    return { actualElectronVersion: actualElectronVersion ?? null, appVersion, tier: "unknown" };
+  }
+  if ((0, import_obsidian_version.compareVersions)(actualElectronVersion, minRecommendedElectronVersion) < 0) {
+    return {
+      actualElectronVersion,
+      appVersion,
+      message: `Obsidian ${appVersion} runs on Electron ${actualElectronVersion} but recommends Electron ${minRecommendedElectronVersion} or newer; pin a newer obsidianInstallerVersion for full compatibility.`,
+      minRecommendedElectronVersion,
+      tier: "nagged"
+    };
+  }
+  return { actualElectronVersion, appVersion, minRecommendedElectronVersion, tier: "ok" };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkElectronCompatibility
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,74 @@
+/**
+ * @file
+ *
+ * Pure verdict on whether the Electron version an owned Obsidian instance is
+ * actually running is new enough for the resolved app version. 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` / `renderer-boot-detection` split.
+ *
+ * This is the tier-2 companion to `installer-compatibility`. That one is fully
+ * offline — it compares the resolved installer version against installer-version
+ * thresholds. But the app's real requirement is a **minimum Electron version**
+ * hardcoded inside `app.js` (e.g. `1.13.1` needs Electron `28.2.3`), and the
+ * installer's bundled Electron is not derivable offline (see
+ * {@link ObsidianVersionMetadata.minRecommendedElectronVersion}). So this verdict
+ * takes the **live** `process.versions.electron` read from the booted renderer and
+ * compares it to `minRecommendedElectronVersion` from `metadata.json`.
+ *
+ * An Electron below the recommendation runs but is nagged (`'nagged'`) — Obsidian
+ * would show its "installer too old" recommendation; it never blocks, so there is
+ * no `'unrunnable'` tier here. When the live version is unreadable or the app
+ * version carries no recommended Electron, the verdict is `'unknown'` and nothing
+ * is warned.
+ */
+import type { ObsidianVersionMetadata } from './obsidian-metadata.cjs';
+/**
+ * Parameters for {@link checkElectronCompatibility}.
+ */
+export interface CheckElectronCompatibilityParams {
+    /** The Electron version the instance is actually running, or `undefined` when unreadable. */
+    readonly actualElectronVersion: string | undefined;
+    /** The resolved Obsidian app (asar) version that is running. */
+    readonly appVersion: string;
+    /** The `metadata.json` entry for {@link appVersion}, or `undefined` when absent. */
+    readonly metadata: ObsidianVersionMetadata | undefined;
+}
+/**
+ * The runtime Electron compatibility verdict for a booted owned instance, carried
+ * as data on the transport / connection result so consumers can assert on it.
+ */
+export interface ElectronCompatibility {
+    /** The Electron version the instance is actually running, or `null` when unreadable. */
+    readonly actualElectronVersion: null | string;
+    /** The resolved Obsidian app (asar) version that is running. */
+    readonly appVersion: string;
+    /** A human-readable explanation, present for the `'nagged'` tier. */
+    readonly message?: string;
+    /** The app's recommended-minimum Electron version, when the table carries one. */
+    readonly minRecommendedElectronVersion?: string;
+    /** The resolved compatibility tier. */
+    readonly tier: ElectronCompatibilityTier;
+}
+/**
+ * The runtime Electron compatibility tier for a booted owned instance.
+ *
+ * - `'ok'` — the running Electron is at or above the app's recommended minimum.
+ * - `'nagged'` — the running Electron is below the recommended minimum; Obsidian
+ *   runs but would show its "installer too old" recommendation.
+ * - `'unknown'` — cannot be determined (the live version was unreadable, or the
+ *   app version carries no recommended Electron version in the table).
+ */
+export type ElectronCompatibilityTier = 'nagged' | 'ok' | 'unknown';
+/**
+ * Computes the runtime Electron compatibility verdict for a booted owned instance.
+ *
+ * Only `'nagged'` warrants a warning; `'ok'` and `'unknown'` are silent. An
+ * Electron mismatch never blocks, so there is no error tier. Comparisons are pure
+ * `x.y.z` version compares — no I/O.
+ *
+ * @param params - The running app version, the live Electron version, and the app
+ *   version's metadata entry.
+ * @returns The compatibility verdict.
+ */
+export declare function checkElectronCompatibility(params: CheckElectronCompatibilityParams): ElectronCompatibility;

package/dist/lib/cjs/index.cjs

@@ -24,6 +24,7 @@ __export(index_exports, {
   IncompatibleInstallerVersionError: () => import_incompatible_installer_version_error.IncompatibleInstallerVersionError,
   RendererFailedToInitializeError: () => import_renderer_failed_to_initialize_error.RendererFailedToInitializeError,
   TempVault: () => import_temp_vault.TempVault,
+  checkElectronCompatibility: () => import_electron_compatibility.checkElectronCompatibility,
   checkInstallerCompatibility: () => import_installer_compatibility.checkInstallerCompatibility,
   connectToCdp: () => import_connect_to_cdp.connectToCdp,
   createTransportFromOptions: () => import_transport_factory.createTransportFromOptions,
@@ -39,6 +40,7 @@ module.exports = __toCommonJS(index_exports);
 var import_connect_to_cdp = require("./connect-to-cdp.cjs");
 var import_context_id = require("./context-id.cjs");
 var import_context_provider = require("./context-provider.cjs");
+var import_electron_compatibility = require("./electron-compatibility.cjs");
 var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
 var import_incompatible_installer_version_error = require("./incompatible-installer-version-error.cjs");
 var import_installer_compatibility = require("./installer-compatibility.cjs");
@@ -58,6 +60,7 @@ var import_vault_registry = require("./vault-registry.cjs");
   IncompatibleInstallerVersionError,
   RendererFailedToInitializeError,
   TempVault,
+  checkElectronCompatibility,
   checkInstallerCompatibility,
   connectToCdp,
   createTransportFromOptions,
@@ -69,4 +72,4 @@ var import_vault_registry = require("./vault-registry.cjs");
   setVaultPathResolver,
   unregisterVault
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/index.d.cts

@@ -8,6 +8,8 @@ export { connectToCdp } from './connect-to-cdp.cjs';
 export { ContextId } from './context-id.cjs';
 export type { TransportOptionsResolver, VaultPathResolver } from './context-provider.cjs';
 export { setTransportOptionsResolver, setVaultPathResolver } from './context-provider.cjs';
+export type { CheckElectronCompatibilityParams, ElectronCompatibility, ElectronCompatibilityTier } from './electron-compatibility.cjs';
+export { checkElectronCompatibility } from './electron-compatibility.cjs';
 export type { EvalInObsidianParams, HoverElementParams, Lib, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams, WaitUntilParams } from './eval-in-obsidian.cjs';
 export { evalInObsidian } from './eval-in-obsidian.cjs';
 export type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.cjs';

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

@@ -61,4 +61,4 @@ function checkInstallerCompatibility(params) {
 0 && (module.exports = {
   checkInstallerCompatibility
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/installer-compatibility.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure verdict on whether a resolved (Obsidian app, installer) version pair is\n * compatible, computed offline from the `metadata.json` thresholds. Kept separate\n * from the integration-only `transport-factory` (which drives real\n * downloads/launches and is excluded from unit tests) so the tier logic stays\n * unit-testable \u2014 mirroring the `renderer-boot-detection` split.\n *\n * Two thresholds drive the verdict, both installer versions directly comparable\n * to the resolved installer/shell version:\n *\n * - `minRunnableInstallerVersion` \u2014 the run floor. Below it the app cannot boot\n *   (`'unrunnable'`); the caller turns this into a proactive\n *   `IncompatibleInstallerVersionError` before any download/launch.\n * - `minRecommendedInstallerVersion` \u2014 the recommended floor (older versions\n *   only). At/above the run floor but below this, the app runs but is below\n *   Obsidian's recommendation (`'nagged'`), surfaced as a warning.\n *\n * When the installer version is unknown (e.g. an undetectable Linux shell) or the\n * app version is absent from the table, the verdict is `'unknown'` and nothing is\n * thrown or warned \u2014 the reactive dead-boot fast-fail remains the safety net.\n */\n\nimport type { ObsidianVersionMetadata } from './obsidian-metadata.cjs';\n\nimport { compareVersions } from './obsidian-version.cjs';\n\n/**\n * Parameters for {@link checkInstallerCompatibility}.\n */\nexport interface CheckInstallerCompatibilityParams {\n  /** The resolved Obsidian app (asar) version. */\n  readonly appVersion: string;\n\n  /** The resolved installer/Electron shell version, or `undefined` when unknown. */\n  readonly installerVersion: string | undefined;\n\n  /** The `metadata.json` entry for {@link appVersion}, or `undefined` when absent. */\n  readonly metadata: ObsidianVersionMetadata | undefined;\n}\n\n/**\n * The compatibility verdict for a resolved (app, installer) version pair, carried\n * as data on the transport / connection result so consumers can assert on it.\n */\nexport interface InstallerCompatibility {\n  /** The resolved Obsidian app (asar) version. */\n  readonly appVersion: string;\n\n  /** The resolved installer/Electron shell version, or `null` when unknown. */\n  readonly installerVersion: null | string;\n\n  /** A human-readable explanation, present for the `'nagged'` tier. */\n  readonly message?: string;\n\n  /** The recommended installer floor, when the table carries one. */\n  readonly minRecommendedInstallerVersion?: string;\n\n  /** The run floor, when the table carries one. */\n  readonly minRunnableInstallerVersion?: string;\n\n  /** The resolved compatibility tier. */\n  readonly tier: InstallerCompatibilityTier;\n}\n\n/**\n * The compatibility tier of a resolved (app, installer) version pair.\n *\n * - `'ok'` \u2014 the installer is at or above the recommended floor (or no\n *   recommended floor is known); runs with full compatibility.\n * - `'nagged'` \u2014 at/above the run floor but below the recommended floor; runs but\n *   Obsidian would show its \"installer too old\" recommendation.\n * - `'unrunnable'` \u2014 below the run floor; the app cannot boot on this installer.\n * - `'unknown'` \u2014 cannot be determined (installer version unknown, or the app\n *   version is absent from the table).\n */\nexport type InstallerCompatibilityTier = 'nagged' | 'ok' | 'unknown' | 'unrunnable';\n\n/**\n * Computes the compatibility verdict for a resolved (app, installer) version pair.\n *\n * Only `'unrunnable'` warrants an error; `'nagged'` warrants a warning; `'ok'` and\n * `'unknown'` are silent. Comparisons are pure `x.y.z` version compares \u2014 no I/O.\n *\n * @param params - The resolved versions and the app version's metadata entry.\n * @returns The compatibility verdict.\n */\nexport function checkInstallerCompatibility(params: CheckInstallerCompatibilityParams): InstallerCompatibility {\n  const { appVersion, installerVersion, metadata } = params;\n  const minRunnableInstallerVersion = metadata?.minRunnableInstallerVersion;\n  const minRecommendedInstallerVersion = metadata?.minRecommendedInstallerVersion;\n\n  if (installerVersion === undefined || minRunnableInstallerVersion === undefined) {\n    return { appVersion, installerVersion: installerVersion ?? null, tier: 'unknown' };\n  }\n\n  const recommendedFloor = minRecommendedInstallerVersion !== undefined && { minRecommendedInstallerVersion };\n\n  if (compareVersions(installerVersion, minRunnableInstallerVersion) < 0) {\n    return {\n      appVersion,\n      installerVersion,\n      minRunnableInstallerVersion,\n      tier: 'unrunnable',\n      ...recommendedFloor\n    };\n  }\n\n  if (minRecommendedInstallerVersion !== undefined && compareVersions(installerVersion, minRecommendedInstallerVersion) < 0) {\n    return {\n      appVersion,\n      installerVersion,\n      message: `Obsidian installer ${installerVersion} runs Obsidian ${appVersion} but is older than the `\n        + `recommended installer ${minRecommendedInstallerVersion}; update the installer for full compatibility.`,\n      minRecommendedInstallerVersion,\n      minRunnableInstallerVersion,\n      tier: 'nagged'\n    };\n  }\n\n  return {\n    appVersion,\n    installerVersion,\n    minRunnableInstallerVersion,\n    tier: 'ok',\n    ...recommendedFloor\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA0BA,8BAAgC;AA8DzB,SAAS,4BAA4B,QAAmE;AAC7G,QAAM,EAAE,YAAY,kBAAkB,SAAS,IAAI;AACnD,QAAM,8BAA8B,UAAU;AAC9C,QAAM,iCAAiC,UAAU;AAEjD,MAAI,qBAAqB,UAAa,gCAAgC,QAAW;AAC/E,WAAO,EAAE,YAAY,kBAAkB,oBAAoB,MAAM,MAAM,UAAU;AAAA,EACnF;AAEA,QAAM,mBAAmB,mCAAmC,UAAa,EAAE,+BAA+B;AAE1G,UAAI,yCAAgB,kBAAkB,2BAA2B,IAAI,GAAG;AACtE,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA,MAAM;AAAA,MACN,GAAG;AAAA,IACL;AAAA,EACF;AAEA,MAAI,mCAAmC,cAAa,yCAAgB,kBAAkB,8BAA8B,IAAI,GAAG;AACzH,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,SAAS,sBAAsB,gBAAgB,kBAAkB,UAAU,gDAC9C,8BAA8B;AAAA,MAC3D;AAAA,MACA;AAAA,MACA,MAAM;AAAA,IACR;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM;AAAA,IACN,GAAG;AAAA,EACL;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/installer-compatibility.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure verdict on whether a resolved (Obsidian app, installer) version pair is\n * compatible, computed offline from the `metadata.json` thresholds. Kept separate\n * from the integration-only `transport-factory` (which drives real\n * downloads/launches and is excluded from unit tests) so the tier logic stays\n * unit-testable \u2014 mirroring the `renderer-boot-detection` split.\n *\n * Two thresholds drive the verdict, both installer versions directly comparable\n * to the resolved installer/shell version:\n *\n * - `minRunnableInstallerVersion` \u2014 the run floor. Below it the app cannot boot\n *   (`'unrunnable'`); the caller turns this into a proactive\n *   `IncompatibleInstallerVersionError` before any download/launch \u2014 unless the\n *   caller has disabled the proactive throw (`shouldThrowOnIncompatibleInstaller`\n *   `false`), in which case the boot proceeds and the reactive dead-boot fast-fail\n *   catches it.\n * - `minRecommendedInstallerVersion` \u2014 the recommended floor (older versions\n *   only). At/above the run floor but below this, the app runs but is below\n *   Obsidian's recommendation (`'nagged'`), surfaced as a warning.\n *\n * When the installer version is unknown (e.g. an undetectable Linux shell) or the\n * app version is absent from the table, the verdict is `'unknown'` and nothing is\n * thrown or warned \u2014 the reactive dead-boot fast-fail remains the safety net.\n */\n\nimport type { ObsidianVersionMetadata } from './obsidian-metadata.cjs';\n\nimport { compareVersions } from './obsidian-version.cjs';\n\n/**\n * Parameters for {@link checkInstallerCompatibility}.\n */\nexport interface CheckInstallerCompatibilityParams {\n  /** The resolved Obsidian app (asar) version. */\n  readonly appVersion: string;\n\n  /** The resolved installer/Electron shell version, or `undefined` when unknown. */\n  readonly installerVersion: string | undefined;\n\n  /** The `metadata.json` entry for {@link appVersion}, or `undefined` when absent. */\n  readonly metadata: ObsidianVersionMetadata | undefined;\n}\n\n/**\n * The compatibility verdict for a resolved (app, installer) version pair, carried\n * as data on the transport / connection result so consumers can assert on it.\n */\nexport interface InstallerCompatibility {\n  /** The resolved Obsidian app (asar) version. */\n  readonly appVersion: string;\n\n  /** The resolved installer/Electron shell version, or `null` when unknown. */\n  readonly installerVersion: null | string;\n\n  /** A human-readable explanation, present for the `'nagged'` tier. */\n  readonly message?: string;\n\n  /** The recommended installer floor, when the table carries one. */\n  readonly minRecommendedInstallerVersion?: string;\n\n  /** The run floor, when the table carries one. */\n  readonly minRunnableInstallerVersion?: string;\n\n  /** The resolved compatibility tier. */\n  readonly tier: InstallerCompatibilityTier;\n}\n\n/**\n * The compatibility tier of a resolved (app, installer) version pair.\n *\n * - `'ok'` \u2014 the installer is at or above the recommended floor (or no\n *   recommended floor is known); runs with full compatibility.\n * - `'nagged'` \u2014 at/above the run floor but below the recommended floor; runs but\n *   Obsidian would show its \"installer too old\" recommendation.\n * - `'unrunnable'` \u2014 below the run floor; the app cannot boot on this installer.\n * - `'unknown'` \u2014 cannot be determined (installer version unknown, or the app\n *   version is absent from the table).\n */\nexport type InstallerCompatibilityTier = 'nagged' | 'ok' | 'unknown' | 'unrunnable';\n\n/**\n * Computes the compatibility verdict for a resolved (app, installer) version pair.\n *\n * Only `'unrunnable'` warrants an error; `'nagged'` warrants a warning; `'ok'` and\n * `'unknown'` are silent. Comparisons are pure `x.y.z` version compares \u2014 no I/O.\n *\n * @param params - The resolved versions and the app version's metadata entry.\n * @returns The compatibility verdict.\n */\nexport function checkInstallerCompatibility(params: CheckInstallerCompatibilityParams): InstallerCompatibility {\n  const { appVersion, installerVersion, metadata } = params;\n  const minRunnableInstallerVersion = metadata?.minRunnableInstallerVersion;\n  const minRecommendedInstallerVersion = metadata?.minRecommendedInstallerVersion;\n\n  if (installerVersion === undefined || minRunnableInstallerVersion === undefined) {\n    return { appVersion, installerVersion: installerVersion ?? null, tier: 'unknown' };\n  }\n\n  const recommendedFloor = minRecommendedInstallerVersion !== undefined && { minRecommendedInstallerVersion };\n\n  if (compareVersions(installerVersion, minRunnableInstallerVersion) < 0) {\n    return {\n      appVersion,\n      installerVersion,\n      minRunnableInstallerVersion,\n      tier: 'unrunnable',\n      ...recommendedFloor\n    };\n  }\n\n  if (minRecommendedInstallerVersion !== undefined && compareVersions(installerVersion, minRecommendedInstallerVersion) < 0) {\n    return {\n      appVersion,\n      installerVersion,\n      message: `Obsidian installer ${installerVersion} runs Obsidian ${appVersion} but is older than the `\n        + `recommended installer ${minRecommendedInstallerVersion}; update the installer for full compatibility.`,\n      minRecommendedInstallerVersion,\n      minRunnableInstallerVersion,\n      tier: 'nagged'\n    };\n  }\n\n  return {\n    appVersion,\n    installerVersion,\n    minRunnableInstallerVersion,\n    tier: 'ok',\n    ...recommendedFloor\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA6BA,8BAAgC;AA8DzB,SAAS,4BAA4B,QAAmE;AAC7G,QAAM,EAAE,YAAY,kBAAkB,SAAS,IAAI;AACnD,QAAM,8BAA8B,UAAU;AAC9C,QAAM,iCAAiC,UAAU;AAEjD,MAAI,qBAAqB,UAAa,gCAAgC,QAAW;AAC/E,WAAO,EAAE,YAAY,kBAAkB,oBAAoB,MAAM,MAAM,UAAU;AAAA,EACnF;AAEA,QAAM,mBAAmB,mCAAmC,UAAa,EAAE,+BAA+B;AAE1G,UAAI,yCAAgB,kBAAkB,2BAA2B,IAAI,GAAG;AACtE,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA,MAAM;AAAA,MACN,GAAG;AAAA,IACL;AAAA,EACF;AAEA,MAAI,mCAAmC,cAAa,yCAAgB,kBAAkB,8BAA8B,IAAI,GAAG;AACzH,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,SAAS,sBAAsB,gBAAgB,kBAAkB,UAAU,gDAC9C,8BAA8B;AAAA,MAC3D;AAAA,MACA;AAAA,MACA,MAAM;AAAA,IACR;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM;AAAA,IACN,GAAG;AAAA,EACL;AACF;",
  "names": []
}


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

@@ -12,7 +12,10 @@
  *
  * - `minRunnableInstallerVersion` — the run floor. Below it the app cannot boot
  *   (`'unrunnable'`); the caller turns this into a proactive
- *   `IncompatibleInstallerVersionError` before any download/launch.
+ *   `IncompatibleInstallerVersionError` before any download/launch — unless the
+ *   caller has disabled the proactive throw (`shouldThrowOnIncompatibleInstaller`
+ *   `false`), in which case the boot proceeds and the reactive dead-boot fast-fail
+ *   catches it.
  * - `minRecommendedInstallerVersion` — the recommended floor (older versions
  *   only). At/above the run floor but below this, the app runs but is below
  *   Obsidian's recommendation (`'nagged'`), surfaced as a warning.

package/dist/lib/cjs/library.cjs

@@ -21,7 +21,7 @@ __export(library_exports, {
   LIBRARY_VERSION: () => LIBRARY_VERSION
 });
 module.exports = __toCommonJS(library_exports);
-const LIBRARY_VERSION = false ? "dev" : "8.1.2";
+const LIBRARY_VERSION = false ? "dev" : "8.2.1";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LIBRARY_VERSION