obsidian-integration-testing 10.4.0 → 12.0.0

package/dist/lib/esm/wedged-appium-server.d.mts

@@ -0,0 +1,187 @@
+/**
+ * @file
+ *
+ * Pure helpers for recognizing a **wedged** Appium server and deciding what to
+ * do about it. Kept separate from the integration-only `transport-factory` so
+ * the classification, the remedy decision and the message stay unit-testable
+ * (the factory itself needs a real device and is excluded from unit tests).
+ *
+ * A wedged server is one that is still **live** — it listens on its port and
+ * answers `/status` with `ready: true` — but is no longer **usable**: its
+ * `appium-adb` can no longer enumerate devices, so every session creation dies
+ * with `Could not find a connected Android device in <n>ms` while the host's own
+ * `adb devices` lists the device instantly. Liveness is not readiness, and the
+ * error names the wrong subject: it blames a device that is demonstrably
+ * present, which sends whoever reads it to `adb devices` — the one diagnostic
+ * that actively misleads here.
+ *
+ * The wedge develops over time in a long-lived server (one auto-started by an
+ * earlier run and left listening), so the preflight cannot see it coming: it can
+ * only be recognized from the failed session, cross-checked against the host's
+ * adb.
+ */
+/**
+ * Parameters for {@link buildWedgedAppiumServerMessage}.
+ */
+export interface BuildWedgedAppiumServerMessageParams {
+    /**
+    Origin of the Appium server that could not see the device (e.g. `http://localhost:4723`).
+     */
+    readonly appiumOrigin: string;
+    /**
+    The device the host's adb can see but Appium cannot.
+     */
+    readonly deviceId: string;
+    /**
+    Why this run is reporting rather than restarting.
+     */
+    readonly reason: WedgedAppiumServerReportReason;
+    /**
+    How long the server has been running, when known from its marker.
+     */
+    readonly serverAgeInMilliseconds?: number | undefined;
+    /**
+    PID of the server, when known from its marker.
+     */
+    readonly serverPid?: number | undefined;
+}
+/**
+ * The server is not to blame: either the failure was a different error, or the
+ * host's adb cannot see the device either. The original error is rethrown.
+ */
+export interface NotWedgedVerdict {
+    /**
+    Which of the two honest-failure cases this is.
+     */
+    readonly reason: 'device-absent' | 'other-error';
+    /**
+    Discriminant.
+     */
+    readonly remedy: 'not-wedged';
+}
+/**
+ * The server is wedged but must not be touched by this run.
+ */
+export interface ReportServerVerdict {
+    /**
+    Why this run is reporting rather than restarting.
+     */
+    readonly reason: WedgedAppiumServerReportReason;
+    /**
+    Discriminant.
+     */
+    readonly remedy: 'report';
+}
+/**
+ * Parameters for {@link resolveWedgedAppiumServerRemedy}.
+ */
+export interface ResolveWedgedAppiumServerRemedyParams {
+    /**
+    Device IDs the **host's** adb currently lists (the cross-check that convicts the server).
+     */
+    readonly connectedDeviceIds: readonly string[];
+    /**
+    The device the session was requested against.
+     */
+    readonly deviceId: string;
+    /**
+    The error the session attempt failed with.
+     */
+    readonly error: unknown;
+    /**
+    Whether the server was already listening and was adopted, rather than started by this run.
+     */
+    readonly isAdoptedServer: boolean;
+    /**
+    Whether this run may start an Appium server (`shouldAutoStartAppium` is not `false`).
+     */
+    readonly isAutoStartAllowed: boolean;
+    /**
+    Whether the adopted server's marker proves an earlier run of this harness started it.
+     */
+    readonly isHarnessOwnedServer: boolean;
+}
+/**
+ * The server is wedged and an earlier run of this harness started it, so this
+ * run may replace it.
+ */
+export interface RestartServerVerdict {
+    /**
+    Always the harness-owned case.
+     */
+    readonly reason: 'harness-owned';
+    /**
+    Discriminant.
+     */
+    readonly remedy: 'restart';
+}
+/**
+ * The classification of a failed session attempt.
+ *
+ * `'device-absent'` and `'other-error'` are the not-wedged verdicts: the
+ * original error was honest and is rethrown untouched.
+ */
+export type WedgedAppiumServerReason = 'device-absent' | 'harness-owned' | 'other-error' | WedgedAppiumServerReportReason;
+/**
+ * What the factory should do with a failed session attempt.
+ */
+export type WedgedAppiumServerRemedy = 'not-wedged' | 'report' | 'restart';
+/**
+ * Why a wedged server is only reported rather than restarted. Each maps to its
+ * own remedy sentence — the whole point of the rewrite is that the message says
+ * what *this* run can and cannot do about the server it found.
+ */
+export type WedgedAppiumServerReportReason = 'auto-start-disabled' | 'foreign-server' | 'freshly-started' | 'restart-did-not-help';
+/**
+ * The verdict on a failed session attempt, discriminated by `remedy` so a
+ * `'report'` verdict carries a reason {@link buildWedgedAppiumServerMessage} can
+ * turn into advice.
+ */
+export type WedgedAppiumServerVerdict = NotWedgedVerdict | ReportServerVerdict | RestartServerVerdict;
+/**
+ * Builds the error message that replaces `Could not find a connected Android
+ * device`, naming the **server** and stating the evidence — the host's adb can
+ * see the device, so the server is the thing that is stale.
+ *
+ * @param params - The server, the device, and why this run is not restarting it.
+ * @returns The message.
+ */
+export declare function buildWedgedAppiumServerMessage(params: BuildWedgedAppiumServerMessageParams): string;
+/**
+ * Checks whether a failed session attempt is `appium-adb`'s device-enumeration
+ * failure. The whole `cause` chain is searched, so WebdriverIO's wrapping of the
+ * server's error does not hide it.
+ *
+ * @param error - The error the session attempt failed with.
+ * @returns `true` when it is the device-not-found failure.
+ */
+export declare function checkIsAppiumDeviceNotFoundError(error: unknown): boolean;
+/**
+ * Checks whether an Appium `/status` body reports a server that is accepting new
+ * sessions.
+ *
+ * Deliberately **tolerant**: only an explicit `ready: false` (Appium sets it
+ * while shutting down) is treated as not-ready. A body that cannot be parsed, or
+ * that omits the flag, reads as ready — an unrecognized shape must not make a
+ * healthy server look unreachable.
+ *
+ * This does not catch the wedge (a wedged server still answers `ready: true`);
+ * it closes the adjacent hole of adopting a server that is on its way down.
+ *
+ * @param statusBody - The raw `/status` response body.
+ * @returns `false` only when the server explicitly reports itself not ready.
+ */
+export declare function checkIsAppiumStatusReady(statusBody: string): boolean;
+/**
+ * Decides what to do with a failed session attempt.
+ *
+ * The device-not-found error is only evidence against the server when the host's
+ * adb *can* still see the device; otherwise the error was honest and is left
+ * alone. A server this harness started in an earlier run is restarted (the
+ * confirmed remedy); every other wedged server is reported rather than killed,
+ * because terminating a process this run does not own is not its call to make.
+ *
+ * @param params - The failed attempt and what is known about the server.
+ * @returns The verdict.
+ */
+export declare function resolveWedgedAppiumServerRemedy(params: ResolveWedgedAppiumServerRemedyParams): WedgedAppiumServerVerdict;

