obsidian-integration-testing 11.0.0 → 12.1.0

package/dist/lib/esm/webview-cdp.mjs

@@ -0,0 +1,235 @@
+import { execFileSync } from "node:child_process";
+import { exec } from "./exec.mjs";
+import { log } from "./log.mjs";
+import { pickFreePort } from "./obsidian-instance.mjs";
+const ADB_TIMEOUT_IN_MILLISECONDS = 15e3;
+const FORWARD_LIST_COLUMN_COUNT = 3;
+const DECIMAL_RADIX = 10;
+const CDP_COMMAND_TIMEOUT_IN_MILLISECONDS = 3e4;
+const CDP_HOST = "127.0.0.1";
+class WebViewCdpConnection {
+  /**
+   * Wraps an already-open debugger socket, plus what is needed to tear its port forward down.
+   *
+   * @param webSocket - The open debugger socket.
+   * @param deviceId - The adb device id, needed to drop the port forward on dispose.
+   * @param port - The forwarded local port.
+   */
+  constructor(webSocket, deviceId, port) {
+    this.webSocket = webSocket;
+    this.deviceId = deviceId;
+    this.port = port;
+    this.webSocket.addEventListener("message", (event) => {
+      const message = JSON.parse(String(event.data));
+      if (message.method === void 0) {
+        return;
+      }
+      this.eventHandlers.get(message.method)?.(message.params ?? {});
+    });
+  }
+  webSocket;
+  deviceId;
+  port;
+  /**
+   * Whether the socket is still usable.
+   *
+   * Restarting the app tears its WebView down and takes the debugger target with it, so a cached
+   * connection has to be re-checked rather than assumed live.
+   *
+   * @returns `true` while the socket is open.
+   */
+  get isOpen() {
+    return this.webSocket.readyState === WebSocket.OPEN;
+  }
+  eventHandlers = /* @__PURE__ */ new Map();
+  messageId = 0;
+  /**
+   * Closes the socket and drops the adb port forward.
+   */
+  async dispose() {
+    this.closeSocket();
+    await removeForward(this.deviceId, this.port);
+  }
+  /**
+   * Synchronous disposal, for `process.on('exit')` handlers where async work cannot run.
+   *
+   * Without this an abrupt worker exit leaves the port forward behind — the async {@link dispose} above
+   * never gets a turn.
+   */
+  disposeSync() {
+    this.closeSocket();
+    try {
+      execFileSync("adb", ["-s", this.deviceId, "forward", "--remove", `tcp:${String(this.port)}`], {
+        stdio: "ignore",
+        timeout: ADB_TIMEOUT_IN_MILLISECONDS
+      });
+    } catch {
+    }
+  }
+  /**
+   * Subscribes to a CDP event. One handler per method; subscribing again replaces it.
+   *
+   * @param method - The CDP event name, e.g. `Runtime.bindingCalled`.
+   * @param handler - Called with the event parameters.
+   */
+  on(method, handler) {
+    this.eventHandlers.set(method, handler);
+  }
+  /**
+   * Sends a CDP command and waits for its response.
+   *
+   * @param method - The CDP method name.
+   * @param params - The CDP method parameters.
+   * @returns The command result.
+   */
+  send(method, params = {}) {
+    const id = ++this.messageId;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.webSocket.removeEventListener("message", handler);
+        reject(new Error(`WebView CDP command timed out after ${String(CDP_COMMAND_TIMEOUT_IN_MILLISECONDS)}ms: ${method}`));
+      }, CDP_COMMAND_TIMEOUT_IN_MILLISECONDS);
+      const handler = (event) => {
+        const message = JSON.parse(String(event.data));
+        if (message.id !== id) {
+          return;
+        }
+        clearTimeout(timeout);
+        this.webSocket.removeEventListener("message", handler);
+        if (message.error) {
+          reject(new Error(`WebView CDP command ${method} failed: ${message.error.message ?? "unknown error"}`));
+          return;
+        }
+        resolve(message.result ?? {});
+      };
+      this.webSocket.addEventListener("message", handler);
+      this.webSocket.send(JSON.stringify({ id, method, params }));
+    });
+  }
+  /**
+   * Sends an ordered command sequence, one command at a time.
+   *
+   * Each command is awaited before the next is sent, which is the only ordering guarantee an input
+   * sequence needs — a long-press holds itself for its own `duration` rather than asking the host to
+   * sleep between two touches, so there is no inter-command delay to honor.
+   *
+   * @param commands - The commands to send, in order.
+   */
+  async sendAll(commands) {
+    for (const command of commands) {
+      await this.send(command.method, command.params);
+    }
+  }
+  /**
+   * Closes the debugger socket and stops routing its events.
+   */
+  closeSocket() {
+    this.eventHandlers.clear();
+    if (this.webSocket.readyState === WebSocket.OPEN) {
+      this.webSocket.close();
+    }
+  }
+}
+async function connectToWebViewCdp(params) {
+  const { appId, deviceId } = params;
+  const pidofOutput = await adb(deviceId, ["shell", "pidof", appId]);
+  const pid = pidofOutput.split(/\s+/, 1)[0] ?? "";
+  if (!pid) {
+    throw new Error(`${appId} is not running on ${deviceId}, so its WebView has no debugger to attach to.`);
+  }
+  const procNetUnix = await adb(deviceId, ["shell", "cat", "/proc/net/unix"]);
+  const socketName = parseWebViewDevtoolsSocketName(procNetUnix, pid);
+  const forwardList = await adb(deviceId, ["forward", "--list"]);
+  const existingPort = parseForwardedPort(forwardList, deviceId, socketName);
+  const port = existingPort ?? await pickFreePort();
+  if (existingPort === void 0) {
+    await adb(deviceId, ["forward", `tcp:${String(port)}`, `localabstract:${socketName}`]);
+    log(`[webview-cdp] Forwarded tcp:${String(port)} -> localabstract:${socketName} (${appId} pid ${pid})`);
+  } else {
+    log(`[webview-cdp] Reusing forward tcp:${String(port)} -> localabstract:${socketName} (${appId} pid ${pid})`);
+  }
+  try {
+    const response = await fetch(`http://${CDP_HOST}:${String(port)}/json`);
+    const target = selectWebViewPageTarget(await response.json());
+    const webSocket = new WebSocket(target.webSocketDebuggerUrl ?? "");
+    await new Promise((resolve, reject) => {
+      webSocket.addEventListener("open", () => {
+        resolve();
+      }, { once: true });
+      webSocket.addEventListener("error", () => {
+        reject(new Error(`Could not open the WebView CDP socket at ${target.webSocketDebuggerUrl ?? ""}.`));
+      }, { once: true });
+    });
+    log(`[webview-cdp] Attached to WebView target "${target.title ?? ""}"`);
+    return new WebViewCdpConnection(webSocket, deviceId, port);
+  } catch (error) {
+    await removeForward(deviceId, port);
+    throw error;
+  }
+}
+function parseForwardedPort(forwardList, deviceId, socketName) {
+  for (const line of forwardList.split("\n")) {
+    const [lineDeviceId, local, remote] = line.trim().split(/\s+/, FORWARD_LIST_COLUMN_COUNT);
+    if (lineDeviceId !== deviceId || remote !== `localabstract:${socketName}` || !local?.startsWith("tcp:")) {
+      continue;
+    }
+    const port = Number.parseInt(local.slice("tcp:".length), DECIMAL_RADIX);
+    if (Number.isSafeInteger(port)) {
+      return port;
+    }
+  }
+  return void 0;
+}
+function parseWebViewDevtoolsSocketName(procNetUnix, pid) {
+  const names = [
+    ...new Set([...procNetUnix.matchAll(/@webview_devtools_remote_\w+/g)].map((match) => match[0].slice("@".length)))
+  ];
+  const [soleName, ...otherNames] = names;
+  if (soleName === void 0) {
+    throw new Error(
+      "No `webview_devtools_remote_*` socket on the device. Obsidian Mobile is not running, or its WebView debugger is disabled."
+    );
+  }
+  const exactName = `webview_devtools_remote_${pid}`;
+  if (names.includes(exactName)) {
+    return exactName;
+  }
+  if (otherNames.length === 0) {
+    return soleName;
+  }
+  throw new Error(
+    `No \`${exactName}\` socket, and ${String(names.length)} other debuggable WebViews are present (${names.join(", ")}), so the right one cannot be chosen.`
+  );
+}
+function selectWebViewPageTarget(targets) {
+  const target = targets.find((candidate) => candidate.type === "page" && Boolean(candidate.webSocketDebuggerUrl)) ?? targets.find((candidate) => Boolean(candidate.webSocketDebuggerUrl));
+  if (!target) {
+    throw new Error("The WebView debugger listed no target with a WebSocket endpoint.");
+  }
+  return target;
+}
+async function adb(deviceId, commandArguments) {
+  const stdout = await exec(["adb", "-s", deviceId, ...commandArguments], {
+    isQuiet: true,
+    timeoutInMilliseconds: ADB_TIMEOUT_IN_MILLISECONDS
+  });
+  return stdout.trim();
+}
+async function removeForward(deviceId, port) {
+  try {
+    await exec(["adb", "-s", deviceId, "forward", "--remove", `tcp:${String(port)}`], {
+      isQuiet: true,
+      shouldIgnoreExitCode: true,
+      timeoutInMilliseconds: ADB_TIMEOUT_IN_MILLISECONDS
+    });
+  } catch {
+  }
+}
+export {
+  WebViewCdpConnection,
+  connectToWebViewCdp,
+  parseForwardedPort,
+  parseWebViewDevtoolsSocketName,
+  selectWebViewPageTarget
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/webview-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A second, independent Chrome DevTools Protocol connection to Obsidian Mobile's WebView, used to inject\n * **trusted** input on Android (see **L39**).\n *\n * It is deliberately separate from the Appium session rather than layered on it. `AppiumTransport.evaluate`\n * runs the whole `evalInObsidian` closure inside one W3C *Execute Script*, which awaits the returned\n * promise \u2014 so while a closure sits waiting on `lib.clickElement(...)`, the WebDriver session is busy and\n * cannot be asked to do anything else. CDP is id-multiplexed and Chromium accepts multiple debugger\n * clients, so this socket stays free exactly when the Appium one does not. That is what lets the renderer\n * call back out to the host mid-closure.\n *\n * Reaching the WebView's debugger is a two-step: the app publishes an abstract unix socket named\n * `webview_devtools_remote_<pid>`, `adb forward` maps it to a local TCP port, and the usual `/json`\n * endpoint then lists the page targets.\n */\n\nimport { execFileSync } from 'node:child_process';\n\nimport type { CdpInputCommand } from './mobile-input.mjs';\n\nimport { exec } from './exec.mjs';\nimport { log } from './log.mjs';\nimport { pickFreePort } from './obsidian-instance.mjs';\n\nconst ADB_TIMEOUT_IN_MILLISECONDS = 15_000;\n// `adb forward --list` prints three columns: `<deviceId> tcp:<port> localabstract:<socketName>`.\nconst FORWARD_LIST_COLUMN_COUNT = 3;\nconst DECIMAL_RADIX = 10;\nconst CDP_COMMAND_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst CDP_HOST = '127.0.0.1';\n\n/**\n * One entry of the debugger's `/json` target list.\n */\nexport interface CdpTarget {\n  readonly title?: string;\n  readonly type?: string;\n  readonly url?: string;\n  readonly webSocketDebuggerUrl?: string;\n}\n\n/**\n * Parameters for {@link connectToWebViewCdp}.\n */\nexport interface ConnectToWebViewCdpParams {\n  /**\n   * The Android application id whose WebView to attach to, e.g. `md.obsidian`.\n   */\n  readonly appId: string;\n\n  /**\n   * The adb device id (`emulator-5554`, a serial) to run adb against.\n   */\n  readonly deviceId: string;\n}\n\n/**\n * The error half of a failed CDP command response.\n */\ninterface CdpError {\n  readonly message?: string;\n}\n\n/**\n * Handles a CDP event.\n */\ntype CdpEventHandler = (params: Record<string, unknown>) => void;\n\n/**\n * A CDP message: either a response to a command (`id`) or an event (`method`).\n */\ninterface CdpMessage {\n  readonly error?: CdpError;\n  readonly id?: number;\n  readonly method?: string;\n  readonly params?: Record<string, unknown>;\n  readonly result?: Record<string, unknown>;\n}\n\n/* v8 ignore start -- Integration-time code (a live WebSocket to a WebView, adb port forwarding). Covered by the Android integration tests, not by unit tests. It ends before `parseForwardedPort`: `perfectionist/sort-modules` places the pure, unit-tested helpers AFTER this class and `connectToWebViewCdp`, so they must stay measured. */\n\n/**\n * An open CDP connection to a WebView.\n *\n * Commands are id-multiplexed, so a command issued from inside an event handler completes while an earlier\n * `Runtime.evaluate` is still awaiting its promise \u2014 which is the whole reason this class exists.\n */\nexport class WebViewCdpConnection {\n  /**\n   * Whether the socket is still usable.\n   *\n   * Restarting the app tears its WebView down and takes the debugger target with it, so a cached\n   * connection has to be re-checked rather than assumed live.\n   *\n   * @returns `true` while the socket is open.\n   */\n  public get isOpen(): boolean {\n    return this.webSocket.readyState === WebSocket.OPEN;\n  }\n\n  private readonly eventHandlers = new Map<string, CdpEventHandler>();\n\n  private messageId = 0;\n\n  /**\n   * Wraps an already-open debugger socket, plus what is needed to tear its port forward down.\n   *\n   * @param webSocket - The open debugger socket.\n   * @param deviceId - The adb device id, needed to drop the port forward on dispose.\n   * @param port - The forwarded local port.\n   */\n  public constructor(private readonly webSocket: WebSocket, private readonly deviceId: string, private readonly port: number) {\n    this.webSocket.addEventListener('message', (event: MessageEvent) => {\n      const message = JSON.parse(String(event.data)) as CdpMessage;\n      if (message.method === undefined) {\n        return;\n      }\n\n      this.eventHandlers.get(message.method)?.(message.params ?? {});\n    });\n  }\n\n  /**\n   * Closes the socket and drops the adb port forward.\n   */\n  public async dispose(): Promise<void> {\n    this.closeSocket();\n    await removeForward(this.deviceId, this.port);\n  }\n\n  /**\n   * Synchronous disposal, for `process.on('exit')` handlers where async work cannot run.\n   *\n   * Without this an abrupt worker exit leaves the port forward behind \u2014 the async {@link dispose} above\n   * never gets a turn.\n   */\n  public disposeSync(): void {\n    this.closeSocket();\n    try {\n      execFileSync('adb', ['-s', this.deviceId, 'forward', '--remove', `tcp:${String(this.port)}`], {\n        stdio: 'ignore',\n        timeout: ADB_TIMEOUT_IN_MILLISECONDS\n      });\n    } catch {\n      // Best effort: adb drops every forward when the device disconnects anyway.\n    }\n  }\n\n  /**\n   * Subscribes to a CDP event. One handler per method; subscribing again replaces it.\n   *\n   * @param method - The CDP event name, e.g. `Runtime.bindingCalled`.\n   * @param handler - Called with the event parameters.\n   */\n  public on(method: string, handler: CdpEventHandler): void {\n    this.eventHandlers.set(method, handler);\n  }\n\n  /**\n   * Sends a CDP command and waits for its response.\n   *\n   * @param method - The CDP method name.\n   * @param params - The CDP method parameters.\n   * @returns The command result.\n   */\n  public send(method: string, params: Record<string, unknown> = {}): Promise<Record<string, unknown>> {\n    const id = ++this.messageId;\n\n    return new Promise<Record<string, unknown>>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        this.webSocket.removeEventListener('message', handler);\n        reject(new Error(`WebView CDP command timed out after ${String(CDP_COMMAND_TIMEOUT_IN_MILLISECONDS)}ms: ${method}`));\n      }, CDP_COMMAND_TIMEOUT_IN_MILLISECONDS);\n\n      const handler = (event: MessageEvent): void => {\n        const message = JSON.parse(String(event.data)) as CdpMessage;\n        if (message.id !== id) {\n          return;\n        }\n\n        clearTimeout(timeout);\n        this.webSocket.removeEventListener('message', handler);\n        if (message.error) {\n          reject(new Error(`WebView CDP command ${method} failed: ${message.error.message ?? 'unknown error'}`));\n          return;\n        }\n\n        resolve(message.result ?? {});\n      };\n\n      this.webSocket.addEventListener('message', handler);\n      this.webSocket.send(JSON.stringify({ id, method, params }));\n    });\n  }\n\n  /**\n   * Sends an ordered command sequence, one command at a time.\n   *\n   * Each command is awaited before the next is sent, which is the only ordering guarantee an input\n   * sequence needs \u2014 a long-press holds itself for its own `duration` rather than asking the host to\n   * sleep between two touches, so there is no inter-command delay to honor.\n   *\n   * @param commands - The commands to send, in order.\n   */\n  public async sendAll(commands: readonly CdpInputCommand[]): Promise<void> {\n    for (const command of commands) {\n      await this.send(command.method, command.params);\n    }\n  }\n\n  /**\n   * Closes the debugger socket and stops routing its events.\n   */\n  private closeSocket(): void {\n    this.eventHandlers.clear();\n    if (this.webSocket.readyState === WebSocket.OPEN) {\n      this.webSocket.close();\n    }\n  }\n}\n\n/**\n * Opens a CDP connection to the app's WebView.\n *\n * @param params - Which app on which device.\n * @returns The open connection. Dispose it to close the socket and drop the adb port forward.\n */\nexport async function connectToWebViewCdp(params: ConnectToWebViewCdpParams): Promise<WebViewCdpConnection> {\n  const { appId, deviceId } = params;\n\n  // `pidof` lists every matching process; the app's main one is first.\n  const pidofOutput = await adb(deviceId, ['shell', 'pidof', appId]);\n  const pid = pidofOutput.split(/\\s+/, 1)[0] ?? '';\n  if (!pid) {\n    throw new Error(`${appId} is not running on ${deviceId}, so its WebView has no debugger to attach to.`);\n  }\n\n  const procNetUnix = await adb(deviceId, ['shell', 'cat', '/proc/net/unix']);\n  const socketName = parseWebViewDevtoolsSocketName(procNetUnix, pid);\n\n  const forwardList = await adb(deviceId, ['forward', '--list']);\n  const existingPort = parseForwardedPort(forwardList, deviceId, socketName);\n  const port = existingPort ?? await pickFreePort();\n  if (existingPort === undefined) {\n    await adb(deviceId, ['forward', `tcp:${String(port)}`, `localabstract:${socketName}`]);\n    log(`[webview-cdp] Forwarded tcp:${String(port)} -> localabstract:${socketName} (${appId} pid ${pid})`);\n  } else {\n    log(`[webview-cdp] Reusing forward tcp:${String(port)} -> localabstract:${socketName} (${appId} pid ${pid})`);\n  }\n\n  try {\n    const response = await fetch(`http://${CDP_HOST}:${String(port)}/json`);\n    const target = selectWebViewPageTarget(await response.json() as CdpTarget[]);\n    const webSocket = new WebSocket(target.webSocketDebuggerUrl ?? '');\n    await new Promise<void>((resolve, reject) => {\n      webSocket.addEventListener('open', () => {\n        resolve();\n      }, { once: true });\n      webSocket.addEventListener('error', () => {\n        reject(new Error(`Could not open the WebView CDP socket at ${target.webSocketDebuggerUrl ?? ''}.`));\n      }, { once: true });\n    });\n    log(`[webview-cdp] Attached to WebView target \"${target.title ?? ''}\"`);\n\n    return new WebViewCdpConnection(webSocket, deviceId, port);\n  } catch (error: unknown) {\n    await removeForward(deviceId, port);\n    throw error;\n  }\n}\n\n/* v8 ignore stop */\n\n/**\n * Finds a port already forwarded to this device socket, so repeated runs reuse one forward.\n *\n * Without this every run allocates a fresh port, and any run that exits without the async\n * {@link WebViewCdpConnection.dispose} \u2014 an abrupt worker exit, where only the synchronous teardown\n * path runs \u2014 leaves its forward behind forever. Reuse bounds that to a single forward per socket\n * rather than one per run.\n *\n * @param forwardList - The output of `adb forward --list`.\n * @param deviceId - The adb device id to match.\n * @param socketName - The abstract socket name to match.\n * @returns The already-forwarded local port, or `undefined` when there is none.\n */\nexport function parseForwardedPort(forwardList: string, deviceId: string, socketName: string): number | undefined {\n  for (const line of forwardList.split('\\n')) {\n    // `adb forward --list` prints `<deviceId> tcp:<port> localabstract:<socketName>`.\n    const [lineDeviceId, local, remote] = line.trim().split(/\\s+/, FORWARD_LIST_COLUMN_COUNT);\n    if (lineDeviceId !== deviceId || remote !== `localabstract:${socketName}` || !local?.startsWith('tcp:')) {\n      continue;\n    }\n\n    const port = Number.parseInt(local.slice('tcp:'.length), DECIMAL_RADIX);\n    if (Number.isSafeInteger(port)) {\n      return port;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Picks the WebView's devtools socket name out of `/proc/net/unix`.\n *\n * A device can host several debuggable WebViews (other apps, a leftover process), so the app's own pid is\n * what disambiguates them. When no socket matches that pid the sole remaining candidate is used \u2014 a\n * WebView whose socket is named after a child process rather than the one `pidof` reported still has to be\n * reachable \u2014 but two unattributable candidates is ambiguous enough to refuse.\n *\n * @param procNetUnix - The contents of `/proc/net/unix`.\n * @param pid - The application's process id.\n * @returns The socket name, e.g. `webview_devtools_remote_18056`.\n */\nexport function parseWebViewDevtoolsSocketName(procNetUnix: string, pid: string): string {\n  // The whole match minus its leading `@`, rather than a named capture group: a mandatory group is always\n  // Present once the pattern has matched, so `match.groups?.['name'] ?? ''` would leave behind two branches\n  // No input can ever reach \u2014 and this file is measured against a 100% branch gate.\n  const names = [\n    ...new Set([...procNetUnix.matchAll(/@webview_devtools_remote_\\w+/g)]\n      .map((match) => match[0].slice('@'.length)))\n  ];\n\n  // Destructured rather than indexed for the same reason: `soleName` carries the \"there is at least one\"\n  // Fact in the type, so neither the empty check below nor the single-candidate one leaves a dead branch.\n  const [soleName, ...otherNames] = names;\n\n  if (soleName === undefined) {\n    throw new Error(\n      'No `webview_devtools_remote_*` socket on the device. Obsidian Mobile is not running, or its WebView '\n        + 'debugger is disabled.'\n    );\n  }\n\n  const exactName = `webview_devtools_remote_${pid}`;\n  if (names.includes(exactName)) {\n    return exactName;\n  }\n\n  if (otherNames.length === 0) {\n    return soleName;\n  }\n\n  throw new Error(\n    `No \\`${exactName}\\` socket, and ${String(names.length)} other debuggable WebViews are present `\n      + `(${names.join(', ')}), so the right one cannot be chosen.`\n  );\n}\n\n/**\n * Picks the Obsidian page target out of the debugger's `/json` list.\n *\n * @param targets - The `/json` response.\n * @returns The page target to attach to.\n */\nexport function selectWebViewPageTarget(targets: readonly CdpTarget[]): CdpTarget {\n  const target = targets.find((candidate) => candidate.type === 'page' && Boolean(candidate.webSocketDebuggerUrl))\n    ?? targets.find((candidate) => Boolean(candidate.webSocketDebuggerUrl));\n\n  if (!target) {\n    throw new Error('The WebView debugger listed no target with a WebSocket endpoint.');\n  }\n\n  return target;\n}\n\n/* v8 ignore start -- Integration-time code (adb shell-outs). Covered by the Android integration tests, not by unit tests. */\n\n/**\n * Runs an adb command against one device.\n *\n * @param deviceId - The adb device id.\n * @param commandArguments - The adb arguments after `-s <deviceId>`.\n * @returns Trimmed stdout.\n */\nasync function adb(deviceId: string, commandArguments: string[]): Promise<string> {\n  const stdout = await exec(['adb', '-s', deviceId, ...commandArguments], {\n    isQuiet: true,\n    timeoutInMilliseconds: ADB_TIMEOUT_IN_MILLISECONDS\n  });\n\n  return stdout.trim();\n}\n\n/**\n * Drops an adb port forward, ignoring the \"not found\" case.\n *\n * @param deviceId - The adb device id.\n * @param port - The forwarded local port.\n */\nasync function removeForward(deviceId: string, port: number): Promise<void> {\n  try {\n    await exec(['adb', '-s', deviceId, 'forward', '--remove', `tcp:${String(port)}`], {\n      isQuiet: true,\n      shouldIgnoreExitCode: true,\n      timeoutInMilliseconds: ADB_TIMEOUT_IN_MILLISECONDS\n    });\n  } catch {\n    // Best effort: the forward is per-run and adb drops it when the device disconnects anyway.\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


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": []
}
