obsidian-integration-testing 9.2.2 → 10.1.0

package/dist/lib/esm/capture-screenshot.mjs

@@ -0,0 +1,55 @@
+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");
+}
+export {
+  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": "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/esm/cli.mjs

@@ -41,7 +41,7 @@ function buildOptions(values) {
 function parseNumber(flag, raw) {
   const value = Number(raw);
   if (!Number.isFinite(value)) {
-    throw new Error(`--${flag} must be a number, got: ${raw}`);
+    throw new TypeError(`--${flag} must be a number, got: ${raw}`);
   }
   return value;
 }
@@ -51,12 +51,12 @@ function waitForShutdownOrInstanceClose(cdpUrl) {
     const versionUrl = `${cdpUrl}/json/version`;
     let isSettled = false;
     const timer = setInterval(() => {
-      checkAlive().catch(() => {
+      probeAlive().catch(() => {
       });
     }, POLL_INTERVAL_IN_MILLISECONDS);
     process.once("SIGINT", settle);
     process.once("SIGTERM", settle);
-    async function checkAlive() {
+    async function probeAlive() {
       try {
         const response = await fetch(versionUrl);
         if (!response.ok) {
@@ -79,4 +79,4 @@ function waitForShutdownOrInstanceClose(cdpUrl) {
 export {
   main
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/cli.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Thin CLI over {@link connectToCdp}: launches (or attaches to) a CDP-enabled\n * Obsidian instance with the runtime helper namespace bootstrapped, prints the\n * chosen CDP port/URL, and stays alive until interrupted so an external tool\n * (raw CDP `ws`, DevTools, \u2026) can attach.\n */\n\n/* v8 ignore start -- Integration-time CLI (launches Obsidian / CDP) covered manually, not by unit tests. */\n\nimport process from 'node:process';\nimport { parseArgs } from 'node:util';\n\nimport type { ConnectToCdpOptions } from './connect-to-cdp.mjs';\n\nimport { connectToCdp } from './connect-to-cdp.mjs';\n\n/**\n * The shape of the parsed CLI flag values.\n */\ninterface ParsedCliValues {\n  'command-timeout'?: string | undefined;\n  'host'?: string | undefined;\n  'no-remove-vault'?: boolean | undefined;\n  'obsidian-installer-version'?: string | undefined;\n  'obsidian-version'?: string | undefined;\n  'port'?: string | undefined;\n  'vault'?: string | undefined;\n}\n\n/**\n * Parses CLI arguments, opens the connection, prints its endpoint, and blocks\n * until `SIGINT`/`SIGTERM` or the owned Obsidian window is closed, disposing the\n * connection on shutdown.\n *\n * @returns A {@link Promise} that resolves once the connection has been disposed.\n */\nexport async function main(): Promise<void> {\n  const { values } = parseArgs({\n    options: {\n      'command-timeout': { type: 'string' },\n      'host': { type: 'string' },\n      'no-remove-vault': { type: 'boolean' },\n      'obsidian-installer-version': { type: 'string' },\n      'obsidian-version': { type: 'string' },\n      'port': { type: 'string' },\n      'vault': { type: 'string' }\n    }\n  });\n\n  const connection = await connectToCdp(buildOptions(values));\n\n  process.stdout.write(\n    'Obsidian CDP ready.\\n'\n      + `  port:   ${String(connection.port)}\\n`\n      + `  cdpUrl: ${connection.cdpUrl}\\n`\n      + `  vault:  ${connection.vault.path}\\n`\n      + 'Runtime helpers bootstrapped as window.__obsidianIntegrationTesting.\\n'\n      + 'Press Ctrl+C to stop.\\n'\n  );\n\n  await waitForShutdownOrInstanceClose(connection.cdpUrl);\n\n  process.stdout.write('\\nShutting down\u2026\\n');\n  await connection.dispose();\n}\n\n/**\n * Builds {@link ConnectToCdpOptions} from parsed CLI flag values.\n *\n * @param values - The parsed `parseArgs` values.\n * @returns The connection options.\n */\nfunction buildOptions(values: ParsedCliValues): ConnectToCdpOptions {\n  return {\n    ...(values['command-timeout'] !== undefined && { commandTimeoutInMilliseconds: parseNumber('command-timeout', values['command-timeout']) }),\n    ...(values.host !== undefined && { host: values.host }),\n    ...(values['no-remove-vault'] === true && { shouldRemoveVaultOnDispose: false }),\n    ...(values['obsidian-installer-version'] !== undefined && { obsidianInstallerVersion: values['obsidian-installer-version'] }),\n    ...(values['obsidian-version'] !== undefined && { obsidianVersion: values['obsidian-version'] }),\n    ...(values.port !== undefined && { port: parseNumber('port', values.port) }),\n    ...(values.vault !== undefined && { vault: values.vault })\n  };\n}\n\n/**\n * Parses a numeric CLI flag value, throwing on a non-finite result.\n *\n * @param flag - The flag name (for the error message).\n * @param raw - The raw string value.\n * @returns The parsed number.\n * @throws Error if `raw` is not a finite number.\n */\nfunction parseNumber(flag: string, raw: string): number {\n  const value = Number(raw);\n  if (!Number.isFinite(value)) {\n    throw new Error(`--${flag} must be a number, got: ${raw}`);\n  }\n  return value;\n}\n\n/**\n * Resolves once the process receives `SIGINT`/`SIGTERM`, or the CDP endpoint\n * stops answering (the owned Obsidian window was closed).\n *\n * @param cdpUrl - The connection's CDP base URL to poll.\n * @returns A {@link Promise} that resolves on the first shutdown trigger.\n */\nfunction waitForShutdownOrInstanceClose(cdpUrl: string): Promise<void> {\n  const POLL_INTERVAL_IN_MILLISECONDS = 1000;\n  return new Promise<void>((resolve) => {\n    const versionUrl = `${cdpUrl}/json/version`;\n    let isSettled = false;\n\n    const timer = setInterval(() => {\n      checkAlive().catch(() => {\n        // Ignore poll errors.\n      });\n    }, POLL_INTERVAL_IN_MILLISECONDS);\n\n    process.once('SIGINT', settle);\n    process.once('SIGTERM', settle);\n\n    async function checkAlive(): Promise<void> {\n      try {\n        const response = await fetch(versionUrl);\n        if (!response.ok) {\n          settle();\n        }\n      } catch {\n        // The CDP port stopped answering: the Obsidian window was closed.\n        settle();\n      }\n    }\n\n    function settle(): void {\n      if (isSettled) {\n        return;\n      }\n      isSettled = true;\n      clearInterval(timer);\n      resolve();\n    }\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAWA,OAAO,aAAa;AACpB,SAAS,iBAAiB;AAI1B,SAAS,oBAAoB;AAsB7B,eAAsB,OAAsB;AAC1C,QAAM,EAAE,OAAO,IAAI,UAAU;AAAA,IAC3B,SAAS;AAAA,MACP,mBAAmB,EAAE,MAAM,SAAS;AAAA,MACpC,QAAQ,EAAE,MAAM,SAAS;AAAA,MACzB,mBAAmB,EAAE,MAAM,UAAU;AAAA,MACrC,8BAA8B,EAAE,MAAM,SAAS;AAAA,MAC/C,oBAAoB,EAAE,MAAM,SAAS;AAAA,MACrC,QAAQ,EAAE,MAAM,SAAS;AAAA,MACzB,SAAS,EAAE,MAAM,SAAS;AAAA,IAC5B;AAAA,EACF,CAAC;AAED,QAAM,aAAa,MAAM,aAAa,aAAa,MAAM,CAAC;AAE1D,UAAQ,OAAO;AAAA,IACb;AAAA,YACiB,OAAO,WAAW,IAAI,CAAC;AAAA,YACvB,WAAW,MAAM;AAAA,YACjB,WAAW,MAAM,IAAI;AAAA;AAAA;AAAA;AAAA,EAGxC;AAEA,QAAM,+BAA+B,WAAW,MAAM;AAEtD,UAAQ,OAAO,MAAM,yBAAoB;AACzC,QAAM,WAAW,QAAQ;AAC3B;AAQA,SAAS,aAAa,QAA8C;AAClE,SAAO;AAAA,IACL,GAAI,OAAO,iBAAiB,MAAM,UAAa,EAAE,8BAA8B,YAAY,mBAAmB,OAAO,iBAAiB,CAAC,EAAE;AAAA,IACzI,GAAI,OAAO,SAAS,UAAa,EAAE,MAAM,OAAO,KAAK;AAAA,IACrD,GAAI,OAAO,iBAAiB,MAAM,QAAQ,EAAE,4BAA4B,MAAM;AAAA,IAC9E,GAAI,OAAO,4BAA4B,MAAM,UAAa,EAAE,0BAA0B,OAAO,4BAA4B,EAAE;AAAA,IAC3H,GAAI,OAAO,kBAAkB,MAAM,UAAa,EAAE,iBAAiB,OAAO,kBAAkB,EAAE;AAAA,IAC9F,GAAI,OAAO,SAAS,UAAa,EAAE,MAAM,YAAY,QAAQ,OAAO,IAAI,EAAE;AAAA,IAC1E,GAAI,OAAO,UAAU,UAAa,EAAE,OAAO,OAAO,MAAM;AAAA,EAC1D;AACF;AAUA,SAAS,YAAY,MAAc,KAAqB;AACtD,QAAM,QAAQ,OAAO,GAAG;AACxB,MAAI,CAAC,OAAO,SAAS,KAAK,GAAG;AAC3B,UAAM,IAAI,MAAM,KAAK,IAAI,2BAA2B,GAAG,EAAE;AAAA,EAC3D;AACA,SAAO;AACT;AASA,SAAS,+BAA+B,QAA+B;AACrE,QAAM,gCAAgC;AACtC,SAAO,IAAI,QAAc,CAAC,YAAY;AACpC,UAAM,aAAa,GAAG,MAAM;AAC5B,QAAI,YAAY;AAEhB,UAAM,QAAQ,YAAY,MAAM;AAC9B,iBAAW,EAAE,MAAM,MAAM;AAAA,MAEzB,CAAC;AAAA,IACH,GAAG,6BAA6B;AAEhC,YAAQ,KAAK,UAAU,MAAM;AAC7B,YAAQ,KAAK,WAAW,MAAM;AAE9B,mBAAe,aAA4B;AACzC,UAAI;AACF,cAAM,WAAW,MAAM,MAAM,UAAU;AACvC,YAAI,CAAC,SAAS,IAAI;AAChB,iBAAO;AAAA,QACT;AAAA,MACF,QAAQ;AAEN,eAAO;AAAA,MACT;AAAA,IACF;AAEA,aAAS,SAAe;AACtB,UAAI,WAAW;AACb;AAAA,MACF;AACA,kBAAY;AACZ,oBAAc,KAAK;AACnB,cAAQ;AAAA,IACV;AAAA,EACF,CAAC;AACH;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/cli.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Thin CLI over {@link connectToCdp}: launches (or attaches to) a CDP-enabled\n * Obsidian instance with the runtime helper namespace bootstrapped, prints the\n * chosen CDP port/URL, and stays alive until interrupted so an external tool\n * (raw CDP `ws`, DevTools, \u2026) can attach.\n */\n\n/* v8 ignore start -- Integration-time CLI (launches Obsidian / CDP) covered manually, not by unit tests. */\n\nimport process from 'node:process';\nimport { parseArgs } from 'node:util';\n\nimport type { ConnectToCdpOptions } from './connect-to-cdp.mjs';\n\nimport { connectToCdp } from './connect-to-cdp.mjs';\n\n/**\n * The shape of the parsed CLI flag values.\n */\ninterface ParsedCliValues {\n  'command-timeout'?: string | undefined;\n  'host'?: string | undefined;\n  'no-remove-vault'?: boolean | undefined;\n  'obsidian-installer-version'?: string | undefined;\n  'obsidian-version'?: string | undefined;\n  'port'?: string | undefined;\n  'vault'?: string | undefined;\n}\n\n/**\n * Parses CLI arguments, opens the connection, prints its endpoint, and blocks\n * until `SIGINT`/`SIGTERM` or the owned Obsidian window is closed, disposing the\n * connection on shutdown.\n *\n * @returns A {@link Promise} that resolves once the connection has been disposed.\n */\nexport async function main(): Promise<void> {\n  const { values } = parseArgs({\n    options: {\n      'command-timeout': { type: 'string' },\n      'host': { type: 'string' },\n      'no-remove-vault': { type: 'boolean' },\n      'obsidian-installer-version': { type: 'string' },\n      'obsidian-version': { type: 'string' },\n      'port': { type: 'string' },\n      'vault': { type: 'string' }\n    }\n  });\n\n  const connection = await connectToCdp(buildOptions(values));\n\n  process.stdout.write(\n    'Obsidian CDP ready.\\n'\n      + `  port:   ${String(connection.port)}\\n`\n      + `  cdpUrl: ${connection.cdpUrl}\\n`\n      + `  vault:  ${connection.vault.path}\\n`\n      + 'Runtime helpers bootstrapped as window.__obsidianIntegrationTesting.\\n'\n      + 'Press Ctrl+C to stop.\\n'\n  );\n\n  await waitForShutdownOrInstanceClose(connection.cdpUrl);\n\n  process.stdout.write('\\nShutting down\u2026\\n');\n  await connection.dispose();\n}\n\n/**\n * Builds {@link ConnectToCdpOptions} from parsed CLI flag values.\n *\n * @param values - The parsed `parseArgs` values.\n * @returns The connection options.\n */\nfunction buildOptions(values: ParsedCliValues): ConnectToCdpOptions {\n  return {\n    ...(values['command-timeout'] !== undefined && { commandTimeoutInMilliseconds: parseNumber('command-timeout', values['command-timeout']) }),\n    ...(values.host !== undefined && { host: values.host }),\n    ...(values['no-remove-vault'] === true && { shouldRemoveVaultOnDispose: false }),\n    ...(values['obsidian-installer-version'] !== undefined && { obsidianInstallerVersion: values['obsidian-installer-version'] }),\n    ...(values['obsidian-version'] !== undefined && { obsidianVersion: values['obsidian-version'] }),\n    ...(values.port !== undefined && { port: parseNumber('port', values.port) }),\n    ...(values.vault !== undefined && { vault: values.vault })\n  };\n}\n\n/**\n * Parses a numeric CLI flag value, throwing on a non-finite result.\n *\n * @param flag - The flag name (for the error message).\n * @param raw - The raw string value.\n * @returns The parsed number.\n * @throws Error if `raw` is not a finite number.\n */\nfunction parseNumber(flag: string, raw: string): number {\n  const value = Number(raw);\n  if (!Number.isFinite(value)) {\n    throw new TypeError(`--${flag} must be a number, got: ${raw}`);\n  }\n  return value;\n}\n\n/**\n * Resolves once the process receives `SIGINT`/`SIGTERM`, or the CDP endpoint\n * stops answering (the owned Obsidian window was closed).\n *\n * @param cdpUrl - The connection's CDP base URL to poll.\n * @returns A {@link Promise} that resolves on the first shutdown trigger.\n */\nfunction waitForShutdownOrInstanceClose(cdpUrl: string): Promise<void> {\n  const POLL_INTERVAL_IN_MILLISECONDS = 1000;\n  return new Promise<void>((resolve) => {\n    const versionUrl = `${cdpUrl}/json/version`;\n    let isSettled = false;\n\n    const timer = setInterval(() => {\n      probeAlive().catch(() => {\n        // Ignore poll errors.\n      });\n    }, POLL_INTERVAL_IN_MILLISECONDS);\n\n    process.once('SIGINT', settle);\n    process.once('SIGTERM', settle);\n\n    async function probeAlive(): Promise<void> {\n      try {\n        const response = await fetch(versionUrl);\n        if (!response.ok) {\n          settle();\n        }\n      } catch {\n        // The CDP port stopped answering: the Obsidian window was closed.\n        settle();\n      }\n    }\n\n    function settle(): void {\n      if (isSettled) {\n        return;\n      }\n      isSettled = true;\n      clearInterval(timer);\n      resolve();\n    }\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAWA,OAAO,aAAa;AACpB,SAAS,iBAAiB;AAI1B,SAAS,oBAAoB;AAsB7B,eAAsB,OAAsB;AAC1C,QAAM,EAAE,OAAO,IAAI,UAAU;AAAA,IAC3B,SAAS;AAAA,MACP,mBAAmB,EAAE,MAAM,SAAS;AAAA,MACpC,QAAQ,EAAE,MAAM,SAAS;AAAA,MACzB,mBAAmB,EAAE,MAAM,UAAU;AAAA,MACrC,8BAA8B,EAAE,MAAM,SAAS;AAAA,MAC/C,oBAAoB,EAAE,MAAM,SAAS;AAAA,MACrC,QAAQ,EAAE,MAAM,SAAS;AAAA,MACzB,SAAS,EAAE,MAAM,SAAS;AAAA,IAC5B;AAAA,EACF,CAAC;AAED,QAAM,aAAa,MAAM,aAAa,aAAa,MAAM,CAAC;AAE1D,UAAQ,OAAO;AAAA,IACb;AAAA,YACiB,OAAO,WAAW,IAAI,CAAC;AAAA,YACvB,WAAW,MAAM;AAAA,YACjB,WAAW,MAAM,IAAI;AAAA;AAAA;AAAA;AAAA,EAGxC;AAEA,QAAM,+BAA+B,WAAW,MAAM;AAEtD,UAAQ,OAAO,MAAM,yBAAoB;AACzC,QAAM,WAAW,QAAQ;AAC3B;AAQA,SAAS,aAAa,QAA8C;AAClE,SAAO;AAAA,IACL,GAAI,OAAO,iBAAiB,MAAM,UAAa,EAAE,8BAA8B,YAAY,mBAAmB,OAAO,iBAAiB,CAAC,EAAE;AAAA,IACzI,GAAI,OAAO,SAAS,UAAa,EAAE,MAAM,OAAO,KAAK;AAAA,IACrD,GAAI,OAAO,iBAAiB,MAAM,QAAQ,EAAE,4BAA4B,MAAM;AAAA,IAC9E,GAAI,OAAO,4BAA4B,MAAM,UAAa,EAAE,0BAA0B,OAAO,4BAA4B,EAAE;AAAA,IAC3H,GAAI,OAAO,kBAAkB,MAAM,UAAa,EAAE,iBAAiB,OAAO,kBAAkB,EAAE;AAAA,IAC9F,GAAI,OAAO,SAAS,UAAa,EAAE,MAAM,YAAY,QAAQ,OAAO,IAAI,EAAE;AAAA,IAC1E,GAAI,OAAO,UAAU,UAAa,EAAE,OAAO,OAAO,MAAM;AAAA,EAC1D;AACF;AAUA,SAAS,YAAY,MAAc,KAAqB;AACtD,QAAM,QAAQ,OAAO,GAAG;AACxB,MAAI,CAAC,OAAO,SAAS,KAAK,GAAG;AAC3B,UAAM,IAAI,UAAU,KAAK,IAAI,2BAA2B,GAAG,EAAE;AAAA,EAC/D;AACA,SAAO;AACT;AASA,SAAS,+BAA+B,QAA+B;AACrE,QAAM,gCAAgC;AACtC,SAAO,IAAI,QAAc,CAAC,YAAY;AACpC,UAAM,aAAa,GAAG,MAAM;AAC5B,QAAI,YAAY;AAEhB,UAAM,QAAQ,YAAY,MAAM;AAC9B,iBAAW,EAAE,MAAM,MAAM;AAAA,MAEzB,CAAC;AAAA,IACH,GAAG,6BAA6B;AAEhC,YAAQ,KAAK,UAAU,MAAM;AAC7B,YAAQ,KAAK,WAAW,MAAM;AAE9B,mBAAe,aAA4B;AACzC,UAAI;AACF,cAAM,WAAW,MAAM,MAAM,UAAU;AACvC,YAAI,CAAC,SAAS,IAAI;AAChB,iBAAO;AAAA,QACT;AAAA,MACF,QAAQ;AAEN,eAAO;AAAA,MACT;AAAA,IACF;AAEA,aAAS,SAAe;AACtB,UAAI,WAAW;AACb;AAAA,MACF;AACA,kBAAY;AACZ,oBAAc,KAAK;AACnB,cAAQ;AAAA,IACV;AAAA,EACF,CAAC;AACH;",
  "names": []
}


package/dist/lib/esm/compatibility-options.d.mts

@@ -50,22 +50,34 @@ export type InstallerCompatibilityAction = 'silent' | 'throw' | 'warn-nagged' |
  * Parameters for {@link resolveAsarFallbackAction}.
  */
 export interface ResolveAsarFallbackActionParams {
-    /** Whether a `'fallback'` verdict throws (vs. proceeds with a warning). */
+    /**
+    Whether a `'fallback'` verdict throws (vs. proceeds with a warning).
+     */
     readonly shouldThrowOnSilentAsarFallback: boolean;
-    /** Whether a non-throwing fallback verdict is logged. */
+    /**
+    Whether a non-throwing fallback verdict is logged.
+     */
     readonly shouldWarnOnCompatibilityIssues: boolean;
-    /** The resolved silent-asar-fallback tier. */
+    /**
+    The resolved silent-asar-fallback tier.
+     */
     readonly tier: AsarFallbackTier;
 }
 /**
  * Parameters for {@link resolveInstallerCompatibilityAction}.
  */
 export interface ResolveInstallerCompatibilityActionParams {
-    /** Whether an `'unrunnable'` verdict throws (vs. proceeds to launch). */
+    /**
+    Whether an `'unrunnable'` verdict throws (vs. proceeds to launch).
+     */
     readonly shouldThrowOnIncompatibleInstaller: boolean;
-    /** Whether a nag / proceeding-unrunnable verdict is logged. */
+    /**
+    Whether a nag / proceeding-unrunnable verdict is logged.
+     */
     readonly shouldWarnOnCompatibilityIssues: boolean;
-    /** The resolved installer↔app compatibility tier. */
+    /**
+    The resolved installer↔app compatibility tier.
+     */
     readonly tier: InstallerCompatibilityTier;
 }
 /**
@@ -88,25 +100,25 @@ export declare function resolveInstallerCompatibilityAction(params: ResolveInsta
  * Whether an `'unrunnable'` installer↔app pair should fail fast with
  * {@link IncompatibleInstallerVersionError} before launch.
  *
- * @param shouldThrowOnIncompatibleInstaller - The resolved option value (omitted → throw).
+ * @param shouldThrow - The configured option value (omitted → throw).
  * @returns `true` when an unrunnable pin should throw (the default).
  */
-export declare function resolveShouldThrowOnIncompatibleInstaller(shouldThrowOnIncompatibleInstaller?: boolean): boolean;
+export declare function willThrowOnIncompatibleInstaller(shouldThrow?: boolean): boolean;
 /**
  * Whether a booted owned instance running a different app (asar) version than the
  * pin — a silent fallback to the installer's own bundled asar — should fail fast
  * with {@link SilentAsarFallbackError}.
  *
- * @param shouldThrowOnSilentAsarFallback - The resolved option value (omitted → throw).
+ * @param shouldThrow - The configured option value (omitted → throw).
  * @returns `true` when a silent fallback should throw (the default).
  */
-export declare function resolveShouldThrowOnSilentAsarFallback(shouldThrowOnSilentAsarFallback?: boolean): boolean;
+export declare function willThrowOnSilentAsarFallback(shouldThrow?: boolean): boolean;
 /**
  * Whether the owned-instance compatibility nag warnings should be emitted (both
  * the installer↔app `'nagged'` warning and the runtime-Electron `'nagged'`
  * warning).
  *
- * @param shouldWarnOnCompatibilityIssues - The resolved option value (omitted → warn).
+ * @param shouldWarn - The configured option value (omitted → warn).
  * @returns `true` when the warnings should be emitted (the default).
  */
-export declare function resolveShouldWarnOnCompatibilityIssues(shouldWarnOnCompatibilityIssues?: boolean): boolean;
+export declare function willWarnOnCompatibilityIssues(shouldWarn?: boolean): boolean;

package/dist/lib/esm/compatibility-options.mjs

@@ -21,20 +21,20 @@ function resolveInstallerCompatibilityAction(params) {
   }
   return "silent";
 }
-function resolveShouldThrowOnIncompatibleInstaller(shouldThrowOnIncompatibleInstaller) {
-  return shouldThrowOnIncompatibleInstaller ?? true;
+function willThrowOnIncompatibleInstaller(shouldThrow) {
+  return shouldThrow ?? true;
 }
-function resolveShouldThrowOnSilentAsarFallback(shouldThrowOnSilentAsarFallback) {
-  return shouldThrowOnSilentAsarFallback ?? true;
+function willThrowOnSilentAsarFallback(shouldThrow) {
+  return shouldThrow ?? true;
 }
-function resolveShouldWarnOnCompatibilityIssues(shouldWarnOnCompatibilityIssues) {
-  return shouldWarnOnCompatibilityIssues ?? true;
+function willWarnOnCompatibilityIssues(shouldWarn) {
+  return shouldWarn ?? true;
 }
 export {
   resolveAsarFallbackAction,
   resolveInstallerCompatibilityAction,
-  resolveShouldThrowOnIncompatibleInstaller,
-  resolveShouldThrowOnSilentAsarFallback,
-  resolveShouldWarnOnCompatibilityIssues
+  willThrowOnIncompatibleInstaller,
+  willThrowOnSilentAsarFallback,
+  willWarnOnCompatibilityIssues
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/compatibility-options.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure resolution of the two owned-instance compatibility knobs \u2014 whether the\n * installer\u2194app / runtime-Electron nag warnings are emitted, and whether an\n * `'unrunnable'` installer\u2194app pair fails fast with\n * {@link IncompatibleInstallerVersionError} before launch.\n *\n * Both default to today's behavior (`true`): warnings on, and an unrunnable pin\n * throws proactively. Setting `shouldWarnOnCompatibilityIssues` to `false`\n * silences both nags (the verdicts are still computed and surfaced as data);\n * setting `shouldThrowOnIncompatibleInstaller` to `false` lets an unrunnable pin\n * proceed to launch, where the reactive dead-boot fast-fail\n * (`RendererFailedToInitializeError`) still catches it.\n *\n * Kept separate from the integration-only launch code (`transport-factory`,\n * `transport-desktop-cdp`, both excluded from unit tests) so the default\n * resolution stays unit-testable \u2014 mirroring the `visibility.ts` /\n * `appium-session-config.ts` pure-resolver split.\n */\n\nimport type { AsarFallbackTier } from './asar-fallback-detection.mjs';\nimport type { InstallerCompatibilityTier } from './installer-compatibility.mjs';\n\n/**\n * The action to take for a resolved silent-asar-fallback verdict, given the\n * throw/warn knobs.\n *\n * - `'throw'` \u2014 the verdict is `'fallback'` and the throw is enabled; the caller\n *   throws `SilentAsarFallbackError`.\n * - `'warn'` \u2014 the verdict is `'fallback'` but the throw is disabled and warnings\n *   are on; the caller logs the fallback warning and lets the boot proceed (the\n *   verdict is still surfaced as data).\n * - `'silent'` \u2014 nothing to do (`'match'` / `'unknown'`, or a suppressed fallback).\n */\nexport type AsarFallbackAction = 'silent' | 'throw' | 'warn';\n\n/**\n * The action to take for a resolved installer\u2194app compatibility verdict, given\n * the throw/warn knobs.\n *\n * - `'throw'` \u2014 the verdict is `'unrunnable'` and the proactive throw is enabled;\n *   the caller throws `IncompatibleInstallerVersionError` before launch.\n * - `'warn-unrunnable'` \u2014 the verdict is `'unrunnable'` but the throw is disabled\n *   and warnings are on; the caller logs a \"proceeding to launch\" warning and\n *   lets the boot proceed (where the reactive dead-boot fast-fail catches it).\n * - `'warn-nagged'` \u2014 the verdict is `'nagged'` and warnings are on; the caller\n *   logs the recommended-installer warning.\n * - `'silent'` \u2014 nothing to do (`'ok'` / `'unknown'`, or warnings disabled).\n */\nexport type InstallerCompatibilityAction = 'silent' | 'throw' | 'warn-nagged' | 'warn-unrunnable';\n\n/**\n * Parameters for {@link resolveAsarFallbackAction}.\n */\nexport interface ResolveAsarFallbackActionParams {\n  /** Whether a `'fallback'` verdict throws (vs. proceeds with a warning). */\n  readonly shouldThrowOnSilentAsarFallback: boolean;\n\n  /** Whether a non-throwing fallback verdict is logged. */\n  readonly shouldWarnOnCompatibilityIssues: boolean;\n\n  /** The resolved silent-asar-fallback tier. */\n  readonly tier: AsarFallbackTier;\n}\n\n/**\n * Parameters for {@link resolveInstallerCompatibilityAction}.\n */\nexport interface ResolveInstallerCompatibilityActionParams {\n  /** Whether an `'unrunnable'` verdict throws (vs. proceeds to launch). */\n  readonly shouldThrowOnIncompatibleInstaller: boolean;\n\n  /** Whether a nag / proceeding-unrunnable verdict is logged. */\n  readonly shouldWarnOnCompatibilityIssues: boolean;\n\n  /** The resolved installer\u2194app compatibility tier. */\n  readonly tier: InstallerCompatibilityTier;\n}\n\n/**\n * Resolves what to do for a silent-asar-fallback verdict, given the throw/warn\n * knobs. Pure \u2014 the caller performs the throw/log side effects.\n *\n * @param params - The verdict tier and the resolved throw/warn knobs.\n * @returns The action the caller should take.\n */\nexport function resolveAsarFallbackAction(params: ResolveAsarFallbackActionParams): AsarFallbackAction {\n  const { shouldThrowOnSilentAsarFallback, shouldWarnOnCompatibilityIssues, tier } = params;\n\n  if (tier !== 'fallback') {\n    return 'silent';\n  }\n\n  if (shouldThrowOnSilentAsarFallback) {\n    return 'throw';\n  }\n\n  return shouldWarnOnCompatibilityIssues ? 'warn' : 'silent';\n}\n\n/**\n * Resolves what to do for an installer\u2194app compatibility verdict, given the\n * throw/warn knobs. Pure \u2014 the caller performs the throw/log side effects.\n *\n * @param params - The verdict tier and the resolved throw/warn knobs.\n * @returns The action the caller should take.\n */\nexport function resolveInstallerCompatibilityAction(params: ResolveInstallerCompatibilityActionParams): InstallerCompatibilityAction {\n  const { shouldThrowOnIncompatibleInstaller, shouldWarnOnCompatibilityIssues, tier } = params;\n\n  if (tier === 'unrunnable') {\n    if (shouldThrowOnIncompatibleInstaller) {\n      return 'throw';\n    }\n\n    return shouldWarnOnCompatibilityIssues ? 'warn-unrunnable' : 'silent';\n  }\n\n  if (tier === 'nagged') {\n    return shouldWarnOnCompatibilityIssues ? 'warn-nagged' : 'silent';\n  }\n\n  return 'silent';\n}\n\n/**\n * Whether an `'unrunnable'` installer\u2194app pair should fail fast with\n * {@link IncompatibleInstallerVersionError} before launch.\n *\n * @param shouldThrowOnIncompatibleInstaller - The resolved option value (omitted \u2192 throw).\n * @returns `true` when an unrunnable pin should throw (the default).\n */\nexport function resolveShouldThrowOnIncompatibleInstaller(shouldThrowOnIncompatibleInstaller?: boolean): boolean {\n  return shouldThrowOnIncompatibleInstaller ?? true;\n}\n\n/**\n * Whether a booted owned instance running a different app (asar) version than the\n * pin \u2014 a silent fallback to the installer's own bundled asar \u2014 should fail fast\n * with {@link SilentAsarFallbackError}.\n *\n * @param shouldThrowOnSilentAsarFallback - The resolved option value (omitted \u2192 throw).\n * @returns `true` when a silent fallback should throw (the default).\n */\nexport function resolveShouldThrowOnSilentAsarFallback(shouldThrowOnSilentAsarFallback?: boolean): boolean {\n  return shouldThrowOnSilentAsarFallback ?? true;\n}\n\n/**\n * Whether the owned-instance compatibility nag warnings should be emitted (both\n * the installer\u2194app `'nagged'` warning and the runtime-Electron `'nagged'`\n * warning).\n *\n * @param shouldWarnOnCompatibilityIssues - The resolved option value (omitted \u2192 warn).\n * @returns `true` when the warnings should be emitted (the default).\n */\nexport function resolveShouldWarnOnCompatibilityIssues(shouldWarnOnCompatibilityIssues?: boolean): boolean {\n  return shouldWarnOnCompatibilityIssues ?? true;\n}\n"],
  "mappings": "AAuFO,SAAS,0BAA0B,QAA6D;AACrG,QAAM,EAAE,iCAAiC,iCAAiC,KAAK,IAAI;AAEnF,MAAI,SAAS,YAAY;AACvB,WAAO;AAAA,EACT;AAEA,MAAI,iCAAiC;AACnC,WAAO;AAAA,EACT;AAEA,SAAO,kCAAkC,SAAS;AACpD;AASO,SAAS,oCAAoC,QAAiF;AACnI,QAAM,EAAE,oCAAoC,iCAAiC,KAAK,IAAI;AAEtF,MAAI,SAAS,cAAc;AACzB,QAAI,oCAAoC;AACtC,aAAO;AAAA,IACT;AAEA,WAAO,kCAAkC,oBAAoB;AAAA,EAC/D;AAEA,MAAI,SAAS,UAAU;AACrB,WAAO,kCAAkC,gBAAgB;AAAA,EAC3D;AAEA,SAAO;AACT;AASO,SAAS,0CAA0C,oCAAuD;AAC/G,SAAO,sCAAsC;AAC/C;AAUO,SAAS,uCAAuC,iCAAoD;AACzG,SAAO,mCAAmC;AAC5C;AAUO,SAAS,uCAAuC,iCAAoD;AACzG,SAAO,mCAAmC;AAC5C;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/compatibility-options.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure resolution of the two owned-instance compatibility knobs \u2014 whether the\n * installer\u2194app / runtime-Electron nag warnings are emitted, and whether an\n * `'unrunnable'` installer\u2194app pair fails fast with\n * {@link IncompatibleInstallerVersionError} before launch.\n *\n * Both default to today's behavior (`true`): warnings on, and an unrunnable pin\n * throws proactively. Setting `shouldWarnOnCompatibilityIssues` to `false`\n * silences both nags (the verdicts are still computed and surfaced as data);\n * setting `shouldThrowOnIncompatibleInstaller` to `false` lets an unrunnable pin\n * proceed to launch, where the reactive dead-boot fast-fail\n * (`RendererFailedToInitializeError`) still catches it.\n *\n * Kept separate from the integration-only launch code (`transport-factory`,\n * `transport-desktop-cdp`, both excluded from unit tests) so the default\n * resolution stays unit-testable \u2014 mirroring the `visibility.ts` /\n * `appium-session-config.ts` pure-resolver split.\n */\n\nimport type { AsarFallbackTier } from './asar-fallback-detection.mjs';\nimport type { InstallerCompatibilityTier } from './installer-compatibility.mjs';\n\n/**\n * The action to take for a resolved silent-asar-fallback verdict, given the\n * throw/warn knobs.\n *\n * - `'throw'` \u2014 the verdict is `'fallback'` and the throw is enabled; the caller\n *   throws `SilentAsarFallbackError`.\n * - `'warn'` \u2014 the verdict is `'fallback'` but the throw is disabled and warnings\n *   are on; the caller logs the fallback warning and lets the boot proceed (the\n *   verdict is still surfaced as data).\n * - `'silent'` \u2014 nothing to do (`'match'` / `'unknown'`, or a suppressed fallback).\n */\nexport type AsarFallbackAction = 'silent' | 'throw' | 'warn';\n\n/**\n * The action to take for a resolved installer\u2194app compatibility verdict, given\n * the throw/warn knobs.\n *\n * - `'throw'` \u2014 the verdict is `'unrunnable'` and the proactive throw is enabled;\n *   the caller throws `IncompatibleInstallerVersionError` before launch.\n * - `'warn-unrunnable'` \u2014 the verdict is `'unrunnable'` but the throw is disabled\n *   and warnings are on; the caller logs a \"proceeding to launch\" warning and\n *   lets the boot proceed (where the reactive dead-boot fast-fail catches it).\n * - `'warn-nagged'` \u2014 the verdict is `'nagged'` and warnings are on; the caller\n *   logs the recommended-installer warning.\n * - `'silent'` \u2014 nothing to do (`'ok'` / `'unknown'`, or warnings disabled).\n */\nexport type InstallerCompatibilityAction = 'silent' | 'throw' | 'warn-nagged' | 'warn-unrunnable';\n\n/**\n * Parameters for {@link resolveAsarFallbackAction}.\n */\nexport interface ResolveAsarFallbackActionParams {\n  /**\n  Whether a `'fallback'` verdict throws (vs. proceeds with a warning).\n   */\n  readonly shouldThrowOnSilentAsarFallback: boolean;\n\n  /**\n  Whether a non-throwing fallback verdict is logged.\n   */\n  readonly shouldWarnOnCompatibilityIssues: boolean;\n\n  /**\n  The resolved silent-asar-fallback tier.\n   */\n  readonly tier: AsarFallbackTier;\n}\n\n/**\n * Parameters for {@link resolveInstallerCompatibilityAction}.\n */\nexport interface ResolveInstallerCompatibilityActionParams {\n  /**\n  Whether an `'unrunnable'` verdict throws (vs. proceeds to launch).\n   */\n  readonly shouldThrowOnIncompatibleInstaller: boolean;\n\n  /**\n  Whether a nag / proceeding-unrunnable verdict is logged.\n   */\n  readonly shouldWarnOnCompatibilityIssues: boolean;\n\n  /**\n  The resolved installer\u2194app compatibility tier.\n   */\n  readonly tier: InstallerCompatibilityTier;\n}\n\n/**\n * Resolves what to do for a silent-asar-fallback verdict, given the throw/warn\n * knobs. Pure \u2014 the caller performs the throw/log side effects.\n *\n * @param params - The verdict tier and the resolved throw/warn knobs.\n * @returns The action the caller should take.\n */\nexport function resolveAsarFallbackAction(params: ResolveAsarFallbackActionParams): AsarFallbackAction {\n  const { shouldThrowOnSilentAsarFallback, shouldWarnOnCompatibilityIssues, tier } = params;\n\n  if (tier !== 'fallback') {\n    return 'silent';\n  }\n\n  if (shouldThrowOnSilentAsarFallback) {\n    return 'throw';\n  }\n\n  return shouldWarnOnCompatibilityIssues ? 'warn' : 'silent';\n}\n\n/**\n * Resolves what to do for an installer\u2194app compatibility verdict, given the\n * throw/warn knobs. Pure \u2014 the caller performs the throw/log side effects.\n *\n * @param params - The verdict tier and the resolved throw/warn knobs.\n * @returns The action the caller should take.\n */\nexport function resolveInstallerCompatibilityAction(params: ResolveInstallerCompatibilityActionParams): InstallerCompatibilityAction {\n  const { shouldThrowOnIncompatibleInstaller, shouldWarnOnCompatibilityIssues, tier } = params;\n\n  if (tier === 'unrunnable') {\n    if (shouldThrowOnIncompatibleInstaller) {\n      return 'throw';\n    }\n\n    return shouldWarnOnCompatibilityIssues ? 'warn-unrunnable' : 'silent';\n  }\n\n  if (tier === 'nagged') {\n    return shouldWarnOnCompatibilityIssues ? 'warn-nagged' : 'silent';\n  }\n\n  return 'silent';\n}\n\n/**\n * Whether an `'unrunnable'` installer\u2194app pair should fail fast with\n * {@link IncompatibleInstallerVersionError} before launch.\n *\n * @param shouldThrow - The configured option value (omitted \u2192 throw).\n * @returns `true` when an unrunnable pin should throw (the default).\n */\nexport function willThrowOnIncompatibleInstaller(shouldThrow?: boolean): boolean {\n  return shouldThrow ?? true;\n}\n\n/**\n * Whether a booted owned instance running a different app (asar) version than the\n * pin \u2014 a silent fallback to the installer's own bundled asar \u2014 should fail fast\n * with {@link SilentAsarFallbackError}.\n *\n * @param shouldThrow - The configured option value (omitted \u2192 throw).\n * @returns `true` when a silent fallback should throw (the default).\n */\nexport function willThrowOnSilentAsarFallback(shouldThrow?: boolean): boolean {\n  return shouldThrow ?? true;\n}\n\n/**\n * Whether the owned-instance compatibility nag warnings should be emitted (both\n * the installer\u2194app `'nagged'` warning and the runtime-Electron `'nagged'`\n * warning).\n *\n * @param shouldWarn - The configured option value (omitted \u2192 warn).\n * @returns `true` when the warnings should be emitted (the default).\n */\nexport function willWarnOnCompatibilityIssues(shouldWarn?: boolean): boolean {\n  return shouldWarn ?? true;\n}\n"],
  "mappings": "AAmGO,SAAS,0BAA0B,QAA6D;AACrG,QAAM,EAAE,iCAAiC,iCAAiC,KAAK,IAAI;AAEnF,MAAI,SAAS,YAAY;AACvB,WAAO;AAAA,EACT;AAEA,MAAI,iCAAiC;AACnC,WAAO;AAAA,EACT;AAEA,SAAO,kCAAkC,SAAS;AACpD;AASO,SAAS,oCAAoC,QAAiF;AACnI,QAAM,EAAE,oCAAoC,iCAAiC,KAAK,IAAI;AAEtF,MAAI,SAAS,cAAc;AACzB,QAAI,oCAAoC;AACtC,aAAO;AAAA,IACT;AAEA,WAAO,kCAAkC,oBAAoB;AAAA,EAC/D;AAEA,MAAI,SAAS,UAAU;AACrB,WAAO,kCAAkC,gBAAgB;AAAA,EAC3D;AAEA,SAAO;AACT;AASO,SAAS,iCAAiC,aAAgC;AAC/E,SAAO,eAAe;AACxB;AAUO,SAAS,8BAA8B,aAAgC;AAC5E,SAAO,eAAe;AACxB;AAUO,SAAS,8BAA8B,YAA+B;AAC3E,SAAO,cAAc;AACvB;",
  "names": []
}


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

@@ -12,11 +12,12 @@
  */
 import type { Except } from 'type-fest';
 import type { AsarFallback } from './asar-fallback-detection.mjs';
+import type { CaptureScreenshotParams } from './capture-screenshot.mjs';
 import type { ContextId } from './context-id.mjs';
 import type { ElectronCompatibility } from './electron-compatibility.mjs';
 import type { EvalInObsidianParams, GenericObject } from './eval-in-obsidian.mjs';
 import type { InstallerCompatibility } from './installer-compatibility.mjs';
-import { TempVault } from './temp-vault.mjs';
+import { TemporaryVault } from './temporary-vault.mjs';
 /**
  * A live connection to a CDP-enabled Obsidian instance with the runtime helper
  * namespace bootstrapped.
@@ -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`.
      */
@@ -70,15 +83,15 @@ export interface CdpConnection extends AsyncDisposable {
     readonly electronCompatibility?: ElectronCompatibility | undefined;
     /**
      * Evaluates a self-contained function inside Obsidian via the rich helper
-     * path, receiving `{ app, lib, obsidianModule, context }` plus any `args`
+     * path, receiving `{ app, lib, obsidianModule, context }` plus any `input`
      * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). Mirrors
      * the top-level `evalInObsidian`, with the transport and vault path pre-bound
      * to this connection.
      *
-     * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).
-     * @returns A {@link Promise} that resolves to the return value of `fn`.
+     * @param params - The evaluation parameters (`callback`, optional `input`/`contextId`).
+     * @returns A {@link Promise} that resolves to the return value of `callback`.
      */
-    evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>): Promise<Result>;
+    evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(params: Except<EvalInObsidianParams<Input, Result, TContextId>, 'transport' | 'vaultPath'>): Promise<Result>;
     /**
      * Evaluates a raw JavaScript expression inside Obsidian and returns the
      * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).
@@ -95,7 +108,7 @@ export interface CdpConnection extends AsyncDisposable {
     /**
      * The opened vault. Exposes `path` and `populate(...)` for seeding files.
      */
-    readonly vault: TempVault;
+    readonly vault: TemporaryVault;
 }
 /**
  * Options for {@link connectToCdp}.

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

@@ -1,12 +1,12 @@
 import { evalInObsidian } from "./eval-in-obsidian.mjs";
 import {
   resolveLeftoverMaxAgeInMilliseconds,
-  resolveShouldSweepLeftovers,
-  sweepHostLeftovers
+  sweepHostLeftovers,
+  willSweepLeftovers
 } from "./leftover-cleanup.mjs";
 import { log } from "./log.mjs";
 import { normalizeOptionalProperties } from "./normalize-optional-properties.mjs";
-import { TempVault } from "./temp-vault.mjs";
+import { TemporaryVault } from "./temporary-vault.mjs";
 import { DesktopCdpTransport } from "./transport-desktop-cdp.mjs";
 import { createTransportFromOptions } from "./transport-factory.mjs";
 const DEFAULT_CDP_HOST = "localhost";
@@ -14,7 +14,7 @@ async function connectToCdp(options) {
   const transportOptions = buildCdpTransportOptions(options);
   await sweepLeftovers(transportOptions);
   const transport = await createTransportFromOptions(transportOptions);
-  const vault = new TempVault(options?.vault);
+  const vault = new TemporaryVault(options?.vault);
   const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? options?.vault === void 0;
   await vault.register(transport);
   const { host, port } = resolveEndpoint(transport, options);
@@ -27,6 +27,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) {
@@ -81,7 +87,7 @@ function resolveEndpoint(transport, options) {
   throw new Error("connectToCdp: could not determine the CDP port.");
 }
 async function sweepLeftovers(transportOptions) {
-  if (!resolveShouldSweepLeftovers(transportOptions)) {
+  if (!willSweepLeftovers(transportOptions)) {
     return;
   }
   try {
@@ -100,4 +106,4 @@ async function sweepLeftovers(transportOptions) {
 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 { 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 {\n  resolveLeftoverMaxAgeInMilliseconds,\n  resolveShouldSweepLeftovers,\n  sweepHostLeftovers\n} from './leftover-cleanup.mjs';\nimport { log } from './log.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 transportOptions = buildCdpTransportOptions(options);\n  await sweepLeftovers(transportOptions);\n  const transport = await createTransportFromOptions(transportOptions);\n  const vault = new TempVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n  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/**\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 (!resolveShouldSweepLeftovers(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.mjs';\nimport type { CaptureScreenshotParams } from './capture-screenshot.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 {\n  resolveLeftoverMaxAgeInMilliseconds,\n  sweepHostLeftovers,\n  willSweepLeftovers\n} from './leftover-cleanup.mjs';\nimport { log } from './log.mjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.mjs';\nimport { TemporaryVault } from './temporary-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   * 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/esm/context-id.d.mts

@@ -7,7 +7,7 @@
 /**
  * Wraps a {@link ContextOf} extraction into an object with a `context` property.
  */
-export interface ContextArgs<TContextId extends ContextId<unknown> | undefined = undefined> {
+export interface ContextArguments<TContextId extends ContextId<unknown> | undefined = undefined> {
     context: ContextOf<TContextId>;
 }
 /**

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

@@ -15,17 +15,17 @@ class ContextId {
    */
   async dispose(vaultPath) {
     await evalInObsidian({
-      args: { id: this.id },
       /* v8 ignore start -- Serialized via toString() and executed inside the Obsidian process. Covered by integration tests. */
-      fn({ id }) {
-        const holder = window;
+      callback({ id }) {
+        const holder = globalThis;
         if (holder.__obsidianIntegrationTesting?.contexts) {
           delete holder.__obsidianIntegrationTesting.contexts[id];
         }
       },
+      input: { id: this.id },
       /* v8 ignore stop */
       shouldSkipPreflightChecks: true,
-      ...vaultPath === void 0 ? {} : { vaultPath }
+      ...vaultPath !== void 0 && { vaultPath }
     });
   }
   /**
@@ -56,4 +56,4 @@ class ContextId {
 export {
   ContextId
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2NvbnRleHQtaWQudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBUeXBlZCBjb250ZXh0IGlkZW50aWZpZXJzIGZvciBwZXJzaXN0aW5nIG5vbi1zZXJpYWxpemFibGUgdmFsdWVzXG4gKiBhY3Jvc3Mge0BsaW5rIGV2YWxJbk9ic2lkaWFufSBjYWxscy5cbiAqL1xuXG5pbXBvcnQgeyBldmFsSW5PYnNpZGlhbiB9IGZyb20gJy4vZXZhbC1pbi1vYnNpZGlhbi5tanMnO1xuXG4vKipcbiAqIFdyYXBzIGEge0BsaW5rIENvbnRleHRPZn0gZXh0cmFjdGlvbiBpbnRvIGFuIG9iamVjdCB3aXRoIGEgYGNvbnRleHRgIHByb3BlcnR5LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIENvbnRleHRBcmdzPFRDb250ZXh0SWQgZXh0ZW5kcyBDb250ZXh0SWQ8dW5rbm93bj4gfCB1bmRlZmluZWQgPSB1bmRlZmluZWQ+IHtcbiAgY29udGV4dDogQ29udGV4dE9mPFRDb250ZXh0SWQ+O1xufVxuXG4vKipcbiAqIEV4dHJhY3RzIHRoZSBjb250ZXh0IHR5cGUgZnJvbSBhIHtAbGluayBDb250ZXh0SWR9LlxuICovXG5leHBvcnQgdHlwZSBDb250ZXh0T2Y8VD4gPSBUIGV4dGVuZHMgQ29udGV4dElkPGluZmVyIENvbnRleHQ+ID8gQ29udGV4dCA6IG5ldmVyO1xuXG4vKipcbiAqIEEgdHlwZWQgY29udGV4dCBpZGVudGlmaWVyIGZvciBwZXJzaXN0aW5nIG5vbi1zZXJpYWxpemFibGUgdmFsdWVzXG4gKiBhY3Jvc3Mge0BsaW5rIGV2YWxJbk9ic2lkaWFufSBjYWxscy5cbiAqXG4gKiBUaGUgY29udGV4dCBpcyBhIHBlcnNpc3RlbnQgb2JqZWN0IHN0b3JlZCBvbiBgd2luZG93YCBpbiB0aGUgT2JzaWRpYW4gcHJvY2Vzcy5cbiAqIEFsbCBjYWxscyBzaGFyaW5nIHRoZSBzYW1lIGBDb250ZXh0SWRgIHNoYXJlIHRoZSBzYW1lIGNvbnRleHQgb2JqZWN0LFxuICogYWxsb3dpbmcgbm9uLXNlcmlhbGl6YWJsZSB2YWx1ZXMgKGUuZy4gYFRGaWxlYCwgYEVkaXRvcmApIHRvIHN1cnZpdmUgYWNyb3NzIGNhbGxzLlxuICpcbiAqIEltcGxlbWVudHMgYEFzeW5jRGlzcG9zYWJsZWAgZm9yIHVzZSB3aXRoIGBhd2FpdCB1c2luZ2AuXG4gKi9cbmV4cG9ydCBjbGFzcyBDb250ZXh0SWQ8X0NvbnRleHQ+IGltcGxlbWVudHMgQXN5bmNEaXNwb3NhYmxlIHtcbiAgcHJpdmF0ZSByZWFkb25seSBpZDogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBDcmVhdGVzIGEgbmV3IGNvbnRleHQgaWQuXG4gICAqL1xuICBwdWJsaWMgY29uc3RydWN0b3IoKSB7XG4gICAgY29uc3QgU0xJQ0VfU1RBUlQgPSAyO1xuICAgIHRoaXMuaWQgPSBgX19jdHhfJHtTdHJpbmcoTWF0aC5yYW5kb20oKSkuc2xpY2UoU0xJQ0VfU1RBUlQpfWA7XG4gIH1cblxuICAvKipcbiAgICogUmVtb3ZlcyB0aGlzIGNvbnRleHQgZnJvbSB0aGUgT2JzaWRpYW4gcHJvY2Vzcy5cbiAgICpcbiAgICogQHBhcmFtIHZhdWx0UGF0aCAtIFRoZSBwYXRoIHRvIHRoZSBPYnNpZGlhbiB2YXVsdC4gRGVmYXVsdHMgdG8gYHByb2Nlc3MuY3dkKClgLlxuICAgKi9cbiAgcHVibGljIGFzeW5jIGRpc3Bvc2UodmF1bHRQYXRoPzogc3RyaW5nKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgYXdhaXQgZXZhbEluT2JzaWRpYW4oe1xuICAgICAgYXJnczogeyBpZDogdGhpcy5pZCB9LFxuICAgICAgLyogdjggaWdub3JlIHN0YXJ0IC0tIFNlcmlhbGl6ZWQgdmlhIHRvU3RyaW5nKCkgYW5kIGV4ZWN1dGVkIGluc2lkZSB0aGUgT2JzaWRpYW4gcHJvY2Vzcy4gQ292ZXJlZCBieSBpbnRlZ3JhdGlvbiB0ZXN0cy4gKi9cbiAgICAgIGZuKHsgaWQgfSk6IHZvaWQge1xuICAgICAgICBpbnRlcmZhY2UgSW50ZWdyYXRpb25UZXN0aW5nQ29udGV4dHMge1xuICAgICAgICAgIGNvbnRleHRzOiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcbiAgICAgICAgfVxuICAgICAgICBpbnRlcmZhY2UgSW50ZWdyYXRpb25UZXN0aW5nSG9sZGVyIHtcbiAgICAgICAgICBfX29ic2lkaWFuSW50ZWdyYXRpb25UZXN0aW5nOiBJbnRlZ3JhdGlvblRlc3RpbmdDb250ZXh0cztcbiAgICAgICAgfVxuXG4gICAgICAgIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1yZXN0cmljdGVkLXN5bnRheCAtLSBBcHByb3ZlZCBkb3VibGUgY2FzdDogYF9fb2JzaWRpYW5JbnRlZ3JhdGlvblRlc3RpbmdgIGlzIG91ciBpbnRlcm5hbCBXaW5kb3cgYXVnbWVudGF0aW9uLCBpbnRlbnRpb25hbGx5IGtlcHQgbG9jYWwgKG5vdCBkZWNsYXJlZCBnbG9iYWxseSkgdG8gYXZvaWQgbGVha2luZyBpbnRvIGNvbnN1bWVyIHR5cGVzLlxuICAgICAgICBjb25zdCBob2xkZXIgPSB3aW5kb3cgYXMgdW5rbm93biBhcyBQYXJ0aWFsPEludGVncmF0aW9uVGVzdGluZ0hvbGRlcj47XG4gICAgICAgIGlmIChob2xkZXIuX19vYnNpZGlhbkludGVncmF0aW9uVGVzdGluZz8uY29udGV4dHMpIHtcbiAgICAgICAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLWR5bmFtaWMtZGVsZXRlIC0tIE5vIG90aGVyIHdheS5cbiAgICAgICAgICBkZWxldGUgaG9sZGVyLl9fb2JzaWRpYW5JbnRlZ3JhdGlvblRlc3RpbmcuY29udGV4dHNbaWRdO1xuICAgICAgICB9XG4gICAgICB9LFxuICAgICAgLyogdjggaWdub3JlIHN0b3AgKi9cbiAgICAgIHNob3VsZFNraXBQcmVmbGlnaHRDaGVja3M6IHRydWUsXG4gICAgICAuLi4odmF1bHRQYXRoID09PSB1bmRlZmluZWQgPyB7fSA6IHsgdmF1bHRQYXRoIH0pXG4gICAgfSk7XG4gIH1cblxuICAvKipcbiAgICogRGlzcG9zZXMgdGhpcyBjb250ZXh0IGlkLlxuICAgKlxuICAgKiBAcmV0dXJucyBBIHByb21pc2UgdGhhdCByZXNvbHZlcyB3aGVuIHRoZSBjb250ZXh0IGlkIGlzIGRpc3Bvc2VkLlxuICAgKi9cbiAgcHVibGljIGFzeW5jIFtTeW1ib2wuYXN5bmNEaXNwb3NlXSgpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBhd2FpdCB0aGlzLmRpc3Bvc2UoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZXR1cm5zIHRoZSBKU09OIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBjb250ZXh0IGlkLlxuICAgKlxuICAgKiBAcmV0dXJucyBUaGUgSlNPTiByZXByZXNlbnRhdGlvbiBvZiB0aGUgY29udGV4dCBpZC5cbiAgICovXG4gIHB1YmxpYyB0b0pTT04oKTogc3RyaW5nIHtcbiAgICByZXR1cm4gdGhpcy5pZDtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZXR1cm5zIHRoZSBzdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgdGhlIGNvbnRleHQgaWQuXG4gICAqXG4gICAqIEByZXR1cm5zIFRoZSBzdHJpbmcgcmVwcmVzZW50YXRpb24gb2YgdGhlIGNvbnRleHQgaWQuXG4gICAqL1xuICBwdWJsaWMgdG9TdHJpbmcoKTogc3RyaW5nIHtcbiAgICByZXR1cm4gdGhpcy5pZDtcbiAgfVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIkFBT0EsU0FBUyxzQkFBc0I7QUF3QnhCLE1BQU0sVUFBK0M7QUFBQSxFQUN6QztBQUFBO0FBQUE7QUFBQTtBQUFBLEVBS1YsY0FBYztBQUNuQixVQUFNLGNBQWM7QUFDcEIsU0FBSyxLQUFLLFNBQVMsT0FBTyxLQUFLLE9BQU8sQ0FBQyxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQUEsRUFDN0Q7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPQSxNQUFhLFFBQVEsV0FBbUM7QUFDdEQsVUFBTSxlQUFlO0FBQUEsTUFDbkIsTUFBTSxFQUFFLElBQUksS0FBSyxHQUFHO0FBQUE7QUFBQSxNQUVwQixHQUFHLEVBQUUsR0FBRyxHQUFTO0FBU2YsY0FBTSxTQUFTO0FBQ2YsWUFBSSxPQUFPLDhCQUE4QixVQUFVO0FBRWpELGlCQUFPLE9BQU8sNkJBQTZCLFNBQVMsRUFBRTtBQUFBLFFBQ3hEO0FBQUEsTUFDRjtBQUFBO0FBQUEsTUFFQSwyQkFBMkI7QUFBQSxNQUMzQixHQUFJLGNBQWMsU0FBWSxDQUFDLElBQUksRUFBRSxVQUFVO0FBQUEsSUFDakQsQ0FBQztBQUFBLEVBQ0g7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPQSxPQUFjLE9BQU8sWUFBWSxJQUFtQjtBQUNsRCxVQUFNLEtBQUssUUFBUTtBQUFBLEVBQ3JCO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBT08sU0FBaUI7QUFDdEIsV0FBTyxLQUFLO0FBQUEsRUFDZDtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQU9PLFdBQW1CO0FBQ3hCLFdBQU8sS0FBSztBQUFBLEVBQ2Q7QUFDRjsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -33,13 +33,13 @@ export declare function getVaultPath(): string | undefined;
  * Registers a resolver function for transport options. Called by framework
  * adapters at module load time to bridge their native injection mechanisms.
  *
- * @param fn - The resolver function.
+ * @param callback - The resolver function.
  */
-export declare function setTransportOptionsResolver(fn: TransportOptionsResolver): void;
+export declare function setTransportOptionsResolver(callback: TransportOptionsResolver): void;
 /**
  * Registers a resolver function for the vault path. Called by framework
  * adapters at module load time to bridge their native injection mechanisms.
  *
- * @param fn - The resolver function.
+ * @param callback - The resolver function.
  */
-export declare function setVaultPathResolver(fn: VaultPathResolver): void;
+export declare function setVaultPathResolver(callback: VaultPathResolver): void;