obsidian-integration-testing 8.1.0 → 8.1.2

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

@@ -68,9 +68,11 @@ export interface ObsidianAndroidAppiumTransportOptions {
      * Whether the auto-started Appium server console window is shown.
      *
      * When `false` (the default), the `npx appium` server process is spawned with
-     * its console window hidden (`windowsHide`), so it never steals focus. Ignored
-     * when attaching to an already-running Appium server ({@link shouldAutoStartAppium}
-     * `false`, or the server already reachable). Set `true` to see the server log window.
+     * its console window hidden (`windowsHide`) and its output discarded, so it
+     * neither steals focus nor writes to the invoking terminal. Ignored when
+     * attaching to an already-running Appium server ({@link shouldAutoStartAppium}
+     * `false`, or the server already reachable). Set `true` to see the server log window
+     * and its live output.
      *
      * @default `false`
      */
@@ -208,16 +210,17 @@ export interface ObsidianCdpTransportOptions {
     /**
      * Whether the owned desktop Obsidian window is shown on screen.
      *
-     * When `false` (the default), the harness launches the owned instance with
+     * When `false`, the harness launches the owned instance with
      * keep-alive Chromium flags and moves its window **off-screen** once Electron's
      * remote bridge is available, so the run never steals focus or pops a window in
      * front of you. Off-screen (not minimized) keeps the renderer live, so
      * `setTimeout`, `requestAnimationFrame`, `:hover`, and trusted input behave
-     * identically to a visible window. Set `true` to watch the window (e.g. when
-     * debugging). Ignored in attach mode ({@link port} set) — the harness never
+     * identically to a visible window. Defaults to `true`; integration setup
+     * explicitly passes `false` to avoid stealing focus. Ignored in attach mode
+     * ({@link port} set) — the harness never
      * moves the user's own running window.
      *
-     * @default `false`
+     * @default `true`
      */
     readonly isObsidianAppVisible?: boolean;
     /**
@@ -253,6 +256,20 @@ export interface ObsidianCdpTransportOptions {
      * @default `undefined`
      */
     readonly port?: number;
+    /**
+     * Whether to launch the owned instance with Chromium's sandbox disabled
+     * (`--no-sandbox`).
+     *
+     * Needed to boot an owned instance on Linux when there is no
+     * correctly-configured setuid `chrome-sandbox` helper — e.g. a portable shell
+     * extracted from an installer, or a CI runner launching as a non-root user, in
+     * which case the renderer otherwise refuses to start. Harmless on
+     * Windows/macOS. Ignored in attach mode ({@link port} set) — the harness never
+     * relaunches the user's running instance.
+     *
+     * @default `false`
+     */
+    readonly shouldDisableSandbox?: boolean;
     /**
      * Discriminant for the transport type.
      */

package/dist/lib/cjs/visibility.cjs

@@ -18,8 +18,10 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var visibility_exports = {};
 __export(visibility_exports, {
+  NO_SANDBOX_LAUNCH_FLAG: () => NO_SANDBOX_LAUNCH_FLAG,
   OWNED_HIDDEN_LAUNCH_FLAGS: () => OWNED_HIDDEN_LAUNCH_FLAGS,
   resolveOwnedHiddenLaunchArgs: () => resolveOwnedHiddenLaunchArgs,
+  resolveSandboxLaunchArgs: () => resolveSandboxLaunchArgs,
   shouldHideAppiumConsole: () => shouldHideAppiumConsole,
   shouldHideEmulatorWindow: () => shouldHideEmulatorWindow,
   shouldHideObsidianApp: () => shouldHideObsidianApp
@@ -31,9 +33,13 @@ const OWNED_HIDDEN_LAUNCH_FLAGS = [
   "--disable-backgrounding-occluded-windows",
   "--disable-renderer-backgrounding"
 ];
+const NO_SANDBOX_LAUNCH_FLAG = "--no-sandbox";
 function resolveOwnedHiddenLaunchArgs(isObsidianAppVisible) {
   return shouldHideObsidianApp(isObsidianAppVisible) ? [...OWNED_HIDDEN_LAUNCH_FLAGS] : [];
 }
+function resolveSandboxLaunchArgs(shouldDisableSandbox) {
+  return shouldDisableSandbox ?? false ? [NO_SANDBOX_LAUNCH_FLAG] : [];
+}
 function shouldHideAppiumConsole(isAppiumConsoleVisible) {
   return !(isAppiumConsoleVisible ?? false);
 }
@@ -41,14 +47,16 @@ function shouldHideEmulatorWindow(isEmulatorVisible) {
   return !(isEmulatorVisible ?? false);
 }
 function shouldHideObsidianApp(isObsidianAppVisible) {
-  return !(isObsidianAppVisible ?? false);
+  return !(isObsidianAppVisible ?? true);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  NO_SANDBOX_LAUNCH_FLAG,
   OWNED_HIDDEN_LAUNCH_FLAGS,
   resolveOwnedHiddenLaunchArgs,
+  resolveSandboxLaunchArgs,
   shouldHideAppiumConsole,
   shouldHideEmulatorWindow,
   shouldHideObsidianApp
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -3,9 +3,9 @@
  *
  * Pure resolution of the process-visibility options — whether the launched
  * desktop Obsidian window, Android emulator window, and Appium server console
- * are shown on screen. All three surfaces are **hidden by default** (`is*Visible`
- * is `false` when omitted) so an integration run never steals focus or pops
- * windows in front of the user.
+ * are shown on screen. The desktop application is visible by default; integration
+ * setup explicitly requests an off-screen instance so test runs do not steal
+ * focus. Android surfaces are hidden by default.
  *
  * Kept separate from the integration-only launch/spawn code (`transport-factory`,
  * `transport-desktop-cdp`, `obsidian-instance`, all excluded from unit tests) so
@@ -28,15 +28,34 @@
  * the window off-screen rather than minimizing it.
  */
 export declare const OWNED_HIDDEN_LAUNCH_FLAGS: string[];
+/**
+ * Chromium switch that disables the setuid sandbox for an owned instance.
+ *
+ * Electron's Linux sandbox needs a correctly-configured (root-owned, setuid)
+ * `chrome-sandbox` helper. A portable shell extracted from an installer — and a
+ * CI runner launching it as a non-root user — has no such helper, so the
+ * renderer refuses to start ("The SUID sandbox helper binary was found, but is
+ * not configured correctly"). Passing `--no-sandbox` disables it. It is harmless
+ * on Windows/macOS (their sandbox is unaffected by extraction), so an owned test
+ * instance can pass it uniformly across platforms.
+ */
+export declare const NO_SANDBOX_LAUNCH_FLAG = "--no-sandbox";
 /**
  * Resolves the extra Chromium launch args for an owned desktop instance: the
- * {@link OWNED_HIDDEN_LAUNCH_FLAGS} when the window is hidden (the default), or
- * an empty list when it is visible.
+ * {@link OWNED_HIDDEN_LAUNCH_FLAGS} when the window is hidden, or an empty list
+ * when it is visible (the default).
  *
- * @param isObsidianAppVisible - The resolved option value (omitted → hidden).
+ * @param isObsidianAppVisible - The resolved option value (omitted → visible).
  * @returns The extra launch args (possibly empty).
  */
 export declare function resolveOwnedHiddenLaunchArgs(isObsidianAppVisible?: boolean): string[];
+/**
+ * Resolves the extra Chromium launch args for disabling the sandbox.
+ *
+ * @param shouldDisableSandbox - The resolved option value (omitted → sandbox kept).
+ * @returns `[{@link NO_SANDBOX_LAUNCH_FLAG}]` when the sandbox should be disabled, else `[]`.
+ */
+export declare function resolveSandboxLaunchArgs(shouldDisableSandbox?: boolean): string[];
 /**
  * Whether the auto-started Appium server console window should be hidden.
  *
@@ -55,7 +74,7 @@ export declare function shouldHideEmulatorWindow(isEmulatorVisible?: boolean): b
 /**
  * Whether the owned desktop Obsidian window should be hidden (moved off-screen).
  *
- * @param isObsidianAppVisible - The resolved option value (omitted → hidden).
- * @returns `true` when the window should be hidden (the default).
+ * @param isObsidianAppVisible - The resolved option value (omitted → visible).
+ * @returns `true` when the window should be hidden.
  */
 export declare function shouldHideObsidianApp(isObsidianAppVisible?: boolean): boolean;

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

@@ -13,6 +13,7 @@
 import type { Except } from 'type-fest';
 import type { ContextId } from './context-id.mjs';
 import type { EvalInObsidianParams, GenericObject } from './eval-in-obsidian.mjs';
+import type { InstallerCompatibility } from './installer-compatibility.mjs';
 import { TempVault } from './temp-vault.mjs';
 /**
  * A live connection to a CDP-enabled Obsidian instance with the runtime helper
@@ -27,6 +28,14 @@ export interface CdpConnection extends AsyncDisposable {
      * The base CDP URL, e.g. `http://localhost:51888`.
      */
     readonly cdpUrl: string;
+    /**
+     * 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.
+     */
+    readonly compatibility?: InstallerCompatibility | undefined;
     /**
      * Disposes the connection: kills an owned instance and removes its isolated
      * user-data dir. The vault directory is removed only when it is a throw-away
@@ -94,9 +103,8 @@ export interface ConnectToCdpOptions {
      */
     readonly host?: string;
     /**
-     * Whether the Obsidian window is shown on screen. Unlike the test transports
-     * (hidden by default), `connectToCdp` **defaults to `true`** — it is meant for
-     * watching/debugging a real Obsidian. Set `false` to launch it off-screen.
+     * Whether the Obsidian window is shown on screen. Defaults to `true`; set
+     * `false` to launch it off-screen.
      * Ignored in attach mode ({@link port} set).
      *
      * @default `true`
@@ -125,6 +133,18 @@ export interface ConnectToCdpOptions {
      * @default `undefined`
      */
     readonly port?: number;
+    /**
+     * Whether to launch the owned instance with Chromium's sandbox disabled
+     * (`--no-sandbox`).
+     *
+     * Needed to boot on Linux without a correctly-configured setuid
+     * `chrome-sandbox` helper (e.g. an installer-extracted portable shell, or CI
+     * running as a non-root user); harmless on Windows/macOS. Ignored in attach
+     * mode ({@link port} set).
+     *
+     * @default `false`
+     */
+    readonly shouldDisableSandbox?: boolean;
     /**
      * Whether to remove the vault directory on {@link CdpConnection.dispose}.
      *

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

@@ -4,24 +4,16 @@ import { DesktopCdpTransport } from "./transport-desktop-cdp.mjs";
 import { createTransportFromOptions } from "./transport-factory.mjs";
 const DEFAULT_CDP_HOST = "localhost";
 async function connectToCdp(options) {
-  const transportOptions = {
-    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 }
-  };
-  const transport = await createTransportFromOptions(transportOptions);
+  const transport = await createTransportFromOptions(buildCdpTransportOptions(options));
   const vault = new TempVault(options?.vault);
   const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? options?.vault === void 0;
   await vault.register(transport);
   const { host, port } = resolveEndpoint(transport, options);
   const cdpUrl = `http://${host}:${String(port)}`;
+  const compatibility = transport instanceof DesktopCdpTransport ? transport.getCompatibility() : void 0;
   const connection = {
     cdpUrl,
+    ...compatibility && { compatibility },
     async dispose() {
       try {
         if (shouldRemoveVaultOnDispose) {
@@ -47,6 +39,19 @@ async function connectToCdp(options) {
   };
   return connection;
 }
+function buildCdpTransportOptions(options) {
+  return {
+    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 }
+  };
+}
 function resolveEndpoint(transport, options) {
   if (transport instanceof DesktopCdpTransport) {
     const endpoint = transport.getOwnedInstanceEndpoint();
@@ -62,4 +67,4 @@ function resolveEndpoint(transport, options) {
 export {
   connectToCdp
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * the base `lib` helpers, `errorToString`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { ContextId } from './context-id.mjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { TempVault } from './temp-vault.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\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. Unlike the test transports\n   * (hidden by default), `connectToCdp` **defaults to `true`** \u2014 it is meant for\n   * watching/debugging a real Obsidian. Set `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 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 transportOptions: ObsidianCdpTransportOptions = {\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  };\n\n  const transport = await createTransportFromOptions(transportOptions);\n  const vault = new TempVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n\n  const connection: CdpConnection = {\n    cdpUrl,\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 * 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": "AAwBA,SAAS,sBAAsB;AAC/B,SAAS,iBAAiB;AAC1B,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAE3C,MAAM,mBAAmB;AAkKzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,mBAAgD;AAAA,IACpD,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,EAC1D;AAEA,QAAM,YAAY,MAAM,2BAA2B,gBAAgB;AACnE,QAAM,QAAQ,IAAI,UAAU,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;AAE7C,QAAM,aAA4B;AAAA,IAChC;AAAA,IAEA,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,aAAO,eAAyC,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;AAWA,SAAS,gBAAgB,WAAoB,SAA4D;AACvG,MAAI,qBAAqB,qBAAqB;AAC5C,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,aAAO,EAAE,MAAM,SAAS,MAAM,MAAM,SAAS,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,MAAI,SAAS,SAAS,QAAW;AAC/B,WAAO,EAAE,MAAM,QAAQ,QAAQ,kBAAkB,MAAM,QAAQ,KAAK;AAAA,EACtE;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;",
  "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.mjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { InstallerCompatibility } from './installer-compatibility.mjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { TempVault } from './temp-vault.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The 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": "AAyBA,SAAS,sBAAsB;AAC/B,SAAS,iBAAiB;AAC1B,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAE3C,MAAM,mBAAmB;AAuLzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,YAAY,MAAM,2BAA2B,yBAAyB,OAAO,CAAC;AACpF,QAAM,QAAQ,IAAI,UAAU,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,sBAAsB,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,aAAO,eAAyC,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,qBAAqB;AAC5C,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,aAAO,EAAE,MAAM,SAAS,MAAM,MAAM,SAAS,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,MAAI,SAAS,SAAS,QAAW;AAC/B,WAAO,EAAE,MAAM,QAAQ,QAAQ,kBAAkB,MAAM,QAAQ,KAAK;AAAA,EACtE;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;",
  "names": []
}


package/dist/lib/esm/context-provider.d.mts

@@ -20,7 +20,7 @@ export type VaultPathResolver = () => string | undefined;
 /**
  * Returns the transport options resolved by the registered framework adapter.
  *
- * @returns The transport options, or `undefined` if not configured (defaults to CLI transport).
+ * @returns The transport options, or `undefined` if not configured.
  */
 export declare function getTransportOptions(): ObsidianTransportOptions | undefined;
 /**

package/dist/lib/esm/context-provider.mjs

@@ -18,4 +18,4 @@ export {
   setTransportOptionsResolver,
   setVaultPathResolver
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/global-setup-core.d.mts

@@ -20,7 +20,7 @@ export interface CoreSetupParams {
      * forcing a re-scan is far slower and less reliable.
      */
     readonly populate?: PopulateFilesParams | undefined;
-    /** Transport options. When omitted, defaults to the CLI transport. */
+    /** Transport options. When omitted, uses an off-screen owned desktop instance. */
     readonly transportOptions?: ObsidianTransportOptions | undefined;
 }
 /**
@@ -56,3 +56,13 @@ export declare function coreSetup(params?: CoreSetupParams): Promise<CoreSetupRe
  * @param result - The result from {@link coreSetup}. When `undefined`, does nothing.
  */
 export declare function coreTeardown(result?: CoreSetupResult): Promise<void>;
+/**
+ * Resolves transport options for an integration run.
+ *
+ * Desktop launches are normally visible, but test setup explicitly keeps its
+ * owned instance off-screen so it does not interrupt the developer.
+ *
+ * @param options - Consumer-provided transport options.
+ * @returns Options with the desktop integration visibility default applied.
+ */
+export declare function resolveIntegrationTransportOptions(options?: ObsidianTransportOptions): ObsidianTransportOptions;

package/dist/lib/esm/global-setup-core.mjs

@@ -38,8 +38,8 @@ async function coreSetup(params) {
   if (existsSync(envFilePath)) {
     loadEnvFile(envFilePath);
   }
-  const transportOptions = params?.transportOptions;
-  const label = transportOptions?.type ?? DEFAULT_TRANSPORT_TYPE;
+  const transportOptions = resolveIntegrationTransportOptions(params?.transportOptions);
+  const label = transportOptions.type;
   const lockScope = getLockScope(transportOptions);
   let lock;
   if (lockScope !== void 0) {
@@ -135,6 +135,16 @@ async function coreTeardown(result) {
     releaseSetupLock(result);
   }
 }
+function resolveIntegrationTransportOptions(options) {
+  if (options?.type === "obsidian-android-appium") {
+    return options;
+  }
+  return {
+    ...options,
+    isObsidianAppVisible: options?.isObsidianAppVisible ?? false,
+    type: "obsidian-cdp"
+  };
+}
 function augmentTransportOptions(options, transport) {
   if (options?.type === "obsidian-android-appium" && transport instanceof AppiumTransport) {
     const sessionInfo = transport.getSessionInfo();
@@ -263,6 +273,7 @@ async function teardownAsync(result) {
 }
 export {
   coreSetup,
-  coreTeardown
+  coreTeardown,
+  resolveIntegrationTransportOptions
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/global-setup-core.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Framework-agnostic core logic for integration test global setup and teardown.\n *\n * Vitest and Jest adapters delegate to these functions.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { PluginManifest } from 'obsidian';\n\nimport {\n  existsSync,\n  rmSync\n} from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  readFile,\n  stat,\n  writeFile\n} from 'node:fs/promises';\nimport { join } from 'node:path';\nimport process, { loadEnvFile } from 'node:process';\n\nimport type { SetupLock } from './setup-lock.mjs';\nimport type { PopulateFilesParams } from './temp-vault.mjs';\nimport type { ObsidianTransportOptions } from './transport-options.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { enablePluginWithErrorCapture } from './enable-plugin.mjs';\nimport { errorToString } from './error-to-string.mjs';\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { log } from './log.mjs';\nimport { acquireSetupLock } from './setup-lock.mjs';\nimport { TempVault } from './temp-vault.mjs';\nimport { AppiumTransport } from './transport-appium.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\n\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cdp';\nconst DIST_DEV = 'dist/dev';\nconst DIST_BUILD = 'dist/build';\nconst MAIN_JS = 'main.js';\nconst OBSIDIAN_CONFIG_DIR = '.obsidian';\nconst PLUGINS_DIR = 'plugins';\nconst COMMUNITY_PLUGINS_JSON = 'community-plugins.json';\n\n/**\n * Tracks setups that completed successfully but haven't been torn down yet.\n * Used by the `beforeExit` handler to clean up when a test runner exits\n * without calling teardown (e.g., when one project's setup fails and the\n * runner aborts before tearing down already-initialized projects).\n */\nconst activeSetups = new Set<CoreSetupResult>();\nconst disposedResults = new WeakSet<CoreSetupResult>();\nlet isCleanupHandlerRegistered = false;\n\n/**\n * The cross-process setup lock held by each active setup. Released when the\n * setup is torn down (or by the process cleanup handlers), allowing a competing\n * run to proceed. See {@link acquireSetupLock}.\n */\nconst setupLocks = new Map<CoreSetupResult, SetupLock>();\n\nconst ANDROID_LOCK_SCOPE = 'android';\n\n/**\n * Parameters for {@link coreSetup}.\n */\nexport interface CoreSetupParams {\n  /**\n   * Files and folders to write into the vault **before** Obsidian opens it, so\n   * its startup scan indexes them in one pass (see {@link TempVault.populate}).\n   * Use this for large fixtures \u2014 writing thousands of notes after open and\n   * forcing a re-scan is far slower and less reliable.\n   */\n  readonly populate?: PopulateFilesParams | undefined;\n\n  /** Transport options. When omitted, defaults to the CLI transport. */\n  readonly transportOptions?: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Result returned by {@link coreSetup}, used by framework adapters\n * to pass context to test workers.\n */\nexport interface CoreSetupResult {\n  /** The temporary vault created during setup. */\n  readonly tempVault: TempVault;\n\n  /** The transport instance used during setup. */\n  readonly transport: ObsidianTransport;\n\n  /** Short label for log messages (e.g. `\"obsidian-cdp\"`). */\n  readonly transportLabel: string;\n\n  /** The transport options that were resolved. */\n  readonly transportOptions: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Framework-agnostic global setup logic.\n *\n * Loads `.env` from the project root, creates a transport, copies the built\n * plugin into a temporary vault, registers the vault with Obsidian, and\n * enables the plugin.\n *\n * @param params - Setup parameters.\n * @returns The setup result containing the temp vault, transport, and resolved options.\n */\nexport async function coreSetup(params?: CoreSetupParams): Promise<CoreSetupResult> {\n  const projectRoot = findProjectRoot();\n  const envFilePath = join(projectRoot, '.env');\n  if (existsSync(envFilePath)) {\n    loadEnvFile(envFilePath);\n  }\n\n  const transportOptions = params?.transportOptions;\n  const label = transportOptions?.type ?? DEFAULT_TRANSPORT_TYPE;\n  const lockScope = getLockScope(transportOptions);\n\n  let lock: SetupLock | undefined;\n  if (lockScope !== undefined) {\n    log(`[integration-setup:${label}] Acquiring '${lockScope}' setup lock (serializes against any concurrent integration-test run)...`);\n    lock = await acquireSetupLock({ label, scope: lockScope });\n    log(`[integration-setup:${label}] Setup lock acquired.`);\n  }\n\n  let transport: ObsidianTransport | undefined;\n  let tempVault: TempVault | undefined;\n\n  try {\n    log(`[integration-setup:${label}] Creating transport...`);\n    transport = await createTransportFromOptions(transportOptions);\n    log(`[integration-setup:${label}] Transport created: ${transport.constructor.name}`);\n\n    log(`[integration-setup:${label}] Project root: ${projectRoot}`);\n    const distPath = await resolveDistPath(projectRoot);\n    const manifestJson = JSON.parse(await readFile(join(distPath, 'manifest.json'), 'utf-8')) as PluginManifest;\n    const pluginId = manifestJson.id;\n\n    if (transport.isMobile && manifestJson.isDesktopOnly) {\n      throw new Error(\n        `Plugin \"${pluginId}\" has isDesktopOnly: true in manifest.json. Mobile integration tests cannot run for desktop-only plugins.`\n      );\n    }\n\n    const mainJs = join(distPath, MAIN_JS);\n    const buildStat = await stat(mainJs);\n\n    log(`[integration-setup:${label}] Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);\n\n    tempVault = new TempVault();\n    log(`[integration-setup:${label}] Created temp vault: ${tempVault.path}`);\n    const pluginDir = join(tempVault.path, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);\n    await mkdir(pluginDir, { recursive: true });\n    await cp(distPath, pluginDir, { recursive: true });\n    await writeFile(join(tempVault.path, OBSIDIAN_CONFIG_DIR, COMMUNITY_PLUGINS_JSON), JSON.stringify([pluginId]));\n\n    if (params?.populate) {\n      const entryCount = Object.keys(params.populate).length;\n      log(`[integration-setup:${label}] Populating vault with ${String(entryCount)} entries before open...`);\n      tempVault.populate(params.populate);\n    }\n\n    log(`[integration-setup:${label}] Syncing vault to device...`);\n    await tempVault.syncToDevice(transport);\n    log(`[integration-setup:${label}] Registering vault...`);\n    await tempVault.register(transport);\n    log(`[integration-setup:${label}] Vault registered.`);\n\n    // Enable the plugin and verify it loaded. Obsidian's enablePlugin() wraps\n    // LoadPlugin() in a try-catch that swallows errors and returns false.\n    // We monkey-patch loadPlugin() to capture the error before it's swallowed.\n    log(`[integration-setup:${label}] Enabling plugin \"${pluginId}\"...`);\n    const { errorMessage } = await evalInObsidian({\n      args: { pluginId },\n      fn: enablePluginWithErrorCapture,\n      shouldSkipPreflightChecks: true,\n      transport,\n      vaultPath: tempVault.path\n    });\n\n    if (errorMessage) {\n      throw new Error(`Plugin \"${pluginId}\" failed to load: ${errorMessage}`);\n    }\n\n    log(`[integration-setup:${label}] Plugin \"${pluginId}\" enabled successfully.`);\n\n    const augmentedOptions = augmentTransportOptions(transportOptions, transport);\n    const result: CoreSetupResult = { tempVault, transport, transportLabel: label, transportOptions: augmentedOptions };\n    activeSetups.add(result);\n    if (lock) {\n      setupLocks.set(result, lock);\n    }\n    registerProcessCleanupHandler();\n    return result;\n  } catch (error: unknown) {\n    log(`[integration-setup:${label}] Setup failed, cleaning up...`);\n    try {\n      if (tempVault && transport) {\n        await tempVault.dispose(transport);\n      }\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Vault cleanup error (non-fatal): ${errorToString(cleanupError)}`);\n    }\n    try {\n      await transport?.dispose?.();\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Transport cleanup error (non-fatal): ${errorToString(cleanupError)}`);\n    }\n\n    // Release the lock so a waiting run can proceed even though this run failed.\n    lock?.release();\n\n    log(`[integration-setup:${label}] NOTE: If the test runner reports \"No test files found\", ignore it \u2014 it is a side effect of the setup failure above.`);\n    throw error;\n  }\n}\n\n/**\n * Framework-agnostic global teardown logic.\n *\n * Disposes of the temporary vault and transport created during setup.\n *\n * @param result - The result from {@link coreSetup}. When `undefined`, does nothing.\n */\nexport async function coreTeardown(result?: CoreSetupResult): Promise<void> {\n  if (!result || disposedResults.has(result)) {\n    return;\n  }\n  disposedResults.add(result);\n\n  log(`[integration-teardown:${result.transportLabel}] Tearing down...`);\n\n  try {\n    await teardownAsync(result);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Cleanup error (non-fatal): ${errorToString(error)}`);\n  } finally {\n    activeSetups.delete(result);\n    releaseSetupLock(result);\n  }\n}\n\n/**\n * Augments transport options with reuse info so test workers can reattach to the\n * instance the global setup already launched instead of creating their own:\n *\n * - **Appium** \u2014 injects the established `sessionId`/`deviceId`.\n * - **Owned desktop CDP** \u2014 injects the owned instance's `host`/`port` (chosen\n *   at launch) plus the internal `isHarnessOwnedInstance` flag, so each worker\n *   **attaches** to that instance over CDP rather than launching (and never\n *   registering) its own \u2014 the bug that otherwise leaves a worker's transport\n *   with no CDP endpoint.\n *\n * @param options - The original transport options.\n * @param transport - The transport instance created during setup.\n * @returns The augmented options, or the original options if not applicable.\n */\nfunction augmentTransportOptions(\n  options: ObsidianTransportOptions | undefined,\n  transport: ObsidianTransport\n): ObsidianTransportOptions | undefined {\n  if (options?.type === 'obsidian-android-appium' && transport instanceof AppiumTransport) {\n    const sessionInfo = transport.getSessionInfo();\n    log(`[integration-setup:${options.type}] Session reuse info: sessionId=${sessionInfo.sessionId}, deviceId=${sessionInfo.deviceId}`);\n    return {\n      ...options,\n      deviceId: sessionInfo.deviceId,\n      sessionId: sessionInfo.sessionId\n    };\n  }\n\n  if ((options === undefined || options.type === 'obsidian-cdp') && transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      log(`[integration-setup:${DEFAULT_TRANSPORT_TYPE}] Owned instance reuse info: host=${endpoint.host}, port=${String(endpoint.port)}`);\n      return {\n        ...options,\n        host: endpoint.host,\n        isHarnessOwnedInstance: true,\n        port: endpoint.port,\n        type: 'obsidian-cdp'\n      };\n    }\n  }\n\n  return options;\n}\n\n/**\n * Finds the project root by walking up from `process.cwd()` looking for `package.json`.\n *\n * @returns The absolute path to the project root.\n */\nfunction findProjectRoot(): string {\n  let dir = process.cwd();\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Loop terminates at filesystem root.\n  while (true) {\n    if (existsSync(join(dir, 'package.json'))) {\n      return dir;\n    }\n    const parent = join(dir, '..');\n    if (parent === dir) {\n      throw new Error('Could not find project root (no package.json found).');\n    }\n    dir = parent;\n  }\n}\n\n/**\n * Resolves the cross-process lock scope for a transport, or `undefined` when no\n * lock is needed.\n *\n * Desktop runs use harness-owned, isolated instances (their own user-data dir\n * and CDP port), so they no longer contend and need no lock. Only the Android\n * transport, which shares the single emulator and Appium server, must serialize.\n *\n * @param transportOptions - The resolved transport options.\n * @returns The lock scope string, or `undefined` if no lock is needed.\n */\nfunction getLockScope(transportOptions: ObsidianTransportOptions | undefined): string | undefined {\n  return transportOptions?.type === 'obsidian-android-appium' ? ANDROID_LOCK_SCOPE : undefined;\n}\n\n/**\n * Registers cleanup handlers for orphaned setups that were never explicitly\n * torn down.\n *\n * Two handlers cover different exit scenarios:\n *\n * - `beforeExit` \u2014 fires when the event loop drains naturally. Allows full\n *   async teardown (unregister vaults, dispose transports). Does NOT fire\n *   when `process.exit()` is called directly.\n *\n * - `unhandledRejection` \u2014 catches async errors that bypass `coreSetup`'s\n *   catch block. Performs full async teardown while we still can.\n *\n * - `exit` \u2014 fires on every exit, including `process.exit()`. Only synchronous\n *   work is possible, so this handler does best-effort cleanup: kills child\n *   processes via `disposeSync()` and removes temp vault directories with\n *   `rmSync`. Unregistering vaults (which requires IPC with Obsidian) is\n *   skipped \u2014 a stale vault entry is an acceptable trade-off vs. leaked\n *   processes and temp directories.\n */\nfunction registerProcessCleanupHandler(): void {\n  if (isCleanupHandlerRegistered) {\n    return;\n  }\n  isCleanupHandlerRegistered = true;\n\n  process.on('beforeExit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Process exiting with ${String(activeSetups.size)} setup(s) not torn down. Cleaning up...`);\n\n    for (const result of [...activeSetups]) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Process cleanup error (non-fatal): ${errorToString(error)}`);\n      });\n    }\n  });\n\n  process.on('unhandledRejection', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Unhandled rejection detected. Tearing down ${String(activeSetups.size)} active setup(s)...`);\n    for (const result of [...activeSetups]) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Rejection cleanup error (non-fatal): ${errorToString(error)}`);\n      });\n    }\n  });\n\n  process.on('exit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Sync cleanup: ${String(activeSetups.size)} orphaned setup(s).`);\n    for (const result of [...activeSetups]) {\n      try {\n        result.transport.disposeSync?.();\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync transport cleanup error (non-fatal): ${errorToString(error)}`);\n      }\n      try {\n        rmSync(result.tempVault.path, { force: true, recursive: true });\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync vault cleanup error (non-fatal): ${errorToString(error)}`);\n      }\n      releaseSetupLock(result);\n    }\n    activeSetups.clear();\n  });\n}\n\n/**\n * Releases and forgets the setup lock associated with a result, if any.\n *\n * @param result - The setup result whose lock should be released.\n */\nfunction releaseSetupLock(result: CoreSetupResult): void {\n  const lock = setupLocks.get(result);\n  if (lock) {\n    lock.release();\n    setupLocks.delete(result);\n  }\n}\n\n/**\n * Resolves the dist path to use for integration tests.\n *\n * Picks whichever of `dist/dev` and `dist/build` has a newer `main.js`.\n * If only one exists, that one is used. Throws if neither exists.\n *\n * @param projectRoot - The absolute path to the project root.\n * @returns The absolute path to the chosen dist folder.\n */\nasync function resolveDistPath(projectRoot: string): Promise<string> {\n  const devPath = join(projectRoot, DIST_DEV);\n  const buildPath = join(projectRoot, DIST_BUILD);\n  const devMainJs = join(devPath, MAIN_JS);\n  const buildMainJs = join(buildPath, MAIN_JS);\n  const devStat = existsSync(devMainJs) ? await stat(devMainJs) : null;\n  const buildStat = existsSync(buildMainJs) ? await stat(buildMainJs) : null;\n\n  if (devStat && buildStat) {\n    return devStat.mtime > buildStat.mtime ? devPath : buildPath;\n  }\n\n  if (devStat) {\n    return devPath;\n  }\n\n  if (buildStat) {\n    return buildPath;\n  }\n\n  throw new Error('No build found. Run `npm run build` or `npm run dev` first.');\n}\n\n/**\n * Performs the async teardown work (vault disposal + transport disposal).\n *\n * @param result - The setup result to tear down.\n */\nasync function teardownAsync(result: CoreSetupResult): Promise<void> {\n  try {\n    await result.tempVault.dispose(result.transport);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Vault cleanup error (non-fatal): ${errorToString(error)}`);\n  }\n\n  try {\n    await result.transport.dispose?.();\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Transport cleanup error (non-fatal): ${errorToString(error)}`);\n  }\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/global-setup-core.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Framework-agnostic core logic for integration test global setup and teardown.\n *\n * Vitest and Jest adapters delegate to these functions.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { PluginManifest } from 'obsidian';\n\nimport {\n  existsSync,\n  rmSync\n} from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  readFile,\n  stat,\n  writeFile\n} from 'node:fs/promises';\nimport { join } from 'node:path';\nimport process, { loadEnvFile } from 'node:process';\n\nimport type { SetupLock } from './setup-lock.mjs';\nimport type { PopulateFilesParams } from './temp-vault.mjs';\nimport type { ObsidianTransportOptions } from './transport-options.mjs';\nimport type { ObsidianTransport } from './transport.mjs';\n\nimport { enablePluginWithErrorCapture } from './enable-plugin.mjs';\nimport { errorToString } from './error-to-string.mjs';\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { log } from './log.mjs';\nimport { acquireSetupLock } from './setup-lock.mjs';\nimport { TempVault } from './temp-vault.mjs';\nimport { AppiumTransport } from './transport-appium.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\n\nconst DEFAULT_TRANSPORT_TYPE = 'obsidian-cdp';\nconst DIST_DEV = 'dist/dev';\nconst DIST_BUILD = 'dist/build';\nconst MAIN_JS = 'main.js';\nconst OBSIDIAN_CONFIG_DIR = '.obsidian';\nconst PLUGINS_DIR = 'plugins';\nconst COMMUNITY_PLUGINS_JSON = 'community-plugins.json';\n\n/**\n * Tracks setups that completed successfully but haven't been torn down yet.\n * Used by the `beforeExit` handler to clean up when a test runner exits\n * without calling teardown (e.g., when one project's setup fails and the\n * runner aborts before tearing down already-initialized projects).\n */\nconst activeSetups = new Set<CoreSetupResult>();\nconst disposedResults = new WeakSet<CoreSetupResult>();\nlet isCleanupHandlerRegistered = false;\n\n/**\n * The cross-process setup lock held by each active setup. Released when the\n * setup is torn down (or by the process cleanup handlers), allowing a competing\n * run to proceed. See {@link acquireSetupLock}.\n */\nconst setupLocks = new Map<CoreSetupResult, SetupLock>();\n\nconst ANDROID_LOCK_SCOPE = 'android';\n\n/**\n * Parameters for {@link coreSetup}.\n */\nexport interface CoreSetupParams {\n  /**\n   * Files and folders to write into the vault **before** Obsidian opens it, so\n   * its startup scan indexes them in one pass (see {@link TempVault.populate}).\n   * Use this for large fixtures \u2014 writing thousands of notes after open and\n   * forcing a re-scan is far slower and less reliable.\n   */\n  readonly populate?: PopulateFilesParams | undefined;\n\n  /** Transport options. When omitted, uses an off-screen owned desktop instance. */\n  readonly transportOptions?: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Result returned by {@link coreSetup}, used by framework adapters\n * to pass context to test workers.\n */\nexport interface CoreSetupResult {\n  /** The temporary vault created during setup. */\n  readonly tempVault: TempVault;\n\n  /** The transport instance used during setup. */\n  readonly transport: ObsidianTransport;\n\n  /** Short label for log messages (e.g. `\"obsidian-cdp\"`). */\n  readonly transportLabel: string;\n\n  /** The transport options that were resolved. */\n  readonly transportOptions: ObsidianTransportOptions | undefined;\n}\n\n/**\n * Framework-agnostic global setup logic.\n *\n * Loads `.env` from the project root, creates a transport, copies the built\n * plugin into a temporary vault, registers the vault with Obsidian, and\n * enables the plugin.\n *\n * @param params - Setup parameters.\n * @returns The setup result containing the temp vault, transport, and resolved options.\n */\nexport async function coreSetup(params?: CoreSetupParams): Promise<CoreSetupResult> {\n  const projectRoot = findProjectRoot();\n  const envFilePath = join(projectRoot, '.env');\n  if (existsSync(envFilePath)) {\n    loadEnvFile(envFilePath);\n  }\n\n  const transportOptions = resolveIntegrationTransportOptions(params?.transportOptions);\n  const label = transportOptions.type;\n  const lockScope = getLockScope(transportOptions);\n\n  let lock: SetupLock | undefined;\n  if (lockScope !== undefined) {\n    log(`[integration-setup:${label}] Acquiring '${lockScope}' setup lock (serializes against any concurrent integration-test run)...`);\n    lock = await acquireSetupLock({ label, scope: lockScope });\n    log(`[integration-setup:${label}] Setup lock acquired.`);\n  }\n\n  let transport: ObsidianTransport | undefined;\n  let tempVault: TempVault | undefined;\n\n  try {\n    log(`[integration-setup:${label}] Creating transport...`);\n    transport = await createTransportFromOptions(transportOptions);\n    log(`[integration-setup:${label}] Transport created: ${transport.constructor.name}`);\n\n    log(`[integration-setup:${label}] Project root: ${projectRoot}`);\n    const distPath = await resolveDistPath(projectRoot);\n    const manifestJson = JSON.parse(await readFile(join(distPath, 'manifest.json'), 'utf-8')) as PluginManifest;\n    const pluginId = manifestJson.id;\n\n    if (transport.isMobile && manifestJson.isDesktopOnly) {\n      throw new Error(\n        `Plugin \"${pluginId}\" has isDesktopOnly: true in manifest.json. Mobile integration tests cannot run for desktop-only plugins.`\n      );\n    }\n\n    const mainJs = join(distPath, MAIN_JS);\n    const buildStat = await stat(mainJs);\n\n    log(`[integration-setup:${label}] Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);\n\n    tempVault = new TempVault();\n    log(`[integration-setup:${label}] Created temp vault: ${tempVault.path}`);\n    const pluginDir = join(tempVault.path, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);\n    await mkdir(pluginDir, { recursive: true });\n    await cp(distPath, pluginDir, { recursive: true });\n    await writeFile(join(tempVault.path, OBSIDIAN_CONFIG_DIR, COMMUNITY_PLUGINS_JSON), JSON.stringify([pluginId]));\n\n    if (params?.populate) {\n      const entryCount = Object.keys(params.populate).length;\n      log(`[integration-setup:${label}] Populating vault with ${String(entryCount)} entries before open...`);\n      tempVault.populate(params.populate);\n    }\n\n    log(`[integration-setup:${label}] Syncing vault to device...`);\n    await tempVault.syncToDevice(transport);\n    log(`[integration-setup:${label}] Registering vault...`);\n    await tempVault.register(transport);\n    log(`[integration-setup:${label}] Vault registered.`);\n\n    // Enable the plugin and verify it loaded. Obsidian's enablePlugin() wraps\n    // LoadPlugin() in a try-catch that swallows errors and returns false.\n    // We monkey-patch loadPlugin() to capture the error before it's swallowed.\n    log(`[integration-setup:${label}] Enabling plugin \"${pluginId}\"...`);\n    const { errorMessage } = await evalInObsidian({\n      args: { pluginId },\n      fn: enablePluginWithErrorCapture,\n      shouldSkipPreflightChecks: true,\n      transport,\n      vaultPath: tempVault.path\n    });\n\n    if (errorMessage) {\n      throw new Error(`Plugin \"${pluginId}\" failed to load: ${errorMessage}`);\n    }\n\n    log(`[integration-setup:${label}] Plugin \"${pluginId}\" enabled successfully.`);\n\n    const augmentedOptions = augmentTransportOptions(transportOptions, transport);\n    const result: CoreSetupResult = { tempVault, transport, transportLabel: label, transportOptions: augmentedOptions };\n    activeSetups.add(result);\n    if (lock) {\n      setupLocks.set(result, lock);\n    }\n    registerProcessCleanupHandler();\n    return result;\n  } catch (error: unknown) {\n    log(`[integration-setup:${label}] Setup failed, cleaning up...`);\n    try {\n      if (tempVault && transport) {\n        await tempVault.dispose(transport);\n      }\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Vault cleanup error (non-fatal): ${errorToString(cleanupError)}`);\n    }\n    try {\n      await transport?.dispose?.();\n    } catch (cleanupError: unknown) {\n      log(`[integration-setup:${label}] Transport cleanup error (non-fatal): ${errorToString(cleanupError)}`);\n    }\n\n    // Release the lock so a waiting run can proceed even though this run failed.\n    lock?.release();\n\n    log(`[integration-setup:${label}] NOTE: If the test runner reports \"No test files found\", ignore it \u2014 it is a side effect of the setup failure above.`);\n    throw error;\n  }\n}\n\n/**\n * Framework-agnostic global teardown logic.\n *\n * Disposes of the temporary vault and transport created during setup.\n *\n * @param result - The result from {@link coreSetup}. When `undefined`, does nothing.\n */\nexport async function coreTeardown(result?: CoreSetupResult): Promise<void> {\n  if (!result || disposedResults.has(result)) {\n    return;\n  }\n  disposedResults.add(result);\n\n  log(`[integration-teardown:${result.transportLabel}] Tearing down...`);\n\n  try {\n    await teardownAsync(result);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Cleanup error (non-fatal): ${errorToString(error)}`);\n  } finally {\n    activeSetups.delete(result);\n    releaseSetupLock(result);\n  }\n}\n\n/**\n * Resolves transport options for an integration run.\n *\n * Desktop launches are normally visible, but test setup explicitly keeps its\n * owned instance off-screen so it does not interrupt the developer.\n *\n * @param options - Consumer-provided transport options.\n * @returns Options with the desktop integration visibility default applied.\n */\nexport function resolveIntegrationTransportOptions(options?: ObsidianTransportOptions): ObsidianTransportOptions {\n  if (options?.type === 'obsidian-android-appium') {\n    return options;\n  }\n\n  return {\n    ...options,\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? false,\n    type: 'obsidian-cdp'\n  };\n}\n\n/**\n * Augments transport options with reuse info so test workers can reattach to the\n * instance the global setup already launched instead of creating their own:\n *\n * - **Appium** \u2014 injects the established `sessionId`/`deviceId`.\n * - **Owned desktop CDP** \u2014 injects the owned instance's `host`/`port` (chosen\n *   at launch) plus the internal `isHarnessOwnedInstance` flag, so each worker\n *   **attaches** to that instance over CDP rather than launching (and never\n *   registering) its own \u2014 the bug that otherwise leaves a worker's transport\n *   with no CDP endpoint.\n *\n * @param options - The original transport options.\n * @param transport - The transport instance created during setup.\n * @returns The augmented options, or the original options if not applicable.\n */\nfunction augmentTransportOptions(\n  options: ObsidianTransportOptions | undefined,\n  transport: ObsidianTransport\n): ObsidianTransportOptions | undefined {\n  if (options?.type === 'obsidian-android-appium' && transport instanceof AppiumTransport) {\n    const sessionInfo = transport.getSessionInfo();\n    log(`[integration-setup:${options.type}] Session reuse info: sessionId=${sessionInfo.sessionId}, deviceId=${sessionInfo.deviceId}`);\n    return {\n      ...options,\n      deviceId: sessionInfo.deviceId,\n      sessionId: sessionInfo.sessionId\n    };\n  }\n\n  if ((options === undefined || options.type === 'obsidian-cdp') && transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      log(`[integration-setup:${DEFAULT_TRANSPORT_TYPE}] Owned instance reuse info: host=${endpoint.host}, port=${String(endpoint.port)}`);\n      return {\n        ...options,\n        host: endpoint.host,\n        isHarnessOwnedInstance: true,\n        port: endpoint.port,\n        type: 'obsidian-cdp'\n      };\n    }\n  }\n\n  return options;\n}\n\n/**\n * Finds the project root by walking up from `process.cwd()` looking for `package.json`.\n *\n * @returns The absolute path to the project root.\n */\nfunction findProjectRoot(): string {\n  let dir = process.cwd();\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Loop terminates at filesystem root.\n  while (true) {\n    if (existsSync(join(dir, 'package.json'))) {\n      return dir;\n    }\n    const parent = join(dir, '..');\n    if (parent === dir) {\n      throw new Error('Could not find project root (no package.json found).');\n    }\n    dir = parent;\n  }\n}\n\n/**\n * Resolves the cross-process lock scope for a transport, or `undefined` when no\n * lock is needed.\n *\n * Desktop runs use harness-owned, isolated instances (their own user-data dir\n * and CDP port), so they no longer contend and need no lock. Only the Android\n * transport, which shares the single emulator and Appium server, must serialize.\n *\n * @param transportOptions - The resolved transport options.\n * @returns The lock scope string, or `undefined` if no lock is needed.\n */\nfunction getLockScope(transportOptions: ObsidianTransportOptions | undefined): string | undefined {\n  return transportOptions?.type === 'obsidian-android-appium' ? ANDROID_LOCK_SCOPE : undefined;\n}\n\n/**\n * Registers cleanup handlers for orphaned setups that were never explicitly\n * torn down.\n *\n * Two handlers cover different exit scenarios:\n *\n * - `beforeExit` \u2014 fires when the event loop drains naturally. Allows full\n *   async teardown (unregister vaults, dispose transports). Does NOT fire\n *   when `process.exit()` is called directly.\n *\n * - `unhandledRejection` \u2014 catches async errors that bypass `coreSetup`'s\n *   catch block. Performs full async teardown while we still can.\n *\n * - `exit` \u2014 fires on every exit, including `process.exit()`. Only synchronous\n *   work is possible, so this handler does best-effort cleanup: kills child\n *   processes via `disposeSync()` and removes temp vault directories with\n *   `rmSync`. Unregistering vaults (which requires IPC with Obsidian) is\n *   skipped \u2014 a stale vault entry is an acceptable trade-off vs. leaked\n *   processes and temp directories.\n */\nfunction registerProcessCleanupHandler(): void {\n  if (isCleanupHandlerRegistered) {\n    return;\n  }\n  isCleanupHandlerRegistered = true;\n\n  process.on('beforeExit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Process exiting with ${String(activeSetups.size)} setup(s) not torn down. Cleaning up...`);\n\n    for (const result of [...activeSetups]) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Process cleanup error (non-fatal): ${errorToString(error)}`);\n      });\n    }\n  });\n\n  process.on('unhandledRejection', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Unhandled rejection detected. Tearing down ${String(activeSetups.size)} active setup(s)...`);\n    for (const result of [...activeSetups]) {\n      coreTeardown(result).catch((error: unknown) => {\n        log(`[integration-teardown:${result.transportLabel}] Rejection cleanup error (non-fatal): ${errorToString(error)}`);\n      });\n    }\n  });\n\n  process.on('exit', () => {\n    if (activeSetups.size === 0) {\n      return;\n    }\n\n    log(`[integration-teardown] Sync cleanup: ${String(activeSetups.size)} orphaned setup(s).`);\n    for (const result of [...activeSetups]) {\n      try {\n        result.transport.disposeSync?.();\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync transport cleanup error (non-fatal): ${errorToString(error)}`);\n      }\n      try {\n        rmSync(result.tempVault.path, { force: true, recursive: true });\n      } catch (error: unknown) {\n        log(`[integration-teardown:${result.transportLabel}] Sync vault cleanup error (non-fatal): ${errorToString(error)}`);\n      }\n      releaseSetupLock(result);\n    }\n    activeSetups.clear();\n  });\n}\n\n/**\n * Releases and forgets the setup lock associated with a result, if any.\n *\n * @param result - The setup result whose lock should be released.\n */\nfunction releaseSetupLock(result: CoreSetupResult): void {\n  const lock = setupLocks.get(result);\n  if (lock) {\n    lock.release();\n    setupLocks.delete(result);\n  }\n}\n\n/**\n * Resolves the dist path to use for integration tests.\n *\n * Picks whichever of `dist/dev` and `dist/build` has a newer `main.js`.\n * If only one exists, that one is used. Throws if neither exists.\n *\n * @param projectRoot - The absolute path to the project root.\n * @returns The absolute path to the chosen dist folder.\n */\nasync function resolveDistPath(projectRoot: string): Promise<string> {\n  const devPath = join(projectRoot, DIST_DEV);\n  const buildPath = join(projectRoot, DIST_BUILD);\n  const devMainJs = join(devPath, MAIN_JS);\n  const buildMainJs = join(buildPath, MAIN_JS);\n  const devStat = existsSync(devMainJs) ? await stat(devMainJs) : null;\n  const buildStat = existsSync(buildMainJs) ? await stat(buildMainJs) : null;\n\n  if (devStat && buildStat) {\n    return devStat.mtime > buildStat.mtime ? devPath : buildPath;\n  }\n\n  if (devStat) {\n    return devPath;\n  }\n\n  if (buildStat) {\n    return buildPath;\n  }\n\n  throw new Error('No build found. Run `npm run build` or `npm run dev` first.');\n}\n\n/**\n * Performs the async teardown work (vault disposal + transport disposal).\n *\n * @param result - The setup result to tear down.\n */\nasync function teardownAsync(result: CoreSetupResult): Promise<void> {\n  try {\n    await result.tempVault.dispose(result.transport);\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Vault cleanup error (non-fatal): ${errorToString(error)}`);\n  }\n\n  try {\n    await result.transport.dispose?.();\n  } catch (error: unknown) {\n    log(`[integration-teardown:${result.transportLabel}] Transport cleanup error (non-fatal): ${errorToString(error)}`);\n  }\n}\n"],
  "mappings": "AAYA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,YAAY;AACrB,OAAO,WAAW,mBAAmB;AAOrC,SAAS,oCAAoC;AAC7C,SAAS,qBAAqB;AAC9B,SAAS,sBAAsB;AAC/B,SAAS,WAAW;AACpB,SAAS,wBAAwB;AACjC,SAAS,iBAAiB;AAC1B,SAAS,uBAAuB;AAChC,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAE3C,MAAM,yBAAyB;AAC/B,MAAM,WAAW;AACjB,MAAM,aAAa;AACnB,MAAM,UAAU;AAChB,MAAM,sBAAsB;AAC5B,MAAM,cAAc;AACpB,MAAM,yBAAyB;AAQ/B,MAAM,eAAe,oBAAI,IAAqB;AAC9C,MAAM,kBAAkB,oBAAI,QAAyB;AACrD,IAAI,6BAA6B;AAOjC,MAAM,aAAa,oBAAI,IAAgC;AAEvD,MAAM,qBAAqB;AA8C3B,eAAsB,UAAU,QAAoD;AAClF,QAAM,cAAc,gBAAgB;AACpC,QAAM,cAAc,KAAK,aAAa,MAAM;AAC5C,MAAI,WAAW,WAAW,GAAG;AAC3B,gBAAY,WAAW;AAAA,EACzB;AAEA,QAAM,mBAAmB,mCAAmC,QAAQ,gBAAgB;AACpF,QAAM,QAAQ,iBAAiB;AAC/B,QAAM,YAAY,aAAa,gBAAgB;AAE/C,MAAI;AACJ,MAAI,cAAc,QAAW;AAC3B,QAAI,sBAAsB,KAAK,gBAAgB,SAAS,0EAA0E;AAClI,WAAO,MAAM,iBAAiB,EAAE,OAAO,OAAO,UAAU,CAAC;AACzD,QAAI,sBAAsB,KAAK,wBAAwB;AAAA,EACzD;AAEA,MAAI;AACJ,MAAI;AAEJ,MAAI;AACF,QAAI,sBAAsB,KAAK,yBAAyB;AACxD,gBAAY,MAAM,2BAA2B,gBAAgB;AAC7D,QAAI,sBAAsB,KAAK,wBAAwB,UAAU,YAAY,IAAI,EAAE;AAEnF,QAAI,sBAAsB,KAAK,mBAAmB,WAAW,EAAE;AAC/D,UAAM,WAAW,MAAM,gBAAgB,WAAW;AAClD,UAAM,eAAe,KAAK,MAAM,MAAM,SAAS,KAAK,UAAU,eAAe,GAAG,OAAO,CAAC;AACxF,UAAM,WAAW,aAAa;AAE9B,QAAI,UAAU,YAAY,aAAa,eAAe;AACpD,YAAM,IAAI;AAAA,QACR,WAAW,QAAQ;AAAA,MACrB;AAAA,IACF;AAEA,UAAM,SAAS,KAAK,UAAU,OAAO;AACrC,UAAM,YAAY,MAAM,KAAK,MAAM;AAEnC,QAAI,sBAAsB,KAAK,WAAW,QAAQ,KAAK,UAAU,MAAM,YAAY,CAAC,0BAA0B;AAE9G,gBAAY,IAAI,UAAU;AAC1B,QAAI,sBAAsB,KAAK,yBAAyB,UAAU,IAAI,EAAE;AACxE,UAAM,YAAY,KAAK,UAAU,MAAM,qBAAqB,aAAa,QAAQ;AACjF,UAAM,MAAM,WAAW,EAAE,WAAW,KAAK,CAAC;AAC1C,UAAM,GAAG,UAAU,WAAW,EAAE,WAAW,KAAK,CAAC;AACjD,UAAM,UAAU,KAAK,UAAU,MAAM,qBAAqB,sBAAsB,GAAG,KAAK,UAAU,CAAC,QAAQ,CAAC,CAAC;AAE7G,QAAI,QAAQ,UAAU;AACpB,YAAM,aAAa,OAAO,KAAK,OAAO,QAAQ,EAAE;AAChD,UAAI,sBAAsB,KAAK,2BAA2B,OAAO,UAAU,CAAC,yBAAyB;AACrG,gBAAU,SAAS,OAAO,QAAQ;AAAA,IACpC;AAEA,QAAI,sBAAsB,KAAK,8BAA8B;AAC7D,UAAM,UAAU,aAAa,SAAS;AACtC,QAAI,sBAAsB,KAAK,wBAAwB;AACvD,UAAM,UAAU,SAAS,SAAS;AAClC,QAAI,sBAAsB,KAAK,qBAAqB;AAKpD,QAAI,sBAAsB,KAAK,sBAAsB,QAAQ,MAAM;AACnE,UAAM,EAAE,aAAa,IAAI,MAAM,eAAe;AAAA,MAC5C,MAAM,EAAE,SAAS;AAAA,MACjB,IAAI;AAAA,MACJ,2BAA2B;AAAA,MAC3B;AAAA,MACA,WAAW,UAAU;AAAA,IACvB,CAAC;AAED,QAAI,cAAc;AAChB,YAAM,IAAI,MAAM,WAAW,QAAQ,qBAAqB,YAAY,EAAE;AAAA,IACxE;AAEA,QAAI,sBAAsB,KAAK,aAAa,QAAQ,yBAAyB;AAE7E,UAAM,mBAAmB,wBAAwB,kBAAkB,SAAS;AAC5E,UAAM,SAA0B,EAAE,WAAW,WAAW,gBAAgB,OAAO,kBAAkB,iBAAiB;AAClH,iBAAa,IAAI,MAAM;AACvB,QAAI,MAAM;AACR,iBAAW,IAAI,QAAQ,IAAI;AAAA,IAC7B;AACA,kCAA8B;AAC9B,WAAO;AAAA,EACT,SAAS,OAAgB;AACvB,QAAI,sBAAsB,KAAK,gCAAgC;AAC/D,QAAI;AACF,UAAI,aAAa,WAAW;AAC1B,cAAM,UAAU,QAAQ,SAAS;AAAA,MACnC;AAAA,IACF,SAAS,cAAuB;AAC9B,UAAI,sBAAsB,KAAK,sCAAsC,cAAc,YAAY,CAAC,EAAE;AAAA,IACpG;AACA,QAAI;AACF,YAAM,WAAW,UAAU;AAAA,IAC7B,SAAS,cAAuB;AAC9B,UAAI,sBAAsB,KAAK,0CAA0C,cAAc,YAAY,CAAC,EAAE;AAAA,IACxG;AAGA,UAAM,QAAQ;AAEd,QAAI,sBAAsB,KAAK,4HAAuH;AACtJ,UAAM;AAAA,EACR;AACF;AASA,eAAsB,aAAa,QAAyC;AAC1E,MAAI,CAAC,UAAU,gBAAgB,IAAI,MAAM,GAAG;AAC1C;AAAA,EACF;AACA,kBAAgB,IAAI,MAAM;AAE1B,MAAI,yBAAyB,OAAO,cAAc,mBAAmB;AAErE,MAAI;AACF,UAAM,cAAc,MAAM;AAAA,EAC5B,SAAS,OAAgB;AACvB,QAAI,yBAAyB,OAAO,cAAc,gCAAgC,cAAc,KAAK,CAAC,EAAE;AAAA,EAC1G,UAAE;AACA,iBAAa,OAAO,MAAM;AAC1B,qBAAiB,MAAM;AAAA,EACzB;AACF;AAWO,SAAS,mCAAmC,SAA8D;AAC/G,MAAI,SAAS,SAAS,2BAA2B;AAC/C,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL,GAAG;AAAA,IACH,sBAAsB,SAAS,wBAAwB;AAAA,IACvD,MAAM;AAAA,EACR;AACF;AAiBA,SAAS,wBACP,SACA,WACsC;AACtC,MAAI,SAAS,SAAS,6BAA6B,qBAAqB,iBAAiB;AACvF,UAAM,cAAc,UAAU,eAAe;AAC7C,QAAI,sBAAsB,QAAQ,IAAI,mCAAmC,YAAY,SAAS,cAAc,YAAY,QAAQ,EAAE;AAClI,WAAO;AAAA,MACL,GAAG;AAAA,MACH,UAAU,YAAY;AAAA,MACtB,WAAW,YAAY;AAAA,IACzB;AAAA,EACF;AAEA,OAAK,YAAY,UAAa,QAAQ,SAAS,mBAAmB,qBAAqB,qBAAqB;AAC1G,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,UAAI,sBAAsB,sBAAsB,qCAAqC,SAAS,IAAI,UAAU,OAAO,SAAS,IAAI,CAAC,EAAE;AACnI,aAAO;AAAA,QACL,GAAG;AAAA,QACH,MAAM,SAAS;AAAA,QACf,wBAAwB;AAAA,QACxB,MAAM,SAAS;AAAA,QACf,MAAM;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAOA,SAAS,kBAA0B;AACjC,MAAI,MAAM,QAAQ,IAAI;AAGtB,SAAO,MAAM;AACX,QAAI,WAAW,KAAK,KAAK,cAAc,CAAC,GAAG;AACzC,aAAO;AAAA,IACT;AACA,UAAM,SAAS,KAAK,KAAK,IAAI;AAC7B,QAAI,WAAW,KAAK;AAClB,YAAM,IAAI,MAAM,sDAAsD;AAAA,IACxE;AACA,UAAM;AAAA,EACR;AACF;AAaA,SAAS,aAAa,kBAA4E;AAChG,SAAO,kBAAkB,SAAS,4BAA4B,qBAAqB;AACrF;AAsBA,SAAS,gCAAsC;AAC7C,MAAI,4BAA4B;AAC9B;AAAA,EACF;AACA,+BAA6B;AAE7B,UAAQ,GAAG,cAAc,MAAM;AAC7B,QAAI,aAAa,SAAS,GAAG;AAC3B;AAAA,IACF;AAEA,QAAI,+CAA+C,OAAO,aAAa,IAAI,CAAC,yCAAyC;AAErH,eAAW,UAAU,CAAC,GAAG,YAAY,GAAG;AACtC,mBAAa,MAAM,EAAE,MAAM,CAAC,UAAmB;AAC7C,YAAI,yBAAyB,OAAO,cAAc,wCAAwC,cAAc,KAAK,CAAC,EAAE;AAAA,MAClH,CAAC;AAAA,IACH;AAAA,EACF,CAAC;AAED,UAAQ,GAAG,sBAAsB,MAAM;AACrC,QAAI,aAAa,SAAS,GAAG;AAC3B;AAAA,IACF;AAEA,QAAI,qEAAqE,OAAO,aAAa,IAAI,CAAC,qBAAqB;AACvH,eAAW,UAAU,CAAC,GAAG,YAAY,GAAG;AACtC,mBAAa,MAAM,EAAE,MAAM,CAAC,UAAmB;AAC7C,YAAI,yBAAyB,OAAO,cAAc,0CAA0C,cAAc,KAAK,CAAC,EAAE;AAAA,MACpH,CAAC;AAAA,IACH;AAAA,EACF,CAAC;AAED,UAAQ,GAAG,QAAQ,MAAM;AACvB,QAAI,aAAa,SAAS,GAAG;AAC3B;AAAA,IACF;AAEA,QAAI,wCAAwC,OAAO,aAAa,IAAI,CAAC,qBAAqB;AAC1F,eAAW,UAAU,CAAC,GAAG,YAAY,GAAG;AACtC,UAAI;AACF,eAAO,UAAU,cAAc;AAAA,MACjC,SAAS,OAAgB;AACvB,YAAI,yBAAyB,OAAO,cAAc,+CAA+C,cAAc,KAAK,CAAC,EAAE;AAAA,MACzH;AACA,UAAI;AACF,eAAO,OAAO,UAAU,MAAM,EAAE,OAAO,MAAM,WAAW,KAAK,CAAC;AAAA,MAChE,SAAS,OAAgB;AACvB,YAAI,yBAAyB,OAAO,cAAc,2CAA2C,cAAc,KAAK,CAAC,EAAE;AAAA,MACrH;AACA,uBAAiB,MAAM;AAAA,IACzB;AACA,iBAAa,MAAM;AAAA,EACrB,CAAC;AACH;AAOA,SAAS,iBAAiB,QAA+B;AACvD,QAAM,OAAO,WAAW,IAAI,MAAM;AAClC,MAAI,MAAM;AACR,SAAK,QAAQ;AACb,eAAW,OAAO,MAAM;AAAA,EAC1B;AACF;AAWA,eAAe,gBAAgB,aAAsC;AACnE,QAAM,UAAU,KAAK,aAAa,QAAQ;AAC1C,QAAM,YAAY,KAAK,aAAa,UAAU;AAC9C,QAAM,YAAY,KAAK,SAAS,OAAO;AACvC,QAAM,cAAc,KAAK,WAAW,OAAO;AAC3C,QAAM,UAAU,WAAW,SAAS,IAAI,MAAM,KAAK,SAAS,IAAI;AAChE,QAAM,YAAY,WAAW,WAAW,IAAI,MAAM,KAAK,WAAW,IAAI;AAEtE,MAAI,WAAW,WAAW;AACxB,WAAO,QAAQ,QAAQ,UAAU,QAAQ,UAAU;AAAA,EACrD;AAEA,MAAI,SAAS;AACX,WAAO;AAAA,EACT;AAEA,MAAI,WAAW;AACb,WAAO;AAAA,EACT;AAEA,QAAM,IAAI,MAAM,6DAA6D;AAC/E;AAOA,eAAe,cAAc,QAAwC;AACnE,MAAI;AACF,UAAM,OAAO,UAAU,QAAQ,OAAO,SAAS;AAAA,EACjD,SAAS,OAAgB;AACvB,QAAI,yBAAyB,OAAO,cAAc,sCAAsC,cAAc,KAAK,CAAC,EAAE;AAAA,EAChH;AAEA,MAAI;AACF,UAAM,OAAO,UAAU,UAAU;AAAA,EACnC,SAAS,OAAgB;AACvB,QAAI,yBAAyB,OAAO,cAAc,0CAA0C,cAAc,KAAK,CAAC,EAAE;AAAA,EACpH;AACF;",
  "names": []
}
