obsidian-integration-testing 10.0.0 → 10.2.0

package/dist/lib/cjs/capture-obsidian-screenshot.cjs

@@ -0,0 +1,60 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var capture_obsidian_screenshot_exports = {};
+__export(capture_obsidian_screenshot_exports, {
+  captureObsidianScreenshot: () => captureObsidianScreenshot
+});
+module.exports = __toCommonJS(capture_obsidian_screenshot_exports);
+var import_node_process = __toESM(require("node:process"), 1);
+var import_context_provider = require("./context-provider.cjs");
+var import_normalize_optional_properties = require("./normalize-optional-properties.cjs");
+var import_transport_factory = require("./transport-factory.cjs");
+async function captureObsidianScreenshot(options) {
+  const {
+    heightInPixels,
+    transport: transportOverride,
+    vaultPath,
+    widthInPixels
+  } = options ?? {};
+  const cwd = vaultPath ?? (0, import_context_provider.getVaultPath)() ?? import_node_process.default.cwd();
+  const transport = transportOverride ?? await (0, import_transport_factory.getOrCreateTransport)((0, import_context_provider.getTransportOptions)());
+  if (!transport.captureScreenshot) {
+    throw new Error("captureObsidianScreenshot: the active transport cannot capture screenshots.");
+  }
+  return transport.captureScreenshot((0, import_normalize_optional_properties.normalizeOptionalProperties)({
+    cwd,
+    heightInPixels,
+    widthInPixels
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  captureObsidianScreenshot
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/capture-obsidian-screenshot.d.cts

@@ -0,0 +1,53 @@
+/**
+ * @file
+ *
+ * Captures a screenshot of the Obsidian instance the current test context is
+ * already driving.
+ *
+ * The transport-level `captureScreenshot` needs a transport in hand, which a
+ * test running under the harness's global setup never has — the instance is
+ * owned by that setup and reached through the context provider. This is the
+ * context-resolving entry point, the screenshot counterpart of
+ * `evalInObsidian` / `pollInObsidian`: with no arguments at all it captures
+ * whatever instance the active project is driving, desktop or mobile.
+ */
+import type { ObsidianTransport } from './transport.cjs';
+/**
+ * Options for {@link captureObsidianScreenshot}.
+ */
+export interface CaptureObsidianScreenshotOptions {
+    /**
+     * The exact height in pixels the captured image should have.
+     *
+     * Desktop only, and only meaningful together with {@link widthInPixels}.
+     * Ignored on mobile, where the image is always the device's native
+     * framebuffer — size those by choosing an AVD with the wanted screen
+     * geometry.
+     */
+    readonly heightInPixels?: number;
+    /**
+     * Override the transport. When omitted, the transport the current test
+     * context is driving is used.
+     */
+    readonly transport?: ObsidianTransport;
+    /**
+     * The vault path to capture. When omitted, the current test context's vault
+     * is used.
+     */
+    readonly vaultPath?: string;
+    /**
+     * The exact width in pixels the captured image should have.
+     *
+     * See {@link heightInPixels} — the two are set together or not at all.
+     */
+    readonly widthInPixels?: number;
+}
+/**
+ * Captures a PNG screenshot of the running Obsidian instance, resolving the
+ * transport and vault from the current test context.
+ *
+ * @param options - Optional size, transport and vault overrides.
+ * @returns A {@link Promise} that resolves to the raw PNG bytes.
+ * @throws Error if the active transport cannot capture screenshots.
+ */
+export declare function captureObsidianScreenshot(options?: CaptureObsidianScreenshotOptions): Promise<Uint8Array>;

package/dist/lib/cjs/capture-screenshot.cjs

@@ -0,0 +1,82 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var capture_screenshot_exports = {};
+__export(capture_screenshot_exports, {
+  buildDeviceMetricsOverride: () => buildDeviceMetricsOverride,
+  decodeBase64Png: () => decodeBase64Png,
+  isPng: () => isPng,
+  readPngDimensions: () => readPngDimensions
+});
+module.exports = __toCommonJS(capture_screenshot_exports);
+const PNG_MARKER = "PNG";
+const PNG_MARKER_OFFSET = 1;
+const PNG_IHDR_MARKER = "IHDR";
+const PNG_IHDR_MARKER_OFFSET = 12;
+const PNG_WIDTH_OFFSET = 16;
+const PNG_HEIGHT_OFFSET = 20;
+const PNG_HEADER_MIN_LENGTH = 24;
+const CAPTURE_DEVICE_SCALE_FACTOR = 1;
+function buildDeviceMetricsOverride(params) {
+  const { heightInPixels, widthInPixels } = params;
+  if (heightInPixels === void 0 && widthInPixels === void 0) {
+    return void 0;
+  }
+  if (heightInPixels === void 0 || widthInPixels === void 0) {
+    throw new Error("captureScreenshot: widthInPixels and heightInPixels must be given together.");
+  }
+  return {
+    deviceScaleFactor: CAPTURE_DEVICE_SCALE_FACTOR,
+    height: heightInPixels,
+    mobile: false,
+    width: widthInPixels
+  };
+}
+function decodeBase64Png(base64) {
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+function isPng(bytes) {
+  return readAscii(bytes, PNG_MARKER_OFFSET, PNG_MARKER.length) === PNG_MARKER && readAscii(bytes, PNG_IHDR_MARKER_OFFSET, PNG_IHDR_MARKER.length) === PNG_IHDR_MARKER;
+}
+function readPngDimensions(bytes) {
+  if (!isPng(bytes)) {
+    throw new Error("readPngDimensions: the given bytes are not a PNG.");
+  }
+  if (bytes.length < PNG_HEADER_MIN_LENGTH) {
+    throw new Error(`readPngDimensions: a PNG header needs at least ${String(PNG_HEADER_MIN_LENGTH)} bytes, got ${String(bytes.length)}.`);
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return {
+    heightInPixels: view.getUint32(PNG_HEIGHT_OFFSET),
+    widthInPixels: view.getUint32(PNG_WIDTH_OFFSET)
+  };
+}
+function readAscii(bytes, offset, length) {
+  if (bytes.length < offset + length) {
+    return "";
+  }
+  return Buffer.from(bytes.subarray(offset, offset + length)).toString("ascii");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildDeviceMetricsOverride,
+  decodeBase64Png,
+  isPng,
+  readPngDimensions
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/capture-screenshot.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for screenshot capture: building the CDP device-metrics override\n * payload, decoding a base64-encoded PNG, and reading a PNG's pixel dimensions\n * out of its IHDR header.\n *\n * Kept separate from the transports (which are integration-only and excluded\n * from unit tests) so the payload shape and the PNG parsing stay unit-testable \u2014\n * the transports themselves only talk to CDP / Appium.\n */\n\nimport type { Except } from 'type-fest';\n\n/**\n * Parameters for capturing a screenshot of a running Obsidian instance.\n */\nexport interface CaptureScreenshotParams {\n  /**\n   * The working directory (vault path) identifying which Obsidian window to\n   * capture.\n   *\n   * Mirrors the `cwd` of an evaluation: a desktop instance can hold several\n   * vault windows, and the capture has to be routed to the right one.\n   */\n  readonly cwd: string;\n\n  /**\n   * The exact height in pixels the captured image should have.\n   *\n   * Desktop only, and only meaningful together with {@link widthInPixels}: the\n   * viewport is pinned to these metrics for the duration of the capture, so the\n   * resulting PNG is exactly this size whatever size the window happens to be.\n   * Omit both to capture the window at its natural size.\n   *\n   * Ignored by the Appium transport, which can only return the device's native\n   * framebuffer \u2014 size a mobile capture by choosing an AVD with the wanted\n   * screen geometry instead.\n   */\n  readonly heightInPixels?: number;\n\n  /**\n   * The exact width in pixels the captured image should have.\n   *\n   * See {@link heightInPixels} \u2014 the two are set together or not at all.\n   */\n  readonly widthInPixels?: number;\n}\n\n/**\n * The pixel dimensions read out of a PNG's IHDR header.\n */\nexport interface PngDimensions {\n  /**\n   * The image height in pixels.\n   */\n  readonly heightInPixels: number;\n\n  /**\n   * The image width in pixels.\n   */\n  readonly widthInPixels: number;\n}\n\n/**\n * The ASCII marker inside a PNG's 8-byte signature.\n *\n * Matched as text rather than as the raw signature bytes so this file stays\n * pure ASCII \u2014 two of those eight bytes are unprintable, and a literal `0x1A`\n * in a source file is read as end-of-file by some Windows tooling.\n */\nconst PNG_MARKER = 'PNG';\n\n/**\n * Byte offset of {@link PNG_MARKER}, immediately after the signature's leading\n * unprintable byte.\n */\nconst PNG_MARKER_OFFSET = 1;\n\n/**\n * The IHDR chunk's type marker.\n *\n * Required alongside {@link PNG_MARKER} because the dimensions are read out of\n * exactly that chunk, so its presence is what actually has to hold here.\n */\nconst PNG_IHDR_MARKER = 'IHDR';\n\n/**\n * Byte offset of {@link PNG_IHDR_MARKER}: the 8-byte signature plus the chunk's\n * 4-byte length field.\n */\nconst PNG_IHDR_MARKER_OFFSET = 12;\n\n/**\n * Byte offset of the big-endian `width` field, immediately after the IHDR type.\n */\nconst PNG_WIDTH_OFFSET = 16;\n\n/**\n * Byte offset of the big-endian `height` field, immediately after `width`.\n */\nconst PNG_HEIGHT_OFFSET = 20;\n\n/**\n * The shortest prefix from which {@link readPngDimensions} can read: everything\n * up to and including the IHDR `height` field.\n */\nconst PNG_HEADER_MIN_LENGTH = 24;\n\n/**\n * Device scale factor for a capture.\n *\n * Always `1`, so the emitted PNG is exactly the requested CSS pixel size rather\n * than a multiple of it.\n */\nconst CAPTURE_DEVICE_SCALE_FACTOR = 1;\n\n/**\n * Builds the `Emulation.setDeviceMetricsOverride` payload that pins a desktop\n * capture to an exact pixel size.\n *\n * Takes only the size half of {@link CaptureScreenshotParams} \u2014 routing the\n * capture to a window is the transport's job, not the payload's.\n *\n * @param params - The requested capture size.\n * @returns The CDP payload, or `undefined` when no size was requested (capture the window as it is).\n * @throws Error if exactly one of the two dimensions is given \u2014 a half-specified size cannot be honoured.\n */\nexport function buildDeviceMetricsOverride(params: Except<CaptureScreenshotParams, 'cwd'>): Record<string, unknown> | undefined {\n  const { heightInPixels, widthInPixels } = params;\n  if (heightInPixels === undefined && widthInPixels === undefined) {\n    return undefined;\n  }\n\n  if (heightInPixels === undefined || widthInPixels === undefined) {\n    throw new Error('captureScreenshot: widthInPixels and heightInPixels must be given together.');\n  }\n\n  return {\n    deviceScaleFactor: CAPTURE_DEVICE_SCALE_FACTOR,\n    height: heightInPixels,\n    mobile: false,\n    width: widthInPixels\n  };\n}\n\n/**\n * Decodes the base64 payload both CDP (`Page.captureScreenshot`) and Appium\n * (`takeScreenshot`) return into raw PNG bytes.\n *\n * @param base64 - The base64-encoded image data.\n * @returns The decoded bytes.\n */\nexport function decodeBase64Png(base64: string): Uint8Array {\n  return new Uint8Array(Buffer.from(base64, 'base64'));\n}\n\n/**\n * Decides whether the given bytes are a PNG carrying an IHDR chunk.\n *\n * Used to fail a capture loudly when a transport hands back something that is\n * not an image, rather than writing a corrupt file to disk.\n *\n * @param bytes - The bytes to check.\n * @returns `true` when the bytes are a PNG.\n */\nexport function isPng(bytes: Uint8Array): boolean {\n  return readAscii(bytes, PNG_MARKER_OFFSET, PNG_MARKER.length) === PNG_MARKER\n    && readAscii(bytes, PNG_IHDR_MARKER_OFFSET, PNG_IHDR_MARKER.length) === PNG_IHDR_MARKER;\n}\n\n/**\n * Reads a PNG's pixel dimensions from its IHDR header.\n *\n * The whole point is verification: a capture that silently comes back at the\n * wrong size is the failure mode that produces an off-spec screenshot set, so\n * the size is read back from the bytes rather than assumed from the request.\n *\n * @param bytes - The PNG bytes.\n * @returns The image's width and height in pixels.\n * @throws Error if the bytes are not a PNG, or are too short to carry an IHDR header.\n */\nexport function readPngDimensions(bytes: Uint8Array): PngDimensions {\n  if (!isPng(bytes)) {\n    throw new Error('readPngDimensions: the given bytes are not a PNG.');\n  }\n\n  if (bytes.length < PNG_HEADER_MIN_LENGTH) {\n    throw new Error(`readPngDimensions: a PNG header needs at least ${String(PNG_HEADER_MIN_LENGTH)} bytes, got ${String(bytes.length)}.`);\n  }\n\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n  return {\n    heightInPixels: view.getUint32(PNG_HEIGHT_OFFSET),\n    widthInPixels: view.getUint32(PNG_WIDTH_OFFSET)\n  };\n}\n\n/**\n * Reads a fixed-length ASCII marker out of a byte buffer.\n *\n * @param bytes - The bytes to read from.\n * @param offset - Byte offset the marker starts at.\n * @param length - Marker length in bytes.\n * @returns The decoded marker, or an empty string when the buffer is too short to hold it.\n */\nfunction readAscii(bytes: Uint8Array, offset: number, length: number): string {\n  if (bytes.length < offset + length) {\n    return '';\n  }\n\n  return Buffer.from(bytes.subarray(offset, offset + length)).toString('ascii');\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuEA,MAAM,aAAa;AAMnB,MAAM,oBAAoB;AAQ1B,MAAM,kBAAkB;AAMxB,MAAM,yBAAyB;AAK/B,MAAM,mBAAmB;AAKzB,MAAM,oBAAoB;AAM1B,MAAM,wBAAwB;AAQ9B,MAAM,8BAA8B;AAa7B,SAAS,2BAA2B,QAAqF;AAC9H,QAAM,EAAE,gBAAgB,cAAc,IAAI;AAC1C,MAAI,mBAAmB,UAAa,kBAAkB,QAAW;AAC/D,WAAO;AAAA,EACT;AAEA,MAAI,mBAAmB,UAAa,kBAAkB,QAAW;AAC/D,UAAM,IAAI,MAAM,6EAA6E;AAAA,EAC/F;AAEA,SAAO;AAAA,IACL,mBAAmB;AAAA,IACnB,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,OAAO;AAAA,EACT;AACF;AASO,SAAS,gBAAgB,QAA4B;AAC1D,SAAO,IAAI,WAAW,OAAO,KAAK,QAAQ,QAAQ,CAAC;AACrD;AAWO,SAAS,MAAM,OAA4B;AAChD,SAAO,UAAU,OAAO,mBAAmB,WAAW,MAAM,MAAM,cAC7D,UAAU,OAAO,wBAAwB,gBAAgB,MAAM,MAAM;AAC5E;AAaO,SAAS,kBAAkB,OAAkC;AAClE,MAAI,CAAC,MAAM,KAAK,GAAG;AACjB,UAAM,IAAI,MAAM,mDAAmD;AAAA,EACrE;AAEA,MAAI,MAAM,SAAS,uBAAuB;AACxC,UAAM,IAAI,MAAM,kDAAkD,OAAO,qBAAqB,CAAC,eAAe,OAAO,MAAM,MAAM,CAAC,GAAG;AAAA,EACvI;AAEA,QAAM,OAAO,IAAI,SAAS,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU;AAC1E,SAAO;AAAA,IACL,gBAAgB,KAAK,UAAU,iBAAiB;AAAA,IAChD,eAAe,KAAK,UAAU,gBAAgB;AAAA,EAChD;AACF;AAUA,SAAS,UAAU,OAAmB,QAAgB,QAAwB;AAC5E,MAAI,MAAM,SAAS,SAAS,QAAQ;AAClC,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,KAAK,MAAM,SAAS,QAAQ,SAAS,MAAM,CAAC,EAAE,SAAS,OAAO;AAC9E;",
  "names": []
}


package/dist/lib/cjs/capture-screenshot.d.cts

@@ -0,0 +1,99 @@
+/**
+ * @file
+ *
+ * Pure helpers for screenshot capture: building the CDP device-metrics override
+ * payload, decoding a base64-encoded PNG, and reading a PNG's pixel dimensions
+ * out of its IHDR header.
+ *
+ * Kept separate from the transports (which are integration-only and excluded
+ * from unit tests) so the payload shape and the PNG parsing stay unit-testable —
+ * the transports themselves only talk to CDP / Appium.
+ */
+import type { Except } from 'type-fest';
+/**
+ * Parameters for capturing a screenshot of a running Obsidian instance.
+ */
+export interface CaptureScreenshotParams {
+    /**
+     * The working directory (vault path) identifying which Obsidian window to
+     * capture.
+     *
+     * Mirrors the `cwd` of an evaluation: a desktop instance can hold several
+     * vault windows, and the capture has to be routed to the right one.
+     */
+    readonly cwd: string;
+    /**
+     * The exact height in pixels the captured image should have.
+     *
+     * Desktop only, and only meaningful together with {@link widthInPixels}: the
+     * viewport is pinned to these metrics for the duration of the capture, so the
+     * resulting PNG is exactly this size whatever size the window happens to be.
+     * Omit both to capture the window at its natural size.
+     *
+     * Ignored by the Appium transport, which can only return the device's native
+     * framebuffer — size a mobile capture by choosing an AVD with the wanted
+     * screen geometry instead.
+     */
+    readonly heightInPixels?: number;
+    /**
+     * The exact width in pixels the captured image should have.
+     *
+     * See {@link heightInPixels} — the two are set together or not at all.
+     */
+    readonly widthInPixels?: number;
+}
+/**
+ * The pixel dimensions read out of a PNG's IHDR header.
+ */
+export interface PngDimensions {
+    /**
+     * The image height in pixels.
+     */
+    readonly heightInPixels: number;
+    /**
+     * The image width in pixels.
+     */
+    readonly widthInPixels: number;
+}
+/**
+ * Builds the `Emulation.setDeviceMetricsOverride` payload that pins a desktop
+ * capture to an exact pixel size.
+ *
+ * Takes only the size half of {@link CaptureScreenshotParams} — routing the
+ * capture to a window is the transport's job, not the payload's.
+ *
+ * @param params - The requested capture size.
+ * @returns The CDP payload, or `undefined` when no size was requested (capture the window as it is).
+ * @throws Error if exactly one of the two dimensions is given — a half-specified size cannot be honoured.
+ */
+export declare function buildDeviceMetricsOverride(params: Except<CaptureScreenshotParams, 'cwd'>): Record<string, unknown> | undefined;
+/**
+ * Decodes the base64 payload both CDP (`Page.captureScreenshot`) and Appium
+ * (`takeScreenshot`) return into raw PNG bytes.
+ *
+ * @param base64 - The base64-encoded image data.
+ * @returns The decoded bytes.
+ */
+export declare function decodeBase64Png(base64: string): Uint8Array;
+/**
+ * Decides whether the given bytes are a PNG carrying an IHDR chunk.
+ *
+ * Used to fail a capture loudly when a transport hands back something that is
+ * not an image, rather than writing a corrupt file to disk.
+ *
+ * @param bytes - The bytes to check.
+ * @returns `true` when the bytes are a PNG.
+ */
+export declare function isPng(bytes: Uint8Array): boolean;
+/**
+ * Reads a PNG's pixel dimensions from its IHDR header.
+ *
+ * The whole point is verification: a capture that silently comes back at the
+ * wrong size is the failure mode that produces an off-spec screenshot set, so
+ * the size is read back from the bytes rather than assumed from the request.
+ *
+ * @param bytes - The PNG bytes.
+ * @returns The image's width and height in pixels.
+ * @throws Error if the bytes are not a PNG, or are too short to carry an IHDR header.
+ */
+export declare function readPngDimensions(bytes: Uint8Array): PngDimensions;

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

@@ -46,6 +46,12 @@ async function connectToCdp(options) {
     ...asarFallback && { asarFallback },
     ...compatibility && { compatibility },
     ...electronCompatibility && { electronCompatibility },
+    async captureScreenshot(params) {
+      if (!transport.captureScreenshot) {
+        throw new Error("connectToCdp: this transport cannot capture screenshots.");
+      }
+      return transport.captureScreenshot({ ...params, cwd: vault.path });
+    },
     async dispose() {
       try {
         if (shouldRemoveVaultOnDispose) {
@@ -120,4 +126,4 @@ async function sweepLeftovers(transportOptions) {
 0 && (module.exports = {
   connectToCdp
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * the base `lib` helpers, `errorToString`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { AsarFallback } from './asar-fallback-detection.cjs';\nimport type { ContextId } from './context-id.cjs';\nimport type { ElectronCompatibility } from './electron-compatibility.cjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.cjs';\nimport type { InstallerCompatibility } from './installer-compatibility.cjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.cjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport {\n  resolveLeftoverMaxAgeInMilliseconds,\n  sweepHostLeftovers,\n  willSweepLeftovers\n} from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.cjs';\nimport { TemporaryVault } from './temporary-vault.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { createTransportFromOptions } from './transport-factory.cjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The silent-asar-fallback verdict for an owned instance, read live after boot:\n   * whether the app version it is actually running matches the swapped-in pin, or\n   * the installer silently reverted to its own bundled asar. `undefined` in attach\n   * mode, when no asar was swapped, or when the running version was unreadable. A\n   * `'fallback'` verdict reaches here only when the throw is disabled\n   * ({@link ConnectToCdpOptions.shouldThrowOnSilentAsarFallback} `false`);\n   * otherwise it throws `SilentAsarFallbackError` before the connection is created.\n   */\n  readonly asarFallback?: AsarFallback | undefined;\n\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * The resolved installer\u2194app compatibility verdict for an owned instance, when\n   * it could be determined. `undefined` in attach mode, or when the verdict is\n   * unknown (undetectable shell version, or the app version is absent from the\n   * table). An `'unrunnable'` verdict reaches here only when the proactive throw\n   * is disabled ({@link ConnectToCdpOptions.shouldThrowOnIncompatibleInstaller}\n   * `false`); otherwise it throws `IncompatibleInstallerVersionError` before the\n   * connection is created.\n   */\n  readonly compatibility?: InstallerCompatibility | undefined;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * The runtime Electron compatibility verdict for an owned instance, read live\n   * after boot: whether the Electron version it is actually running is new enough\n   * for the running app version. `undefined` in attach mode, or when the verdict\n   * is unknown (the live version was unreadable, or the app version carries no\n   * recommended Electron version). An old Electron never blocks \u2014 it only warns \u2014\n   * so unlike {@link compatibility} there is no throwing tier.\n   */\n  readonly electronCompatibility?: ElectronCompatibility | undefined;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, lib, obsidianModule, context }` plus any `input`\n   * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). Mirrors\n   * the top-level `evalInObsidian`, with the transport and vault path pre-bound\n   * to this connection.\n   *\n   * @param params - The evaluation parameters (`callback`, optional `input`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `callback`.\n   */\n  evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Input, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TemporaryVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * Grace window in milliseconds for fast-failing a dead boot of the owned\n   * instance \u2014 the renderer loaded but the app never bootstrapped (empty\n   * `<body>`, no `window.app`), the terminal state when the asar cannot run on\n   * the launched Electron shell. Once it has held this long a\n   * `RendererFailedToInitializeError` is thrown instead of waiting out the full\n   * readiness timeout. Ignored in attach mode ({@link port} set). Set `0` to\n   * disable fast-fail.\n   *\n   * @default `10000`\n   */\n  readonly deadBootGraceInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Whether the Obsidian window is shown on screen. Defaults to `true`; set\n   * `false` to launch it off-screen.\n   * Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to launch the owned instance with Chromium's sandbox disabled\n   * (`--no-sandbox`).\n   *\n   * Needed to boot on Linux without a correctly-configured setuid\n   * `chrome-sandbox` helper (e.g. an installer-extracted portable shell, or CI\n   * running as a non-root user); harmless on Windows/macOS. Ignored in attach\n   * mode ({@link port} set).\n   *\n   * @default `false`\n   */\n  readonly shouldDisableSandbox?: boolean;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Whether an **unrunnable** installer\u2194app version pair fails fast before launch.\n   *\n   * When `true` (the default), an installer below the app's run floor throws\n   * `IncompatibleInstallerVersionError` from version resolution before anything is\n   * downloaded or launched. Set `false` to let the pin proceed to launch \u2014 where\n   * the reactive dead-boot fast-fail still catches the black-screen boot, and the\n   * `'unrunnable'` verdict is surfaced on {@link CdpConnection.compatibility}\n   * rather than thrown. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnIncompatibleInstaller?: boolean;\n\n  /**\n   * Whether a post-boot **silent asar fallback** fails fast.\n   *\n   * When an asar is swapped onto an installer shell too old for it, the instance\n   * may silently revert to the installer's own bundled asar and run the **wrong\n   * (older)** version behind a healthy UI. When `true` (the default), the running\n   * app version is verified against the pin post-boot and a mismatch throws\n   * `SilentAsarFallbackError`. Set `false` to let the boot proceed \u2014 the mismatch\n   * is then surfaced on {@link CdpConnection.asarFallback} rather than thrown.\n   * Ignored in attach mode ({@link port} set) and when no asar is swapped.\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnSilentAsarFallback?: boolean;\n\n  /**\n   * Whether the owned-instance compatibility **nag warnings** are emitted.\n   *\n   * Covers both the offline installer\u2194app warning and the post-boot\n   * runtime-Electron warning. When `true` (the default) each fires via the harness\n   * log; set `false` to silence both \u2014 the verdicts are still surfaced on\n   * {@link CdpConnection.compatibility} / {@link CdpConnection.electronCompatibility},\n   * only the log is suppressed. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldWarnOnCompatibilityIssues?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transportOptions = buildCdpTransportOptions(options);\n  await sweepLeftovers(transportOptions);\n  const transport = await createTransportFromOptions(transportOptions);\n  const vault = new TemporaryVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n  const asarFallback = transport instanceof DesktopCdpTransport ? transport.getAsarFallback() : undefined;\n  const compatibility = transport instanceof DesktopCdpTransport ? transport.getCompatibility() : undefined;\n  const electronCompatibility = transport instanceof DesktopCdpTransport ? transport.getElectronCompatibility() : undefined;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n    ...(asarFallback && { asarFallback }),\n    ...(compatibility && { compatibility }),\n    ...(electronCompatibility && { electronCompatibility }),\n\n    async dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Input, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Input, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Builds the {@link ObsidianCdpTransportOptions} for a connection, threading only\n * the provided {@link ConnectToCdpOptions} through (owned-visible defaults to\n * `true`, unlike the hidden-by-default test transports). Unset knobs pass through\n * as `undefined` and are read with `?? default` / `!== undefined` guards\n * downstream, so an explicit `undefined` is indistinguishable from an absent key.\n *\n * @param options - The connection options.\n * @returns The transport options to create the connection's transport from.\n */\nfunction buildCdpTransportOptions(options?: ConnectToCdpOptions): ObsidianCdpTransportOptions {\n  return normalizeOptionalProperties<ObsidianCdpTransportOptions>({\n    commandTimeoutInMilliseconds: options?.commandTimeoutInMilliseconds,\n    deadBootGraceInMilliseconds: options?.deadBootGraceInMilliseconds,\n    host: options?.host,\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    obsidianInstallerVersion: options?.obsidianInstallerVersion,\n    obsidianVersion: options?.obsidianVersion,\n    port: options?.port,\n    shouldDisableSandbox: options?.shouldDisableSandbox,\n    shouldThrowOnIncompatibleInstaller: options?.shouldThrowOnIncompatibleInstaller,\n    shouldThrowOnSilentAsarFallback: options?.shouldThrowOnSilentAsarFallback,\n    shouldWarnOnCompatibilityIssues: options?.shouldWarnOnCompatibilityIssues,\n    type: 'obsidian-cdp'\n  });\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/**\n * Removes the host-side temp directories earlier runs leaked, before this\n * connection adds its own.\n *\n * `connectToCdp` mints the same `temp-vault-*` / owned `userdata-*` directories\n * the test global setup does, and an ad-hoc debugging session is exactly the\n * kind that gets killed with a leftover behind \u2014 so it sweeps too. Age-gated and\n * best-effort; see the core's `sweepLeftovers`.\n *\n * @param transportOptions - The resolved transport options (source of the sweep knobs).\n */\nasync function sweepLeftovers(transportOptions: ObsidianCdpTransportOptions): Promise<void> {\n  if (!willSweepLeftovers(transportOptions)) {\n    return;\n  }\n\n  try {\n    const result = await sweepHostLeftovers({\n      maxAgeInMilliseconds: resolveLeftoverMaxAgeInMilliseconds(transportOptions)\n    });\n    if (result.removedCount > 0 || result.failedCount > 0) {\n      log(\n        `[connect-to-cdp] Swept ${String(result.removedCount)} leftover temp director(ies) from earlier runs `\n          + `(${String(result.failedCount)} still in use).`\n      );\n    }\n  } catch (error: unknown) {\n    log(`[connect-to-cdp] Leftover sweep error (non-fatal): ${String(error)}`);\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * the base `lib` helpers, `errorToString`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { AsarFallback } from './asar-fallback-detection.cjs';\nimport type { CaptureScreenshotParams } from './capture-screenshot.cjs';\nimport type { ContextId } from './context-id.cjs';\nimport type { ElectronCompatibility } from './electron-compatibility.cjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.cjs';\nimport type { InstallerCompatibility } from './installer-compatibility.cjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.cjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport {\n  resolveLeftoverMaxAgeInMilliseconds,\n  sweepHostLeftovers,\n  willSweepLeftovers\n} from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.cjs';\nimport { TemporaryVault } from './temporary-vault.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { createTransportFromOptions } from './transport-factory.cjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The silent-asar-fallback verdict for an owned instance, read live after boot:\n   * whether the app version it is actually running matches the swapped-in pin, or\n   * the installer silently reverted to its own bundled asar. `undefined` in attach\n   * mode, when no asar was swapped, or when the running version was unreadable. A\n   * `'fallback'` verdict reaches here only when the throw is disabled\n   * ({@link ConnectToCdpOptions.shouldThrowOnSilentAsarFallback} `false`);\n   * otherwise it throws `SilentAsarFallbackError` before the connection is created.\n   */\n  readonly asarFallback?: AsarFallback | undefined;\n\n  /**\n   * Captures a PNG screenshot of this connection's Obsidian window, with the\n   * vault path pre-bound.\n   *\n   * Pass `widthInPixels` + `heightInPixels` to pin the viewport for the duration\n   * of the capture, so the emitted PNG is exactly that size whatever size the\n   * window happens to be.\n   *\n   * @param params - The exact size to capture at. Omit to capture the window at its natural size.\n   * @returns A {@link Promise} that resolves to the raw PNG bytes.\n   */\n  captureScreenshot(params?: Except<CaptureScreenshotParams, 'cwd'>): Promise<Uint8Array>;\n\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * The resolved installer\u2194app compatibility verdict for an owned instance, when\n   * it could be determined. `undefined` in attach mode, or when the verdict is\n   * unknown (undetectable shell version, or the app version is absent from the\n   * table). An `'unrunnable'` verdict reaches here only when the proactive throw\n   * is disabled ({@link ConnectToCdpOptions.shouldThrowOnIncompatibleInstaller}\n   * `false`); otherwise it throws `IncompatibleInstallerVersionError` before the\n   * connection is created.\n   */\n  readonly compatibility?: InstallerCompatibility | undefined;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * The runtime Electron compatibility verdict for an owned instance, read live\n   * after boot: whether the Electron version it is actually running is new enough\n   * for the running app version. `undefined` in attach mode, or when the verdict\n   * is unknown (the live version was unreadable, or the app version carries no\n   * recommended Electron version). An old Electron never blocks \u2014 it only warns \u2014\n   * so unlike {@link compatibility} there is no throwing tier.\n   */\n  readonly electronCompatibility?: ElectronCompatibility | undefined;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, lib, obsidianModule, context }` plus any `input`\n   * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). Mirrors\n   * the top-level `evalInObsidian`, with the transport and vault path pre-bound\n   * to this connection.\n   *\n   * @param params - The evaluation parameters (`callback`, optional `input`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `callback`.\n   */\n  evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Input, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TemporaryVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * Grace window in milliseconds for fast-failing a dead boot of the owned\n   * instance \u2014 the renderer loaded but the app never bootstrapped (empty\n   * `<body>`, no `window.app`), the terminal state when the asar cannot run on\n   * the launched Electron shell. Once it has held this long a\n   * `RendererFailedToInitializeError` is thrown instead of waiting out the full\n   * readiness timeout. Ignored in attach mode ({@link port} set). Set `0` to\n   * disable fast-fail.\n   *\n   * @default `10000`\n   */\n  readonly deadBootGraceInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Whether the Obsidian window is shown on screen. Defaults to `true`; set\n   * `false` to launch it off-screen.\n   * Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to launch the owned instance with Chromium's sandbox disabled\n   * (`--no-sandbox`).\n   *\n   * Needed to boot on Linux without a correctly-configured setuid\n   * `chrome-sandbox` helper (e.g. an installer-extracted portable shell, or CI\n   * running as a non-root user); harmless on Windows/macOS. Ignored in attach\n   * mode ({@link port} set).\n   *\n   * @default `false`\n   */\n  readonly shouldDisableSandbox?: boolean;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Whether an **unrunnable** installer\u2194app version pair fails fast before launch.\n   *\n   * When `true` (the default), an installer below the app's run floor throws\n   * `IncompatibleInstallerVersionError` from version resolution before anything is\n   * downloaded or launched. Set `false` to let the pin proceed to launch \u2014 where\n   * the reactive dead-boot fast-fail still catches the black-screen boot, and the\n   * `'unrunnable'` verdict is surfaced on {@link CdpConnection.compatibility}\n   * rather than thrown. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnIncompatibleInstaller?: boolean;\n\n  /**\n   * Whether a post-boot **silent asar fallback** fails fast.\n   *\n   * When an asar is swapped onto an installer shell too old for it, the instance\n   * may silently revert to the installer's own bundled asar and run the **wrong\n   * (older)** version behind a healthy UI. When `true` (the default), the running\n   * app version is verified against the pin post-boot and a mismatch throws\n   * `SilentAsarFallbackError`. Set `false` to let the boot proceed \u2014 the mismatch\n   * is then surfaced on {@link CdpConnection.asarFallback} rather than thrown.\n   * Ignored in attach mode ({@link port} set) and when no asar is swapped.\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnSilentAsarFallback?: boolean;\n\n  /**\n   * Whether the owned-instance compatibility **nag warnings** are emitted.\n   *\n   * Covers both the offline installer\u2194app warning and the post-boot\n   * runtime-Electron warning. When `true` (the default) each fires via the harness\n   * log; set `false` to silence both \u2014 the verdicts are still surfaced on\n   * {@link CdpConnection.compatibility} / {@link CdpConnection.electronCompatibility},\n   * only the log is suppressed. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldWarnOnCompatibilityIssues?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transportOptions = buildCdpTransportOptions(options);\n  await sweepLeftovers(transportOptions);\n  const transport = await createTransportFromOptions(transportOptions);\n  const vault = new TemporaryVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n  const asarFallback = transport instanceof DesktopCdpTransport ? transport.getAsarFallback() : undefined;\n  const compatibility = transport instanceof DesktopCdpTransport ? transport.getCompatibility() : undefined;\n  const electronCompatibility = transport instanceof DesktopCdpTransport ? transport.getElectronCompatibility() : undefined;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n    ...(asarFallback && { asarFallback }),\n    ...(compatibility && { compatibility }),\n    ...(electronCompatibility && { electronCompatibility }),\n\n    async captureScreenshot(params?: Except<CaptureScreenshotParams, 'cwd'>): Promise<Uint8Array> {\n      // Every transport `connectToCdp` builds is a DesktopCdpTransport, which\n      // Implements the optional method \u2014 but the interface still types it\n      // Optional, so the absence is reported rather than silently thrown at.\n      if (!transport.captureScreenshot) {\n        throw new Error('connectToCdp: this transport cannot capture screenshots.');\n      }\n\n      return transport.captureScreenshot({ ...params, cwd: vault.path });\n    },\n\n    async dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Input, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Input, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Builds the {@link ObsidianCdpTransportOptions} for a connection, threading only\n * the provided {@link ConnectToCdpOptions} through (owned-visible defaults to\n * `true`, unlike the hidden-by-default test transports). Unset knobs pass through\n * as `undefined` and are read with `?? default` / `!== undefined` guards\n * downstream, so an explicit `undefined` is indistinguishable from an absent key.\n *\n * @param options - The connection options.\n * @returns The transport options to create the connection's transport from.\n */\nfunction buildCdpTransportOptions(options?: ConnectToCdpOptions): ObsidianCdpTransportOptions {\n  return normalizeOptionalProperties<ObsidianCdpTransportOptions>({\n    commandTimeoutInMilliseconds: options?.commandTimeoutInMilliseconds,\n    deadBootGraceInMilliseconds: options?.deadBootGraceInMilliseconds,\n    host: options?.host,\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    obsidianInstallerVersion: options?.obsidianInstallerVersion,\n    obsidianVersion: options?.obsidianVersion,\n    port: options?.port,\n    shouldDisableSandbox: options?.shouldDisableSandbox,\n    shouldThrowOnIncompatibleInstaller: options?.shouldThrowOnIncompatibleInstaller,\n    shouldThrowOnSilentAsarFallback: options?.shouldThrowOnSilentAsarFallback,\n    shouldWarnOnCompatibilityIssues: options?.shouldWarnOnCompatibilityIssues,\n    type: 'obsidian-cdp'\n  });\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/**\n * Removes the host-side temp directories earlier runs leaked, before this\n * connection adds its own.\n *\n * `connectToCdp` mints the same `temp-vault-*` / owned `userdata-*` directories\n * the test global setup does, and an ad-hoc debugging session is exactly the\n * kind that gets killed with a leftover behind \u2014 so it sweeps too. Age-gated and\n * best-effort; see the core's `sweepLeftovers`.\n *\n * @param transportOptions - The resolved transport options (source of the sweep knobs).\n */\nasync function sweepLeftovers(transportOptions: ObsidianCdpTransportOptions): Promise<void> {\n  if (!willSweepLeftovers(transportOptions)) {\n    return;\n  }\n\n  try {\n    const result = await sweepHostLeftovers({\n      maxAgeInMilliseconds: resolveLeftoverMaxAgeInMilliseconds(transportOptions)\n    });\n    if (result.removedCount > 0 || result.failedCount > 0) {\n      log(\n        `[connect-to-cdp] Swept ${String(result.removedCount)} leftover temp director(ies) from earlier runs `\n          + `(${String(result.failedCount)} still in use).`\n      );\n    }\n  } catch (error: unknown) {\n    log(`[connect-to-cdp] Leftover sweep error (non-fatal): ${String(error)}`);\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


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

@@ -12,6 +12,7 @@
  */
 import type { Except } from 'type-fest';
 import type { AsarFallback } from './asar-fallback-detection.cjs';
+import type { CaptureScreenshotParams } from './capture-screenshot.cjs';
 import type { ContextId } from './context-id.cjs';
 import type { ElectronCompatibility } from './electron-compatibility.cjs';
 import type { EvalInObsidianParams, GenericObject } from './eval-in-obsidian.cjs';
@@ -36,6 +37,18 @@ export interface CdpConnection extends AsyncDisposable {
      * otherwise it throws `SilentAsarFallbackError` before the connection is created.
      */
     readonly asarFallback?: AsarFallback | undefined;
+    /**
+     * Captures a PNG screenshot of this connection's Obsidian window, with the
+     * vault path pre-bound.
+     *
+     * Pass `widthInPixels` + `heightInPixels` to pin the viewport for the duration
+     * of the capture, so the emitted PNG is exactly that size whatever size the
+     * window happens to be.
+     *
+     * @param params - The exact size to capture at. Omit to capture the window at its natural size.
+     * @returns A {@link Promise} that resolves to the raw PNG bytes.
+     */
+    captureScreenshot(params?: Except<CaptureScreenshotParams, 'cwd'>): Promise<Uint8Array>;
     /**
      * The base CDP URL, e.g. `http://localhost:51888`.
      */