obsidian-integration-testing 15.0.0 → 17.0.0

package/dist/lib/esm/port-owner-query-verdict.d.mts

@@ -0,0 +1,161 @@
+/**
+ * @file
+ *
+ * Pure classification of the port-owner query — `netstat -ano` on Windows,
+ * `lsof -ti tcp:<port>` elsewhere — deciding, from how it ended, whether it
+ * **answered** or **failed**, and saying which failure in one line.
+ *
+ * The query is the only real escalation the Appium teardown has: the PID the
+ * harness holds is the `shell: true` wrapper it spawned, so what survives a kill
+ * is found by asking who still listens on the port (**L46**). It used to resolve
+ * an empty list for every error, which made three different endings one silent
+ * value:
+ *
+ * - `lsof` exiting 1 with nothing on either stream — which is how it says
+ *   nothing holds the port*, a legitimate empty answer;
+ * - the budget running out on a contended host;
+ * - the child dying.
+ *
+ * Only the first is an answer. The other two disarm the escalation exactly the
+ * way a silently failed process listing disarmed the emulator's
+ * (`host-process-query-verdict.ts`), so they are classified by the same rules
+ * and reported, not swallowed.
+ *
+ * **Why a module of its own rather than an option on the process-listing
+ * verdict.** The two queries disagree in two places, not one. Zero owners is a
+ * legitimate answer here, so `zero-rows` never applies; and `lsof`'s silent exit
+ * 1 means *nothing listens*, where for `tasklist` a silent non-zero exit is a
+ * crash. The failure branches themselves are delegated to
+ * {@link resolveHostQueryFailure}, so there is still one definition of
+ * `crashed`, `timed-out` and `refused`.
+ */
+import type { HostQueryFailure } from './host-process-query-verdict.mjs';
+/**
+ * Parameters for {@link buildPortOwnerQueryMessage}.
+ */
+export interface BuildPortOwnerQueryMessageParams {
+    /**
+    The command that was run, for the reader to try by hand — e.g. `netstat -ano`.
+     */
+    readonly command: string;
+    /**
+    How long the call took before it ended, in milliseconds.
+     */
+    readonly elapsedInMilliseconds: number;
+    /**
+    The child's exit code, when it exited rather than failing to start or being killed.
+     */
+    readonly exitCode: null | number;
+    /**
+    The verdict from {@link resolvePortOwnerQueryOutcome}.
+     */
+    readonly outcome: PortOwnerQueryOutcome;
+    /**
+    The port whose owners were asked for.
+     */
+    readonly port: number;
+    /**
+    The signal the child was killed with, when it was killed.
+     */
+    readonly signal: null | string;
+    /**
+    Whatever the child wrote to stderr.
+     */
+    readonly standardError: string;
+    /**
+    The budget the call was given, in milliseconds.
+     */
+    readonly timeoutInMilliseconds: number;
+}
+/**
+ * The fields {@link normalizeSyncExecError} extracts from an `execFileSync` throw.
+ */
+export interface NormalizedSyncExecError {
+    /**
+    The error code in `execFile`'s vocabulary: the numeric exit code, or a string such as `ENOENT` or `ERR_CHILD_PROCESS_STDIO_MAXBUFFER`.
+     */
+    readonly errorCode: null | number | string;
+    /**
+    The child's exit code, when it exited.
+     */
+    readonly exitCode: null | number;
+    /**
+    Whether the budget expired and the child was killed.
+     */
+    readonly isKilled: boolean;
+    /**
+    The signal the child was killed with.
+     */
+    readonly signal: null | string;
+    /**
+    Whatever the child wrote to stderr.
+     */
+    readonly standardError: string;
+    /**
+    Whatever the child wrote to stdout before it ended.
+     */
+    readonly standardOutput: string;
+}
+/**
+ * How the port-owner query ended.
+ *
+ * `answered` covers both a listener found and none found — the query succeeded
+ * either way. The rest are {@link resolveHostQueryFailure}'s failures.
+ */
+export type PortOwnerQueryOutcome = 'answered' | HostQueryFailure;
+/**
+ * Parameters for {@link resolvePortOwnerQueryOutcome}.
+ */
+export interface ResolvePortOwnerQueryOutcomeParams {
+    /**
+    `execFile`'s `error.code`: the numeric exit code, or a string like `ENOENT` when the child never ran.
+     */
+    readonly errorCode: null | number | string;
+    /**
+    Whether `execFile` reported an error at all.
+     */
+    readonly hasFailed: boolean;
+    /**
+    `execFile`'s `error.killed`: whether the budget expired and the child was killed.
+     */
+    readonly isKilled: boolean;
+    /**
+    The host platform, which decides whether a silent exit 1 is `lsof` saying *nothing listens*.
+     */
+    readonly platform: NodeJS.Platform;
+    /**
+    Whatever the child wrote to stderr.
+     */
+    readonly standardError: string;
+    /**
+    Whatever the child wrote to stdout.
+     */
+    readonly standardOutput: string;
+}
+/**
+ * Builds the single line the query logs for an outcome.
+ *
+ * @param params - The outcome plus the command, the port, the budget and what the child left behind.
+ * @returns The warning to log, or `undefined` when the query answered.
+ */
+export declare function buildPortOwnerQueryMessage(params: BuildPortOwnerQueryMessageParams): string | undefined;
+/**
+ * Extracts what an `execFileSync` throw carries, in `execFile`'s vocabulary.
+ *
+ * The synchronous API reports the same endings with different fields: an
+ * expired budget is `code: 'ETIMEDOUT'` rather than `killed: true`, an overrun
+ * buffer is `ENOBUFS`, and the exit code is `status` rather than `code`.
+ * Normalizing here lets the sync teardown classify with the same verdict as the
+ * async one.
+ *
+ * @param error - Whatever `execFileSync` threw.
+ * @returns The normalized fields; an unrecognizable throw reads as a crash with no evidence.
+ */
+export declare function normalizeSyncExecError(error: unknown): NormalizedSyncExecError;
+/**
+ * Decides how the port-owner query ended.
+ *
+ * @param params - What `execFile` reported, and the platform it ran on.
+ * @returns The outcome.
+ */
+export declare function resolvePortOwnerQueryOutcome(params: ResolvePortOwnerQueryOutcomeParams): PortOwnerQueryOutcome;

package/dist/lib/esm/port-owner-query-verdict.mjs