package/dist/lib/esm/wedged-appium-server.mjs

@@ -0,0 +1,86 @@
+import { errorToString } from "./error-to-string.mjs";
+const DEVICE_NOT_FOUND_MESSAGE_FRAGMENT = "Could not find a connected Android device";
+const MILLISECONDS_PER_SECOND = 1e3;
+const SECONDS_PER_MINUTE = 60;
+const MILLISECONDS_PER_MINUTE = MILLISECONDS_PER_SECOND * SECONDS_PER_MINUTE;
+function buildWedgedAppiumServerMessage(params) {
+  const lines = [
+    `The Appium server at ${params.appiumOrigin} cannot see Android device ${params.deviceId}, although this host's adb can.`,
+    "The server is stale \u2014 its adb connection is wedged \u2014 not the device, so `adb devices` will list the device and mislead you.",
+    resolveRemedyAdvice(params)
+  ];
+  const provenance = describeServer(params);
+  if (provenance) {
+    lines.push(provenance);
+  }
+  return lines.join("\n");
+}
+function checkIsAppiumDeviceNotFoundError(error) {
+  return errorToString(error).includes(DEVICE_NOT_FOUND_MESSAGE_FRAGMENT);
+}
+function checkIsAppiumStatusReady(statusBody) {
+  let parsed;
+  try {
+    parsed = JSON.parse(statusBody);
+  } catch {
+    return true;
+  }
+  return readReadyFlag(parsed) !== false;
+}
+function resolveWedgedAppiumServerRemedy(params) {
+  if (!checkIsAppiumDeviceNotFoundError(params.error)) {
+    return { reason: "other-error", remedy: "not-wedged" };
+  }
+  if (!params.connectedDeviceIds.includes(params.deviceId)) {
+    return { reason: "device-absent", remedy: "not-wedged" };
+  }
+  if (!params.isAdoptedServer) {
+    return { reason: "freshly-started", remedy: "report" };
+  }
+  if (!params.isAutoStartAllowed) {
+    return { reason: "auto-start-disabled", remedy: "report" };
+  }
+  if (!params.isHarnessOwnedServer) {
+    return { reason: "foreign-server", remedy: "report" };
+  }
+  return { reason: "harness-owned", remedy: "restart" };
+}
+function describeServer(params) {
+  if (params.serverPid === void 0) {
+    return "";
+  }
+  const age = params.serverAgeInMilliseconds === void 0 ? "" : `, running for ${formatAge(params.serverAgeInMilliseconds)}`;
+  return `The server was started by an earlier obsidian-integration-testing run (pid ${String(params.serverPid)}${age}).`;
+}
+function formatAge(ageInMilliseconds) {
+  if (ageInMilliseconds < MILLISECONDS_PER_MINUTE) {
+    return `${String(Math.round(ageInMilliseconds / MILLISECONDS_PER_SECOND))}s`;
+  }
+  return `${String(Math.round(ageInMilliseconds / MILLISECONDS_PER_MINUTE))}min`;
+}
+function readReadyFlag(parsed) {
+  if (typeof parsed !== "object" || parsed === null) {
+    return void 0;
+  }
+  const record = parsed;
+  const value = record["value"];
+  const nested = typeof value === "object" && value !== null ? value["ready"] : void 0;
+  const ready = nested ?? record["ready"];
+  return typeof ready === "boolean" ? ready : void 0;
+}
+function resolveRemedyAdvice(params) {
+  const advice = {
+    "auto-start-disabled": `Appium auto-start is disabled (\`shouldAutoStartAppium: false\`), so this server is yours to manage: kill it and start a fresh one on ${params.appiumOrigin}, then re-run.`,
+    "foreign-server": `This server was not started by obsidian-integration-testing, so it was left running: kill it and start a fresh one on ${params.appiumOrigin}, then re-run.`,
+    "freshly-started": "This server was started by this run, so restarting it would change nothing: check that adb and the emulator agree (`adb kill-server && adb devices`), then re-run.",
+    "restart-did-not-help": `Restarting the server on ${params.appiumOrigin} did not help \u2014 a fresh one still could not serve this run, so the wedge is not the server alone: check adb itself (\`adb kill-server && adb devices\`) and that nothing else holds the port, then re-run.`
+  };
+  return advice[params.reason];
+}
+export {
+  buildWedgedAppiumServerMessage,
+  checkIsAppiumDeviceNotFoundError,
+  checkIsAppiumStatusReady,
+  resolveWedgedAppiumServerRemedy
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/wedged-appium-server.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for recognizing a **wedged** Appium server and deciding what to\n * do about it. Kept separate from the integration-only `transport-factory` so\n * the classification, the remedy decision and the message stay unit-testable\n * (the factory itself needs a real device and is excluded from unit tests).\n *\n * A wedged server is one that is still **live** \u2014 it listens on its port and\n * answers `/status` with `ready: true` \u2014 but is no longer **usable**: its\n * `appium-adb` can no longer enumerate devices, so every session creation dies\n * with `Could not find a connected Android device in <n>ms` while the host's own\n * `adb devices` lists the device instantly. Liveness is not readiness, and the\n * error names the wrong subject: it blames a device that is demonstrably\n * present, which sends whoever reads it to `adb devices` \u2014 the one diagnostic\n * that actively misleads here.\n *\n * The wedge develops over time in a long-lived server (one auto-started by an\n * earlier run and left listening), so the preflight cannot see it coming: it can\n * only be recognized from the failed session, cross-checked against the host's\n * adb.\n */\n\nimport { errorToString } from './error-to-string.mjs';\n\n/**\n * The fragment `appium-adb` throws when it cannot enumerate devices \u2014\n * `` `Could not find a connected Android device in ${timeoutMs}ms` `` from its\n * `getDevicesWithRetry` (`lib/tools/system-calls.ts`). Matched as a substring so\n * the timeout value and any wrapping by WebdriverIO do not affect it.\n */\nconst DEVICE_NOT_FOUND_MESSAGE_FRAGMENT = 'Could not find a connected Android device';\n\nconst MILLISECONDS_PER_SECOND = 1000;\nconst SECONDS_PER_MINUTE = 60;\nconst MILLISECONDS_PER_MINUTE = MILLISECONDS_PER_SECOND * SECONDS_PER_MINUTE;\n\n/**\n * Parameters for {@link buildWedgedAppiumServerMessage}.\n */\nexport interface BuildWedgedAppiumServerMessageParams {\n  /**\n  Origin of the Appium server that could not see the device (e.g. `http://localhost:4723`).\n   */\n  readonly appiumOrigin: string;\n\n  /**\n  The device the host's adb can see but Appium cannot.\n   */\n  readonly deviceId: string;\n\n  /**\n  Why this run is reporting rather than restarting.\n   */\n  readonly reason: WedgedAppiumServerReportReason;\n\n  /**\n  How long the server has been running, when known from its marker.\n   */\n  readonly serverAgeInMilliseconds?: number | undefined;\n\n  /**\n  PID of the server, when known from its marker.\n   */\n  readonly serverPid?: number | undefined;\n}\n\n/**\n * The server is not to blame: either the failure was a different error, or the\n * host's adb cannot see the device either. The original error is rethrown.\n */\nexport interface NotWedgedVerdict {\n  /**\n  Which of the two honest-failure cases this is.\n   */\n  readonly reason: 'device-absent' | 'other-error';\n\n  /**\n  Discriminant.\n   */\n  readonly remedy: 'not-wedged';\n}\n\n/**\n * The server is wedged but must not be touched by this run.\n */\nexport interface ReportServerVerdict {\n  /**\n  Why this run is reporting rather than restarting.\n   */\n  readonly reason: WedgedAppiumServerReportReason;\n\n  /**\n  Discriminant.\n   */\n  readonly remedy: 'report';\n}\n\n/**\n * Parameters for {@link resolveWedgedAppiumServerRemedy}.\n */\nexport interface ResolveWedgedAppiumServerRemedyParams {\n  /**\n  Device IDs the **host's** adb currently lists (the cross-check that convicts the server).\n   */\n  readonly connectedDeviceIds: readonly string[];\n\n  /**\n  The device the session was requested against.\n   */\n  readonly deviceId: string;\n\n  /**\n  The error the session attempt failed with.\n   */\n  readonly error: unknown;\n\n  /**\n  Whether the server was already listening and was adopted, rather than started by this run.\n   */\n  readonly isAdoptedServer: boolean;\n\n  /**\n  Whether this run may start an Appium server (`shouldAutoStartAppium` is not `false`).\n   */\n  readonly isAutoStartAllowed: boolean;\n\n  /**\n  Whether the adopted server's marker proves an earlier run of this harness started it.\n   */\n  readonly isHarnessOwnedServer: boolean;\n}\n\n/**\n * The server is wedged and an earlier run of this harness started it, so this\n * run may replace it.\n */\nexport interface RestartServerVerdict {\n  /**\n  Always the harness-owned case.\n   */\n  readonly reason: 'harness-owned';\n\n  /**\n  Discriminant.\n   */\n  readonly remedy: 'restart';\n}\n\n/**\n * The classification of a failed session attempt.\n *\n * `'device-absent'` and `'other-error'` are the not-wedged verdicts: the\n * original error was honest and is rethrown untouched.\n */\nexport type WedgedAppiumServerReason = 'device-absent' | 'harness-owned' | 'other-error' | WedgedAppiumServerReportReason;\n\n/**\n * What the factory should do with a failed session attempt.\n */\nexport type WedgedAppiumServerRemedy = 'not-wedged' | 'report' | 'restart';\n\n/**\n * Why a wedged server is only reported rather than restarted. Each maps to its\n * own remedy sentence \u2014 the whole point of the rewrite is that the message says\n * what *this* run can and cannot do about the server it found.\n */\nexport type WedgedAppiumServerReportReason =\n  | 'auto-start-disabled'\n  | 'foreign-server'\n  | 'freshly-started'\n  | 'restart-did-not-help';\n\n/**\n * The verdict on a failed session attempt, discriminated by `remedy` so a\n * `'report'` verdict carries a reason {@link buildWedgedAppiumServerMessage} can\n * turn into advice.\n */\nexport type WedgedAppiumServerVerdict = NotWedgedVerdict | ReportServerVerdict | RestartServerVerdict;\n\n/**\n * Builds the error message that replaces `Could not find a connected Android\n * device`, naming the **server** and stating the evidence \u2014 the host's adb can\n * see the device, so the server is the thing that is stale.\n *\n * @param params - The server, the device, and why this run is not restarting it.\n * @returns The message.\n */\nexport function buildWedgedAppiumServerMessage(params: BuildWedgedAppiumServerMessageParams): string {\n  const lines = [\n    `The Appium server at ${params.appiumOrigin} cannot see Android device ${params.deviceId}, although this host's adb can.`,\n    'The server is stale \u2014 its adb connection is wedged \u2014 not the device, so `adb devices` will list the device and mislead you.',\n    resolveRemedyAdvice(params)\n  ];\n\n  const provenance = describeServer(params);\n  if (provenance) {\n    lines.push(provenance);\n  }\n\n  return lines.join('\\n');\n}\n\n/**\n * Checks whether a failed session attempt is `appium-adb`'s device-enumeration\n * failure. The whole `cause` chain is searched, so WebdriverIO's wrapping of the\n * server's error does not hide it.\n *\n * @param error - The error the session attempt failed with.\n * @returns `true` when it is the device-not-found failure.\n */\nexport function checkIsAppiumDeviceNotFoundError(error: unknown): boolean {\n  return errorToString(error).includes(DEVICE_NOT_FOUND_MESSAGE_FRAGMENT);\n}\n\n/**\n * Checks whether an Appium `/status` body reports a server that is accepting new\n * sessions.\n *\n * Deliberately **tolerant**: only an explicit `ready: false` (Appium sets it\n * while shutting down) is treated as not-ready. A body that cannot be parsed, or\n * that omits the flag, reads as ready \u2014 an unrecognized shape must not make a\n * healthy server look unreachable.\n *\n * This does not catch the wedge (a wedged server still answers `ready: true`);\n * it closes the adjacent hole of adopting a server that is on its way down.\n *\n * @param statusBody - The raw `/status` response body.\n * @returns `false` only when the server explicitly reports itself not ready.\n */\nexport function checkIsAppiumStatusReady(statusBody: string): boolean {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(statusBody);\n  } catch {\n    return true;\n  }\n\n  return readReadyFlag(parsed) !== false;\n}\n\n/**\n * Decides what to do with a failed session attempt.\n *\n * The device-not-found error is only evidence against the server when the host's\n * adb *can* still see the device; otherwise the error was honest and is left\n * alone. A server this harness started in an earlier run is restarted (the\n * confirmed remedy); every other wedged server is reported rather than killed,\n * because terminating a process this run does not own is not its call to make.\n *\n * @param params - The failed attempt and what is known about the server.\n * @returns The verdict.\n */\nexport function resolveWedgedAppiumServerRemedy(params: ResolveWedgedAppiumServerRemedyParams): WedgedAppiumServerVerdict {\n  if (!checkIsAppiumDeviceNotFoundError(params.error)) {\n    return { reason: 'other-error', remedy: 'not-wedged' };\n  }\n\n  if (!params.connectedDeviceIds.includes(params.deviceId)) {\n    return { reason: 'device-absent', remedy: 'not-wedged' };\n  }\n\n  if (!params.isAdoptedServer) {\n    return { reason: 'freshly-started', remedy: 'report' };\n  }\n\n  if (!params.isAutoStartAllowed) {\n    return { reason: 'auto-start-disabled', remedy: 'report' };\n  }\n\n  if (!params.isHarnessOwnedServer) {\n    return { reason: 'foreign-server', remedy: 'report' };\n  }\n\n  return { reason: 'harness-owned', remedy: 'restart' };\n}\n\nfunction describeServer(params: BuildWedgedAppiumServerMessageParams): string {\n  if (params.serverPid === undefined) {\n    return '';\n  }\n\n  const age = params.serverAgeInMilliseconds === undefined ? '' : `, running for ${formatAge(params.serverAgeInMilliseconds)}`;\n  return `The server was started by an earlier obsidian-integration-testing run (pid ${String(params.serverPid)}${age}).`;\n}\n\nfunction formatAge(ageInMilliseconds: number): string {\n  if (ageInMilliseconds < MILLISECONDS_PER_MINUTE) {\n    return `${String(Math.round(ageInMilliseconds / MILLISECONDS_PER_SECOND))}s`;\n  }\n\n  return `${String(Math.round(ageInMilliseconds / MILLISECONDS_PER_MINUTE))}min`;\n}\n\nfunction readReadyFlag(parsed: unknown): boolean | undefined {\n  if (typeof parsed !== 'object' || parsed === null) {\n    return undefined;\n  }\n\n  const record = parsed as Record<string, unknown>;\n  const value = record['value'];\n  const nested = typeof value === 'object' && value !== null ? (value as Record<string, unknown>)['ready'] : undefined;\n  const ready = nested ?? record['ready'];\n  return typeof ready === 'boolean' ? ready : undefined;\n}\n\nfunction resolveRemedyAdvice(params: BuildWedgedAppiumServerMessageParams): string {\n  const advice: Record<WedgedAppiumServerReportReason, string> = {\n    'auto-start-disabled': `Appium auto-start is disabled (\\`shouldAutoStartAppium: false\\`), so this server is yours to manage: kill it and start a fresh one on ${params.appiumOrigin}, then re-run.`,\n    'foreign-server': `This server was not started by obsidian-integration-testing, so it was left running: kill it and start a fresh one on ${params.appiumOrigin}, then re-run.`,\n    'freshly-started': 'This server was started by this run, so restarting it would change nothing: check that adb and the emulator agree (`adb kill-server && adb devices`), then re-run.',\n    'restart-did-not-help': `Restarting the server on ${params.appiumOrigin} did not help \u2014 a fresh one still could not serve this run, so the wedge is not the server alone: check adb itself (\\`adb kill-server && adb devices\\`) and that nothing else holds the port, then re-run.`\n  };\n\n  return advice[params.reason];\n}\n"],
  "mappings": "AAuBA,SAAS,qBAAqB;AAQ9B,MAAM,oCAAoC;AAE1C,MAAM,0BAA0B;AAChC,MAAM,qBAAqB;AAC3B,MAAM,0BAA0B,0BAA0B;AAyJnD,SAAS,+BAA+B,QAAsD;AACnG,QAAM,QAAQ;AAAA,IACZ,wBAAwB,OAAO,YAAY,8BAA8B,OAAO,QAAQ;AAAA,IACxF;AAAA,IACA,oBAAoB,MAAM;AAAA,EAC5B;AAEA,QAAM,aAAa,eAAe,MAAM;AACxC,MAAI,YAAY;AACd,UAAM,KAAK,UAAU;AAAA,EACvB;AAEA,SAAO,MAAM,KAAK,IAAI;AACxB;AAUO,SAAS,iCAAiC,OAAyB;AACxE,SAAO,cAAc,KAAK,EAAE,SAAS,iCAAiC;AACxE;AAiBO,SAAS,yBAAyB,YAA6B;AACpE,MAAI;AACJ,MAAI;AACF,aAAS,KAAK,MAAM,UAAU;AAAA,EAChC,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,SAAO,cAAc,MAAM,MAAM;AACnC;AAcO,SAAS,gCAAgC,QAA0E;AACxH,MAAI,CAAC,iCAAiC,OAAO,KAAK,GAAG;AACnD,WAAO,EAAE,QAAQ,eAAe,QAAQ,aAAa;AAAA,EACvD;AAEA,MAAI,CAAC,OAAO,mBAAmB,SAAS,OAAO,QAAQ,GAAG;AACxD,WAAO,EAAE,QAAQ,iBAAiB,QAAQ,aAAa;AAAA,EACzD;AAEA,MAAI,CAAC,OAAO,iBAAiB;AAC3B,WAAO,EAAE,QAAQ,mBAAmB,QAAQ,SAAS;AAAA,EACvD;AAEA,MAAI,CAAC,OAAO,oBAAoB;AAC9B,WAAO,EAAE,QAAQ,uBAAuB,QAAQ,SAAS;AAAA,EAC3D;AAEA,MAAI,CAAC,OAAO,sBAAsB;AAChC,WAAO,EAAE,QAAQ,kBAAkB,QAAQ,SAAS;AAAA,EACtD;AAEA,SAAO,EAAE,QAAQ,iBAAiB,QAAQ,UAAU;AACtD;AAEA,SAAS,eAAe,QAAsD;AAC5E,MAAI,OAAO,cAAc,QAAW;AAClC,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,OAAO,4BAA4B,SAAY,KAAK,iBAAiB,UAAU,OAAO,uBAAuB,CAAC;AAC1H,SAAO,8EAA8E,OAAO,OAAO,SAAS,CAAC,GAAG,GAAG;AACrH;AAEA,SAAS,UAAU,mBAAmC;AACpD,MAAI,oBAAoB,yBAAyB;AAC/C,WAAO,GAAG,OAAO,KAAK,MAAM,oBAAoB,uBAAuB,CAAC,CAAC;AAAA,EAC3E;AAEA,SAAO,GAAG,OAAO,KAAK,MAAM,oBAAoB,uBAAuB,CAAC,CAAC;AAC3E;AAEA,SAAS,cAAc,QAAsC;AAC3D,MAAI,OAAO,WAAW,YAAY,WAAW,MAAM;AACjD,WAAO;AAAA,EACT;AAEA,QAAM,SAAS;AACf,QAAM,QAAQ,OAAO,OAAO;AAC5B,QAAM,SAAS,OAAO,UAAU,YAAY,UAAU,OAAQ,MAAkC,OAAO,IAAI;AAC3G,QAAM,QAAQ,UAAU,OAAO,OAAO;AACtC,SAAO,OAAO,UAAU,YAAY,QAAQ;AAC9C;AAEA,SAAS,oBAAoB,QAAsD;AACjF,QAAM,SAAyD;AAAA,IAC7D,uBAAuB,yIAAyI,OAAO,YAAY;AAAA,IACnL,kBAAkB,yHAAyH,OAAO,YAAY;AAAA,IAC9J,mBAAmB;AAAA,IACnB,wBAAwB,4BAA4B,OAAO,YAAY;AAAA,EACzE;AAEA,SAAO,OAAO,OAAO,MAAM;AAC7B;",
  "names": []
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-integration-testing",
-  "version": "10.4.0",
+  "version": "12.0.0",
   "description": "Simplifies integration testing of Obsidian plugins.",
   "keywords": [
     "obsidian",
@@ -151,6 +151,7 @@
     "lint:fix": "jiti scripts/lint-fix.ts",
     "lint:md": "jiti scripts/lint-md.ts",
     "lint:md:fix": "jiti scripts/lint-md-fix.ts",
+    "merge:runtime-versions": "jiti scripts/merge-runtime-versions.ts",
     "prepare": "jiti scripts/prepare.ts",
     "refresh:metadata": "jiti scripts/refresh-metadata.ts",
     "spellcheck": "jiti scripts/spellcheck.ts",
@@ -170,7 +171,7 @@
     "glob": "^13.0.6",
     "js-yaml": "4.3.1",
     "lodash": "4.18.1",
-    "markdown-it": "^15.0.0",
+    "markdown-it": "^15.0.1",
     "readdir-glob": "^3.0.0",
     "test-exclude": "^8.0.0",
     "tmp": "^0.2.7",
@@ -179,19 +180,19 @@
     "vite": "$vite"
   },
   "dependencies": {
-    "puppeteer-core": "^25.8.0",
+    "puppeteer-core": "^25.9.0",
     "webdriverio": "9.27.0"
   },
   "devDependencies": {
     "@astrojs/markdown-remark": "^7.2.4",
-    "@astrojs/starlight": "^0.41.8",
+    "@astrojs/starlight": "^0.41.10",
     "@commitlint/cli": "^21.2.2",
     "@commitlint/config-conventional": "^21.2.2",
     "@commitlint/types": "^21.2.0",
     "@eslint-community/eslint-plugin-eslint-comments": "^4.7.2",
     "@eslint/config-helpers": "^0.7.0",
     "@eslint/js": "^10.0.1",
-    "@obsidian-typings/obsidian-public-latest": "^6.34.0",
+    "@obsidian-typings/obsidian-public-latest": "^6.35.0",
     "@resvg/resvg-js": "^2.6.2",
     "@stylistic/eslint-plugin": "^5.10.0",
     "@total-typescript/ts-reset": "^0.6.1",
@@ -201,9 +202,9 @@
     "@typescript-eslint/rule-tester": "^8.68.0",
     "@typescript-eslint/utils": "^8.68.0",
     "@vitest/coverage-v8": "^4.1.11",
-    "astro": "^7.2.6",
+    "astro": "^7.2.9",
     "better-typescript-lib": "^2.12.0",
-    "cspell": "^10.1.0",
+    "cspell": "^10.1.1",
     "czg": "^1.14.0",
     "dedent": "^1.7.2",
     "dprint": "^0.56.1",
@@ -215,13 +216,13 @@
     "eslint-plugin-jsdoc": "^64.2.1",
     "eslint-plugin-perfectionist": "^5.10.1",
     "eslint-plugin-tsdoc": "^0.5.2",
-    "eslint-plugin-unicorn": "^73.0.0",
+    "eslint-plugin-unicorn": "^74.0.0",
     "globals": "^17.11.0",
     "husky": "^9.1.7",
-    "jest": "^30.4.2",
-    "jest-config": "^30.4.2",
+    "jest": "^30.5.0",
+    "jest-config": "^30.5.0",
     "jiti": "^2.7.0",
-    "linkinator": "^8.0.4",
+    "linkinator": "^8.1.0",
     "markdownlint": "^0.41.1",
     "markdownlint-cli2": "^0.23.2",
     "markdownlint-rule-relative-links": "^5.1.2",
@@ -229,7 +230,7 @@
     "obsidian": "^1.13.1",
     "satori": "^0.33.4",
     "semver": "^7.8.5",
-    "sharp": "^0.35.3",
+    "sharp": "^0.35.4",
     "starlight-github-alerts": "^0.4.0",
     "ts-jest": "^29.4.12",
     "ts-morph": "^28.0.0",