gestament 0.2.0 → 0.3.0

package/dist/launchGtkApp-BIO_5Xjn.cjs

@@ -0,0 +1,2479 @@
+"use strict";
+const node_child_process = require("node:child_process");
+const wait = require("./wait-eOIz4nZm.cjs");
+const errors = require("./errors-6gj5YuLw.cjs");
+const node_fs = require("node:fs");
+const node_net = require("node:net");
+const node_os = require("node:os");
+const node_path = require("node:path");
+const node_url = require("node:url");
+const prerequisites = require("./prerequisites-BuZST2Dy.cjs");
+const native = require("./native-CBXaFWP-.cjs");
+var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+const defaultDisplay = "xvfb";
+const defaultGSettings = "memory";
+const defaultTheme = "Adwaita";
+const defaultXvfbScreen = "1280x720x24";
+const defaultXvfbTrayHost = true;
+const defaultXvfbPoolMaxIdlePerKey = 1;
+const defaultXvfbPoolMaxIdleTotal = 4;
+const screenPattern = /^[1-9][0-9]*x[1-9][0-9]*x[1-9][0-9]*$/;
+const sessionStartupTimeoutMs = 3e4;
+const sessionReleaseTimeoutMs = 5e3;
+const xvfbStartupTimeoutMs = 1e4;
+const xvfbPoolProbeTimeoutMs = 5e3;
+const firstPooledDisplayNumber = 90;
+const lastPooledDisplayNumber = 590;
+let socketCounter = 0;
+const leasedDisplayNumbers = /* @__PURE__ */ new Set();
+const idleXvfbByKey = /* @__PURE__ */ new Map();
+const idleAllByKey = /* @__PURE__ */ new Map();
+const directXvfbs = /* @__PURE__ */ new Set();
+let poolCleanupInstalled = false;
+const hasValue = (value) => value !== void 0 && value.length > 0;
+const delay = (timeoutMs) => new Promise((resolveDelay) => {
+  setTimeout(resolveDelay, timeoutMs);
+});
+const appendOutput$1 = (lines, chunk) => {
+  lines.push(chunk.toString("utf8"));
+  if (lines.length > 40) {
+    lines.splice(0, lines.length - 40);
+  }
+};
+const unrefHandle = (handle) => {
+  const maybeRefHandle = handle;
+  if (typeof maybeRefHandle.unref === "function") {
+    maybeRefHandle.unref();
+  }
+};
+const formatOutputTail = (stdout, stderr) => {
+  const stdoutText = stdout.join("").trim();
+  const stderrText = stderr.join("").trim();
+  if (stdoutText.length === 0 && stderrText.length === 0) {
+    return "";
+  }
+  return `
+stdout:
+${stdoutText}
+stderr:
+${stderrText}`;
+};
+const getHostDisplayState = () => ({
+  display: process.env.DISPLAY,
+  waylandDisplay: process.env.WAYLAND_DISPLAY
+});
+const resolveHostDisplayKind = (state) => {
+  if (hasValue(state.waylandDisplay)) {
+    return "wayland";
+  }
+  if (hasValue(state.display)) {
+    return "x11";
+  }
+  return void 0;
+};
+const resolveDisplay = (display) => {
+  if (display === void 0) {
+    return defaultDisplay;
+  }
+  if (display === "xvfb" || display === "host") {
+    return display;
+  }
+  throw errors.createGtkInvalidArgumentError(
+    `display must be "xvfb" or "host": ${String(display)}`
+  );
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const resolvePoolLimit = (name, value, defaultValue) => {
+  if (value === void 0) {
+    return defaultValue;
+  }
+  if (!Number.isInteger(value) || value < 0) {
+    throw errors.createGtkInvalidArgumentError(`${name} must be an integer >= 0.`);
+  }
+  return value;
+};
+const resolveXvfbPool = (pool) => {
+  if (pool === void 0) {
+    return void 0;
+  }
+  if (!isRecord(pool)) {
+    throw errors.createGtkInvalidArgumentError(
+      'xvfbPool must be an object with type "xvfb" or "all".'
+    );
+  }
+  const { type } = pool;
+  if (type !== "xvfb" && type !== "all") {
+    throw errors.createGtkInvalidArgumentError(
+      `xvfbPool.type must be "xvfb" or "all": ${String(type)}`
+    );
+  }
+  return {
+    maxIdlePerKey: resolvePoolLimit(
+      "xvfbPool.maxIdlePerKey",
+      pool.maxIdlePerKey,
+      defaultXvfbPoolMaxIdlePerKey
+    ),
+    maxIdleTotal: resolvePoolLimit(
+      "xvfbPool.maxIdleTotal",
+      pool.maxIdleTotal,
+      defaultXvfbPoolMaxIdleTotal
+    ),
+    type
+  };
+};
+const nonePoolLimits = () => ({
+  maxIdlePerKey: 0,
+  maxIdleTotal: 0
+});
+const poolLimits = (pool) => ({
+  maxIdlePerKey: pool.maxIdlePerKey,
+  maxIdleTotal: pool.maxIdleTotal
+});
+const shouldRetainIdlePool = (limits) => limits.maxIdlePerKey > 0 && limits.maxIdleTotal > 0;
+const removeArrayEntry = (map, key, entry) => {
+  const entries = map.get(key);
+  if (entries === void 0) {
+    return;
+  }
+  const index = entries.indexOf(entry);
+  if (index >= 0) {
+    entries.splice(index, 1);
+  }
+  if (entries.length === 0) {
+    map.delete(key);
+  }
+};
+const pushArrayEntry = (map, key, entry) => {
+  const entries = map.get(key);
+  if (entries === void 0) {
+    map.set(key, [entry]);
+    return;
+  }
+  entries.push(entry);
+};
+const popArrayEntry = (map, key) => {
+  const entries = map.get(key);
+  if (entries === void 0) {
+    return void 0;
+  }
+  const entry = entries.pop();
+  if (entries.length === 0) {
+    map.delete(key);
+  }
+  return entry;
+};
+const totalArrayEntryCount = (map) => [...map.values()].reduce((total, entries) => total + entries.length, 0);
+const oldestEntry = (entries) => [...entries].sort((first, second) => first.lastUsedAt - second.lastUsedAt)[0];
+const allIdleXvfbs = () => [...idleXvfbByKey.values()].flat();
+const allIdleAllSessions = () => [...idleAllByKey.values()].flat();
+const totalIdlePoolSize = () => totalArrayEntryCount(idleXvfbByKey) + totalArrayEntryCount(idleAllByKey);
+const candidateOldestIdlePool = () => {
+  const candidates = [
+    ...allIdleXvfbs().map((xvfb) => ({
+      kind: "xvfb",
+      lastUsedAt: xvfb.lastUsedAt,
+      xvfb
+    })),
+    ...allIdleAllSessions().map((session) => ({
+      kind: "all",
+      lastUsedAt: session.lastUsedAt,
+      session
+    }))
+  ].sort((first, second) => first.lastUsedAt - second.lastUsedAt);
+  const candidate = candidates[0];
+  if (candidate === void 0) {
+    return void 0;
+  }
+  return candidate.kind === "xvfb" ? { kind: "xvfb", xvfb: candidate.xvfb } : { kind: "all", session: candidate.session };
+};
+const evictIdleXvfb = async (xvfb) => {
+  removeArrayEntry(idleXvfbByKey, xvfb.key, xvfb);
+  await terminateXvfb(xvfb);
+};
+const evictIdleAllSession = async (session) => {
+  removeArrayEntry(idleAllByKey, session.key, session);
+  await session.session.terminate();
+};
+const evictIdlePools = async (maxIdleTotal) => {
+  while (totalIdlePoolSize() > maxIdleTotal) {
+    const candidate = candidateOldestIdlePool();
+    if (candidate === void 0) {
+      return;
+    }
+    if (candidate.kind === "xvfb") {
+      await evictIdleXvfb(candidate.xvfb);
+    } else {
+      await evictIdleAllSession(candidate.session);
+    }
+  }
+};
+const trimIdleXvfbKey = async (key, maxIdlePerKey) => {
+  while ((idleXvfbByKey.get(key)?.length ?? 0) > maxIdlePerKey) {
+    const entry = oldestEntry(idleXvfbByKey.get(key) ?? []);
+    if (entry === void 0) {
+      return;
+    }
+    await evictIdleXvfb(entry);
+  }
+};
+const trimIdleAllKey = async (key, maxIdlePerKey) => {
+  while ((idleAllByKey.get(key)?.length ?? 0) > maxIdlePerKey) {
+    const entry = oldestEntry(idleAllByKey.get(key) ?? []);
+    if (entry === void 0) {
+      return;
+    }
+    await evictIdleAllSession(entry);
+  }
+};
+const retainIdleXvfb = async (xvfb, limits) => {
+  if (!shouldRetainIdlePool(limits)) {
+    await terminateXvfb(xvfb);
+    return;
+  }
+  xvfb.lastUsedAt = Date.now();
+  pushArrayEntry(idleXvfbByKey, xvfb.key, xvfb);
+  await trimIdleXvfbKey(xvfb.key, limits.maxIdlePerKey);
+  await evictIdlePools(limits.maxIdleTotal);
+};
+const retainIdleAllSession = async (session, limits) => {
+  if (!shouldRetainIdlePool(limits)) {
+    await session.session.terminate();
+    return;
+  }
+  session.lastUsedAt = Date.now();
+  session.xvfb.lastUsedAt = session.lastUsedAt;
+  pushArrayEntry(idleAllByKey, session.key, session);
+  await trimIdleAllKey(session.key, limits.maxIdlePerKey);
+  await evictIdlePools(limits.maxIdleTotal);
+};
+const emptyDriverSessionPoolOptions = () => ({
+  allKey: void 0,
+  allowedMappedWindowCount: 0,
+  limits: nonePoolLimits(),
+  mode: "none",
+  xvfb: void 0
+});
+const resolveXvfbOptions = (options) => {
+  const screen = options.xvfbScreen ?? defaultXvfbScreen;
+  if (!screenPattern.test(screen)) {
+    throw errors.createGtkInvalidArgumentError(
+      `xvfbScreen must be WIDTHxHEIGHTxDEPTH: ${screen}`
+    );
+  }
+  return {
+    pool: resolveXvfbPool(options.xvfbPool),
+    screen,
+    trayHost: options.xvfbTrayHost ?? defaultXvfbTrayHost
+  };
+};
+const resolveEffectiveDisplay = (display, xvfb) => {
+  if (display === "xvfb") {
+    return {
+      hostDisplay: void 0,
+      hostWaylandDisplay: void 0,
+      kind: "xvfb",
+      xvfb
+    };
+  }
+  const hostDisplay = getHostDisplayState();
+  if (resolveHostDisplayKind(hostDisplay) !== void 0) {
+    return {
+      hostDisplay: hostDisplay.display,
+      hostWaylandDisplay: hostDisplay.waylandDisplay,
+      kind: "host",
+      xvfb: void 0
+    };
+  }
+  return {
+    hostDisplay: void 0,
+    hostWaylandDisplay: void 0,
+    kind: "xvfb",
+    xvfb
+  };
+};
+const resolveGdkBackend = (effective) => {
+  if (effective.kind === "xvfb") {
+    return "x11";
+  }
+  if (process.env.GDK_BACKEND !== void 0) {
+    return void 0;
+  }
+  if (hasValue(effective.hostDisplay)) {
+    return "x11";
+  }
+  if (hasValue(effective.hostWaylandDisplay)) {
+    return "wayland";
+  }
+  return void 0;
+};
+const toWireEnvironment = (env) => {
+  const wireEnv = {};
+  for (const [key, value] of Object.entries(env)) {
+    wireEnv[key] = value ?? null;
+  }
+  return wireEnv;
+};
+const resolveLauncherEnvironment = (options, effective) => toWireEnvironment({
+  GDK_BACKEND: resolveGdkBackend(effective),
+  GSETTINGS_BACKEND: options.gsettings === null ? void 0 : options.gsettings ?? defaultGSettings,
+  GTK_THEME: options.theme === null ? void 0 : options.theme ?? defaultTheme,
+  ...options.env
+});
+const resolveDriverPath = () => {
+  const driverPath = node_path.resolve(
+    node_path.dirname(node_url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("launchGtkApp-BIO_5Xjn.cjs", document.baseURI).href)),
+    "..",
+    "dist",
+    "gestament-launcher-driver.cjs"
+  );
+  if (!node_fs.existsSync(driverPath)) {
+    throw errors.createGtkOperationFailedError(
+      `Internal launcher driver was not found: ${driverPath}`
+    );
+  }
+  return driverPath;
+};
+const resolveXvfbPoolProbePath = () => {
+  const probePath = node_path.resolve(
+    node_path.dirname(node_url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("launchGtkApp-BIO_5Xjn.cjs", document.baseURI).href)),
+    "..",
+    "dist",
+    "gestament-xvfb-pool-probe.cjs"
+  );
+  if (!node_fs.existsSync(probePath)) {
+    throw errors.createGtkOperationFailedError(
+      `Internal Xvfb pool probe was not found: ${probePath}`
+    );
+  }
+  return probePath;
+};
+const createDriverEnvironment = (effective, xvfb) => {
+  const env = { ...process.env };
+  delete env.AT_SPI_BUS_ADDRESS;
+  delete env.NO_AT_BRIDGE;
+  if (effective.kind === "xvfb") {
+    env.GDK_BACKEND = "x11";
+    env.GESTAMENT_XVFB_ACTIVE = "1";
+    if (xvfb !== void 0) {
+      env.DISPLAY = xvfb.display;
+      delete env.XAUTHORITY;
+    }
+  }
+  return env;
+};
+const xvfbSocketPath = (displayNumber) => `/tmp/.X11-unix/X${displayNumber}`;
+const isDisplayNumberAvailable = (displayNumber) => !leasedDisplayNumbers.has(displayNumber) && !node_fs.existsSync(xvfbSocketPath(displayNumber));
+const connectUnixSocket = (path, timeoutMs) => new Promise((resolveConnect, rejectConnect) => {
+  const socket = node_net.createConnection(path);
+  let settled = false;
+  const settle = (callback) => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    clearTimeout(timeout);
+    socket.destroy();
+    callback();
+  };
+  const timeout = setTimeout(() => {
+    settle(() => {
+      rejectConnect(
+        errors.createGtkOperationFailedError(`Timed out connecting to ${path}.`)
+      );
+    });
+  }, timeoutMs);
+  socket.once("connect", () => {
+    settle(resolveConnect);
+  });
+  socket.once("error", (error) => {
+    settle(() => {
+      rejectConnect(error);
+    });
+  });
+});
+const waitForXvfbReady = async (displayNumber) => {
+  const startedAt = Date.now();
+  const path = xvfbSocketPath(displayNumber);
+  while (Date.now() - startedAt <= xvfbStartupTimeoutMs) {
+    if (node_fs.existsSync(path)) {
+      try {
+        await connectUnixSocket(path, 250);
+        return;
+      } catch {
+      }
+    }
+    await delay(25);
+  }
+  throw errors.createGtkOperationFailedError(
+    `Timed out waiting for Xvfb display :${displayNumber}.`
+  );
+};
+const killXvfbNow = (xvfb) => {
+  if (xvfb.child.exitCode === null && xvfb.child.signalCode === null) {
+    xvfb.child.kill("SIGTERM");
+  }
+};
+const installPoolCleanup = () => {
+  if (poolCleanupInstalled) {
+    return;
+  }
+  poolCleanupInstalled = true;
+  process.once("exit", () => {
+    for (const xvfb of directXvfbs) {
+      killXvfbNow(xvfb);
+    }
+  });
+};
+const spawnDirectXvfb = async (screen) => {
+  installPoolCleanup();
+  for (let displayNumber = firstPooledDisplayNumber; displayNumber <= lastPooledDisplayNumber; displayNumber += 1) {
+    if (!isDisplayNumberAvailable(displayNumber)) {
+      continue;
+    }
+    leasedDisplayNumbers.add(displayNumber);
+    const stdout = [];
+    const stderr = [];
+    const child = node_child_process.spawn(
+      "Xvfb",
+      [`:${displayNumber}`, "-screen", "0", screen, "-nolisten", "tcp"],
+      {
+        env: process.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    child.stdout.on("data", (chunk) => {
+      appendOutput$1(stdout, chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      appendOutput$1(stderr, chunk);
+    });
+    child.unref();
+    unrefHandle(child.stdout);
+    unrefHandle(child.stderr);
+    try {
+      await Promise.race([
+        waitForXvfbReady(displayNumber),
+        new Promise((_resolve, reject) => {
+          child.once("error", reject);
+        }),
+        new Promise((_resolve, reject) => {
+          child.once("exit", (code, signal) => {
+            reject(
+              errors.createGtkOperationFailedError(
+                `Xvfb exited before ready: code=${String(
+                  code
+                )}, signal=${String(signal)}` + formatOutputTail(stdout, stderr)
+              )
+            );
+          });
+        })
+      ]);
+      const xvfb = {
+        child,
+        display: `:${displayNumber}`,
+        displayNumber,
+        key: screen,
+        lastUsedAt: Date.now(),
+        screen,
+        stderr,
+        stdout
+      };
+      directXvfbs.add(xvfb);
+      return xvfb;
+    } catch (error) {
+      killXvfbNow({
+        child
+      });
+      leasedDisplayNumbers.delete(displayNumber);
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("ENOENT")) {
+        throw errors.createGtkOperationFailedError(
+          prerequisites.appendPrerequisiteInstallHint(`Failed to start Xvfb: ${message}`)
+        );
+      }
+    }
+  }
+  throw errors.createGtkOperationFailedError(
+    `Failed to allocate a pooled Xvfb display for screen ${screen}.`
+  );
+};
+const terminateXvfb = async (xvfb) => {
+  removeArrayEntry(idleXvfbByKey, xvfb.key, xvfb);
+  directXvfbs.delete(xvfb);
+  if (xvfb.child.exitCode === null && xvfb.child.signalCode === null) {
+    xvfb.child.kill("SIGTERM");
+    const startedAt = Date.now();
+    while (xvfb.child.exitCode === null && xvfb.child.signalCode === null) {
+      if (Date.now() - startedAt > sessionReleaseTimeoutMs) {
+        xvfb.child.kill("SIGKILL");
+        break;
+      }
+      await delay(25);
+    }
+  }
+  leasedDisplayNumbers.delete(xvfb.displayNumber);
+};
+const leaseXvfb = async (screen) => {
+  for (; ; ) {
+    const idle = popArrayEntry(idleXvfbByKey, screen);
+    if (idle === void 0) {
+      return spawnDirectXvfb(screen);
+    }
+    if (idle.child.exitCode === null && idle.child.signalCode === null) {
+      idle.lastUsedAt = Date.now();
+      return idle;
+    }
+    await terminateXvfb(idle);
+  }
+};
+const runXvfbProbe = (xvfb) => new Promise((resolveProbe, rejectProbe) => {
+  const probePath = resolveXvfbPoolProbePath();
+  const stdout = [];
+  const stderr = [];
+  const child = node_child_process.spawn(process.execPath, [probePath], {
+    env: {
+      ...process.env,
+      DISPLAY: xvfb.display,
+      GDK_BACKEND: "x11"
+    },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const timeout = setTimeout(() => {
+    child.kill("SIGKILL");
+    rejectProbe(
+      errors.createGtkOperationFailedError("Timed out probing Xvfb pool.")
+    );
+  }, xvfbPoolProbeTimeoutMs);
+  child.stdout.on("data", (chunk) => {
+    appendOutput$1(stdout, chunk);
+  });
+  child.stderr.on("data", (chunk) => {
+    appendOutput$1(stderr, chunk);
+  });
+  child.once("error", (error) => {
+    clearTimeout(timeout);
+    rejectProbe(error);
+  });
+  child.once("exit", (code, signal) => {
+    clearTimeout(timeout);
+    if (code !== 0) {
+      rejectProbe(
+        errors.createGtkOperationFailedError(
+          `Xvfb pool probe failed: code=${String(code)}, signal=${String(
+            signal
+          )}` + formatOutputTail(stdout, stderr)
+        )
+      );
+      return;
+    }
+    const output = stdout.join("").trim().split("\n").at(-1);
+    if (output === void 0 || output.length === 0) {
+      rejectProbe(
+        errors.createGtkOperationFailedError(
+          "Xvfb pool probe did not return a result." + formatOutputTail(stdout, stderr)
+        )
+      );
+      return;
+    }
+    try {
+      resolveProbe(JSON.parse(output));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      rejectProbe(
+        errors.createGtkOperationFailedError(
+          `Xvfb pool probe returned invalid JSON: ${message}` + formatOutputTail(stdout, stderr)
+        )
+      );
+    }
+  });
+});
+const cleanCheckXvfb = async (xvfb, allowedMappedWindowCount) => {
+  try {
+    const probe = await runXvfbProbe(xvfb);
+    return probe.mappedWindowCount <= allowedMappedWindowCount;
+  } catch {
+    return false;
+  }
+};
+const returnXvfbToPool = async (xvfb, limits) => {
+  const clean = await cleanCheckXvfb(xvfb, 0);
+  if (!clean) {
+    await terminateXvfb(xvfb);
+    return;
+  }
+  await retainIdleXvfb(xvfb, limits);
+};
+const allPoolKey = (xvfb) => `${xvfb.screen}
+${xvfb.trayHost ? "tray" : "no-tray"}`;
+const spawnDriverProcess = (driverPath, socketPath, effective, xvfb) => {
+  const driverArgs = [
+    "--socket",
+    socketPath,
+    ...effective.kind === "xvfb" && effective.xvfb?.trayHost === true ? ["--with-tray-host"] : []
+  ];
+  const env = createDriverEnvironment(effective, xvfb);
+  const stdout = [];
+  const stderr = [];
+  const command = effective.kind === "xvfb" && xvfb === void 0 ? {
+    args: [
+      "-a",
+      "-s",
+      `-screen 0 ${effective.xvfb?.screen ?? defaultXvfbScreen}`,
+      "--",
+      "dbus-run-session",
+      "--",
+      process.execPath,
+      driverPath,
+      ...driverArgs
+    ],
+    bin: "xvfb-run"
+  } : effective.kind === "xvfb" ? {
+    args: ["--", process.execPath, driverPath, ...driverArgs],
+    bin: "dbus-run-session"
+  } : {
+    args: [driverPath, ...driverArgs],
+    bin: process.execPath
+  };
+  const child = node_child_process.spawn(command.bin, command.args, {
+    env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  child.stdout.on("data", (chunk) => {
+    appendOutput$1(stdout, chunk);
+  });
+  child.stderr.on("data", (chunk) => {
+    appendOutput$1(stderr, chunk);
+  });
+  const commandLine = [command.bin, ...command.args].join(" ");
+  return { child, commandLine, stderr, stdout };
+};
+const listenOnSocket = (server, socketPath) => new Promise((resolveListen, rejectListen) => {
+  const rejectFromError = (error) => {
+    server.removeListener("listening", resolveFromListening);
+    rejectListen(error);
+  };
+  const resolveFromListening = () => {
+    server.removeListener("error", rejectFromError);
+    resolveListen();
+  };
+  server.once("error", rejectFromError);
+  server.once("listening", resolveFromListening);
+  server.listen(socketPath);
+});
+const parseReadyMessage = (line) => {
+  const value = JSON.parse(line);
+  if (typeof value === "object" && value !== null && !Array.isArray(value) && "type" in value && value.type === "ready") {
+    return value;
+  }
+  return void 0;
+};
+const waitForDriverReady = (server, processState) => new Promise((resolveReady, rejectReady) => {
+  let socket;
+  let input = "";
+  let settled = false;
+  const cleanup = () => {
+    clearTimeout(timeout);
+    server.removeListener("connection", acceptConnection);
+    server.removeListener("error", rejectFromError);
+    processState.child.removeListener("error", rejectFromError);
+    processState.child.removeListener("exit", rejectFromExit);
+    socket?.removeListener("data", readReadyData);
+    socket?.removeListener("error", rejectFromError);
+    socket?.removeListener("close", rejectFromSocketClose);
+  };
+  const rejectOnce = (error) => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    cleanup();
+    socket?.destroy();
+    rejectReady(error);
+  };
+  const rejectFromError = (error) => {
+    rejectOnce(
+      errors.createGtkOperationFailedError(
+        prerequisites.appendPrerequisiteInstallHint(
+          `Launcher driver failed to start: ${error.message}` + formatOutputTail(processState.stdout, processState.stderr)
+        )
+      )
+    );
+  };
+  const rejectFromExit = (code, signal) => {
+    rejectOnce(
+      errors.createGtkOperationFailedError(
+        prerequisites.appendPrerequisiteInstallHint(
+          `Launcher driver exited before ready: code=${String(
+            code
+          )}, signal=${String(signal)}` + formatOutputTail(processState.stdout, processState.stderr)
+        )
+      )
+    );
+  };
+  const rejectFromSocketClose = () => {
+    rejectOnce(
+      errors.createGtkOperationFailedError(
+        "Launcher driver socket closed before ready." + formatOutputTail(processState.stdout, processState.stderr)
+      )
+    );
+  };
+  const readReadyData = (chunk) => {
+    input += chunk.toString("utf8");
+    let newlineIndex = input.indexOf("\n");
+    while (newlineIndex >= 0) {
+      const line = input.slice(0, newlineIndex);
+      input = input.slice(newlineIndex + 1);
+      try {
+        if (parseReadyMessage(line) !== void 0) {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          cleanup();
+          if (socket === void 0) {
+            rejectReady(
+              errors.createGtkOperationFailedError(
+                "Launcher driver reported ready without a socket."
+              )
+            );
+            return;
+          }
+          resolveReady({ bufferedInput: input, socket });
+          return;
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        rejectOnce(
+          errors.createGtkOperationFailedError(
+            `Launcher driver sent invalid ready message: ${message}` + formatOutputTail(processState.stdout, processState.stderr)
+          )
+        );
+        return;
+      }
+      newlineIndex = input.indexOf("\n");
+    }
+  };
+  const acceptConnection = (acceptedSocket) => {
+    if (socket !== void 0) {
+      acceptedSocket.destroy();
+      return;
+    }
+    socket = acceptedSocket;
+    acceptedSocket.on("data", readReadyData);
+    acceptedSocket.once("error", rejectFromError);
+    acceptedSocket.once("close", rejectFromSocketClose);
+  };
+  const timeout = setTimeout(() => {
+    rejectOnce(
+      errors.createGtkOperationFailedError(
+        `Timed out waiting for launcher driver: ${processState.commandLine}` + formatOutputTail(processState.stdout, processState.stderr)
+      )
+    );
+  }, sessionStartupTimeoutMs);
+  server.on("connection", acceptConnection);
+  server.once("error", rejectFromError);
+  processState.child.once("error", rejectFromError);
+  processState.child.once("exit", rejectFromExit);
+});
+const serializeRequest = (id, command, payload) => {
+  const deadlineMs = wait.currentWaitDeadlineMs();
+  const request = deadlineMs === void 0 ? { command, id, payload } : { command, deadlineMs, id, payload };
+  return `${JSON.stringify(request)}
+`;
+};
+const reconstructDriverError = (error) => {
+  const reconstructed = new Error(error.message);
+  reconstructed.name = error.name;
+  if (error.stack !== void 0) {
+    reconstructed.stack = error.stack;
+  }
+  if (error.code !== void 0) {
+    Object.defineProperty(reconstructed, "code", {
+      enumerable: true,
+      value: error.code
+    });
+  }
+  return reconstructed;
+};
+const decodeCapture = (capture) => ({
+  bounds: capture.bounds,
+  clipped: capture.clipped,
+  image: Buffer.from(capture.imageBase64, "base64"),
+  visibleBounds: capture.visibleBounds
+});
+const createDriverSession = (socket, bufferedInput, processState, tempDirectory, poolOptions) => {
+  const pending = /* @__PURE__ */ new Map();
+  let input = bufferedInput;
+  let nextRequestId = 1;
+  let closed = false;
+  const rejectPending = (error) => {
+    const entries = [...pending.values()];
+    pending.clear();
+    for (const entry of entries) {
+      entry.reject(error);
+    }
+    socket.unref();
+  };
+  const markClosed = () => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    rejectPending(errors.createGtkAppExitedError("Launcher driver has exited."));
+  };
+  const handleResponse = (line) => {
+    const response = JSON.parse(line);
+    const entry = pending.get(response.id);
+    if (entry === void 0) {
+      return;
+    }
+    pending.delete(response.id);
+    if (pending.size === 0) {
+      socket.unref();
+    }
+    if (response.ok) {
+      entry.resolve(response.value);
+    } else {
+      entry.reject(
+        reconstructDriverError(response.error)
+      );
+    }
+  };
+  const readData = (chunk) => {
+    input += chunk.toString("utf8");
+    let newlineIndex = input.indexOf("\n");
+    while (newlineIndex >= 0) {
+      const line = input.slice(0, newlineIndex);
+      input = input.slice(newlineIndex + 1);
+      try {
+        handleResponse(line);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        rejectPending(
+          errors.createGtkOperationFailedError(
+            `Launcher driver sent an invalid response: ${message}`
+          )
+        );
+      }
+      newlineIndex = input.indexOf("\n");
+    }
+  };
+  socket.on("data", readData);
+  socket.once("close", markClosed);
+  socket.once("error", markClosed);
+  processState.child.once("exit", markClosed);
+  processState.child.unref();
+  unrefHandle(processState.child.stdout);
+  unrefHandle(processState.child.stderr);
+  socket.unref();
+  const request = (command, payload) => {
+    if (closed) {
+      return Promise.reject(
+        errors.createGtkAppExitedError("Launcher driver has exited.")
+      );
+    }
+    const id = nextRequestId;
+    nextRequestId += 1;
+    socket.ref();
+    return new Promise((resolveRequest, rejectRequest) => {
+      pending.set(id, {
+        reject: rejectRequest,
+        resolve: (value) => {
+          resolveRequest(value);
+        }
+      });
+      socket.write(serializeRequest(id, command, payload), (error) => {
+        if (error != null) {
+          pending.delete(id);
+          if (pending.size === 0) {
+            socket.unref();
+          }
+          rejectRequest(
+            errors.createGtkOperationFailedError(
+              `Failed to write launcher driver request: ${error.message}`
+            )
+          );
+        }
+      });
+    });
+  };
+  const waitForExit = async () => {
+    const startedAt = Date.now();
+    while (processState.child.exitCode === null && processState.child.signalCode === null) {
+      if (Date.now() - startedAt > sessionReleaseTimeoutMs) {
+        processState.child.kill("SIGKILL");
+        break;
+      }
+      await delay(25);
+    }
+  };
+  const closeDriver = async () => {
+    if (!closed) {
+      try {
+        await request("launcher.release", null);
+      } catch (error) {
+        if (!closed) {
+          throw error;
+        }
+      }
+    }
+    closed = true;
+    socket.destroy();
+    await waitForExit();
+    node_fs.rmSync(tempDirectory, { force: true, recursive: true });
+  };
+  const terminate = async () => {
+    try {
+      await closeDriver();
+    } finally {
+      if (poolOptions.xvfb !== void 0) {
+        await terminateXvfb(poolOptions.xvfb);
+      }
+    }
+  };
+  let session;
+  const release = async () => {
+    if (poolOptions.mode === "none") {
+      await closeDriver();
+      return;
+    }
+    if (poolOptions.mode === "xvfb") {
+      try {
+        await closeDriver();
+      } catch (error) {
+        if (poolOptions.xvfb !== void 0) {
+          await terminateXvfb(poolOptions.xvfb);
+        }
+        throw error;
+      }
+      if (poolOptions.xvfb !== void 0) {
+        await returnXvfbToPool(poolOptions.xvfb, poolOptions.limits);
+      }
+      return;
+    }
+    if (poolOptions.xvfb === void 0 || poolOptions.allKey === void 0) {
+      await terminate();
+      return;
+    }
+    let resetResult;
+    try {
+      resetResult = await request("launcher.reset", null);
+    } catch (error) {
+      await terminate().catch(() => void 0);
+      throw error;
+    }
+    const tablesAreEmpty = resetResult.appCount === 0 && resetResult.elementCount === 0 && resetResult.imageInfoCount === 0 && resetResult.trayItemCount === 0;
+    const clean = tablesAreEmpty && await cleanCheckXvfb(
+      poolOptions.xvfb,
+      poolOptions.allowedMappedWindowCount
+    );
+    if (!clean) {
+      await terminate();
+      return;
+    }
+    await retainIdleAllSession(
+      {
+        key: poolOptions.allKey,
+        lastUsedAt: Date.now(),
+        session,
+        xvfb: poolOptions.xvfb
+      },
+      poolOptions.limits
+    );
+  };
+  session = { release, request, terminate };
+  return session;
+};
+const startFreshDriverSession = async (effective, xvfb, poolOptions) => {
+  const driverPath = resolveDriverPath();
+  const tempDirectory = node_fs.mkdtempSync(
+    node_path.join(node_os.tmpdir(), `gestament-launcher-${process.pid}-${socketCounter}-`)
+  );
+  socketCounter += 1;
+  const socketPath = node_path.join(tempDirectory, "driver.sock");
+  const server = node_net.createServer();
+  let processState;
+  try {
+    await listenOnSocket(server, socketPath);
+    server.unref();
+    processState = spawnDriverProcess(driverPath, socketPath, effective, xvfb);
+    const connection = await waitForDriverReady(server, processState);
+    server.close();
+    const resolvedPoolOptions = poolOptions.mode === "all" && xvfb !== void 0 ? {
+      ...poolOptions,
+      allowedMappedWindowCount: (await runXvfbProbe(xvfb)).mappedWindowCount
+    } : poolOptions;
+    return createDriverSession(
+      connection.socket,
+      connection.bufferedInput,
+      processState,
+      tempDirectory,
+      resolvedPoolOptions
+    );
+  } catch (error) {
+    server.close();
+    if (processState !== void 0 && processState.child.exitCode === null && processState.child.signalCode === null) {
+      processState.child.kill("SIGTERM");
+    }
+    if (xvfb !== void 0) {
+      await terminateXvfb(xvfb);
+    }
+    node_fs.rmSync(tempDirectory, { force: true, recursive: true });
+    throw error;
+  }
+};
+const startDriverSession = async (options) => {
+  const display = resolveDisplay(options.display);
+  const xvfbOptions = resolveXvfbOptions(options);
+  const effective = resolveEffectiveDisplay(display, xvfbOptions);
+  if (effective.kind !== "xvfb" || effective.xvfb === void 0) {
+    return startFreshDriverSession(
+      effective,
+      void 0,
+      emptyDriverSessionPoolOptions()
+    );
+  }
+  const pool = effective.xvfb.pool;
+  if (pool === void 0) {
+    return startFreshDriverSession(
+      effective,
+      void 0,
+      emptyDriverSessionPoolOptions()
+    );
+  }
+  if (pool.type === "xvfb") {
+    const xvfb2 = await leaseXvfb(effective.xvfb.screen);
+    return startFreshDriverSession(effective, xvfb2, {
+      allKey: void 0,
+      allowedMappedWindowCount: 0,
+      limits: poolLimits(pool),
+      mode: "xvfb",
+      xvfb: xvfb2
+    });
+  }
+  const key = allPoolKey(effective.xvfb);
+  for (; ; ) {
+    const idle = popArrayEntry(idleAllByKey, key);
+    if (idle === void 0) {
+      break;
+    }
+    if (idle.xvfb.child.exitCode === null && idle.xvfb.child.signalCode === null) {
+      idle.lastUsedAt = Date.now();
+      idle.xvfb.lastUsedAt = idle.lastUsedAt;
+      return idle.session;
+    }
+    await idle.session.terminate().catch(() => void 0);
+  }
+  const xvfb = await leaseXvfb(effective.xvfb.screen);
+  return startFreshDriverSession(effective, xvfb, {
+    allKey: key,
+    allowedMappedWindowCount: 0,
+    limits: poolLimits(pool),
+    mode: "all",
+    xvfb
+  });
+};
+const createLaunchPayload = (options, args) => {
+  const display = resolveDisplay(options.display);
+  const xvfb = resolveXvfbOptions(options);
+  const effective = resolveEffectiveDisplay(display, xvfb);
+  return {
+    appPath: options.appPath,
+    args: [...options.args ?? [], ...args],
+    env: resolveLauncherEnvironment(options, effective),
+    timeoutMs: options.timeoutMs ?? null
+  };
+};
+const elementRefToProxy = (session, ref) => ref === null ? void 0 : createProxyGtkElement(session, ref);
+const trayRefToProxy = (session, ref) => ref === null ? void 0 : createProxyGtkTrayItem(session, ref);
+const createProxyGtkApp = (session, ref) => {
+  let released = false;
+  const assertNotReleased = () => {
+    if (released) {
+      throw errors.createGtkAppExitedError("GTK application has been released.");
+    }
+  };
+  const appRequest = (command, payload = {}) => {
+    assertNotReleased();
+    return session.request(command, {
+      appId: ref.appId,
+      ...payload
+    });
+  };
+  const release = async () => {
+    if (released) {
+      return;
+    }
+    released = true;
+    await session.request("app.release", { appId: ref.appId });
+  };
+  const app = {
+    capture: async () => decodeCapture(await appRequest("app.capture")),
+    findById: async (id) => elementRefToProxy(
+      session,
+      await appRequest("app.findById", { id })
+    ),
+    getById: async (id) => createProxyGtkElement(
+      session,
+      await appRequest("app.getById", { id })
+    ),
+    findByPath: async (path) => elementRefToProxy(
+      session,
+      await appRequest("app.findByPath", { path })
+    ),
+    getByPath: async (path) => createProxyGtkElement(
+      session,
+      await appRequest("app.getByPath", { path })
+    ),
+    windowAt: async (index) => elementRefToProxy(
+      session,
+      await appRequest("app.windowAt", { index })
+    ),
+    getWindowCount: () => appRequest("app.getWindowCount"),
+    findTrayItem: async (selector) => trayRefToProxy(
+      session,
+      await appRequest("app.findTrayItem", {
+        selector
+      })
+    ),
+    getTrayItem: async (selector) => createProxyGtkTrayItem(
+      session,
+      await appRequest("app.getTrayItem", { selector })
+    ),
+    trayItemAt: async (index) => trayRefToProxy(
+      session,
+      await appRequest("app.trayItemAt", {
+        index
+      })
+    ),
+    getTrayItemCount: () => appRequest("app.getTrayItemCount"),
+    release,
+    [Symbol.asyncDispose]: release
+  };
+  return app;
+};
+const addChildContainerProxyOperations = (session, elementId, target) => {
+  target.childAt = async (index) => elementRefToProxy(
+    session,
+    await session.request("element.childAt", {
+      elementId,
+      index
+    })
+  );
+  target.getChildCount = () => session.request("element.getChildCount", { elementId });
+};
+const addSelectableChildContainerProxyOperations = (session, elementId, target) => {
+  addChildContainerProxyOperations(session, elementId, target);
+  target.getSelectedChildCount = () => session.request("element.getSelectedChildCount", { elementId });
+  target.selectedChildAt = async (selectedIndex) => elementRefToProxy(
+    session,
+    await session.request(
+      "element.selectedChildAt",
+      {
+        elementId,
+        selectedIndex
+      }
+    )
+  );
+  target.isChildSelected = (index) => session.request("element.isChildSelected", { elementId, index });
+  target.selectChildAt = (index) => session.request("element.selectChildAt", { elementId, index }).then(() => void 0);
+  target.deselectChildAt = (index) => session.request("element.deselectChildAt", { elementId, index }).then(() => void 0);
+  target.selectAllChildren = () => session.request("element.selectAllChildren", { elementId }).then(() => void 0);
+  target.clearSelection = () => session.request("element.clearSelection", { elementId }).then(() => void 0);
+};
+const addClickableProxyOperation = (session, elementId, target) => {
+  target.click = () => session.request("element.click", { elementId }).then(() => void 0);
+};
+const addCheckableProxyOperations = (session, elementId, target) => {
+  target.isChecked = () => session.request("element.isChecked", { elementId });
+  target.toggle = () => session.request("element.toggle", { elementId }).then(() => void 0);
+};
+const addTextProxyOperation = (session, elementId, target) => {
+  target.text = () => session.request("element.text", { elementId });
+};
+const addValueProxyOperations = (session, elementId, target, writable) => {
+  target.value = () => session.request("element.value", { elementId });
+  target.valueInfo = () => session.request("element.valueInfo", { elementId });
+  if (writable) {
+    target.setValue = (value) => session.request("element.setValue", { elementId, value }).then(() => void 0);
+  }
+};
+const createProxyImageInfo = (session, info) => ({
+  bounds: info.bounds,
+  capture: async () => decodeCapture(
+    await session.request("imageInfo.capture", {
+      imageInfoId: info.imageInfoId
+    })
+  ),
+  description: info.description,
+  locale: info.locale,
+  position: info.position,
+  size: info.size
+});
+const createProxyGtkElement = (session, ref) => {
+  const elementId = ref.elementId;
+  const target = {
+    capture: async () => decodeCapture(
+      await session.request("element.capture", { elementId })
+    ),
+    info: () => session.request("element.info", { elementId }),
+    kind: ref.kind
+  };
+  switch (ref.kind) {
+    case "window":
+    case "container":
+    case "menu":
+      addChildContainerProxyOperations(session, elementId, target);
+      break;
+    case "button":
+    case "listItem":
+    case "menuItem":
+      addClickableProxyOperation(session, elementId, target);
+      break;
+    case "label":
+    case "text":
+      addTextProxyOperation(session, elementId, target);
+      break;
+    case "entry":
+      addTextProxyOperation(session, elementId, target);
+      target.setText = (text) => session.request("element.setText", { elementId, text }).then(() => void 0);
+      break;
+    case "checkbox":
+    case "switch":
+    case "radio":
+    case "toggleButton":
+      addClickableProxyOperation(session, elementId, target);
+      addCheckableProxyOperations(session, elementId, target);
+      break;
+    case "slider":
+      addValueProxyOperations(session, elementId, target, true);
+      break;
+    case "spinButton":
+      addValueProxyOperations(session, elementId, target, true);
+      target.increment = () => session.request("element.increment", { elementId }).then(() => void 0);
+      target.decrement = () => session.request("element.decrement", { elementId }).then(() => void 0);
+      break;
+    case "progressBar":
+      addValueProxyOperations(session, elementId, target, false);
+      break;
+    case "comboBox":
+      addClickableProxyOperation(session, elementId, target);
+      addSelectableChildContainerProxyOperations(session, elementId, target);
+      break;
+    case "list":
+      addSelectableChildContainerProxyOperations(session, elementId, target);
+      break;
+    case "table":
+      target.getRowCount = () => session.request("element.getRowCount", { elementId });
+      target.getColumnCount = () => session.request("element.getColumnCount", { elementId });
+      target.cellAt = async (row, column) => elementRefToProxy(
+        session,
+        await session.request("element.cellAt", {
+          column,
+          elementId,
+          row
+        })
+      );
+      target.selectedRows = () => session.request("element.selectedRows", {
+        elementId
+      });
+      target.selectedColumns = () => session.request("element.selectedColumns", {
+        elementId
+      });
+      target.isRowSelected = (row) => session.request("element.isRowSelected", { elementId, row });
+      target.isColumnSelected = (column) => session.request("element.isColumnSelected", {
+        column,
+        elementId
+      });
+      target.isCellSelected = (row, column) => session.request("element.isCellSelected", {
+        column,
+        elementId,
+        row
+      });
+      target.selectRow = (row) => session.request("element.selectRow", { elementId, row }).then(() => void 0);
+      target.deselectRow = (row) => session.request("element.deselectRow", { elementId, row }).then(() => void 0);
+      target.selectColumn = (column) => session.request("element.selectColumn", { column, elementId }).then(() => void 0);
+      target.deselectColumn = (column) => session.request("element.deselectColumn", { column, elementId }).then(() => void 0);
+      break;
+    case "image":
+      target.imageInfo = async () => createProxyImageInfo(
+        session,
+        await session.request("element.imageInfo", {
+          elementId
+        })
+      );
+      break;
+  }
+  return target;
+};
+const createProxyGtkTrayItem = (session, ref) => {
+  const trayItemId = ref.trayItemId;
+  return {
+    capture: async () => decodeCapture(
+      await session.request("tray.capture", { trayItemId })
+    ),
+    click: () => session.request("tray.click", { trayItemId }).then(() => void 0),
+    element: async () => elementRefToProxy(
+      session,
+      await session.request("tray.element", {
+        trayItemId
+      })
+    ),
+    metadata: () => session.request("tray.metadata", { trayItemId }),
+    openMenu: async () => elementRefToProxy(
+      session,
+      await session.request("tray.openMenu", {
+        trayItemId
+      })
+    )
+  };
+};
+const createDriverBackedGtkAppLauncher = (options) => {
+  let sessionPromise;
+  const ensureSession = () => {
+    sessionPromise ??= startDriverSession(options);
+    return sessionPromise;
+  };
+  const launch = async (args) => {
+    const session = await ensureSession();
+    const appRef = await session.request(
+      "launcher.launch",
+      createLaunchPayload(options, args ?? [])
+    );
+    return createProxyGtkApp(session, appRef);
+  };
+  const release = async () => {
+    const releasingSession = sessionPromise;
+    sessionPromise = void 0;
+    if (releasingSession === void 0) {
+      return;
+    }
+    const session = await releasingSession;
+    await session.release();
+  };
+  return {
+    launch,
+    release,
+    [Symbol.asyncDispose]: release
+  };
+};
+const assertNonNegativeIndex$1 = (name, index) => {
+  if (!Number.isInteger(index) || index < 0) {
+    throw errors.createGtkInvalidArgumentError(
+      `${name} must be a non-negative integer.`
+    );
+  }
+};
+const assertFiniteNumber = (name, value) => {
+  if (!Number.isFinite(value)) {
+    throw errors.createGtkInvalidArgumentError(`${name} must be a finite number.`);
+  }
+};
+const normalizeRoleName = (roleName) => roleName.trim().toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ");
+const hasInterface = (info, name) => info.interfaces.some(
+  (interfaceName) => interfaceName.toLowerCase() === name.toLowerCase()
+);
+const hasState = (info, name) => info.states.some((state) => state.toLowerCase() === name.toLowerCase());
+const elementInfoOverrides = /* @__PURE__ */ new WeakMap();
+const overrideElementInfo = (handle, override) => {
+  elementInfoOverrides.set(handle, override);
+  return handle;
+};
+const nativeInfoKind = (handle) => elementInfoOverrides.get(handle)?.kind ?? widgetKindFromInfo(native.nativeElementInfo(handle));
+const widgetKindFromInfo = (info) => {
+  const roleName = normalizeRoleName(info.roleName);
+  if (hasInterface(info, "TableCell")) {
+    return "tableCell";
+  }
+  switch (roleName) {
+    case "frame":
+    case "dialog":
+    case "window":
+      return "window";
+    case "filler":
+    case "panel":
+    case "scroll pane":
+    case "layered pane":
+    case "split pane":
+    case "viewport":
+      return "container";
+    case "button":
+    case "push button":
+    case "push button menu":
+      return "button";
+    case "label":
+    case "static":
+      return "label";
+    case "entry":
+    case "password text":
+    case "search box":
+      return "entry";
+    case "text":
+      return hasInterface(info, "EditableText") || hasState(info, "editable") || hasState(info, "singleLine") ? "entry" : "text";
+    case "paragraph":
+      return "text";
+    case "check box":
+      return "checkbox";
+    case "switch":
+      return "switch";
+    case "radio button":
+      return "radio";
+    case "toggle button":
+      return hasInterface(info, "Image") || info.name.length > 0 ? "toggleButton" : "switch";
+    case "slider":
+      return "slider";
+    case "spin button":
+      return "spinButton";
+    case "progress bar":
+    case "level bar":
+      return "progressBar";
+    case "combo box":
+      return "comboBox";
+    case "list":
+    case "list box":
+      return "list";
+    case "tree":
+      return hasInterface(info, "Table") ? "table" : "list";
+    case "list item":
+    case "tree item":
+      return "listItem";
+    case "table":
+    case "tree table":
+      return "table";
+    case "table cell":
+      return "tableCell";
+    case "image":
+    case "icon":
+      return "image";
+    case "menu":
+    case "menu bar":
+    case "popup menu":
+      return "menu";
+    case "menu item":
+    case "check menu item":
+    case "radio menu item":
+    case "tearoff menu item":
+      return "menuItem";
+    default:
+      return "unknown";
+  }
+};
+const toGtkElementInfo = (info) => ({
+  ...info,
+  kind: widgetKindFromInfo(info)
+});
+const toGtkElementInfoForHandle = (handle) => {
+  const info = toGtkElementInfo(native.nativeElementInfo(handle));
+  const override = elementInfoOverrides.get(handle);
+  return override === void 0 ? info : { ...info, ...override };
+};
+const createCommonElement = (handle) => ({
+  info: async () => toGtkElementInfoForHandle(handle),
+  capture: async () => native.nativeCapture(handle)
+});
+const expectedKindLabel = (expectedKinds) => expectedKinds.join(", ");
+const assertExpectedKind = (element, expectedKinds, operation) => {
+  if (!expectedKinds.includes(element.kind)) {
+    throw errors.createGtkUnsupportedInterfaceError(
+      `${operation} returned ${element.kind}, expected ${expectedKindLabel(
+        expectedKinds
+      )}.`
+    );
+  }
+  return element;
+};
+const createGetChildCountOperation = (handle) => async () => native.nativeChildCount(handle);
+const createChildAtOperation = (handle, expectedKinds) => async (index) => {
+  assertNonNegativeIndex$1("index", index);
+  const childHandle = native.nativeChildAt(handle, index);
+  if (childHandle === void 0) {
+    return void 0;
+  }
+  const child = createGtkElement(childHandle);
+  return expectedKinds === void 0 ? child : assertExpectedKind(child, expectedKinds, "childAt()");
+};
+const createChildContainerOperations = (handle, expectedKinds) => ({
+  childAt: createChildAtOperation(handle, expectedKinds),
+  getChildCount: createGetChildCountOperation(handle)
+});
+const createSelectableChildContainerOperations = (handle, expectedKinds) => ({
+  ...createChildContainerOperations(handle, expectedKinds),
+  getSelectedChildCount: async () => native.nativeSelectedChildCount(handle),
+  selectedChildAt: async (selectedIndex) => {
+    assertNonNegativeIndex$1("selectedIndex", selectedIndex);
+    const childHandle = native.nativeSelectedChildAt(handle, selectedIndex);
+    if (childHandle === void 0) {
+      return void 0;
+    }
+    const child = createGtkElement(childHandle);
+    return assertExpectedKind(child, expectedKinds, "selectedChildAt()");
+  },
+  isChildSelected: async (index) => {
+    assertNonNegativeIndex$1("index", index);
+    return native.nativeIsChildSelected(handle, index);
+  },
+  selectChildAt: async (index) => {
+    assertNonNegativeIndex$1("index", index);
+    native.nativeSelectChildAt(handle, index);
+  },
+  deselectChildAt: async (index) => {
+    assertNonNegativeIndex$1("index", index);
+    native.nativeDeselectChildAt(handle, index);
+  },
+  selectAllChildren: async () => {
+    native.nativeSelectAllChildren(handle);
+  },
+  clearSelection: async () => {
+    native.nativeClearSelection(handle);
+  }
+});
+const createOperationFailedForOutOfRangeIndex = (index) => errors.createGtkOperationFailedError(`Child index is out of range: ${index}`);
+const isUnsupportedInterfaceError = (error) => error.code === "UNSUPPORTED_INTERFACE";
+const visitNativeDescendants = (handle, visitor, maxNodes) => {
+  const queue = [];
+  const childCount = native.nativeChildCount(handle);
+  for (let index = 0; index < childCount; index += 1) {
+    const childHandle = native.nativeChildAt(handle, index);
+    if (childHandle !== void 0) {
+      queue.push(childHandle);
+    }
+  }
+  let visitedNodes = 0;
+  while (queue.length > 0 && visitedNodes < maxNodes) {
+    const currentHandle = queue.shift();
+    visitedNodes += 1;
+    if (visitor(currentHandle)) {
+      return;
+    }
+    const currentChildCount = native.nativeChildCount(currentHandle);
+    for (let index = 0; index < currentChildCount; index += 1) {
+      const childHandle = native.nativeChildAt(currentHandle, index);
+      if (childHandle !== void 0) {
+        queue.push(childHandle);
+      }
+    }
+  }
+};
+const findFirstDescendantName = (handle) => {
+  let foundName;
+  visitNativeDescendants(
+    handle,
+    (descendantHandle) => {
+      const name = native.nativeElementInfo(descendantHandle).name;
+      if (name.length === 0) {
+        return false;
+      }
+      foundName = name;
+      return true;
+    },
+    64
+  );
+  return foundName;
+};
+const directChildKindAt = (handle, index) => {
+  const childHandle = native.nativeChildAt(handle, index);
+  return childHandle === void 0 ? void 0 : nativeInfoKind(childHandle);
+};
+const handleContainsComboItems = (handle) => {
+  const childCount = native.nativeChildCount(handle);
+  if (childCount === 0) {
+    return false;
+  }
+  const firstChildKind = directChildKindAt(handle, 0);
+  return firstChildKind === "listItem" || firstChildKind === "menuItem";
+};
+const findComboBoxItemContainerHandle = (handle) => {
+  if (handleContainsComboItems(handle)) {
+    return handle;
+  }
+  let foundHandle;
+  visitNativeDescendants(
+    handle,
+    (descendantHandle) => {
+      const kind = nativeInfoKind(descendantHandle);
+      if ((kind === "list" || kind === "menu") && handleContainsComboItems(descendantHandle)) {
+        foundHandle = descendantHandle;
+        return true;
+      }
+      return false;
+    },
+    128
+  );
+  return foundHandle;
+};
+const resolveComboBoxItemContainerHandle = (handle) => {
+  const descendantItemContainer = findComboBoxItemContainerHandle(handle);
+  if (descendantItemContainer !== void 0) {
+    return descendantItemContainer;
+  }
+  const childCount = native.nativeChildCount(handle);
+  if (childCount !== 1) {
+    return handle;
+  }
+  const childHandle = native.nativeChildAt(handle, 0);
+  if (childHandle === void 0) {
+    return handle;
+  }
+  const childKind = nativeInfoKind(childHandle);
+  return childKind === "menu" || childKind === "list" ? childHandle : handle;
+};
+const comboBoxClickTargetHandle = (handle) => {
+  const childHandle = native.nativeChildAt(handle, 0);
+  if (childHandle === void 0) {
+    return handle;
+  }
+  const childKind = nativeInfoKind(childHandle);
+  return childKind === "button" || childKind === "toggleButton" ? childHandle : handle;
+};
+const overrideComboBoxItemInfo = (handle) => {
+  const info = native.nativeElementInfo(handle);
+  if (info.name.length > 0) {
+    return handle;
+  }
+  const descendantName = findFirstDescendantName(handle);
+  return descendantName === void 0 ? handle : overrideElementInfo(handle, { name: descendantName });
+};
+const itemIdentityMatches = (candidate, selected) => {
+  if (candidate.accessibleId.length > 0 && selected.accessibleId.length > 0) {
+    return candidate.accessibleId === selected.accessibleId;
+  }
+  return candidate.kind === selected.kind && candidate.roleName === selected.roleName && candidate.name === selected.name && candidate.description === selected.description;
+};
+const comboBoxItemLookupAt = (handle, index) => {
+  const itemContainerHandle = resolveComboBoxItemContainerHandle(handle);
+  const itemHandle = native.nativeChildAt(itemContainerHandle, index);
+  if (itemHandle === void 0) {
+    throw createOperationFailedForOutOfRangeIndex(index);
+  }
+  const itemKind = nativeInfoKind(itemHandle);
+  if (itemKind !== "listItem" && itemKind !== "menuItem") {
+    throw errors.createGtkUnsupportedInterfaceError(
+      `ComboBox childAt() returned ${itemKind}, expected listItem, menuItem.`
+    );
+  }
+  return {
+    itemContainerHandle,
+    itemHandle: overrideComboBoxItemInfo(itemHandle)
+  };
+};
+const comboBoxItemHandleAt = (handle, index) => comboBoxItemLookupAt(handle, index).itemHandle;
+const createComboBoxOperations = (handle) => ({
+  childAt: async (index) => {
+    assertNonNegativeIndex$1("index", index);
+    const itemContainerHandle = resolveComboBoxItemContainerHandle(handle);
+    const itemHandle = native.nativeChildAt(itemContainerHandle, index);
+    if (itemHandle === void 0) {
+      return void 0;
+    }
+    overrideComboBoxItemInfo(itemHandle);
+    return assertExpectedKind(
+      createGtkElement(itemHandle),
+      ["listItem", "menuItem"],
+      "childAt()"
+    );
+  },
+  getChildCount: async () => native.nativeChildCount(resolveComboBoxItemContainerHandle(handle)),
+  getSelectedChildCount: async () => native.nativeSelectedChildCount(handle),
+  selectedChildAt: async (selectedIndex) => {
+    assertNonNegativeIndex$1("selectedIndex", selectedIndex);
+    const childHandle = native.nativeSelectedChildAt(handle, selectedIndex);
+    if (childHandle === void 0) {
+      return void 0;
+    }
+    return assertExpectedKind(
+      createGtkElement(childHandle),
+      ["listItem", "menuItem"],
+      "selectedChildAt()"
+    );
+  },
+  isChildSelected: async (index) => {
+    assertNonNegativeIndex$1("index", index);
+    const itemHandle = comboBoxItemHandleAt(handle, index);
+    const itemInfo = toGtkElementInfoForHandle(itemHandle);
+    const selectedCount = native.nativeSelectedChildCount(handle);
+    for (let selectedIndex = 0; selectedIndex < selectedCount; selectedIndex += 1) {
+      const selectedHandle = native.nativeSelectedChildAt(handle, selectedIndex);
+      if (selectedHandle === void 0) {
+        continue;
+      }
+      const selectedInfo = toGtkElementInfo(native.nativeElementInfo(selectedHandle));
+      if (itemIdentityMatches(itemInfo, selectedInfo)) {
+        return true;
+      }
+    }
+    return false;
+  },
+  selectChildAt: async (index) => {
+    assertNonNegativeIndex$1("index", index);
+    const { itemContainerHandle, itemHandle } = comboBoxItemLookupAt(
+      handle,
+      index
+    );
+    const expectedName = toGtkElementInfoForHandle(itemHandle).name;
+    native.nativeClick(itemHandle);
+    if (itemContainerHandle !== handle && expectedName.length > 0 && native.nativeElementInfo(handle).name !== expectedName) {
+      throw errors.createGtkOperationFailedError(
+        "ComboBox child selection did not change the selected item."
+      );
+    }
+  },
+  deselectChildAt: async (index) => {
+    assertNonNegativeIndex$1("index", index);
+    comboBoxItemHandleAt(handle, index);
+    native.nativeDeselectChildAt(handle, 0);
+  },
+  selectAllChildren: async () => {
+    native.nativeSelectAllChildren(handle);
+  },
+  clearSelection: async () => {
+    const selectedBefore = native.nativeSelectedChildCount(handle);
+    native.nativeClearSelection(handle);
+    if (selectedBefore > 0 && native.nativeSelectedChildCount(handle) > 0) {
+      throw errors.createGtkOperationFailedError(
+        "ComboBox selection could not be cleared."
+      );
+    }
+  }
+});
+const createSetTextOperation = (handle) => async (text) => {
+  native.nativeSetText(handle, text);
+};
+const createClickOperation = (handle) => async () => {
+  native.nativeClick(handle);
+};
+const createComboBoxClickOperation = (handle) => async () => {
+  native.nativeClick(comboBoxClickTargetHandle(handle));
+};
+const createTextOperation = (handle) => async () => native.nativeText(handle);
+const createIsCheckedOperation = (handle) => async () => {
+  const info = native.nativeElementInfo(handle);
+  return hasState(info, "checked") || hasState(info, "pressed");
+};
+const createToggleOperation = (handle) => async () => {
+  native.nativeClick(handle);
+};
+const createValueInfoOperation = (handle) => async () => native.nativeValueInfo(handle);
+const createImageInfoOperation = (handle) => async () => {
+  const info = native.nativeImageInfo(handle);
+  return {
+    ...info,
+    capture: async () => native.nativeCaptureBounds(info.bounds)
+  };
+};
+const createValueOperation = (handle) => async () => native.nativeValueInfo(handle).value;
+const createSetValueOperation = (handle) => async (value) => {
+  assertFiniteNumber("value", value);
+  native.nativeSetValue(handle, value);
+};
+const assertUsableValueMetadata = (info) => {
+  if (!Number.isFinite(info.value) || !Number.isFinite(info.minimum) || !Number.isFinite(info.maximum) || !Number.isFinite(info.minimumIncrement)) {
+    throw errors.createGtkOperationFailedError(
+      "Accessible value metadata does not contain usable numeric values."
+    );
+  }
+};
+const valueStep = (info) => {
+  assertUsableValueMetadata(info);
+  if (info.minimumIncrement > 0) {
+    return info.minimumIncrement;
+  }
+  const range = info.maximum - info.minimum;
+  if (!Number.isFinite(range) || range <= 0) {
+    throw errors.createGtkOperationFailedError(
+      "Accessible value metadata does not contain a usable increment."
+    );
+  }
+  return Math.min(1, range);
+};
+const clampedValue = (value, minimum, maximum) => Math.min(Math.max(value, minimum), maximum);
+const createIncrementOperation = (handle) => async () => {
+  const info = native.nativeValueInfo(handle);
+  const step = valueStep(info);
+  native.nativeSetValue(
+    handle,
+    clampedValue(info.value + step, info.minimum, info.maximum)
+  );
+};
+const createDecrementOperation = (handle) => async () => {
+  const info = native.nativeValueInfo(handle);
+  const step = valueStep(info);
+  native.nativeSetValue(
+    handle,
+    clampedValue(info.value - step, info.minimum, info.maximum)
+  );
+};
+const collectDirectTableCellChildren = (rowHandle) => {
+  const cells = [];
+  const childCount = native.nativeChildCount(rowHandle);
+  for (let index = 0; index < childCount; index += 1) {
+    const childHandle = native.nativeChildAt(rowHandle, index);
+    if (childHandle !== void 0 && nativeInfoKind(childHandle) === "tableCell") {
+      cells.push(childHandle);
+    }
+  }
+  return cells;
+};
+const collectFallbackTableRows = (handle) => {
+  const rows = [];
+  visitNativeDescendants(
+    handle,
+    (descendantHandle) => {
+      const roleName = normalizeRoleName(
+        native.nativeElementInfo(descendantHandle).roleName
+      );
+      if (roleName !== "table row") {
+        return false;
+      }
+      const cells = collectDirectTableCellChildren(descendantHandle);
+      if (cells.length > 0) {
+        rows.push(
+          cells.map(
+            (cellHandle) => overrideElementInfo(cellHandle, { kind: "tableCell" })
+          )
+        );
+      }
+      return false;
+    },
+    512
+  );
+  return rows;
+};
+const fallbackTableRowCount = (handle) => collectFallbackTableRows(handle).length;
+const fallbackTableColumnCount = (handle) => {
+  const rows = collectFallbackTableRows(handle);
+  return rows.reduce((max, row) => Math.max(max, row.length), 0);
+};
+const fallbackTableCellAt = (handle, row, column) => {
+  const rows = collectFallbackTableRows(handle);
+  return rows[row]?.[column];
+};
+const createTableCellAtOperation = (handle) => async (row, column) => {
+  assertNonNegativeIndex$1("row", row);
+  assertNonNegativeIndex$1("column", column);
+  let cellHandle;
+  try {
+    cellHandle = native.nativeTableCellAt(handle, row, column);
+  } catch (error) {
+    if (!isUnsupportedInterfaceError(error)) {
+      throw error;
+    }
+    cellHandle = fallbackTableCellAt(handle, row, column);
+  }
+  if (cellHandle === void 0) {
+    return void 0;
+  }
+  overrideElementInfo(cellHandle, { kind: "tableCell" });
+  return assertExpectedKind(
+    createGtkElement(cellHandle),
+    ["tableCell"],
+    "cellAt()"
+  );
+};
+const createTableOperations = (handle) => ({
+  getRowCount: async () => {
+    try {
+      return native.nativeTableRowCount(handle);
+    } catch (error) {
+      if (!isUnsupportedInterfaceError(error)) {
+        throw error;
+      }
+      return fallbackTableRowCount(handle);
+    }
+  },
+  getColumnCount: async () => {
+    try {
+      return native.nativeTableColumnCount(handle);
+    } catch (error) {
+      if (!isUnsupportedInterfaceError(error)) {
+        throw error;
+      }
+      return fallbackTableColumnCount(handle);
+    }
+  },
+  cellAt: createTableCellAtOperation(handle),
+  selectedRows: async () => native.nativeTableSelectedRows(handle),
+  selectedColumns: async () => native.nativeTableSelectedColumns(handle),
+  isRowSelected: async (row) => {
+    assertNonNegativeIndex$1("row", row);
+    return native.nativeTableIsRowSelected(handle, row);
+  },
+  isColumnSelected: async (column) => {
+    assertNonNegativeIndex$1("column", column);
+    return native.nativeTableIsColumnSelected(handle, column);
+  },
+  isCellSelected: async (row, column) => {
+    assertNonNegativeIndex$1("row", row);
+    assertNonNegativeIndex$1("column", column);
+    return native.nativeTableIsCellSelected(handle, row, column);
+  },
+  selectRow: async (row) => {
+    assertNonNegativeIndex$1("row", row);
+    native.nativeTableSelectRow(handle, row);
+  },
+  deselectRow: async (row) => {
+    assertNonNegativeIndex$1("row", row);
+    native.nativeTableDeselectRow(handle, row);
+  },
+  selectColumn: async (column) => {
+    assertNonNegativeIndex$1("column", column);
+    native.nativeTableSelectColumn(handle, column);
+  },
+  deselectColumn: async (column) => {
+    assertNonNegativeIndex$1("column", column);
+    native.nativeTableDeselectColumn(handle, column);
+  }
+});
+const createGtkElement = (handle) => {
+  const initialInfo = toGtkElementInfoForHandle(handle);
+  const common = createCommonElement(handle);
+  switch (initialInfo.kind) {
+    case "window":
+      return {
+        ...common,
+        kind: "window",
+        ...createChildContainerOperations(handle, void 0)
+      };
+    case "button":
+      return { ...common, kind: "button", click: createClickOperation(handle) };
+    case "container":
+      return {
+        ...common,
+        kind: "container",
+        ...createChildContainerOperations(handle, void 0)
+      };
+    case "label":
+      return { ...common, kind: "label", text: createTextOperation(handle) };
+    case "entry":
+      return {
+        ...common,
+        kind: "entry",
+        setText: createSetTextOperation(handle),
+        text: createTextOperation(handle)
+      };
+    case "text":
+      return { ...common, kind: "text", text: createTextOperation(handle) };
+    case "checkbox":
+      return {
+        ...common,
+        kind: "checkbox",
+        click: createClickOperation(handle),
+        isChecked: createIsCheckedOperation(handle),
+        toggle: createToggleOperation(handle)
+      };
+    case "switch":
+      return {
+        ...common,
+        kind: "switch",
+        click: createClickOperation(handle),
+        isChecked: createIsCheckedOperation(handle),
+        toggle: createToggleOperation(handle)
+      };
+    case "radio":
+      return {
+        ...common,
+        kind: "radio",
+        click: createClickOperation(handle),
+        isChecked: createIsCheckedOperation(handle),
+        toggle: createToggleOperation(handle)
+      };
+    case "toggleButton":
+      return {
+        ...common,
+        kind: "toggleButton",
+        click: createClickOperation(handle),
+        isChecked: createIsCheckedOperation(handle),
+        toggle: createToggleOperation(handle)
+      };
+    case "slider":
+      return {
+        ...common,
+        kind: "slider",
+        value: createValueOperation(handle),
+        valueInfo: createValueInfoOperation(handle),
+        setValue: createSetValueOperation(handle)
+      };
+    case "spinButton":
+      return {
+        ...common,
+        kind: "spinButton",
+        value: createValueOperation(handle),
+        valueInfo: createValueInfoOperation(handle),
+        setValue: createSetValueOperation(handle),
+        increment: createIncrementOperation(handle),
+        decrement: createDecrementOperation(handle)
+      };
+    case "progressBar":
+      return {
+        ...common,
+        kind: "progressBar",
+        value: createValueOperation(handle),
+        valueInfo: createValueInfoOperation(handle)
+      };
+    case "comboBox":
+      return {
+        ...common,
+        kind: "comboBox",
+        click: createComboBoxClickOperation(handle),
+        ...createComboBoxOperations(handle)
+      };
+    case "list":
+      return {
+        ...common,
+        kind: "list",
+        ...createSelectableChildContainerOperations(
+          handle,
+          ["listItem"]
+        )
+      };
+    case "listItem":
+      return {
+        ...common,
+        kind: "listItem",
+        click: createClickOperation(handle)
+      };
+    case "table":
+      return { ...common, kind: "table", ...createTableOperations(handle) };
+    case "tableCell":
+      return { ...common, kind: "tableCell" };
+    case "image":
+      return {
+        ...common,
+        kind: "image",
+        imageInfo: createImageInfoOperation(handle)
+      };
+    case "menu":
+      return {
+        ...common,
+        kind: "menu",
+        ...createChildContainerOperations(handle, [
+          "menuItem"
+        ])
+      };
+    case "menuItem":
+      return {
+        ...common,
+        kind: "menuItem",
+        click: createClickOperation(handle)
+      };
+    case "unknown":
+      return { ...common, kind: "unknown" };
+  }
+};
+const optionalString = (value) => value.length === 0 ? void 0 : value;
+const toMetadata = (item) => {
+  const iconName = optionalString(item.iconName);
+  const id = optionalString(item.id);
+  const status = optionalString(item.status);
+  const title = optionalString(item.title);
+  return {
+    backend: "status-notifier",
+    ...iconName === void 0 ? {} : { iconName },
+    ...id === void 0 ? {} : { id },
+    ...status === void 0 ? {} : { status },
+    ...title === void 0 ? {} : { title }
+  };
+};
+const sameTrayItem = (first, second) => first.busName === second.busName && first.objectPath === second.objectPath;
+const staleTrayItemError = () => errors.createGtkStaleElementError("Tray item is no longer registered.");
+const resolveCurrentInfo = (handle) => {
+  const item = native.nativeTrayItems(handle.processId).find(
+    (candidate) => sameTrayItem(handle, candidate)
+  );
+  if (item === void 0) {
+    throw staleTrayItemError();
+  }
+  return item;
+};
+const isClickableElement = (element) => {
+  switch (element.kind) {
+    case "button":
+    case "checkbox":
+    case "switch":
+    case "radio":
+    case "toggleButton":
+    case "comboBox":
+    case "listItem":
+    case "menuItem":
+      return true;
+    default:
+      return false;
+  }
+};
+const nativeTrayItemMatchesSelector = (item, selector) => {
+  if ("id" in selector) {
+    return item.id === selector.id;
+  }
+  if ("title" in selector) {
+    return item.title === selector.title;
+  }
+  if ("busName" in selector) {
+    return item.busName === selector.busName && (selector.objectPath === void 0 || item.objectPath === selector.objectPath);
+  }
+  return false;
+};
+const createGtkTrayItem = (processId, item) => {
+  const handle = {
+    busName: item.busName,
+    objectPath: item.objectPath,
+    processId
+  };
+  const trayItem = {
+    metadata: async () => toMetadata(resolveCurrentInfo(handle)),
+    element: async () => {
+      const current = resolveCurrentInfo(handle);
+      const elementHandle = native.nativeFindAnyById(current.accessibleId);
+      return elementHandle === void 0 ? void 0 : createGtkElement(elementHandle);
+    },
+    capture: async () => {
+      const element = await trayItem.element();
+      if (element === void 0) {
+        throw errors.createGtkElementNotFoundError(
+          "Tray item is registered but not visible."
+        );
+      }
+      return element.capture();
+    },
+    click: async () => {
+      const element = await trayItem.element();
+      if (element === void 0) {
+        throw errors.createGtkElementNotFoundError(
+          "Tray item is registered but not visible."
+        );
+      }
+      if (!isClickableElement(element)) {
+        throw errors.createGtkUnsupportedInterfaceError(
+          `Tray item element does not support click: ${element.kind}.`
+        );
+      }
+      await element.click();
+    },
+    openMenu: async () => {
+      resolveCurrentInfo(handle);
+      return void 0;
+    }
+  };
+  return trayItem;
+};
+const appendOutput = (lines, chunk) => {
+  lines.push(chunk.toString("utf8"));
+  if (lines.length > 40) {
+    lines.splice(0, lines.length - 40);
+  }
+};
+const formatProcessOutput = (state) => {
+  const stdout = state.stdout.join("").trim();
+  const stderr = state.stderr.join("").trim();
+  if (stdout.length === 0 && stderr.length === 0) {
+    return "";
+  }
+  return `
+stdout:
+${stdout}
+stderr:
+${stderr}`;
+};
+const assertProcessRunning = (state, command) => {
+  if (state.exitCode !== null || state.exitSignal !== null) {
+    throw errors.createGtkAppExitedError(
+      `GTK application exited before the operation completed: ${command} (code=${String(state.exitCode)}, signal=${String(state.exitSignal)})` + formatProcessOutput(state)
+    );
+  }
+  const processId = state.process.pid;
+  if (processId === void 0) {
+    throw errors.createGtkAppExitedError(
+      `GTK application did not expose a process id: ${command}`
+    );
+  }
+  return processId;
+};
+const assertNonNegativeIndex = (name, index) => {
+  if (!Number.isInteger(index) || index < 0) {
+    throw errors.createGtkInvalidArgumentError(
+      `${name} must be a non-negative integer.`
+    );
+  }
+};
+const parseElementPath = (path) => {
+  const segments = path.split(/[.:;,]/u);
+  const id = segments[0];
+  if (id === void 0 || id.length === 0) {
+    throw errors.createGtkInvalidArgumentError(
+      "path must start with an accessible id."
+    );
+  }
+  const childIndexes = [];
+  for (let index = 1; index < segments.length; index += 1) {
+    const segment = segments[index];
+    if (segment === void 0 || !/^\d+$/u.test(segment)) {
+      throw errors.createGtkInvalidArgumentError(
+        "path child indexes must be non-negative decimal integers."
+      );
+    }
+    const childIndex = Number(segment);
+    if (!Number.isSafeInteger(childIndex)) {
+      throw errors.createGtkInvalidArgumentError(
+        "path child indexes must be safe non-negative integers."
+      );
+    }
+    childIndexes.push(childIndex);
+  }
+  return { id, childIndexes };
+};
+const isPathChildContainer = (element) => "childAt" in element;
+const waitForAtspiReady = async (state, command, timeoutMs, startedAt) => {
+  if (state.atspiReady) {
+    return assertProcessRunning(state, command);
+  }
+  while (Date.now() - startedAt <= timeoutMs) {
+    const processId = assertProcessRunning(state, command);
+    state.atspiReadiness = native.nativeProcessAtspiReadiness(processId);
+    if (state.atspiReadiness === "ready") {
+      state.atspiReady = true;
+      return processId;
+    }
+    await wait.delay(50);
+  }
+  assertProcessRunning(state, command);
+  throw errors.createGtkOperationFailedError(
+    prerequisites.appendPrerequisiteInstallHint(
+      `AT-SPI did not become ready for GTK application: ${command} (last readiness: ${state.atspiReadiness})` + formatProcessOutput(state)
+    )
+  );
+};
+const createGtkAppEnvironment = (baseEnv, overrides) => {
+  const env = {
+    ...baseEnv,
+    GDK_BACKEND: baseEnv.GDK_BACKEND ?? "x11",
+    GSETTINGS_BACKEND: baseEnv.GSETTINGS_BACKEND ?? "memory",
+    GTK_THEME: baseEnv.GTK_THEME ?? "Adwaita",
+    ...overrides
+  };
+  delete env.NO_AT_BRIDGE;
+  for (const key of Object.keys(env)) {
+    if (env[key] === void 0) {
+      delete env[key];
+    }
+  }
+  return env;
+};
+const launchGtkApp = (appPath, args, options) => {
+  const _args = args ?? [];
+  const _timeoutMs = options?.timeoutMs ?? 1e4;
+  const child = node_child_process.spawn(appPath, [..._args], {
+    env: createGtkAppEnvironment(process.env, options?.env),
+    stdio: "pipe"
+  });
+  const state = {
+    atspiReadiness: "missing-bus-name",
+    atspiReady: false,
+    exitCode: null,
+    exitSignal: null,
+    process: child,
+    stderr: [],
+    stdout: []
+  };
+  child.stdout.on("data", (chunk) => {
+    appendOutput(state.stdout, chunk);
+  });
+  child.stderr.on("data", (chunk) => {
+    appendOutput(state.stderr, chunk);
+  });
+  child.on("exit", (code, signal) => {
+    state.exitCode = code;
+    state.exitSignal = signal;
+  });
+  const release = async () => {
+    if (state.exitCode !== null || state.exitSignal !== null) {
+      return;
+    }
+    child.kill("SIGTERM");
+    const startedAt = Date.now();
+    while (state.exitCode === null && state.exitSignal === null) {
+      if (Date.now() - startedAt > 2e3) {
+        child.kill("SIGKILL");
+        break;
+      }
+      await wait.delay(25);
+    }
+  };
+  const findById = async (id) => {
+    const startedAt = Date.now();
+    const timeoutMs = wait.effectiveWaitTimeoutMs(_timeoutMs);
+    await waitForAtspiReady(state, appPath, timeoutMs, startedAt);
+    while (Date.now() - startedAt <= timeoutMs) {
+      const processId = assertProcessRunning(state, appPath);
+      try {
+        const handle = native.nativeFindById(processId, id);
+        if (handle !== void 0) {
+          return createGtkElement(handle);
+        }
+      } catch (error) {
+        throw errors.normalizeNativeError(error);
+      }
+      await wait.delay(50);
+    }
+    assertProcessRunning(state, appPath);
+    return void 0;
+  };
+  const getById = async (id) => {
+    const element = await findById(id);
+    if (element === void 0) {
+      throw errors.createGtkElementNotFoundError(`Accessible id was not found: ${id}`);
+    }
+    return element;
+  };
+  const findByPath = async (path) => {
+    const parsedPath = parseElementPath(path);
+    const startedAt = Date.now();
+    const timeoutMs = wait.effectiveWaitTimeoutMs(_timeoutMs);
+    await waitForAtspiReady(state, appPath, timeoutMs, startedAt);
+    while (Date.now() - startedAt <= timeoutMs) {
+      const processId = assertProcessRunning(state, appPath);
+      try {
+        const handle = native.nativeFindById(processId, parsedPath.id);
+        if (handle !== void 0) {
+          let element = createGtkElement(handle);
+          let resolved = true;
+          for (const childIndex of parsedPath.childIndexes) {
+            if (!isPathChildContainer(element)) {
+              resolved = false;
+              break;
+            }
+            const child2 = await element.childAt(childIndex);
+            if (child2 === void 0) {
+              resolved = false;
+              break;
+            }
+            element = child2;
+          }
+          if (resolved) {
+            return element;
+          }
+        }
+      } catch (error) {
+        throw errors.normalizeNativeError(error);
+      }
+      await wait.delay(50);
+    }
+    assertProcessRunning(state, appPath);
+    return void 0;
+  };
+  const getByPath = async (path) => {
+    const element = await findByPath(path);
+    if (element === void 0) {
+      throw errors.createGtkElementNotFoundError(
+        `Element path was not found: ${path}`
+      );
+    }
+    return element;
+  };
+  const findTrayItem = async (selector) => {
+    const startedAt = Date.now();
+    const timeoutMs = wait.effectiveWaitTimeoutMs(_timeoutMs);
+    while (Date.now() - startedAt <= timeoutMs) {
+      const processId = assertProcessRunning(state, appPath);
+      try {
+        const item = native.nativeTrayItems(processId).find(
+          (candidate) => nativeTrayItemMatchesSelector(candidate, selector)
+        );
+        if (item !== void 0) {
+          return createGtkTrayItem(processId, item);
+        }
+      } catch (error) {
+        const normalizedError = errors.normalizeNativeError(error);
+        if (normalizedError.code === "OPERATION_FAILED" && normalizedError.message.includes("Timeout was reached")) {
+          await wait.delay(50);
+          continue;
+        }
+        throw normalizedError;
+      }
+      await wait.delay(50);
+    }
+    assertProcessRunning(state, appPath);
+    return void 0;
+  };
+  const getTrayItem = async (selector) => {
+    const trayItem = await findTrayItem(selector);
+    if (trayItem === void 0) {
+      throw errors.createGtkElementNotFoundError(
+        `StatusNotifier tray item was not found: ${JSON.stringify(selector)}`
+      );
+    }
+    return trayItem;
+  };
+  const app = {
+    capture: async () => {
+      assertProcessRunning(state, appPath);
+      try {
+        return native.nativeCaptureScreen();
+      } catch (error) {
+        throw errors.normalizeNativeError(error);
+      }
+    },
+    findById,
+    findByPath,
+    getById,
+    getByPath,
+    windowAt: async (index) => {
+      assertNonNegativeIndex("index", index);
+      const startedAt = Date.now();
+      const processId = await waitForAtspiReady(
+        state,
+        appPath,
+        wait.effectiveWaitTimeoutMs(_timeoutMs),
+        startedAt
+      );
+      try {
+        const handle = native.nativeWindowAt(processId, index);
+        return handle === void 0 ? void 0 : createGtkElement(handle);
+      } catch (error) {
+        throw errors.normalizeNativeError(error);
+      }
+    },
+    getWindowCount: async () => {
+      const startedAt = Date.now();
+      const processId = await waitForAtspiReady(
+        state,
+        appPath,
+        wait.effectiveWaitTimeoutMs(_timeoutMs),
+        startedAt
+      );
+      try {
+        return native.nativeWindowCount(processId);
+      } catch (error) {
+        throw errors.normalizeNativeError(error);
+      }
+    },
+    findTrayItem,
+    getTrayItem,
+    trayItemAt: async (index) => {
+      assertNonNegativeIndex("index", index);
+      const processId = assertProcessRunning(state, appPath);
+      try {
+        const item = native.nativeTrayItems(processId)[index];
+        return item === void 0 ? void 0 : createGtkTrayItem(processId, item);
+      } catch (error) {
+        throw errors.normalizeNativeError(error);
+      }
+    },
+    getTrayItemCount: async () => {
+      const processId = assertProcessRunning(state, appPath);
+      try {
+        return native.nativeTrayItems(processId).length;
+      } catch (error) {
+        throw errors.normalizeNativeError(error);
+      }
+    },
+    release,
+    [Symbol.asyncDispose]: release
+  };
+  child.on("error", (error) => {
+    appendOutput(state.stderr, Buffer.from(error.message));
+  });
+  return Promise.resolve(app);
+};
+const createGtkAppLauncher = (options) => createDriverBackedGtkAppLauncher(options);
+exports.createGtkAppEnvironment = createGtkAppEnvironment;
+exports.createGtkAppLauncher = createGtkAppLauncher;
+exports.launchGtkApp = launchGtkApp;
+//# sourceMappingURL=launchGtkApp-BIO_5Xjn.cjs.map