obsidian-integration-testing 8.3.0 → 9.0.0

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

@@ -1,4 +1,5 @@
 import { evalInObsidian } from "./eval-in-obsidian.mjs";
+import { normalizeOptionalProperties } from "./normalize-optional-properties.mjs";
 import { TempVault } from "./temp-vault.mjs";
 import { DesktopCdpTransport } from "./transport-desktop-cdp.mjs";
 import { createTransportFromOptions } from "./transport-factory.mjs";
@@ -10,10 +11,12 @@ async function connectToCdp(options) {
   await vault.register(transport);
   const { host, port } = resolveEndpoint(transport, options);
   const cdpUrl = `http://${host}:${String(port)}`;
+  const asarFallback = transport instanceof DesktopCdpTransport ? transport.getAsarFallback() : void 0;
   const compatibility = transport instanceof DesktopCdpTransport ? transport.getCompatibility() : void 0;
   const electronCompatibility = transport instanceof DesktopCdpTransport ? transport.getElectronCompatibility() : void 0;
   const connection = {
     cdpUrl,
+    ...asarFallback && { asarFallback },
     ...compatibility && { compatibility },
     ...electronCompatibility && { electronCompatibility },
     async dispose() {
@@ -42,24 +45,20 @@ async function connectToCdp(options) {
   return connection;
 }
 function buildCdpTransportOptions(options) {
-  return {
+  return normalizeOptionalProperties({
+    commandTimeoutInMilliseconds: options?.commandTimeoutInMilliseconds,
+    deadBootGraceInMilliseconds: options?.deadBootGraceInMilliseconds,
+    host: options?.host,
     isObsidianAppVisible: options?.isObsidianAppVisible ?? true,
-    type: "obsidian-cdp",
-    ...options?.commandTimeoutInMilliseconds !== void 0 && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds },
-    ...options?.deadBootGraceInMilliseconds !== void 0 && { deadBootGraceInMilliseconds: options.deadBootGraceInMilliseconds },
-    ...options?.host !== void 0 && { host: options.host },
-    ...options?.obsidianInstallerVersion !== void 0 && { obsidianInstallerVersion: options.obsidianInstallerVersion },
-    ...options?.obsidianVersion !== void 0 && { obsidianVersion: options.obsidianVersion },
-    ...options?.port !== void 0 && { port: options.port },
-    ...options?.shouldDisableSandbox !== void 0 && { shouldDisableSandbox: options.shouldDisableSandbox },
-    ...buildCompatibilityTransportOptions(options)
-  };
-}
-function buildCompatibilityTransportOptions(options) {
-  return {
-    ...options?.shouldThrowOnIncompatibleInstaller !== void 0 && { shouldThrowOnIncompatibleInstaller: options.shouldThrowOnIncompatibleInstaller },
-    ...options?.shouldWarnOnCompatibilityIssues !== void 0 && { shouldWarnOnCompatibilityIssues: options.shouldWarnOnCompatibilityIssues }
-  };
+    obsidianInstallerVersion: options?.obsidianInstallerVersion,
+    obsidianVersion: options?.obsidianVersion,
+    port: options?.port,
+    shouldDisableSandbox: options?.shouldDisableSandbox,
+    shouldThrowOnIncompatibleInstaller: options?.shouldThrowOnIncompatibleInstaller,
+    shouldThrowOnSilentAsarFallback: options?.shouldThrowOnSilentAsarFallback,
+    shouldWarnOnCompatibilityIssues: options?.shouldWarnOnCompatibilityIssues,
+    type: "obsidian-cdp"
+  });
 }
 function resolveEndpoint(transport, options) {
   if (transport instanceof DesktopCdpTransport) {
@@ -76,4 +75,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 { ElectronCompatibility } from './electron-compatibility.mjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { InstallerCompatibility } from './installer-compatibility.mjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { 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 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": "AA0BA,SAAS,sBAAsB;AAC/B,SAAS,iBAAiB;AAC1B,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAE3C,MAAM,mBAAmB;AA8NzB,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;AAChG,QAAM,wBAAwB,qBAAqB,sBAAsB,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,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,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,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 { AsarFallback } from './asar-fallback-detection.mjs';\nimport type { ContextId } from './context-id.mjs';\nimport type { ElectronCompatibility } from './electron-compatibility.mjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { InstallerCompatibility } from './installer-compatibility.mjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.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 silent-asar-fallback verdict for an owned instance, read live after boot:\n   * whether the app version it is actually running matches the swapped-in pin, or\n   * the installer silently reverted to its own bundled asar. `undefined` in attach\n   * mode, when no asar was swapped, or when the running version was unreadable. A\n   * `'fallback'` verdict reaches here only when the throw is disabled\n   * ({@link ConnectToCdpOptions.shouldThrowOnSilentAsarFallback} `false`);\n   * otherwise it throws `SilentAsarFallbackError` before the connection is created.\n   */\n  readonly asarFallback?: AsarFallback | undefined;\n\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * The resolved installer\u2194app compatibility verdict for an owned instance, when\n   * it could be determined. `undefined` in attach mode, or when the verdict is\n   * unknown (undetectable shell version, or the app version is absent from the\n   * table). An `'unrunnable'` verdict reaches here only when the proactive throw\n   * is disabled ({@link ConnectToCdpOptions.shouldThrowOnIncompatibleInstaller}\n   * `false`); otherwise it throws `IncompatibleInstallerVersionError` before the\n   * connection is created.\n   */\n  readonly compatibility?: InstallerCompatibility | undefined;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * The runtime Electron compatibility verdict for an owned instance, read live\n   * after boot: whether the Electron version it is actually running is new enough\n   * for the running app version. `undefined` in attach mode, or when the verdict\n   * is unknown (the live version was unreadable, or the app version carries no\n   * recommended Electron version). An old Electron never blocks \u2014 it only warns \u2014\n   * so unlike {@link compatibility} there is no throwing tier.\n   */\n  readonly electronCompatibility?: ElectronCompatibility | undefined;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, lib, obsidianModule, context }` plus any `args`\n   * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). Mirrors\n   * the top-level `evalInObsidian`, with the transport and vault path pre-bound\n   * to this connection.\n   *\n   * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `fn`.\n   */\n  evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TempVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * Grace window in milliseconds for fast-failing a dead boot of the owned\n   * instance \u2014 the renderer loaded but the app never bootstrapped (empty\n   * `<body>`, no `window.app`), the terminal state when the asar cannot run on\n   * the launched Electron shell. Once it has held this long a\n   * `RendererFailedToInitializeError` is thrown instead of waiting out the full\n   * readiness timeout. Ignored in attach mode ({@link port} set). Set `0` to\n   * disable fast-fail.\n   *\n   * @default `10000`\n   */\n  readonly deadBootGraceInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Whether the Obsidian window is shown on screen. Defaults to `true`; set\n   * `false` to launch it off-screen.\n   * Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to launch the owned instance with Chromium's sandbox disabled\n   * (`--no-sandbox`).\n   *\n   * Needed to boot on Linux without a correctly-configured setuid\n   * `chrome-sandbox` helper (e.g. an installer-extracted portable shell, or CI\n   * running as a non-root user); harmless on Windows/macOS. Ignored in attach\n   * mode ({@link port} set).\n   *\n   * @default `false`\n   */\n  readonly shouldDisableSandbox?: boolean;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Whether an **unrunnable** installer\u2194app version pair fails fast before launch.\n   *\n   * When `true` (the default), an installer below the app's run floor throws\n   * `IncompatibleInstallerVersionError` from version resolution before anything is\n   * downloaded or launched. Set `false` to let the pin proceed to launch \u2014 where\n   * the reactive dead-boot fast-fail still catches the black-screen boot, and the\n   * `'unrunnable'` verdict is surfaced on {@link CdpConnection.compatibility}\n   * rather than thrown. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnIncompatibleInstaller?: boolean;\n\n  /**\n   * Whether a post-boot **silent asar fallback** fails fast.\n   *\n   * When an asar is swapped onto an installer shell too old for it, the instance\n   * may silently revert to the installer's own bundled asar and run the **wrong\n   * (older)** version behind a healthy UI. When `true` (the default), the running\n   * app version is verified against the pin post-boot and a mismatch throws\n   * `SilentAsarFallbackError`. Set `false` to let the boot proceed \u2014 the mismatch\n   * is then surfaced on {@link CdpConnection.asarFallback} rather than thrown.\n   * Ignored in attach mode ({@link port} set) and when no asar is swapped.\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnSilentAsarFallback?: boolean;\n\n  /**\n   * Whether the owned-instance compatibility **nag warnings** are emitted.\n   *\n   * Covers both the offline installer\u2194app warning and the post-boot\n   * runtime-Electron warning. When `true` (the default) each fires via the harness\n   * log; set `false` to silence both \u2014 the verdicts are still surfaced on\n   * {@link CdpConnection.compatibility} / {@link CdpConnection.electronCompatibility},\n   * only the log is suppressed. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldWarnOnCompatibilityIssues?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transport = await createTransportFromOptions(buildCdpTransportOptions(options));\n  const vault = new TempVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n  const asarFallback = transport instanceof DesktopCdpTransport ? transport.getAsarFallback() : undefined;\n  const compatibility = transport instanceof DesktopCdpTransport ? transport.getCompatibility() : undefined;\n  const electronCompatibility = transport instanceof DesktopCdpTransport ? transport.getElectronCompatibility() : undefined;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n    ...(asarFallback && { asarFallback }),\n    ...(compatibility && { compatibility }),\n    ...(electronCompatibility && { electronCompatibility }),\n\n    async dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Args, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Builds the {@link ObsidianCdpTransportOptions} for a connection, threading only\n * the provided {@link ConnectToCdpOptions} through (owned-visible defaults to\n * `true`, unlike the hidden-by-default test transports). Unset knobs pass through\n * as `undefined` and are read with `?? default` / `!== undefined` guards\n * downstream, so an explicit `undefined` is indistinguishable from an absent key.\n *\n * @param options - The connection options.\n * @returns The transport options to create the connection's transport from.\n */\nfunction buildCdpTransportOptions(options?: ConnectToCdpOptions): ObsidianCdpTransportOptions {\n  return normalizeOptionalProperties<ObsidianCdpTransportOptions>({\n    commandTimeoutInMilliseconds: options?.commandTimeoutInMilliseconds,\n    deadBootGraceInMilliseconds: options?.deadBootGraceInMilliseconds,\n    host: options?.host,\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    obsidianInstallerVersion: options?.obsidianInstallerVersion,\n    obsidianVersion: options?.obsidianVersion,\n    port: options?.port,\n    shouldDisableSandbox: options?.shouldDisableSandbox,\n    shouldThrowOnIncompatibleInstaller: options?.shouldThrowOnIncompatibleInstaller,\n    shouldThrowOnSilentAsarFallback: options?.shouldThrowOnSilentAsarFallback,\n    shouldWarnOnCompatibilityIssues: options?.shouldWarnOnCompatibilityIssues,\n    type: 'obsidian-cdp'\n  });\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AA2BA,SAAS,sBAAsB;AAC/B,SAAS,mCAAmC;AAC5C,SAAS,iBAAiB;AAC1B,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAE3C,MAAM,mBAAmB;AAwPzB,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,eAAe,qBAAqB,sBAAsB,UAAU,gBAAgB,IAAI;AAC9F,QAAM,gBAAgB,qBAAqB,sBAAsB,UAAU,iBAAiB,IAAI;AAChG,QAAM,wBAAwB,qBAAqB,sBAAsB,UAAU,yBAAyB,IAAI;AAEhH,QAAM,aAA4B;AAAA,IAChC;AAAA,IACA,GAAI,gBAAgB,EAAE,aAAa;AAAA,IACnC,GAAI,iBAAiB,EAAE,cAAc;AAAA,IACrC,GAAI,yBAAyB,EAAE,sBAAsB;AAAA,IAErD,MAAM,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;AAYA,SAAS,yBAAyB,SAA4D;AAC5F,SAAO,4BAAyD;AAAA,IAC9D,8BAA8B,SAAS;AAAA,IACvC,6BAA6B,SAAS;AAAA,IACtC,MAAM,SAAS;AAAA,IACf,sBAAsB,SAAS,wBAAwB;AAAA,IACvD,0BAA0B,SAAS;AAAA,IACnC,iBAAiB,SAAS;AAAA,IAC1B,MAAM,SAAS;AAAA,IACf,sBAAsB,SAAS;AAAA,IAC/B,oCAAoC,SAAS;AAAA,IAC7C,iCAAiC,SAAS;AAAA,IAC1C,iCAAiC,SAAS;AAAA,IAC1C,MAAM;AAAA,EACR,CAAC;AACH;AAWA,SAAS,gBAAgB,WAAoB,SAA4D;AACvG,MAAI,qBAAqB,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/demo-vault-tree.d.mts

@@ -0,0 +1,34 @@
+/**
+ * @file
+ *
+ * Reads a plugin's in-repo `demo-vault/` tree into a populate map so a Vitest/Jest global setup can
+ * seed it into the temp vault BEFORE Obsidian opens it. Seeding pre-launch lets Obsidian's startup scan
+ * index every note in one pass, avoiding the file-watcher race that silently drops events under a bulk
+ * post-launch {@link TempVault.populate}.
+ */
+import type { PopulateFilesParams } from './temp-vault.mjs';
+/**
+ * Parameters for {@link readDemoVaultTree}.
+ */
+export interface ReadDemoVaultTreeParams {
+    /**
+     * Absolute path to the demo vault directory to read.
+     */
+    readonly demoVaultPath: string;
+    /**
+     * Names (of files or directories, matched at any depth) to skip. Defaults to `.git` and `.obsidian`:
+     * the harness provisions `.obsidian/plugins/<id>` itself, so the vault's own `.obsidian` must not be
+     * copied over it.
+     *
+     * @default `['.git', '.obsidian']`
+     */
+    readonly excludedNames?: Iterable<string>;
+}
+/**
+ * Reads a demo vault directory tree recursively into a {@link PopulateFilesParams} map (vault-relative
+ * POSIX path to file bytes), skipping {@link ReadDemoVaultTreeParams.excludedNames}.
+ *
+ * @param params - The {@link ReadDemoVaultTreeParams}.
+ * @returns The populate map, ready to hand to {@link TempVault.populate} or a global setup's `populate`.
+ */
+export declare function readDemoVaultTree(params: ReadDemoVaultTreeParams): PopulateFilesParams;

package/dist/lib/esm/demo-vault-tree.mjs

@@ -0,0 +1,35 @@
+import {
+  readdirSync,
+  readFileSync
+} from "node:fs";
+import {
+  join,
+  relative,
+  sep
+} from "node:path";
+const DEFAULT_EXCLUDED_NAMES = [".git", ".obsidian"];
+function readDemoVaultTree(params) {
+  const { demoVaultPath } = params;
+  const excludedNames = new Set(params.excludedNames ?? DEFAULT_EXCLUDED_NAMES);
+  const map = {};
+  collect(demoVaultPath, demoVaultPath, excludedNames, map);
+  return map;
+}
+function collect(root, dir, excludedNames, map) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (excludedNames.has(entry.name)) {
+      continue;
+    }
+    const absolutePath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      collect(root, absolutePath, excludedNames, map);
+      continue;
+    }
+    const relativePath = relative(root, absolutePath).split(sep).join("/");
+    map[relativePath] = readFileSync(absolutePath);
+  }
+}
+export {
+  readDemoVaultTree
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/ecmascript-version.d.mts

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

package/dist/lib/esm/ecmascript-version.mjs

@@ -0,0 +1,39 @@
+const CHROME_MAJOR_FOR_ES2015 = 51;
+const CHROME_MAJOR_FOR_ES2016 = 52;
+const CHROME_MAJOR_FOR_ES2017 = 58;
+const CHROME_MAJOR_FOR_ES2018 = 64;
+const CHROME_MAJOR_FOR_ES2019 = 73;
+const CHROME_MAJOR_FOR_ES2020 = 80;
+const CHROME_MAJOR_FOR_ES2021 = 85;
+const CHROME_MAJOR_FOR_ES2022 = 94;
+const CHROME_MAJOR_FOR_ES2023 = 110;
+const CHROME_MAJOR_FOR_ES2024 = 122;
+const ECMA_SCRIPT_BREAKPOINTS = [
+  { ecmaScriptVersion: "ES2024", minChromeMajor: CHROME_MAJOR_FOR_ES2024 },
+  { ecmaScriptVersion: "ES2023", minChromeMajor: CHROME_MAJOR_FOR_ES2023 },
+  { ecmaScriptVersion: "ES2022", minChromeMajor: CHROME_MAJOR_FOR_ES2022 },
+  { ecmaScriptVersion: "ES2021", minChromeMajor: CHROME_MAJOR_FOR_ES2021 },
+  { ecmaScriptVersion: "ES2020", minChromeMajor: CHROME_MAJOR_FOR_ES2020 },
+  { ecmaScriptVersion: "ES2019", minChromeMajor: CHROME_MAJOR_FOR_ES2019 },
+  { ecmaScriptVersion: "ES2018", minChromeMajor: CHROME_MAJOR_FOR_ES2018 },
+  { ecmaScriptVersion: "ES2017", minChromeMajor: CHROME_MAJOR_FOR_ES2017 },
+  { ecmaScriptVersion: "ES2016", minChromeMajor: CHROME_MAJOR_FOR_ES2016 },
+  { ecmaScriptVersion: "ES2015", minChromeMajor: CHROME_MAJOR_FOR_ES2015 }
+];
+const DECIMAL_RADIX = 10;
+function deriveEcmaScriptVersion(chromeVersion) {
+  const chromeMajor = Number.parseInt(chromeVersion, DECIMAL_RADIX);
+  if (Number.isNaN(chromeMajor)) {
+    return void 0;
+  }
+  for (const breakpoint of ECMA_SCRIPT_BREAKPOINTS) {
+    if (chromeMajor >= breakpoint.minChromeMajor) {
+      return breakpoint.ecmaScriptVersion;
+    }
+  }
+  return void 0;
+}
+export {
+  deriveEcmaScriptVersion
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -13,6 +13,16 @@ import { TempVault } from './temp-vault.mjs';
  * Parameters for {@link coreSetup}.
  */
 export interface CoreSetupParams {
+    /**
+     * Whether to install and enable the built plugin in the temp vault. Defaults
+     * to `true`. Set to `false` for a **non-plugin** consumer (e.g. a typings
+     * crawler) that only needs a registered, empty vault to `evalInObsidian`
+     * against: the plugin `dist`/`manifest.json` read, the copy into
+     * `.obsidian/plugins`, the `community-plugins.json` write, and the enable step
+     * are all skipped, while the transport, temp vault, registration, and
+     * worker-facing endpoint provisioning still run unchanged.
+     */
+    readonly installPlugin?: boolean | undefined;
     /**
      * Files and folders to write into the vault **before** Obsidian opens it, so
      * its startup scan indexes them in one pass (see {@link TempVault.populate}).
@@ -40,9 +50,11 @@ export interface CoreSetupResult {
 /**
  * Framework-agnostic global setup logic.
  *
- * Loads `.env` from the project root, creates a transport, copies the built
- * plugin into a temporary vault, registers the vault with Obsidian, and
- * enables the plugin.
+ * Loads `.env` from the project root, creates a transport, creates and registers
+ * a temporary vault with Obsidian, and — unless {@link CoreSetupParams.installPlugin}
+ * is `false` — copies the built plugin into the vault and enables it. The
+ * plugin-less mode still launches the owned instance and publishes its
+ * worker-facing endpoint, so a non-plugin consumer reuses the same attach wiring.
  *
  * @param params - Setup parameters.
  * @returns The setup result containing the temp vault, transport, and resolved options.

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

@@ -54,23 +54,15 @@ async function coreSetup(params) {
     transport = await createTransportFromOptions(transportOptions);
     log(`[integration-setup:${label}] Transport created: ${transport.constructor.name}`);
     log(`[integration-setup:${label}] Project root: ${projectRoot}`);
-    const distPath = await resolveDistPath(projectRoot);
-    const manifestJson = JSON.parse(await readFile(join(distPath, "manifest.json"), "utf-8"));
-    const pluginId = manifestJson.id;
-    if (transport.isMobile && manifestJson.isDesktopOnly) {
-      throw new Error(
-        `Plugin "${pluginId}" has isDesktopOnly: true in manifest.json. Mobile integration tests cannot run for desktop-only plugins.`
-      );
-    }
-    const mainJs = join(distPath, MAIN_JS);
-    const buildStat = await stat(mainJs);
-    log(`[integration-setup:${label}] Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);
+    const shouldInstallPlugin = params?.installPlugin !== false;
     tempVault = new TempVault();
     log(`[integration-setup:${label}] Created temp vault: ${tempVault.path}`);
-    const pluginDir = join(tempVault.path, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);
-    await mkdir(pluginDir, { recursive: true });
-    await cp(distPath, pluginDir, { recursive: true });
-    await writeFile(join(tempVault.path, OBSIDIAN_CONFIG_DIR, COMMUNITY_PLUGINS_JSON), JSON.stringify([pluginId]));
+    let pluginId;
+    if (shouldInstallPlugin) {
+      pluginId = await copyPluginIntoVault({ label, projectRoot, tempVault, transport });
+    } else {
+      log(`[integration-setup:${label}] Skipping plugin install (installPlugin: false) \u2014 registering an empty vault.`);
+    }
     if (params?.populate) {
       const entryCount = Object.keys(params.populate).length;
       log(`[integration-setup:${label}] Populating vault with ${String(entryCount)} entries before open...`);
@@ -81,18 +73,9 @@ async function coreSetup(params) {
     log(`[integration-setup:${label}] Registering vault...`);
     await tempVault.register(transport);
     log(`[integration-setup:${label}] Vault registered.`);
-    log(`[integration-setup:${label}] Enabling plugin "${pluginId}"...`);
-    const { errorMessage } = await evalInObsidian({
-      args: { pluginId },
-      fn: enablePluginWithErrorCapture,
-      shouldSkipPreflightChecks: true,
-      transport,
-      vaultPath: tempVault.path
-    });
-    if (errorMessage) {
-      throw new Error(`Plugin "${pluginId}" failed to load: ${errorMessage}`);
+    if (pluginId !== void 0) {
+      await enablePluginInVault({ label, pluginId, tempVault, transport });
     }
-    log(`[integration-setup:${label}] Plugin "${pluginId}" enabled successfully.`);
     const augmentedOptions = augmentTransportOptions(transportOptions, transport);
     const result = { tempVault, transport, transportLabel: label, transportOptions: augmentedOptions };
     activeSetups.add(result);
@@ -170,6 +153,40 @@ function augmentTransportOptions(options, transport) {
   }
   return options;
 }
+async function copyPluginIntoVault(params) {
+  const { label, projectRoot, tempVault, transport } = params;
+  const distPath = await resolveDistPath(projectRoot);
+  const manifestJson = JSON.parse(await readFile(join(distPath, "manifest.json"), "utf-8"));
+  const pluginId = manifestJson.id;
+  if (transport.isMobile && manifestJson.isDesktopOnly) {
+    throw new Error(
+      `Plugin "${pluginId}" has isDesktopOnly: true in manifest.json. Mobile integration tests cannot run for desktop-only plugins.`
+    );
+  }
+  const mainJs = join(distPath, MAIN_JS);
+  const buildStat = await stat(mainJs);
+  log(`[integration-setup:${label}] Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);
+  const pluginDir = join(tempVault.path, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);
+  await mkdir(pluginDir, { recursive: true });
+  await cp(distPath, pluginDir, { recursive: true });
+  await writeFile(join(tempVault.path, OBSIDIAN_CONFIG_DIR, COMMUNITY_PLUGINS_JSON), JSON.stringify([pluginId]));
+  return pluginId;
+}
+async function enablePluginInVault(params) {
+  const { label, pluginId, tempVault, transport } = params;
+  log(`[integration-setup:${label}] Enabling plugin "${pluginId}"...`);
+  const { errorMessage } = await evalInObsidian({
+    args: { pluginId },
+    fn: enablePluginWithErrorCapture,
+    shouldSkipPreflightChecks: true,
+    transport,
+    vaultPath: tempVault.path
+  });
+  if (errorMessage) {
+    throw new Error(`Plugin "${pluginId}" failed to load: ${errorMessage}`);
+  }
+  log(`[integration-setup:${label}] Plugin "${pluginId}" enabled successfully.`);
+}
 function findProjectRoot() {
   let dir = process.cwd();
   while (true) {
@@ -276,4 +293,4 @@ export {
   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, 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": "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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   * Whether to install and enable the built plugin in the temp vault. Defaults\n   * to `true`. Set to `false` for a **non-plugin** consumer (e.g. a typings\n   * crawler) that only needs a registered, empty vault to `evalInObsidian`\n   * against: the plugin `dist`/`manifest.json` read, the copy into\n   * `.obsidian/plugins`, the `community-plugins.json` write, and the enable step\n   * are all skipped, while the transport, temp vault, registration, and\n   * worker-facing endpoint provisioning still run unchanged.\n   */\n  readonly installPlugin?: boolean | undefined;\n\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 * Parameters for {@link copyPluginIntoVault}.\n */\ninterface CopyPluginIntoVaultParams {\n  /** Short label for log messages. */\n  readonly label: string;\n\n  /** The project root to resolve the built plugin from. */\n  readonly projectRoot: string;\n\n  /** The temp vault to copy the plugin into. */\n  readonly tempVault: TempVault;\n\n  /** The transport (used for the mobile/desktop-only compatibility check). */\n  readonly transport: ObsidianTransport;\n}\n\n/**\n * Parameters for {@link enablePluginInVault}.\n */\ninterface EnablePluginInVaultParams {\n  /** Short label for log messages. */\n  readonly label: string;\n\n  /** The id of the plugin to enable. */\n  readonly pluginId: string;\n\n  /** The temp vault the plugin was copied into. */\n  readonly tempVault: TempVault;\n\n  /** The transport to evaluate against. */\n  readonly transport: ObsidianTransport;\n}\n\n/**\n * Framework-agnostic global setup logic.\n *\n * Loads `.env` from the project root, creates a transport, creates and registers\n * a temporary vault with Obsidian, and \u2014 unless {@link CoreSetupParams.installPlugin}\n * is `false` \u2014 copies the built plugin into the vault and enables it. The\n * plugin-less mode still launches the owned instance and publishes its\n * worker-facing endpoint, so a non-plugin consumer reuses the same attach wiring.\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 shouldInstallPlugin = params?.installPlugin !== false;\n\n    tempVault = new TempVault();\n    log(`[integration-setup:${label}] Created temp vault: ${tempVault.path}`);\n\n    let pluginId: string | undefined;\n\n    if (shouldInstallPlugin) {\n      pluginId = await copyPluginIntoVault({ label, projectRoot, tempVault, transport });\n    } else {\n      log(`[integration-setup:${label}] Skipping plugin install (installPlugin: false) \u2014 registering an empty vault.`);\n    }\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    if (pluginId !== undefined) {\n      await enablePluginInVault({ label, pluginId, tempVault, transport });\n    }\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 * Copies the built plugin into the temp vault and marks it as a community plugin.\n *\n * Reads `manifest.json` from the newer of `dist/dev`/`dist/build`, rejects a\n * desktop-only plugin on a mobile transport, copies the build into\n * `.obsidian/plugins/<id>`, and writes `.obsidian/community-plugins.json`.\n *\n * @param params - The copy parameters.\n * @returns The plugin id read from the manifest.\n */\nasync function copyPluginIntoVault(params: CopyPluginIntoVaultParams): Promise<string> {\n  const { label, projectRoot, tempVault, transport } = params;\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  log(`[integration-setup:${label}] Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);\n\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  return pluginId;\n}\n\n/**\n * Enables the plugin in the registered vault and verifies it loaded.\n *\n * Obsidian's `enablePlugin()` wraps `loadPlugin()` in a try-catch that swallows\n * errors and returns false, so {@link enablePluginWithErrorCapture} monkey-patches\n * `loadPlugin()` to capture the error before it's swallowed.\n *\n * @param params - The enable parameters.\n */\nasync function enablePluginInVault(params: EnablePluginInVaultParams): Promise<void> {\n  const { label, pluginId, tempVault, transport } = params;\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\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": []
}