@@ -0,0 +1,73 @@
+import { Buffer } from "node:buffer";
+import {
+  formatDuration,
+  formatExitCode,
+  formatRefusal,
+  resolveHostQueryFailure
+} from "./host-process-query-verdict.mjs";
+import { assertNever } from "./type-guards.mjs";
+const LSOF_NOTHING_FOUND_EXIT_CODE = 1;
+function buildPortOwnerQueryMessage(params) {
+  const cost = `after ${formatDuration(params.elapsedInMilliseconds)}`;
+  const subject = `\`${params.command}\` (asking who listens on port ${String(params.port)})`;
+  const consequence = `Nothing is known about what still holds port ${String(params.port)}, so the escalation has no PID to kill \u2014 this is not the same as nothing holding it.`;
+  switch (params.outcome) {
+    case "answered": {
+      return void 0;
+    }
+    case "crashed": {
+      return `Warning: ${subject} died ${cost} without explaining itself (exit ${formatExitCode(params.exitCode)}, nothing on stderr). Suspect a crash or an interfering security product, and try the command by hand. ${consequence}`;
+    }
+    case "not-found": {
+      return `Warning: ${subject} could not be run at all ${cost}: the executable was not found on PATH. ${consequence}`;
+    }
+    case "output-overran": {
+      return `Warning: ${subject} produced more output ${cost} than the query's buffer allows, so none of it could be read. Raise the buffer. ${consequence}`;
+    }
+    case "refused": {
+      return `Warning: ${subject} refused the request ${cost} (exit ${formatExitCode(params.exitCode)}): ${formatRefusal(params.standardError)} ${consequence}`;
+    }
+    case "timed-out": {
+      return `Warning: ${subject} did not finish within its ${formatDuration(params.timeoutInMilliseconds)} budget and was killed ${cost}${params.signal === null ? "" : ` (${params.signal})`}. ${consequence}`;
+    }
+    default: {
+      return assertNever(params.outcome);
+    }
+  }
+}
+function normalizeSyncExecError(error) {
+  const record = typeof error === "object" && error !== null ? error : {};
+  const code = typeof record["code"] === "string" ? record["code"] : void 0;
+  const status = typeof record["status"] === "number" ? record["status"] : null;
+  const signal = typeof record["signal"] === "string" ? record["signal"] : null;
+  const isKilled = code === "ETIMEDOUT";
+  let errorCode = status;
+  if (code === "ENOBUFS") {
+    errorCode = "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+  } else if (code !== void 0 && !isKilled) {
+    errorCode = code;
+  }
+  return {
+    errorCode,
+    exitCode: status,
+    isKilled,
+    signal,
+    standardError: toText(record["stderr"]),
+    standardOutput: toText(record["stdout"])
+  };
+}
+function resolvePortOwnerQueryOutcome(params) {
+  return !params.hasFailed || params.platform !== "win32" && !params.isKilled && params.errorCode === LSOF_NOTHING_FOUND_EXIT_CODE && params.standardError.trim() === "" && params.standardOutput.trim() === "" ? "answered" : resolveHostQueryFailure(params);
+}
+function toText(stream) {
+  if (typeof stream === "string") {
+    return stream;
+  }
+  return Buffer.isBuffer(stream) ? stream.toString("utf-8") : "";
+}
+export {
+  buildPortOwnerQueryMessage,
+  normalizeSyncExecError,
+  resolvePortOwnerQueryOutcome
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/port-owner-query-verdict.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure classification of the port-owner query \u2014 `netstat -ano` on Windows,\n * `lsof -ti tcp:<port>` elsewhere \u2014 deciding, from how it ended, whether it\n * **answered** or **failed**, and saying which failure in one line.\n *\n * The query is the only real escalation the Appium teardown has: the PID the\n * harness holds is the `shell: true` wrapper it spawned, so what survives a kill\n * is found by asking who still listens on the port (**L46**). It used to resolve\n * an empty list for every error, which made three different endings one silent\n * value:\n *\n * - `lsof` exiting 1 with nothing on either stream \u2014 which is how it says\n *   nothing holds the port*, a legitimate empty answer;\n * - the budget running out on a contended host;\n * - the child dying.\n *\n * Only the first is an answer. The other two disarm the escalation exactly the\n * way a silently failed process listing disarmed the emulator's\n * (`host-process-query-verdict.ts`), so they are classified by the same rules\n * and reported, not swallowed.\n *\n * **Why a module of its own rather than an option on the process-listing\n * verdict.** The two queries disagree in two places, not one. Zero owners is a\n * legitimate answer here, so `zero-rows` never applies; and `lsof`'s silent exit\n * 1 means *nothing listens*, where for `tasklist` a silent non-zero exit is a\n * crash. The failure branches themselves are delegated to\n * {@link resolveHostQueryFailure}, so there is still one definition of\n * `crashed`, `timed-out` and `refused`.\n */\n\nimport { Buffer } from 'node:buffer';\n\nimport type { HostQueryFailure } from './host-process-query-verdict.mjs';\n\nimport {\n  formatDuration,\n  formatExitCode,\n  formatRefusal,\n  resolveHostQueryFailure\n} from './host-process-query-verdict.mjs';\nimport { assertNever } from './type-guards.mjs';\n\n/**\n * The exit code `lsof` uses for \"found nothing\", which it reports on neither stream.\n */\nconst LSOF_NOTHING_FOUND_EXIT_CODE = 1;\n\n/**\n * Parameters for {@link buildPortOwnerQueryMessage}.\n */\nexport interface BuildPortOwnerQueryMessageParams {\n  /**\n  The command that was run, for the reader to try by hand \u2014 e.g. `netstat -ano`.\n   */\n  readonly command: string;\n\n  /**\n  How long the call took before it ended, in milliseconds.\n   */\n  readonly elapsedInMilliseconds: number;\n\n  /**\n  The child's exit code, when it exited rather than failing to start or being killed.\n   */\n  readonly exitCode: null | number;\n\n  /**\n  The verdict from {@link resolvePortOwnerQueryOutcome}.\n   */\n  readonly outcome: PortOwnerQueryOutcome;\n\n  /**\n  The port whose owners were asked for.\n   */\n  readonly port: number;\n\n  /**\n  The signal the child was killed with, when it was killed.\n   */\n  readonly signal: null | string;\n\n  /**\n  Whatever the child wrote to stderr.\n   */\n  readonly standardError: string;\n\n  /**\n  The budget the call was given, in milliseconds.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * The fields {@link normalizeSyncExecError} extracts from an `execFileSync` throw.\n */\nexport interface NormalizedSyncExecError {\n  /**\n  The error code in `execFile`'s vocabulary: the numeric exit code, or a string such as `ENOENT` or `ERR_CHILD_PROCESS_STDIO_MAXBUFFER`.\n   */\n  readonly errorCode: null | number | string;\n\n  /**\n  The child's exit code, when it exited.\n   */\n  readonly exitCode: null | number;\n\n  /**\n  Whether the budget expired and the child was killed.\n   */\n  readonly isKilled: boolean;\n\n  /**\n  The signal the child was killed with.\n   */\n  readonly signal: null | string;\n\n  /**\n  Whatever the child wrote to stderr.\n   */\n  readonly standardError: string;\n\n  /**\n  Whatever the child wrote to stdout before it ended.\n   */\n  readonly standardOutput: string;\n}\n\n/**\n * How the port-owner query ended.\n *\n * `answered` covers both a listener found and none found \u2014 the query succeeded\n * either way. The rest are {@link resolveHostQueryFailure}'s failures.\n */\nexport type PortOwnerQueryOutcome = 'answered' | HostQueryFailure;\n\n/**\n * Parameters for {@link resolvePortOwnerQueryOutcome}.\n */\nexport interface ResolvePortOwnerQueryOutcomeParams {\n  /**\n  `execFile`'s `error.code`: the numeric exit code, or a string like `ENOENT` when the child never ran.\n   */\n  readonly errorCode: null | number | string;\n\n  /**\n  Whether `execFile` reported an error at all.\n   */\n  readonly hasFailed: boolean;\n\n  /**\n  `execFile`'s `error.killed`: whether the budget expired and the child was killed.\n   */\n  readonly isKilled: boolean;\n\n  /**\n  The host platform, which decides whether a silent exit 1 is `lsof` saying *nothing listens*.\n   */\n  readonly platform: NodeJS.Platform;\n\n  /**\n  Whatever the child wrote to stderr.\n   */\n  readonly standardError: string;\n\n  /**\n  Whatever the child wrote to stdout.\n   */\n  readonly standardOutput: string;\n}\n\n/**\n * Builds the single line the query logs for an outcome.\n *\n * @param params - The outcome plus the command, the port, the budget and what the child left behind.\n * @returns The warning to log, or `undefined` when the query answered.\n */\nexport function buildPortOwnerQueryMessage(params: BuildPortOwnerQueryMessageParams): string | undefined {\n  const cost = `after ${formatDuration(params.elapsedInMilliseconds)}`;\n  const subject = `\\`${params.command}\\` (asking who listens on port ${String(params.port)})`;\n  const consequence = `Nothing is known about what still holds port ${String(params.port)}, so the escalation has no PID to kill \u2014 this is not the same as nothing holding it.`;\n\n  switch (params.outcome) {\n    case 'answered': {\n      return undefined;\n    }\n    case 'crashed': {\n      return `Warning: ${subject} died ${cost} without explaining itself (exit ${formatExitCode(params.exitCode)}, nothing on stderr). Suspect a crash or an interfering security product, and try the command by hand. ${consequence}`;\n    }\n    case 'not-found': {\n      return `Warning: ${subject} could not be run at all ${cost}: the executable was not found on PATH. ${consequence}`;\n    }\n    case 'output-overran': {\n      return `Warning: ${subject} produced more output ${cost} than the query's buffer allows, so none of it could be read. Raise the buffer. ${consequence}`;\n    }\n    case 'refused': {\n      return `Warning: ${subject} refused the request ${cost} (exit ${formatExitCode(params.exitCode)}): ${formatRefusal(params.standardError)} ${consequence}`;\n    }\n    case 'timed-out': {\n      return `Warning: ${subject} did not finish within its ${formatDuration(params.timeoutInMilliseconds)} budget and was killed ${cost}${params.signal === null ? '' : ` (${params.signal})`}. ${consequence}`;\n    }\n    default: {\n      return assertNever(params.outcome);\n    }\n  }\n}\n\n/**\n * Extracts what an `execFileSync` throw carries, in `execFile`'s vocabulary.\n *\n * The synchronous API reports the same endings with different fields: an\n * expired budget is `code: 'ETIMEDOUT'` rather than `killed: true`, an overrun\n * buffer is `ENOBUFS`, and the exit code is `status` rather than `code`.\n * Normalizing here lets the sync teardown classify with the same verdict as the\n * async one.\n *\n * @param error - Whatever `execFileSync` threw.\n * @returns The normalized fields; an unrecognizable throw reads as a crash with no evidence.\n */\nexport function normalizeSyncExecError(error: unknown): NormalizedSyncExecError {\n  const record = typeof error === 'object' && error !== null ? error as Record<string, unknown> : {};\n  const code = typeof record['code'] === 'string' ? record['code'] : undefined;\n  const status = typeof record['status'] === 'number' ? record['status'] : null;\n  const signal = typeof record['signal'] === 'string' ? record['signal'] : null;\n  const isKilled = code === 'ETIMEDOUT';\n\n  let errorCode: null | number | string = status;\n  if (code === 'ENOBUFS') {\n    errorCode = 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER';\n  } else if (code !== undefined && !isKilled) {\n    errorCode = code;\n  }\n\n  return {\n    errorCode,\n    exitCode: status,\n    isKilled,\n    signal,\n    standardError: toText(record['stderr']),\n    standardOutput: toText(record['stdout'])\n  };\n}\n\n/**\n * Decides how the port-owner query ended.\n *\n * @param params - What `execFile` reported, and the platform it ran on.\n * @returns The outcome.\n */\nexport function resolvePortOwnerQueryOutcome(params: ResolvePortOwnerQueryOutcomeParams): PortOwnerQueryOutcome {\n  return !params.hasFailed || (params.platform !== 'win32'\n      && !params.isKilled\n      && params.errorCode === LSOF_NOTHING_FOUND_EXIT_CODE\n      && params.standardError.trim() === ''\n      && params.standardOutput.trim() === '')\n    ? 'answered'\n    : resolveHostQueryFailure(params);\n}\n\n/**\n * Reads a child's captured stream, whichever form `execFileSync` left it in.\n *\n * @param stream - A string, a `Buffer`, or nothing.\n * @returns The text, or an empty string.\n */\nfunction toText(stream: unknown): string {\n  if (typeof stream === 'string') {\n    return stream;\n  }\n\n  return Buffer.isBuffer(stream) ? stream.toString('utf-8') : '';\n}\n"],
  "mappings": "AAgCA,SAAS,cAAc;AAIvB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,mBAAmB;AAK5B,MAAM,+BAA+B;AAmI9B,SAAS,2BAA2B,QAA8D;AACvG,QAAM,OAAO,SAAS,eAAe,OAAO,qBAAqB,CAAC;AAClE,QAAM,UAAU,KAAK,OAAO,OAAO,kCAAkC,OAAO,OAAO,IAAI,CAAC;AACxF,QAAM,cAAc,gDAAgD,OAAO,OAAO,IAAI,CAAC;AAEvF,UAAQ,OAAO,SAAS;AAAA,IACtB,KAAK,YAAY;AACf,aAAO;AAAA,IACT;AAAA,IACA,KAAK,WAAW;AACd,aAAO,YAAY,OAAO,SAAS,IAAI,oCAAoC,eAAe,OAAO,QAAQ,CAAC,0GAA0G,WAAW;AAAA,IACjO;AAAA,IACA,KAAK,aAAa;AAChB,aAAO,YAAY,OAAO,4BAA4B,IAAI,2CAA2C,WAAW;AAAA,IAClH;AAAA,IACA,KAAK,kBAAkB;AACrB,aAAO,YAAY,OAAO,yBAAyB,IAAI,mFAAmF,WAAW;AAAA,IACvJ;AAAA,IACA,KAAK,WAAW;AACd,aAAO,YAAY,OAAO,wBAAwB,IAAI,UAAU,eAAe,OAAO,QAAQ,CAAC,MAAM,cAAc,OAAO,aAAa,CAAC,IAAI,WAAW;AAAA,IACzJ;AAAA,IACA,KAAK,aAAa;AAChB,aAAO,YAAY,OAAO,8BAA8B,eAAe,OAAO,qBAAqB,CAAC,0BAA0B,IAAI,GAAG,OAAO,WAAW,OAAO,KAAK,KAAK,OAAO,MAAM,GAAG,KAAK,WAAW;AAAA,IAC1M;AAAA,IACA,SAAS;AACP,aAAO,YAAY,OAAO,OAAO;AAAA,IACnC;AAAA,EACF;AACF;AAcO,SAAS,uBAAuB,OAAyC;AAC9E,QAAM,SAAS,OAAO,UAAU,YAAY,UAAU,OAAO,QAAmC,CAAC;AACjG,QAAM,OAAO,OAAO,OAAO,MAAM,MAAM,WAAW,OAAO,MAAM,IAAI;AACnE,QAAM,SAAS,OAAO,OAAO,QAAQ,MAAM,WAAW,OAAO,QAAQ,IAAI;AACzE,QAAM,SAAS,OAAO,OAAO,QAAQ,MAAM,WAAW,OAAO,QAAQ,IAAI;AACzE,QAAM,WAAW,SAAS;AAE1B,MAAI,YAAoC;AACxC,MAAI,SAAS,WAAW;AACtB,gBAAY;AAAA,EACd,WAAW,SAAS,UAAa,CAAC,UAAU;AAC1C,gBAAY;AAAA,EACd;AAEA,SAAO;AAAA,IACL;AAAA,IACA,UAAU;AAAA,IACV;AAAA,IACA;AAAA,IACA,eAAe,OAAO,OAAO,QAAQ,CAAC;AAAA,IACtC,gBAAgB,OAAO,OAAO,QAAQ,CAAC;AAAA,EACzC;AACF;AAQO,SAAS,6BAA6B,QAAmE;AAC9G,SAAO,CAAC,OAAO,aAAc,OAAO,aAAa,WAC1C,CAAC,OAAO,YACR,OAAO,cAAc,gCACrB,OAAO,cAAc,KAAK,MAAM,MAChC,OAAO,eAAe,KAAK,MAAM,KACpC,aACA,wBAAwB,MAAM;AACpC;AAQA,SAAS,OAAO,QAAyB;AACvC,MAAI,OAAO,WAAW,UAAU;AAC9B,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,SAAS,MAAM,IAAI,OAAO,SAAS,OAAO,IAAI;AAC9D;",
  "names": []
}


package/dist/lib/esm/resolve-emulator-device-id.mjs

@@ -3,7 +3,14 @@ import {
   runAdbText,
   runAdbTextWithoutDevice
 } from "./adb.mjs";
+import {
+  buildAvdNameChannelCommand,
+  FIRST_AVD_NAME_CHANNEL,
+  parseAvdNameAnswer,
+  resolveNextAvdNameChannel
+} from "./avd-name-channel.mjs";
 import { selectEmulatorDeviceId } from "./emulator-device-id.mjs";
+import { ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS } from "./emulator-reclaim.mjs";
 const EMULATOR_DEVICE_ID_PREFIX = "emulator-";
 async function resolveEmulatorDeviceId(params) {
   const candidates = await listEmulatorDeviceCandidates();
@@ -21,13 +28,34 @@ async function listEmulatorDeviceCandidates() {
   const deviceIds = listOnlineDeviceIds(devicesOutput).filter((deviceId) => deviceId.startsWith(EMULATOR_DEVICE_ID_PREFIX));
   const candidates = [];
   for (const deviceId of deviceIds) {
-    const output = await runAdbText({ commandArguments: ["emu", "avd", "name"], deviceId });
-    const avdName = output.split("\n", 1)[0]?.trim() ?? "";
-    candidates.push({ avdName, deviceId });
+    candidates.push({ avdName: await probeAvdName(deviceId), deviceId });
   }
   return candidates;
 }
+async function probeAvdName(deviceId) {
+  let channel = FIRST_AVD_NAME_CHANNEL;
+  while (channel !== void 0) {
+    let didChannelRespond = true;
+    let reportedAvdName = "";
+    try {
+      reportedAvdName = parseAvdNameAnswer(
+        await runAdbText({
+          commandArguments: buildAvdNameChannelCommand(channel),
+          deviceId,
+          timeoutInMilliseconds: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS
+        })
+      );
+    } catch {
+      didChannelRespond = false;
+    }
+    if (reportedAvdName.length > 0) {
+      return reportedAvdName;
+    }
+    channel = resolveNextAvdNameChannel({ channel, didChannelRespond });
+  }
+  return "";
+}
 export {
   resolveEmulatorDeviceId
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/resolve-emulator-device-id.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Asks the running emulators which AVD each was started from, and resolves one\n * by name through {@link ./emulator-device-id.ts}'s selection.\n *\n * Every function here shells out, so the whole module is integration-time code\n * \u2014 which is exactly why the selection it delegates to lives in its own module\n * and stays unit-tested.\n */\n\n/* v8 ignore start -- Integration-time code (shells out to a real device) covered by integration tests, not unit tests. */\n\nimport type { AvdNameChannel } from './avd-name-channel.mjs';\nimport type { EmulatorDeviceCandidate } from './emulator-device-id.mjs';\n\nimport { listOnlineDeviceIds } from './adb-device-list.mjs';\nimport {\n  runAdbText,\n  runAdbTextWithoutDevice\n} from './adb.mjs';\nimport {\n  buildAvdNameChannelCommand,\n  FIRST_AVD_NAME_CHANNEL,\n  parseAvdNameAnswer,\n  resolveNextAvdNameChannel\n} from './avd-name-channel.mjs';\nimport { selectEmulatorDeviceId } from './emulator-device-id.mjs';\nimport { ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS } from './emulator-reclaim.mjs';\n\n/**\n * Parameters for {@link resolveEmulatorDeviceId}.\n */\nexport interface ResolveEmulatorDeviceIdParams {\n  /**\n   * The AVD name to match, e.g. `obsidian_screenshots`.\n   */\n  readonly avdName: string;\n}\n\n/**\n * The prefix `adb devices` gives an emulator, as opposed to a physically attached device.\n */\nconst EMULATOR_DEVICE_ID_PREFIX = 'emulator-';\n\n/**\n * Finds the running emulator whose AVD is the named one.\n *\n * @param params - The AVD to match.\n * @returns A {@link Promise} that resolves to the device UDID to address it by.\n * @throws Error if no running emulator was started from that AVD. The message lists what IS running, since\n *   \"the wrong emulator is up\" and \"no emulator is up\" need different answers.\n */\nexport async function resolveEmulatorDeviceId(params: ResolveEmulatorDeviceIdParams): Promise<string> {\n  const candidates = await listEmulatorDeviceCandidates();\n  const deviceId = selectEmulatorDeviceId({ avdName: params.avdName, candidates });\n\n  if (!deviceId) {\n    const listed = candidates.map((candidate) => `${candidate.deviceId} (${candidate.avdName})`).join(', ') || 'none';\n    throw new Error(\n      `resolveEmulatorDeviceId: no running emulator for AVD \"${params.avdName}\". Running emulators: ${listed}. `\n        + 'Start it, or run this project once to have the harness start it.'\n    );\n  }\n\n  return deviceId;\n}\n\n/**\n * Asks every online emulator which AVD it was started from.\n *\n * **A device that will not identify itself is listed with an empty name, not\n * thrown over.** It is somebody else's wedged emulator far more often than it is\n * this caller's, and failing the whole lookup over it is precisely the\n * machine-wide interlock `avd-name-channel.ts` exists to undo \u2014 the wanted\n * emulator, sitting right beside it and answering perfectly, is still found.\n *\n * @returns A {@link Promise} that resolves to one entry per running emulator.\n */\nasync function listEmulatorDeviceCandidates(): Promise<EmulatorDeviceCandidate[]> {\n  const devicesOutput = await runAdbTextWithoutDevice(['devices']);\n  const deviceIds = listOnlineDeviceIds(devicesOutput).filter((deviceId) => deviceId.startsWith(EMULATOR_DEVICE_ID_PREFIX));\n\n  const candidates: EmulatorDeviceCandidate[] = [];\n  for (const deviceId of deviceIds) {\n    candidates.push({ avdName: await probeAvdName(deviceId), deviceId });\n  }\n\n  return candidates;\n}\n\n/**\n * Asks one emulator which AVD it was started from, over each channel in turn.\n *\n * The guest property comes first because it travels `adbd` \u2014 the channel this\n * lookup needs anyway \u2014 while the console is a separate port that wedges on its\n * own; see `avd-name-channel.ts`. Every call is bounded, so one unresponsive\n * device costs a timeout rather than the whole lookup.\n *\n * @param deviceId - The emulator to ask.\n * @returns A {@link Promise} that resolves to the AVD name, or `''` when no channel identified it.\n */\nasync function probeAvdName(deviceId: string): Promise<string> {\n  let channel: AvdNameChannel | undefined = FIRST_AVD_NAME_CHANNEL;\n\n  while (channel !== undefined) {\n    let didChannelRespond = true;\n    let reportedAvdName = '';\n\n    try {\n      reportedAvdName = parseAvdNameAnswer(\n        await runAdbText({\n          commandArguments: buildAvdNameChannelCommand(channel),\n          deviceId,\n          timeoutInMilliseconds: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS\n        })\n      );\n    } catch {\n      didChannelRespond = false;\n    }\n\n    if (reportedAvdName.length > 0) {\n      return reportedAvdName;\n    }\n\n    channel = resolveNextAvdNameChannel({ channel, didChannelRespond });\n  }\n\n  return '';\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAgBA,SAAS,2BAA2B;AACpC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,8BAA8B;AACvC,SAAS,gDAAgD;AAezD,MAAM,4BAA4B;AAUlC,eAAsB,wBAAwB,QAAwD;AACpG,QAAM,aAAa,MAAM,6BAA6B;AACtD,QAAM,WAAW,uBAAuB,EAAE,SAAS,OAAO,SAAS,WAAW,CAAC;AAE/E,MAAI,CAAC,UAAU;AACb,UAAM,SAAS,WAAW,IAAI,CAAC,cAAc,GAAG,UAAU,QAAQ,KAAK,UAAU,OAAO,GAAG,EAAE,KAAK,IAAI,KAAK;AAC3G,UAAM,IAAI;AAAA,MACR,yDAAyD,OAAO,OAAO,yBAAyB,MAAM;AAAA,IAExG;AAAA,EACF;AAEA,SAAO;AACT;AAaA,eAAe,+BAAmE;AAChF,QAAM,gBAAgB,MAAM,wBAAwB,CAAC,SAAS,CAAC;AAC/D,QAAM,YAAY,oBAAoB,aAAa,EAAE,OAAO,CAAC,aAAa,SAAS,WAAW,yBAAyB,CAAC;AAExH,QAAM,aAAwC,CAAC;AAC/C,aAAW,YAAY,WAAW;AAChC,eAAW,KAAK,EAAE,SAAS,MAAM,aAAa,QAAQ,GAAG,SAAS,CAAC;AAAA,EACrE;AAEA,SAAO;AACT;AAaA,eAAe,aAAa,UAAmC;AAC7D,MAAI,UAAsC;AAE1C,SAAO,YAAY,QAAW;AAC5B,QAAI,oBAAoB;AACxB,QAAI,kBAAkB;AAEtB,QAAI;AACF,wBAAkB;AAAA,QAChB,MAAM,WAAW;AAAA,UACf,kBAAkB,2BAA2B,OAAO;AAAA,UACpD;AAAA,UACA,uBAAuB;AAAA,QACzB,CAAC;AAAA,MACH;AAAA,IACF,QAAQ;AACN,0BAAoB;AAAA,IACtB;AAEA,QAAI,gBAAgB,SAAS,GAAG;AAC9B,aAAO;AAAA,IACT;AAEA,cAAU,0BAA0B,EAAE,SAAS,kBAAkB,CAAC;AAAA,EACpE;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/esm/sharp-loader.d.mts

@@ -12,12 +12,31 @@
  */
 /**
  * A layer passed to `sharp`'s `composite`.
+ *
+ * The input is either bytes to draw — an SVG, a PNG — or a block `sharp` creates
+ * on the spot, which is how a flat fill is composited without building an image
+ * for it first.
  */
 export interface SharpCompositeLayer {
-    readonly input: Buffer;
+    readonly input: Buffer | SharpCreateInput;
     readonly left: number;
     readonly top: number;
 }
+/**
+ * A solid block of color, created by `sharp` rather than supplied as bytes.
+ */
+export interface SharpCreateInput {
+    readonly create: SharpCreateSpec;
+}
+/**
+ * The block `sharp` is asked to create: a rectangle of one flat color.
+ */
+export interface SharpCreateSpec {
+    readonly background: SharpRgbColor;
+    readonly channels: number;
+    readonly height: number;
+    readonly width: number;
+}
 /**
  * The `sharp` entry point the image helpers use.
  */
@@ -28,10 +47,12 @@ export type SharpFactory = (input: Uint8Array) => SharpInstance;
 export interface SharpInstance {
     blur: (this: void, sigma: number) => SharpInstance;
     composite: (this: void, layers: SharpCompositeLayer[]) => SharpInstance;
+    ensureAlpha: (this: void) => SharpInstance;
     metadata: (this: void) => Promise<SharpMetadata>;
     png: (this: void) => SharpInstance;
+    raw: (this: void) => SharpInstance;
     resize: (this: void, width: number, height: number, options?: SharpResizeOptions) => SharpInstance;
-    toBuffer: (this: void) => Promise<Buffer>;
+    toBuffer: SharpToBuffer;
     trim: (this: void, options: SharpTrimOptions) => SharpInstance;
 }
 /**
@@ -41,12 +62,56 @@ export interface SharpMetadata {
     readonly height?: number | undefined;
     readonly width?: number | undefined;
 }
+/**
+ * The geometry raw pixels have to be read with — without it they are a flat run of bytes.
+ */
+export interface SharpRawInfo {
+    readonly channels: number;
+    readonly height: number;
+    readonly width: number;
+}
+/**
+ * A frame's raw pixels and the geometry they have to be read with.
+ */
+export interface SharpRawResult {
+    readonly data: Uint8Array;
+    readonly info: SharpRawInfo;
+}
 /**
  * The subset of `sharp`'s resize options the image helpers set.
  */
 export interface SharpResizeOptions {
     readonly fit: 'cover' | 'fill';
 }
+/**
+ * Asks `toBuffer` for the pixels AND the geometry they are to be read with.
+ *
+ * Literal `true` rather than `boolean`, so the overload that returns
+ * {@link SharpRawResult} is only selected when the geometry is genuinely coming
+ * back — a `false` would resolve to bare bytes with the width silently missing.
+ */
+export interface SharpResolveWithObjectOptions {
+    readonly resolveWithObject: true;
+}
+/**
+ * A color as `sharp` names its channels.
+ */
+export interface SharpRgbColor {
+    readonly b: number;
+    readonly g: number;
+    readonly r: number;
+}
+/**
+ * `sharp`'s `toBuffer`, in the two shapes the image helpers call it in.
+ *
+ * Written as an overloaded call signature rather than a union return, because
+ * which one comes back is decided by the argument and a caller should not have
+ * to narrow a result it already knows the shape of.
+ */
+export interface SharpToBuffer {
+    (this: void): Promise<Buffer>;
+    (this: void, options: SharpResolveWithObjectOptions): Promise<SharpRawResult>;
+}
 /**
  * The subset of `sharp`'s trim options the image helpers set.
  */

package/dist/lib/esm/sharp-loader.mjs

@@ -13,4 +13,4 @@ async function importSharp(caller) {
 export {
   importSharp
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/soft-keyboard-geometry.d.mts

@@ -148,12 +148,25 @@ export declare const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;
  * A bare "the keyboard did not come up" is unreadable — what the reader needs is what the page saw and what
  * the device thought, side by side, because the two disagreeing is the whole diagnosis. The page's half is
  * the lift and the two tops it came from, since the lift is the verdict; a lift of zero gets a sentence of
- * its own, being the one reading that an already-up keyboard also produces.
+ * its own, saying what is left once an already-up keyboard has been ruled out.
  *
  * @param params - The evidence gathered before the first touch and after the last one.
  * @returns The message, ready to throw.
  */
 export declare function buildSoftKeyboardDiagnosticMessage(params: BuildSoftKeyboardDiagnosticMessageParams): string;
+/**
+ * Decides whether the device reports an IME showing, from `dumpsys input_method`.
+ *
+ * This is the DEVICE's answer, and it is the one `raiseSoftKeyboard` asks before it measures anything:
+ * nothing in the page reports the keyboard, and the geometric proof in {@link checkIsSoftKeyboardUp}
+ * cannot see a keyboard that was already up when its baseline was read. It is deliberately NOT the proof
+ * that a raise worked — a device reports `mInputShown=true` just as readily for an IME drawn over a field
+ * that never moved, which is exactly the unproved frame the geometric delta exists to refuse.
+ *
+ * @param inputMethodState - The fields {@link parseInputMethodState} returned.
+ * @returns Whether the device says an IME is showing.
+ */
+export declare function checkIsInputMethodShown(inputMethodState: string): boolean;
 /**
  * Decides whether the IME is up, from how far the field moved.
  *
@@ -167,7 +180,9 @@ export declare function buildSoftKeyboardDiagnosticMessage(params: BuildSoftKeyb
  * that from a centred modal with no keyboard — both read as "clear of the bottom and not moving" — and of
  * the two possible wrong answers, a loud `false` is the one worth keeping: it fails a capture rather than
  * silently returning a screenshot of a keyboard that is not there. Read the baseline with the keyboard
- * down, which is what `raiseSoftKeyboard` does.
+ * down. `raiseSoftKeyboard` guarantees that itself: it asks the device ({@link checkIsInputMethodShown})
+ * and puts a showing keyboard down before it reads the baseline, so every call proves its own lift rather
+ * than taking the device's word for one.
  *
  * @param params - The geometry before and after the touch, and how far the field must have lifted.
  * @returns Whether the field lifted far enough to have made room for a keyboard.

package/dist/lib/esm/soft-keyboard-geometry.mjs

@@ -1,5 +1,6 @@
 const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;
 const INPUT_METHOD_STATE_REG_EXP = /mInputShown|mIsInputViewShown|mHaveConnection|mShowRequested/;
+const INPUT_SHOWN_REG_EXP = /(?:^|[\s|])mInputShown=true(?:$|[\s|])/;
 const CENTER_DIVISOR = 2;
 function buildSoftKeyboardDiagnosticMessage(params) {
   const baselineTop = params.baselineSnapshot.inputRect?.top ?? null;
@@ -9,10 +10,13 @@ function buildSoftKeyboardDiagnosticMessage(params) {
     `raiseSoftKeyboard: the keyboard did not come up. Device framebuffer written to ${params.screenshotPath}.`,
     `page: innerHeight=${String(params.snapshot.innerHeight)} baselineInputTop=${formatMeasurement(baselineTop)} inputTop=${formatMeasurement(currentTop)} lift=${formatMeasurement(lift)}`,
     `device: ${params.inputMethodState || "(no input_method state reported)"}`,
-    ...lift === 0 ? ["The field did not move at all. If the device says the keyboard is showing, it was already up before the first touch \u2014 this check cannot tell that from a field that never lifts."] : []
+    ...lift === 0 ? [buildZeroLiftStatement(params.inputMethodState)] : []
   ];
   return lines.join("\n");
 }
+function checkIsInputMethodShown(inputMethodState) {
+  return INPUT_SHOWN_REG_EXP.test(inputMethodState);
+}
 function checkIsSoftKeyboardUp(params) {
   const baselineRect = params.baselineSnapshot.inputRect;
   const { inputRect } = params.snapshot;
@@ -38,14 +42,19 @@ function resolveSoftKeyboardTapPoints(params) {
     { xInPixels, yInPixels: centerYInPixels }
   ];
 }
+function buildZeroLiftStatement(inputMethodState) {
+  const cause = checkIsInputMethodShown(inputMethodState) ? "The device says a keyboard is showing now, so the touch raised one and it did not lift this field." : "The device says no keyboard is showing, so the touch raised none.";
+  return `The field did not move at all. No keyboard was up when the baseline was read \u2014 raiseSoftKeyboard puts down one the device reports showing before it measures \u2014 so this is not a keyboard left up by an earlier call. ${cause}`;
+}
 function formatMeasurement(value) {
   return value === null ? "(no input)" : String(value);
 }
 export {
   DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS,
   buildSoftKeyboardDiagnosticMessage,
+  checkIsInputMethodShown,
   checkIsSoftKeyboardUp,
   parseInputMethodState,
   resolveSoftKeyboardTapPoints
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/soft-keyboard-geometry.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Decides whether the Android soft keyboard is up, and where to touch to raise\n * it \u2014 from geometry alone.\n *\n * **Nothing in the page reports the keyboard.** `innerHeight`, `visualViewport`\n * and the modal container all stay at their full height with the keyboard shown\n * and `dumpsys input_method` reporting `mInputShown=true` \u2014 Obsidian Mobile keeps\n * a full-screen container and lifts its contents inside it. The only signal is\n * that the field *moves*, which is why the detection here is geometric rather\n * than an API call. Two runs failed on that before a framebuffer dump said so,\n * which is also why the diagnostic below exists.\n *\n * **The signal is a DELTA against a baseline read before the touch, not the\n * field's absolute offset from the bottom.** The absolute offset was the original\n * test and it is right only for a **bottom-anchored** field \u2014 a suggester, a\n * command palette \u2014 where \"clear of the bottom\" and \"lifted\" are the same\n * sentence. For a **centred modal** the condition is already true with no\n * keyboard at all, so the test passed vacuously and `raiseSoftKeyboard` returned\n * success having dispatched no touch (measured 2026-09-12 against a centred\n * prompt modal: the field's `top` read `352.4453125` before and after real taps\n * and the check said the keyboard was up both times). A delta is the same public\n * API for both shapes, and it costs a field that cannot move its verdict \u2014 see\n * {@link checkIsSoftKeyboardUp} for the one case that trades away.\n *\n * Pure and unit-tested; the touching and the capture live in `soft-keyboard`.\n */\n\n/**\n * Parameters for {@link buildSoftKeyboardDiagnosticMessage}.\n */\nexport interface BuildSoftKeyboardDiagnosticMessageParams {\n  /**\n   * The geometry read before the first touch, which is what the verdict is measured against.\n   */\n  readonly baselineSnapshot: SoftKeyboardViewportSnapshot;\n\n  /**\n   * The lines of `dumpsys input_method` worth reading, as {@link parseInputMethodState} returned them.\n   */\n  readonly inputMethodState: string;\n\n  /**\n   * Where the device framebuffer was written, so the reader can look at what the device was showing.\n   */\n  readonly screenshotPath: string;\n\n  /**\n   * The geometry read after the last touch.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * Parameters for {@link checkIsSoftKeyboardUp}.\n */\nexport interface CheckIsSoftKeyboardUpParams {\n  /**\n   * The geometry read **before** the first touch, with the keyboard still down.\n   *\n   * Required, and deliberately not optional: an absent baseline could only mean falling back to the\n   * absolute-offset test, which is the vacuous pass this parameter exists to make unrepresentable.\n   */\n  readonly baselineSnapshot: SoftKeyboardViewportSnapshot;\n\n  /**\n   * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.\n   *\n   * @default {@link DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS}\n   */\n  readonly minimumKeyboardHeightInPixels?: number;\n\n  /**\n   * The geometry to judge, read after the touch.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * A rectangle as the renderer reports it, in CSS pixels.\n */\nexport interface ElementRect {\n  /**\n   * The rectangle's height.\n   */\n  readonly height: number;\n\n  /**\n   * The distance from the viewport's left edge.\n   */\n  readonly left: number;\n\n  /**\n   * The distance from the viewport's top edge.\n   */\n  readonly top: number;\n\n  /**\n   * The rectangle's width.\n   */\n  readonly width: number;\n}\n\n/**\n * Parameters for {@link resolveSoftKeyboardTapPoints}.\n */\nexport interface ResolveSoftKeyboardTapPointsParams {\n  /**\n   * The geometry the tap is aimed from.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * A point on the device's screen, in device pixels.\n */\nexport interface SoftKeyboardTapPoint {\n  /**\n   * The distance from the screen's left edge.\n   */\n  readonly xInPixels: number;\n\n  /**\n   * The distance from the screen's top edge.\n   */\n  readonly yInPixels: number;\n}\n\n/**\n * What the renderer knows about its own geometry.\n */\nexport interface SoftKeyboardViewportSnapshot {\n  /**\n   * The ratio between CSS pixels and the device pixels `adb shell input tap` speaks in.\n   */\n  readonly devicePixelRatio: number;\n\n  /**\n   * The viewport's height in CSS pixels.\n   *\n   * Kept for the diagnostic as much as the decision: it does **not** shrink when the keyboard comes up.\n   */\n  readonly innerHeight: number;\n\n  /**\n   * The field's rect, which is what says whether the keyboard is up, or `null` when it is not on screen.\n   */\n  readonly inputRect: ElementRect | null;\n\n  /**\n   * The window's offset from the top of the screen, as the page understands it.\n   */\n  readonly screenY: number;\n}\n\n/**\n * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.\n *\n * Exported because it is the number both {@link checkIsSoftKeyboardUp} and `raiseSoftKeyboard` default to,\n * and a suite tightening it wants to say so relative to this rather than in the abstract.\n */\nexport const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;\n\n/**\n * The `dumpsys input_method` fields that say whether the IME is actually showing.\n */\nconst INPUT_METHOD_STATE_REG_EXP = /mInputShown|mIsInputViewShown|mHaveConnection|mShowRequested/;\n\n/**\n * How many equal parts the field is split into to find its centre.\n */\nconst CENTER_DIVISOR = 2;\n\n/**\n * Builds the message a failed raise reports.\n *\n * A bare \"the keyboard did not come up\" is unreadable \u2014 what the reader needs is what the page saw and what\n * the device thought, side by side, because the two disagreeing is the whole diagnosis. The page's half is\n * the lift and the two tops it came from, since the lift is the verdict; a lift of zero gets a sentence of\n * its own, being the one reading that an already-up keyboard also produces.\n *\n * @param params - The evidence gathered before the first touch and after the last one.\n * @returns The message, ready to throw.\n */\nexport function buildSoftKeyboardDiagnosticMessage(params: BuildSoftKeyboardDiagnosticMessageParams): string {\n  const baselineTop = params.baselineSnapshot.inputRect?.top ?? null;\n  const currentTop = params.snapshot.inputRect?.top ?? null;\n  const lift = baselineTop === null || currentTop === null ? null : baselineTop - currentTop;\n\n  const lines = [\n    `raiseSoftKeyboard: the keyboard did not come up. Device framebuffer written to ${params.screenshotPath}.`,\n    `page: innerHeight=${String(params.snapshot.innerHeight)} baselineInputTop=${formatMeasurement(baselineTop)} inputTop=${formatMeasurement(currentTop)} lift=${formatMeasurement(lift)}`,\n    `device: ${params.inputMethodState || '(no input_method state reported)'}`,\n    ...(lift === 0 ? ['The field did not move at all. If the device says the keyboard is showing, it was already up before the first touch \u2014 this check cannot tell that from a field that never lifts.'] : [])\n  ];\n\n  return lines.join('\\n');\n}\n\n/**\n * Decides whether the IME is up, from how far the field moved.\n *\n * The verdict is a **delta**: the field must have risen from where it sat before the touch, by at least\n * `minimumKeyboardHeightInPixels`. Obsidian Mobile lifts whatever is on screen to make room for the IME,\n * so a field that has not moved has had no keyboard arrive under it \u2014 whether it is a bottom-anchored\n * suggester or a centred modal.\n *\n * **The one case this gets wrong, deliberately:** a keyboard that was *already* up before the baseline was\n * read. The field has nowhere left to lift to, so the answer is `false`. No amount of geometry separates\n * that from a centred modal with no keyboard \u2014 both read as \"clear of the bottom and not moving\" \u2014 and of\n * the two possible wrong answers, a loud `false` is the one worth keeping: it fails a capture rather than\n * silently returning a screenshot of a keyboard that is not there. Read the baseline with the keyboard\n * down, which is what `raiseSoftKeyboard` does.\n *\n * @param params - The geometry before and after the touch, and how far the field must have lifted.\n * @returns Whether the field lifted far enough to have made room for a keyboard.\n */\nexport function checkIsSoftKeyboardUp(params: CheckIsSoftKeyboardUpParams): boolean {\n  const baselineRect = params.baselineSnapshot.inputRect;\n  const { inputRect } = params.snapshot;\n  if (!baselineRect || !inputRect) {\n    return false;\n  }\n\n  const minimumKeyboardHeightInPixels = params.minimumKeyboardHeightInPixels ?? DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS;\n  return baselineRect.top - inputRect.top > minimumKeyboardHeightInPixels;\n}\n\n/**\n * Reduces `dumpsys input_method` to the handful of fields that say whether the IME is showing.\n *\n * @param dumpsysOutput - Raw stdout of `adb shell dumpsys input_method`.\n * @returns The interesting fields, trimmed and joined, or an empty string when none were reported.\n */\nexport function parseInputMethodState(dumpsysOutput: string): string {\n  return dumpsysOutput\n    .split('\\n')\n    .filter((line) => INPUT_METHOD_STATE_REG_EXP.test(line))\n    .map((line) => line.trim())\n    .join(' | ');\n}\n\n/**\n * Works out where to touch, in the device pixels `adb shell input tap` speaks.\n *\n * Two candidates, not one: the WebView may or may not start at the top of the screen, and the page cannot\n * tell which. Both land inside the field \u2014 it is taller than the offset \u2014 so a wrong guess costs one touch\n * rather than a mis-tap on whatever sits below.\n *\n * @param params - The geometry the tap is aimed from.\n * @returns The points to try, in order, or an empty array when the field is not on screen.\n */\nexport function resolveSoftKeyboardTapPoints(params: ResolveSoftKeyboardTapPointsParams): SoftKeyboardTapPoint[] {\n  const { devicePixelRatio, inputRect, screenY } = params.snapshot;\n  if (!inputRect) {\n    return [];\n  }\n\n  const xInPixels = Math.round((inputRect.left + inputRect.width / CENTER_DIVISOR) * devicePixelRatio);\n  const centerYInPixels = Math.round((inputRect.top + inputRect.height / CENTER_DIVISOR) * devicePixelRatio);\n  const topOffsetInPixels = Math.round(screenY * devicePixelRatio);\n\n  return topOffsetInPixels === 0\n    ? [{ xInPixels, yInPixels: centerYInPixels }]\n    : [\n      { xInPixels, yInPixels: centerYInPixels + topOffsetInPixels },\n      { xInPixels, yInPixels: centerYInPixels }\n    ];\n}\n\n/**\n * Formats a measurement for the diagnostic, saying so rather than printing a number when there was none.\n *\n * @param value - The measurement, or `null` when the field was not on screen to measure.\n * @returns The number as text, or `(no input)`.\n */\nfunction formatMeasurement(value: null | number): string {\n  return value === null ? '(no input)' : String(value);\n}\n"],
  "mappings": "AAkKO,MAAM,4CAA4C;AAKzD,MAAM,6BAA6B;AAKnC,MAAM,iBAAiB;AAahB,SAAS,mCAAmC,QAA0D;AAC3G,QAAM,cAAc,OAAO,iBAAiB,WAAW,OAAO;AAC9D,QAAM,aAAa,OAAO,SAAS,WAAW,OAAO;AACrD,QAAM,OAAO,gBAAgB,QAAQ,eAAe,OAAO,OAAO,cAAc;AAEhF,QAAM,QAAQ;AAAA,IACZ,kFAAkF,OAAO,cAAc;AAAA,IACvG,qBAAqB,OAAO,OAAO,SAAS,WAAW,CAAC,qBAAqB,kBAAkB,WAAW,CAAC,aAAa,kBAAkB,UAAU,CAAC,SAAS,kBAAkB,IAAI,CAAC;AAAA,IACrL,WAAW,OAAO,oBAAoB,kCAAkC;AAAA,IACxE,GAAI,SAAS,IAAI,CAAC,uLAAkL,IAAI,CAAC;AAAA,EAC3M;AAEA,SAAO,MAAM,KAAK,IAAI;AACxB;AAoBO,SAAS,sBAAsB,QAA8C;AAClF,QAAM,eAAe,OAAO,iBAAiB;AAC7C,QAAM,EAAE,UAAU,IAAI,OAAO;AAC7B,MAAI,CAAC,gBAAgB,CAAC,WAAW;AAC/B,WAAO;AAAA,EACT;AAEA,QAAM,gCAAgC,OAAO,iCAAiC;AAC9E,SAAO,aAAa,MAAM,UAAU,MAAM;AAC5C;AAQO,SAAS,sBAAsB,eAA+B;AACnE,SAAO,cACJ,MAAM,IAAI,EACV,OAAO,CAAC,SAAS,2BAA2B,KAAK,IAAI,CAAC,EACtD,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EACzB,KAAK,KAAK;AACf;AAYO,SAAS,6BAA6B,QAAoE;AAC/G,QAAM,EAAE,kBAAkB,WAAW,QAAQ,IAAI,OAAO;AACxD,MAAI,CAAC,WAAW;AACd,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,YAAY,KAAK,OAAO,UAAU,OAAO,UAAU,QAAQ,kBAAkB,gBAAgB;AACnG,QAAM,kBAAkB,KAAK,OAAO,UAAU,MAAM,UAAU,SAAS,kBAAkB,gBAAgB;AACzG,QAAM,oBAAoB,KAAK,MAAM,UAAU,gBAAgB;AAE/D,SAAO,sBAAsB,IACzB,CAAC,EAAE,WAAW,WAAW,gBAAgB,CAAC,IAC1C;AAAA,IACA,EAAE,WAAW,WAAW,kBAAkB,kBAAkB;AAAA,IAC5D,EAAE,WAAW,WAAW,gBAAgB;AAAA,EAC1C;AACJ;AAQA,SAAS,kBAAkB,OAA8B;AACvD,SAAO,UAAU,OAAO,eAAe,OAAO,KAAK;AACrD;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/soft-keyboard-geometry.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Decides whether the Android soft keyboard is up, and where to touch to raise\n * it \u2014 from geometry alone.\n *\n * **Nothing in the page reports the keyboard.** `innerHeight`, `visualViewport`\n * and the modal container all stay at their full height with the keyboard shown\n * and `dumpsys input_method` reporting `mInputShown=true` \u2014 Obsidian Mobile keeps\n * a full-screen container and lifts its contents inside it. The only signal is\n * that the field *moves*, which is why the detection here is geometric rather\n * than an API call. Two runs failed on that before a framebuffer dump said so,\n * which is also why the diagnostic below exists.\n *\n * **The signal is a DELTA against a baseline read before the touch, not the\n * field's absolute offset from the bottom.** The absolute offset was the original\n * test and it is right only for a **bottom-anchored** field \u2014 a suggester, a\n * command palette \u2014 where \"clear of the bottom\" and \"lifted\" are the same\n * sentence. For a **centred modal** the condition is already true with no\n * keyboard at all, so the test passed vacuously and `raiseSoftKeyboard` returned\n * success having dispatched no touch (measured 2026-09-12 against a centred\n * prompt modal: the field's `top` read `352.4453125` before and after real taps\n * and the check said the keyboard was up both times). A delta is the same public\n * API for both shapes, and it costs a field that cannot move its verdict \u2014 see\n * {@link checkIsSoftKeyboardUp} for the one case that trades away.\n *\n * Pure and unit-tested; the touching and the capture live in `soft-keyboard`.\n */\n\n/**\n * Parameters for {@link buildSoftKeyboardDiagnosticMessage}.\n */\nexport interface BuildSoftKeyboardDiagnosticMessageParams {\n  /**\n   * The geometry read before the first touch, which is what the verdict is measured against.\n   */\n  readonly baselineSnapshot: SoftKeyboardViewportSnapshot;\n\n  /**\n   * The lines of `dumpsys input_method` worth reading, as {@link parseInputMethodState} returned them.\n   */\n  readonly inputMethodState: string;\n\n  /**\n   * Where the device framebuffer was written, so the reader can look at what the device was showing.\n   */\n  readonly screenshotPath: string;\n\n  /**\n   * The geometry read after the last touch.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * Parameters for {@link checkIsSoftKeyboardUp}.\n */\nexport interface CheckIsSoftKeyboardUpParams {\n  /**\n   * The geometry read **before** the first touch, with the keyboard still down.\n   *\n   * Required, and deliberately not optional: an absent baseline could only mean falling back to the\n   * absolute-offset test, which is the vacuous pass this parameter exists to make unrepresentable.\n   */\n  readonly baselineSnapshot: SoftKeyboardViewportSnapshot;\n\n  /**\n   * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.\n   *\n   * @default {@link DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS}\n   */\n  readonly minimumKeyboardHeightInPixels?: number;\n\n  /**\n   * The geometry to judge, read after the touch.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * A rectangle as the renderer reports it, in CSS pixels.\n */\nexport interface ElementRect {\n  /**\n   * The rectangle's height.\n   */\n  readonly height: number;\n\n  /**\n   * The distance from the viewport's left edge.\n   */\n  readonly left: number;\n\n  /**\n   * The distance from the viewport's top edge.\n   */\n  readonly top: number;\n\n  /**\n   * The rectangle's width.\n   */\n  readonly width: number;\n}\n\n/**\n * Parameters for {@link resolveSoftKeyboardTapPoints}.\n */\nexport interface ResolveSoftKeyboardTapPointsParams {\n  /**\n   * The geometry the tap is aimed from.\n   */\n  readonly snapshot: SoftKeyboardViewportSnapshot;\n}\n\n/**\n * A point on the device's screen, in device pixels.\n */\nexport interface SoftKeyboardTapPoint {\n  /**\n   * The distance from the screen's left edge.\n   */\n  readonly xInPixels: number;\n\n  /**\n   * The distance from the screen's top edge.\n   */\n  readonly yInPixels: number;\n}\n\n/**\n * What the renderer knows about its own geometry.\n */\nexport interface SoftKeyboardViewportSnapshot {\n  /**\n   * The ratio between CSS pixels and the device pixels `adb shell input tap` speaks in.\n   */\n  readonly devicePixelRatio: number;\n\n  /**\n   * The viewport's height in CSS pixels.\n   *\n   * Kept for the diagnostic as much as the decision: it does **not** shrink when the keyboard comes up.\n   */\n  readonly innerHeight: number;\n\n  /**\n   * The field's rect, which is what says whether the keyboard is up, or `null` when it is not on screen.\n   */\n  readonly inputRect: ElementRect | null;\n\n  /**\n   * The window's offset from the top of the screen, as the page understands it.\n   */\n  readonly screenY: number;\n}\n\n/**\n * The least a raised keyboard lifts the field by, so a stray rounding pixel is not read as one.\n *\n * Exported because it is the number both {@link checkIsSoftKeyboardUp} and `raiseSoftKeyboard` default to,\n * and a suite tightening it wants to say so relative to this rather than in the abstract.\n */\nexport const DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS = 100;\n\n/**\n * The `dumpsys input_method` fields that say whether the IME is actually showing.\n */\nconst INPUT_METHOD_STATE_REG_EXP = /mInputShown|mIsInputViewShown|mHaveConnection|mShowRequested/;\n\n/**\n * The flag `dumpsys input_method` sets while an IME is showing, as a whole token \u2014 so neither a value that\n * merely starts with `true` nor a longer field name ending in `mInputShown` can match.\n */\nconst INPUT_SHOWN_REG_EXP = /(?:^|[\\s|])mInputShown=true(?:$|[\\s|])/;\n\n/**\n * How many equal parts the field is split into to find its centre.\n */\nconst CENTER_DIVISOR = 2;\n\n/**\n * Builds the message a failed raise reports.\n *\n * A bare \"the keyboard did not come up\" is unreadable \u2014 what the reader needs is what the page saw and what\n * the device thought, side by side, because the two disagreeing is the whole diagnosis. The page's half is\n * the lift and the two tops it came from, since the lift is the verdict; a lift of zero gets a sentence of\n * its own, saying what is left once an already-up keyboard has been ruled out.\n *\n * @param params - The evidence gathered before the first touch and after the last one.\n * @returns The message, ready to throw.\n */\nexport function buildSoftKeyboardDiagnosticMessage(params: BuildSoftKeyboardDiagnosticMessageParams): string {\n  const baselineTop = params.baselineSnapshot.inputRect?.top ?? null;\n  const currentTop = params.snapshot.inputRect?.top ?? null;\n  const lift = baselineTop === null || currentTop === null ? null : baselineTop - currentTop;\n\n  const lines = [\n    `raiseSoftKeyboard: the keyboard did not come up. Device framebuffer written to ${params.screenshotPath}.`,\n    `page: innerHeight=${String(params.snapshot.innerHeight)} baselineInputTop=${formatMeasurement(baselineTop)} inputTop=${formatMeasurement(currentTop)} lift=${formatMeasurement(lift)}`,\n    `device: ${params.inputMethodState || '(no input_method state reported)'}`,\n    ...(lift === 0 ? [buildZeroLiftStatement(params.inputMethodState)] : [])\n  ];\n\n  return lines.join('\\n');\n}\n\n/**\n * Decides whether the device reports an IME showing, from `dumpsys input_method`.\n *\n * This is the DEVICE's answer, and it is the one `raiseSoftKeyboard` asks before it measures anything:\n * nothing in the page reports the keyboard, and the geometric proof in {@link checkIsSoftKeyboardUp}\n * cannot see a keyboard that was already up when its baseline was read. It is deliberately NOT the proof\n * that a raise worked \u2014 a device reports `mInputShown=true` just as readily for an IME drawn over a field\n * that never moved, which is exactly the unproved frame the geometric delta exists to refuse.\n *\n * @param inputMethodState - The fields {@link parseInputMethodState} returned.\n * @returns Whether the device says an IME is showing.\n */\nexport function checkIsInputMethodShown(inputMethodState: string): boolean {\n  return INPUT_SHOWN_REG_EXP.test(inputMethodState);\n}\n\n/**\n * Decides whether the IME is up, from how far the field moved.\n *\n * The verdict is a **delta**: the field must have risen from where it sat before the touch, by at least\n * `minimumKeyboardHeightInPixels`. Obsidian Mobile lifts whatever is on screen to make room for the IME,\n * so a field that has not moved has had no keyboard arrive under it \u2014 whether it is a bottom-anchored\n * suggester or a centred modal.\n *\n * **The one case this gets wrong, deliberately:** a keyboard that was *already* up before the baseline was\n * read. The field has nowhere left to lift to, so the answer is `false`. No amount of geometry separates\n * that from a centred modal with no keyboard \u2014 both read as \"clear of the bottom and not moving\" \u2014 and of\n * the two possible wrong answers, a loud `false` is the one worth keeping: it fails a capture rather than\n * silently returning a screenshot of a keyboard that is not there. Read the baseline with the keyboard\n * down. `raiseSoftKeyboard` guarantees that itself: it asks the device ({@link checkIsInputMethodShown})\n * and puts a showing keyboard down before it reads the baseline, so every call proves its own lift rather\n * than taking the device's word for one.\n *\n * @param params - The geometry before and after the touch, and how far the field must have lifted.\n * @returns Whether the field lifted far enough to have made room for a keyboard.\n */\nexport function checkIsSoftKeyboardUp(params: CheckIsSoftKeyboardUpParams): boolean {\n  const baselineRect = params.baselineSnapshot.inputRect;\n  const { inputRect } = params.snapshot;\n  if (!baselineRect || !inputRect) {\n    return false;\n  }\n\n  const minimumKeyboardHeightInPixels = params.minimumKeyboardHeightInPixels ?? DEFAULT_MINIMUM_KEYBOARD_HEIGHT_IN_PIXELS;\n  return baselineRect.top - inputRect.top > minimumKeyboardHeightInPixels;\n}\n\n/**\n * Reduces `dumpsys input_method` to the handful of fields that say whether the IME is showing.\n *\n * @param dumpsysOutput - Raw stdout of `adb shell dumpsys input_method`.\n * @returns The interesting fields, trimmed and joined, or an empty string when none were reported.\n */\nexport function parseInputMethodState(dumpsysOutput: string): string {\n  return dumpsysOutput\n    .split('\\n')\n    .filter((line) => INPUT_METHOD_STATE_REG_EXP.test(line))\n    .map((line) => line.trim())\n    .join(' | ');\n}\n\n/**\n * Works out where to touch, in the device pixels `adb shell input tap` speaks.\n *\n * Two candidates, not one: the WebView may or may not start at the top of the screen, and the page cannot\n * tell which. Both land inside the field \u2014 it is taller than the offset \u2014 so a wrong guess costs one touch\n * rather than a mis-tap on whatever sits below.\n *\n * @param params - The geometry the tap is aimed from.\n * @returns The points to try, in order, or an empty array when the field is not on screen.\n */\nexport function resolveSoftKeyboardTapPoints(params: ResolveSoftKeyboardTapPointsParams): SoftKeyboardTapPoint[] {\n  const { devicePixelRatio, inputRect, screenY } = params.snapshot;\n  if (!inputRect) {\n    return [];\n  }\n\n  const xInPixels = Math.round((inputRect.left + inputRect.width / CENTER_DIVISOR) * devicePixelRatio);\n  const centerYInPixels = Math.round((inputRect.top + inputRect.height / CENTER_DIVISOR) * devicePixelRatio);\n  const topOffsetInPixels = Math.round(screenY * devicePixelRatio);\n\n  return topOffsetInPixels === 0\n    ? [{ xInPixels, yInPixels: centerYInPixels }]\n    : [\n      { xInPixels, yInPixels: centerYInPixels + topOffsetInPixels },\n      { xInPixels, yInPixels: centerYInPixels }\n    ];\n}\n\n/**\n * Says what a lift of zero means, now that `raiseSoftKeyboard` puts down any keyboard already showing\n * before it reads its baseline.\n *\n * It used to be a hint \u2014 \"if the device says the keyboard is showing, it was already up\" \u2014 printed under an\n * error whose own device line often said exactly that. The helper has since taken that cause away, so the\n * sentence states what is left rather than guessing at what might be.\n *\n * @param inputMethodState - The fields {@link parseInputMethodState} returned after the last touch.\n * @returns The statement.\n */\nfunction buildZeroLiftStatement(inputMethodState: string): string {\n  const cause = checkIsInputMethodShown(inputMethodState)\n    ? 'The device says a keyboard is showing now, so the touch raised one and it did not lift this field.'\n    : 'The device says no keyboard is showing, so the touch raised none.';\n\n  return 'The field did not move at all. No keyboard was up when the baseline was read \u2014 raiseSoftKeyboard puts down '\n    + `one the device reports showing before it measures \u2014 so this is not a keyboard left up by an earlier call. ${cause}`;\n}\n\n/**\n * Formats a measurement for the diagnostic, saying so rather than printing a number when there was none.\n *\n * @param value - The measurement, or `null` when the field was not on screen to measure.\n * @returns The number as text, or `(no input)`.\n */\nfunction formatMeasurement(value: null | number): string {\n  return value === null ? '(no input)' : String(value);\n}\n"],
  "mappings": "AAkKO,MAAM,4CAA4C;AAKzD,MAAM,6BAA6B;AAMnC,MAAM,sBAAsB;AAK5B,MAAM,iBAAiB;AAahB,SAAS,mCAAmC,QAA0D;AAC3G,QAAM,cAAc,OAAO,iBAAiB,WAAW,OAAO;AAC9D,QAAM,aAAa,OAAO,SAAS,WAAW,OAAO;AACrD,QAAM,OAAO,gBAAgB,QAAQ,eAAe,OAAO,OAAO,cAAc;AAEhF,QAAM,QAAQ;AAAA,IACZ,kFAAkF,OAAO,cAAc;AAAA,IACvG,qBAAqB,OAAO,OAAO,SAAS,WAAW,CAAC,qBAAqB,kBAAkB,WAAW,CAAC,aAAa,kBAAkB,UAAU,CAAC,SAAS,kBAAkB,IAAI,CAAC;AAAA,IACrL,WAAW,OAAO,oBAAoB,kCAAkC;AAAA,IACxE,GAAI,SAAS,IAAI,CAAC,uBAAuB,OAAO,gBAAgB,CAAC,IAAI,CAAC;AAAA,EACxE;AAEA,SAAO,MAAM,KAAK,IAAI;AACxB;AAcO,SAAS,wBAAwB,kBAAmC;AACzE,SAAO,oBAAoB,KAAK,gBAAgB;AAClD;AAsBO,SAAS,sBAAsB,QAA8C;AAClF,QAAM,eAAe,OAAO,iBAAiB;AAC7C,QAAM,EAAE,UAAU,IAAI,OAAO;AAC7B,MAAI,CAAC,gBAAgB,CAAC,WAAW;AAC/B,WAAO;AAAA,EACT;AAEA,QAAM,gCAAgC,OAAO,iCAAiC;AAC9E,SAAO,aAAa,MAAM,UAAU,MAAM;AAC5C;AAQO,SAAS,sBAAsB,eAA+B;AACnE,SAAO,cACJ,MAAM,IAAI,EACV,OAAO,CAAC,SAAS,2BAA2B,KAAK,IAAI,CAAC,EACtD,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EACzB,KAAK,KAAK;AACf;AAYO,SAAS,6BAA6B,QAAoE;AAC/G,QAAM,EAAE,kBAAkB,WAAW,QAAQ,IAAI,OAAO;AACxD,MAAI,CAAC,WAAW;AACd,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,YAAY,KAAK,OAAO,UAAU,OAAO,UAAU,QAAQ,kBAAkB,gBAAgB;AACnG,QAAM,kBAAkB,KAAK,OAAO,UAAU,MAAM,UAAU,SAAS,kBAAkB,gBAAgB;AACzG,QAAM,oBAAoB,KAAK,MAAM,UAAU,gBAAgB;AAE/D,SAAO,sBAAsB,IACzB,CAAC,EAAE,WAAW,WAAW,gBAAgB,CAAC,IAC1C;AAAA,IACA,EAAE,WAAW,WAAW,kBAAkB,kBAAkB;AAAA,IAC5D,EAAE,WAAW,WAAW,gBAAgB;AAAA,EAC1C;AACJ;AAaA,SAAS,uBAAuB,kBAAkC;AAChE,QAAM,QAAQ,wBAAwB,gBAAgB,IAClD,uGACA;AAEJ,SAAO,kOAC0G,KAAK;AACxH;AAQA,SAAS,kBAAkB,OAA8B;AACvD,SAAO,UAAU,OAAO,eAAe,OAAO,KAAK;AACrD;",
  "names": []
}
