gestament 0.3.0 → 0.5.0

package/dist/{launchGtkApp-qi1qm5G4.js → launchGtkApp-EI6OIpPI.js}

@@ -7,7 +7,232 @@ import { tmpdir } from "node:os";
 import { join, resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { a as appendPrerequisiteInstallHint } from "./prerequisites-JB0SKPVd.js";
-import { c as nativeElementInfo, d as nativeClick, e as nativeImageInfo, f as nativeCaptureBounds, g as nativeTableDeselectColumn, h as nativeTableSelectColumn, i as nativeTableDeselectRow, j as nativeTableSelectRow, k as nativeTableIsCellSelected, l as nativeTableIsColumnSelected, m as nativeTableIsRowSelected, o as nativeTableSelectedColumns, p as nativeTableSelectedRows, q as nativeTableColumnCount, r as nativeTableRowCount, s as nativeClearSelection, t as nativeSelectAllChildren, u as nativeDeselectChildAt, v as nativeSelectChildAt, w as nativeIsChildSelected, x as nativeSelectedChildAt, y as nativeSelectedChildCount, z as nativeChildCount, A as nativeChildAt, B as nativeValueInfo, C as nativeSetValue, D as nativeText, E as nativeSetText, F as nativeCapture, G as nativeTableCellAt, H as nativeFindAnyById, I as nativeTrayItems, J as nativeWindowCount, K as nativeWindowAt, a as nativeCaptureScreen, L as nativeFindById, M as nativeProcessAtspiReadiness } from "./native-CWdUmdty.js";
+import { c as nativeElementInfo, d as nativeClick, e as nativeImageInfo, f as nativeCaptureBounds, g as nativeTableDeselectColumn, h as nativeTableSelectColumn, i as nativeTableDeselectRow, j as nativeTableSelectRow, k as nativeTableIsCellSelected, l as nativeTableIsColumnSelected, m as nativeTableIsRowSelected, o as nativeTableSelectedColumns, p as nativeTableSelectedRows, q as nativeTableColumnCount, r as nativeTableRowCount, s as nativeClearSelection, t as nativeSelectAllChildren, u as nativeDeselectChildAt, v as nativeSelectChildAt, w as nativeIsChildSelected, x as nativeSelectedChildAt, y as nativeSelectedChildCount, z as nativeChildCount, A as nativeChildAt, B as nativeValueInfo, C as nativeSetValue, D as nativeText, E as nativeSetText, F as nativeX11Info, G as nativeResizeHints, H as nativeBounds, I as nativeCapture, J as nativeTableCellAt, K as nativeFindAnyById, L as nativeTrayItems, M as nativeWindowCount, N as nativeWindowAt, a as nativeCaptureScreen, O as nativeFindById, P as nativeProcessAtspiReadiness } from "./native-DlCBBWlV.js";
+const normalizeOutputBufferBytes = (value, optionName = "outputBufferBytes") => {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw createGtkInvalidArgumentError(
+      `${optionName} must be a non-negative safe integer.`
+    );
+  }
+  return value;
+};
+const createStreamState = () => ({
+  byteLength: 0,
+  chunks: [],
+  decoder: new TextDecoder(),
+  flushed: false,
+  truncated: false
+});
+const appendBoundedChunk = (state, chunk, maxBytes) => {
+  if (chunk.length === 0) {
+    return;
+  }
+  if (maxBytes === void 0) {
+    state.chunks.push(Buffer.from(chunk));
+    state.byteLength += chunk.length;
+    return;
+  }
+  if (maxBytes === 0) {
+    state.truncated = true;
+    return;
+  }
+  if (chunk.length >= maxBytes) {
+    state.chunks.splice(
+      0,
+      state.chunks.length,
+      Buffer.from(chunk.subarray(chunk.length - maxBytes))
+    );
+    state.byteLength = maxBytes;
+    state.truncated = true;
+    return;
+  }
+  state.chunks.push(Buffer.from(chunk));
+  state.byteLength += chunk.length;
+  while (state.byteLength > maxBytes) {
+    const first = state.chunks[0];
+    if (first === void 0) {
+      state.byteLength = 0;
+      return;
+    }
+    const excess = state.byteLength - maxBytes;
+    if (first.length <= excess) {
+      state.chunks.shift();
+      state.byteLength -= first.length;
+      state.truncated = true;
+      continue;
+    }
+    state.chunks[0] = Buffer.from(first.subarray(excess));
+    state.byteLength -= excess;
+    state.truncated = true;
+  }
+};
+const streamText = (state) => Buffer.concat(state.chunks, state.byteLength).toString("utf8");
+const createOutputEvent = (nextSequence, create, text) => {
+  if (text.length === 0) {
+    return void 0;
+  }
+  return create(nextSequence());
+};
+const createGtkAppOutputRecorder = (outputBufferBytes) => {
+  const maxBytes = normalizeOutputBufferBytes(outputBufferBytes);
+  const stdout = createStreamState();
+  const stderr = createStreamState();
+  let nextSequence = 0;
+  const streamState = (stream) => stream === "stdout" ? stdout : stderr;
+  const takeSequence = () => {
+    const sequence = nextSequence;
+    nextSequence += 1;
+    return sequence;
+  };
+  const createEvent = (stream, text) => createOutputEvent(
+    takeSequence,
+    (sequence) => ({
+      sequence,
+      stream,
+      text,
+      timestampMs: Date.now()
+    }),
+    text
+  );
+  return {
+    append: (stream, chunk) => {
+      const state = streamState(stream);
+      appendBoundedChunk(state, chunk, maxBytes);
+      return createEvent(stream, state.decoder.decode(chunk, { stream: true }));
+    },
+    flush: (stream) => {
+      const state = streamState(stream);
+      if (state.flushed) {
+        return void 0;
+      }
+      state.flushed = true;
+      return createEvent(stream, state.decoder.decode());
+    },
+    snapshot: (exitCode, exitSignal) => ({
+      exitCode,
+      exitSignal,
+      stderr: streamText(stderr),
+      stderrTruncated: stderr.truncated,
+      stdout: streamText(stdout),
+      stdoutTruncated: stdout.truncated
+    })
+  };
+};
+const systemOutputSources = [
+  "xvfb",
+  "launcher-driver",
+  "tray-host"
+];
+const createSourceState = () => ({
+  stderr: createStreamState(),
+  stdout: createStreamState()
+});
+const createGtkSystemOutputRecorder = (systemOutputBufferBytes) => {
+  const maxBytes = normalizeOutputBufferBytes(
+    systemOutputBufferBytes,
+    "systemOutputBufferBytes"
+  );
+  const sources = /* @__PURE__ */ new Map();
+  let nextSequence = 0;
+  const takeSequence = () => {
+    const sequence = nextSequence;
+    nextSequence += 1;
+    return sequence;
+  };
+  const sourceState = (source) => {
+    const existing = sources.get(source);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const state = createSourceState();
+    sources.set(source, state);
+    return state;
+  };
+  const streamState = (source, stream) => {
+    const state = sourceState(source);
+    return stream === "stdout" ? state.stdout : state.stderr;
+  };
+  const existingStreamState = (source, stream) => {
+    const state = sources.get(source);
+    if (state === void 0) {
+      return void 0;
+    }
+    return stream === "stdout" ? state.stdout : state.stderr;
+  };
+  const createEvent = (source, stream, text) => createOutputEvent(
+    takeSequence,
+    (sequence) => ({
+      sequence,
+      source,
+      stream,
+      text,
+      timestampMs: Date.now()
+    }),
+    text
+  );
+  const sourceSnapshot = (source, state) => ({
+    source,
+    stderr: streamText(state.stderr),
+    stderrTruncated: state.stderr.truncated,
+    stdout: streamText(state.stdout),
+    stdoutTruncated: state.stdout.truncated
+  });
+  return {
+    append: (source, stream, chunk) => {
+      const state = streamState(source, stream);
+      appendBoundedChunk(state, chunk, maxBytes);
+      return createEvent(
+        source,
+        stream,
+        state.decoder.decode(chunk, { stream: true })
+      );
+    },
+    flush: (source, stream) => {
+      const state = existingStreamState(source, stream);
+      if (state === void 0) {
+        return void 0;
+      }
+      if (state.flushed) {
+        return void 0;
+      }
+      state.flushed = true;
+      return createEvent(source, stream, state.decoder.decode());
+    },
+    snapshot: () => ({
+      sources: systemOutputSources.flatMap((source) => {
+        const state = sources.get(source);
+        return state === void 0 ? [] : [sourceSnapshot(source, state)];
+      })
+    })
+  };
+};
+const notifyGtkAppOutput = (callback, event) => {
+  if (callback === void 0 || event === void 0) {
+    return;
+  }
+  try {
+    callback(event);
+  } catch (error) {
+    queueMicrotask(() => {
+      throw error;
+    });
+  }
+};
+const notifyGtkSystemOutput = (callback, event) => {
+  if (callback === void 0 || event === void 0) {
+    return;
+  }
+  try {
+    callback(event);
+  } catch (error) {
+    queueMicrotask(() => {
+      throw error;
+    });
+  }
+};
 const defaultDisplay = "xvfb";
 const defaultGSettings = "memory";
 const defaultTheme = "Adwaita";
@@ -20,8 +245,23 @@ const sessionStartupTimeoutMs = 3e4;
 const sessionReleaseTimeoutMs = 5e3;
 const xvfbStartupTimeoutMs = 1e4;
 const xvfbPoolProbeTimeoutMs = 5e3;
+const xvfbPoolProbeRetryIntervalMs = 50;
+const xvfbPoolProbePrefix = "gestament-xvfb-pool-probe: ";
+const x11DisplayOpenFailureMessage = "Failed to open the X11 display. Ensure DISPLAY points to an X11 display.";
 const firstPooledDisplayNumber = 90;
 const lastPooledDisplayNumber = 590;
+const sessionOwnedEnvironmentKeys = [
+  "DISPLAY",
+  "WAYLAND_DISPLAY",
+  "GDK_BACKEND",
+  "DBUS_SESSION_BUS_ADDRESS",
+  "AT_SPI_BUS_ADDRESS",
+  "NO_AT_BRIDGE",
+  "XAUTHORITY",
+  "GESTAMENT_XVFB_ACTIVE",
+  "XDG_SESSION_TYPE"
+];
+let outputScopeCounter = 0;
 let socketCounter = 0;
 const leasedDisplayNumbers = /* @__PURE__ */ new Set();
 const idleXvfbByKey = /* @__PURE__ */ new Map();
@@ -38,6 +278,12 @@ const appendOutput$1 = (lines, chunk) => {
     lines.splice(0, lines.length - 40);
   }
 };
+const appendSystemOutput = (sink, source, stream, chunk) => {
+  sink?.append(source, stream, chunk);
+};
+const flushSystemOutput = (sink, source, stream) => {
+  sink?.flush(source, stream);
+};
 const unrefHandle = (handle) => {
   const maybeRefHandle = handle;
   if (typeof maybeRefHandle.unref === "function") {
@@ -56,6 +302,41 @@ ${stdoutText}
 stderr:
 ${stderrText}`;
 };
+const createXvfbProbeError = (message, retryable) => {
+  const error = createGtkOperationFailedError(message);
+  Object.defineProperty(error, "retryable", {
+    value: retryable
+  });
+  return error;
+};
+const parseXvfbProbeErrorPayload = (stderrText) => {
+  const lines = stderrText.trim().split("\n").reverse();
+  for (const line of lines) {
+    if (!line.startsWith(xvfbPoolProbePrefix)) {
+      continue;
+    }
+    try {
+      const value = JSON.parse(
+        line.slice(xvfbPoolProbePrefix.length)
+      );
+      if (!isRecord(value)) {
+        return void 0;
+      }
+      return {
+        code: typeof value.code === "string" ? value.code : void 0,
+        message: typeof value.message === "string" ? value.message : void 0
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+};
+const isRetryableXvfbProbeExit = (stderrText) => {
+  const payload = parseXvfbProbeErrorPayload(stderrText);
+  return payload?.code === "OPERATION_FAILED" && payload.message === x11DisplayOpenFailureMessage;
+};
+const isRetryableXvfbProbeError = (error) => isRecord(error) && typeof error.retryable === "boolean" && error.retryable;
 const getHostDisplayState = () => ({
   display: process.env.DISPLAY,
   waylandDisplay: process.env.WAYLAND_DISPLAY
@@ -81,6 +362,63 @@ const resolveDisplay = (display) => {
   );
 };
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const createDriverEventKey = (channel, scopeId) => `${channel}
+${scopeId}`;
+const createOutputScopeId = () => {
+  const scopeId = `output-${process.pid}-${outputScopeCounter}`;
+  outputScopeCounter += 1;
+  return scopeId;
+};
+const isDriverEventMessage = (message) => isRecord(message) && message.type === "event" && typeof message.channel === "string" && typeof message.scopeId === "string";
+const resolveOutputBufferBytes = (launcherValue, launchValue) => {
+  const value = launchValue ?? launcherValue;
+  if (value === void 0) {
+    return null;
+  }
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw createGtkInvalidArgumentError(
+      "outputBufferBytes must be a non-negative safe integer."
+    );
+  }
+  return value;
+};
+const createSystemOutputSink = (recorder, callback) => ({
+  append: (source, stream, chunk) => {
+    notifyGtkSystemOutput(callback, recorder.append(source, stream, chunk));
+  },
+  flush: (source, stream) => {
+    notifyGtkSystemOutput(callback, recorder.flush(source, stream));
+  }
+});
+const isGtkSystemOutputSource = (value) => value === "xvfb" || value === "launcher-driver" || value === "tray-host";
+const isGtkAppOutputStream = (value) => value === "stdout" || value === "stderr";
+const isWireGtkSystemOutput = (value) => {
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (!isGtkSystemOutputSource(value.source) || !isGtkAppOutputStream(value.stream)) {
+    return false;
+  }
+  if (value.type === "flush") {
+    return true;
+  }
+  return value.type === "chunk" && typeof value.chunkBase64 === "string";
+};
+const routeWireSystemOutput = (sink, value) => {
+  if (!isWireGtkSystemOutput(value)) {
+    return;
+  }
+  if (value.type === "flush") {
+    flushSystemOutput(sink, value.source, value.stream);
+    return;
+  }
+  appendSystemOutput(
+    sink,
+    value.source,
+    value.stream,
+    Buffer.from(value.chunkBase64, "base64")
+  );
+};
 const resolvePoolLimit = (name, value, defaultValue) => {
   if (value === void 0) {
     return defaultValue;
@@ -228,6 +566,7 @@ const retainIdleXvfb = async (xvfb, limits) => {
     await terminateXvfb(xvfb);
     return;
   }
+  xvfb.systemOutputSink = void 0;
   xvfb.lastUsedAt = Date.now();
   pushArrayEntry(idleXvfbByKey, xvfb.key, xvfb);
   await trimIdleXvfbKey(xvfb.key, limits.maxIdlePerKey);
@@ -238,6 +577,8 @@ const retainIdleAllSession = async (session, limits) => {
     await session.session.terminate();
     return;
   }
+  session.session.setSystemOutputSink(void 0);
+  session.xvfb.systemOutputSink = void 0;
   session.lastUsedAt = Date.now();
   session.xvfb.lastUsedAt = session.lastUsedAt;
   pushArrayEntry(idleAllByKey, session.key, session);
@@ -311,12 +652,34 @@ const toWireEnvironment = (env) => {
   }
   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 wireEnvironmentToGtkAppEnvironment = (env) => {
+  const appEnv = {};
+  for (const [key, value] of Object.entries(env)) {
+    appEnv[key] = value === null ? void 0 : value;
+  }
+  return appEnv;
+};
+const assertNoSessionOwnedEnvironmentOverrides = (options, effective) => {
+  if (effective.kind !== "xvfb" || options.env === void 0) {
+    return;
+  }
+  for (const key of sessionOwnedEnvironmentKeys) {
+    if (Object.hasOwn(options.env, key)) {
+      throw createGtkInvalidArgumentError(
+        `options.env must not override ${key} when using internal Xvfb.`
+      );
+    }
+  }
+};
+const resolveLauncherEnvironment = (options, effective) => {
+  assertNoSessionOwnedEnvironmentOverrides(options, effective);
+  return 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 = resolve(
     dirname(fileURLToPath(import.meta.url)),
@@ -350,11 +713,17 @@ const createDriverEnvironment = (effective, xvfb) => {
   delete env.AT_SPI_BUS_ADDRESS;
   delete env.NO_AT_BRIDGE;
   if (effective.kind === "xvfb") {
+    delete env.DBUS_SESSION_BUS_ADDRESS;
+    delete env.DISPLAY;
+    delete env.WAYLAND_DISPLAY;
+    delete env.AT_SPI_BUS_ADDRESS;
+    delete env.NO_AT_BRIDGE;
+    delete env.XAUTHORITY;
     env.GDK_BACKEND = "x11";
     env.GESTAMENT_XVFB_ACTIVE = "1";
+    env.XDG_SESSION_TYPE = "x11";
     if (xvfb !== void 0) {
       env.DISPLAY = xvfb.display;
-      delete env.XAUTHORITY;
     }
   }
   return env;
@@ -422,7 +791,7 @@ const installPoolCleanup = () => {
     }
   });
 };
-const spawnDirectXvfb = async (screen) => {
+const spawnDirectXvfb = async (screen, systemOutputSink) => {
   installPoolCleanup();
   for (let displayNumber = firstPooledDisplayNumber; displayNumber <= lastPooledDisplayNumber; displayNumber += 1) {
     if (!isDisplayNumberAvailable(displayNumber)) {
@@ -439,11 +808,30 @@ const spawnDirectXvfb = async (screen) => {
         stdio: ["ignore", "pipe", "pipe"]
       }
     );
+    const xvfb = {
+      child,
+      display: `:${displayNumber}`,
+      displayNumber,
+      key: screen,
+      lastUsedAt: Date.now(),
+      screen,
+      stderr,
+      stdout,
+      systemOutputSink
+    };
     child.stdout.on("data", (chunk) => {
       appendOutput$1(stdout, chunk);
+      appendSystemOutput(xvfb.systemOutputSink, "xvfb", "stdout", chunk);
     });
     child.stderr.on("data", (chunk) => {
       appendOutput$1(stderr, chunk);
+      appendSystemOutput(xvfb.systemOutputSink, "xvfb", "stderr", chunk);
+    });
+    child.stdout.once("end", () => {
+      flushSystemOutput(xvfb.systemOutputSink, "xvfb", "stdout");
+    });
+    child.stderr.once("end", () => {
+      flushSystemOutput(xvfb.systemOutputSink, "xvfb", "stderr");
     });
     child.unref();
     unrefHandle(child.stdout);
@@ -466,22 +854,10 @@ const spawnDirectXvfb = async (screen) => {
           });
         })
       ]);
-      const xvfb = {
-        child,
-        display: `:${displayNumber}`,
-        displayNumber,
-        key: screen,
-        lastUsedAt: Date.now(),
-        screen,
-        stderr,
-        stdout
-      };
       directXvfbs.add(xvfb);
       return xvfb;
     } catch (error) {
-      killXvfbNow({
-        child
-      });
+      killXvfbNow(xvfb);
       leasedDisplayNumbers.delete(displayNumber);
       const message = error instanceof Error ? error.message : String(error);
       if (message.includes("ENOENT")) {
@@ -509,39 +885,69 @@ const terminateXvfb = async (xvfb) => {
       await delay(25);
     }
   }
+  xvfb.systemOutputSink = void 0;
   leasedDisplayNumbers.delete(xvfb.displayNumber);
 };
-const leaseXvfb = async (screen) => {
+const leaseXvfb = async (screen, systemOutputSink) => {
   for (; ; ) {
     const idle = popArrayEntry(idleXvfbByKey, screen);
     if (idle === void 0) {
-      return spawnDirectXvfb(screen);
+      return spawnDirectXvfb(screen, systemOutputSink);
     }
     if (idle.child.exitCode === null && idle.child.signalCode === null) {
       idle.lastUsedAt = Date.now();
+      idle.systemOutputSink = systemOutputSink;
       return idle;
     }
     await terminateXvfb(idle);
   }
 };
-const runXvfbProbe = (xvfb) => new Promise((resolveProbe, rejectProbe) => {
+const runXvfbProbeOnce = (xvfb, timeoutMs) => new Promise((resolveProbe, rejectProbe) => {
   const probePath = resolveXvfbPoolProbePath();
   const stdout = [];
   const stderr = [];
+  const env = {
+    ...process.env,
+    DISPLAY: xvfb.display,
+    GDK_BACKEND: "x11",
+    GESTAMENT_XVFB_ACTIVE: "1",
+    XDG_SESSION_TYPE: "x11"
+  };
+  delete env.AT_SPI_BUS_ADDRESS;
+  delete env.DBUS_SESSION_BUS_ADDRESS;
+  delete env.NO_AT_BRIDGE;
+  delete env.WAYLAND_DISPLAY;
+  delete env.XAUTHORITY;
   const child = spawn(process.execPath, [probePath], {
-    env: {
-      ...process.env,
-      DISPLAY: xvfb.display,
-      GDK_BACKEND: "x11"
-    },
+    env,
     stdio: ["ignore", "pipe", "pipe"]
   });
-  const timeout = setTimeout(() => {
+  let settled = false;
+  let timeout;
+  const rejectOnce = (error) => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    if (timeout !== void 0) {
+      clearTimeout(timeout);
+    }
+    rejectProbe(error);
+  };
+  const resolveOnce = (result) => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    if (timeout !== void 0) {
+      clearTimeout(timeout);
+    }
+    resolveProbe(result);
+  };
+  timeout = setTimeout(() => {
     child.kill("SIGKILL");
-    rejectProbe(
-      createGtkOperationFailedError("Timed out probing Xvfb pool.")
-    );
-  }, xvfbPoolProbeTimeoutMs);
+    rejectOnce(createXvfbProbeError("Timed out probing Xvfb pool.", false));
+  }, timeoutMs);
   child.stdout.on("data", (chunk) => {
     appendOutput$1(stdout, chunk);
   });
@@ -549,42 +955,71 @@ const runXvfbProbe = (xvfb) => new Promise((resolveProbe, rejectProbe) => {
     appendOutput$1(stderr, chunk);
   });
   child.once("error", (error) => {
-    clearTimeout(timeout);
-    rejectProbe(error);
+    rejectOnce(error);
   });
   child.once("exit", (code, signal) => {
-    clearTimeout(timeout);
     if (code !== 0) {
-      rejectProbe(
-        createGtkOperationFailedError(
+      const stderrText = stderr.join("");
+      rejectOnce(
+        createXvfbProbeError(
           `Xvfb pool probe failed: code=${String(code)}, signal=${String(
             signal
-          )}` + formatOutputTail(stdout, stderr)
+          )}` + formatOutputTail(stdout, stderr),
+          isRetryableXvfbProbeExit(stderrText)
         )
       );
       return;
     }
     const output = stdout.join("").trim().split("\n").at(-1);
     if (output === void 0 || output.length === 0) {
-      rejectProbe(
-        createGtkOperationFailedError(
-          "Xvfb pool probe did not return a result." + formatOutputTail(stdout, stderr)
+      rejectOnce(
+        createXvfbProbeError(
+          "Xvfb pool probe did not return a result." + formatOutputTail(stdout, stderr),
+          false
         )
       );
       return;
     }
     try {
-      resolveProbe(JSON.parse(output));
+      resolveOnce(JSON.parse(output));
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      rejectProbe(
-        createGtkOperationFailedError(
-          `Xvfb pool probe returned invalid JSON: ${message}` + formatOutputTail(stdout, stderr)
+      rejectOnce(
+        createXvfbProbeError(
+          `Xvfb pool probe returned invalid JSON: ${message}` + formatOutputTail(stdout, stderr),
+          false
         )
       );
     }
   });
 });
+const runXvfbProbe = async (xvfb) => {
+  const startedAt = Date.now();
+  let lastError;
+  while (Date.now() - startedAt < xvfbPoolProbeTimeoutMs) {
+    const remainingTimeoutMs = Math.max(
+      1,
+      xvfbPoolProbeTimeoutMs - (Date.now() - startedAt)
+    );
+    try {
+      return await runXvfbProbeOnce(xvfb, remainingTimeoutMs);
+    } catch (error) {
+      lastError = error;
+      if (!isRetryableXvfbProbeError(error)) {
+        throw error;
+      }
+    }
+    const remainingDelayMs = xvfbPoolProbeTimeoutMs - (Date.now() - startedAt);
+    if (remainingDelayMs <= 0) {
+      break;
+    }
+    await delay(Math.min(xvfbPoolProbeRetryIntervalMs, remainingDelayMs));
+  }
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+  throw createGtkOperationFailedError("Timed out probing Xvfb pool.");
+};
 const cleanCheckXvfb = async (xvfb, allowedMappedWindowCount) => {
   try {
     const probe = await runXvfbProbe(xvfb);
@@ -603,7 +1038,7 @@ const returnXvfbToPool = async (xvfb, limits) => {
 };
 const allPoolKey = (xvfb) => `${xvfb.screen}
 ${xvfb.trayHost ? "tray" : "no-tray"}`;
-const spawnDriverProcess = (driverPath, socketPath, effective, xvfb) => {
+const spawnDriverProcess = (driverPath, socketPath, effective, xvfb, systemOutputSink) => {
   const driverArgs = [
     "--socket",
     socketPath,
@@ -636,14 +1071,46 @@ const spawnDriverProcess = (driverPath, socketPath, effective, xvfb) => {
     env,
     stdio: ["ignore", "pipe", "pipe"]
   });
+  const processState = {
+    child,
+    commandLine: [command.bin, ...command.args].join(" "),
+    stderr,
+    stdout,
+    systemOutputSink
+  };
   child.stdout.on("data", (chunk) => {
     appendOutput$1(stdout, chunk);
+    appendSystemOutput(
+      processState.systemOutputSink,
+      "launcher-driver",
+      "stdout",
+      chunk
+    );
   });
   child.stderr.on("data", (chunk) => {
     appendOutput$1(stderr, chunk);
+    appendSystemOutput(
+      processState.systemOutputSink,
+      "launcher-driver",
+      "stderr",
+      chunk
+    );
   });
-  const commandLine = [command.bin, ...command.args].join(" ");
-  return { child, commandLine, stderr, stdout };
+  child.stdout.once("end", () => {
+    flushSystemOutput(
+      processState.systemOutputSink,
+      "launcher-driver",
+      "stdout"
+    );
+  });
+  child.stderr.once("end", () => {
+    flushSystemOutput(
+      processState.systemOutputSink,
+      "launcher-driver",
+      "stderr"
+    );
+  });
+  return processState;
 };
 const listenOnSocket = (server, socketPath) => new Promise((resolveListen, rejectListen) => {
   const rejectFromError = (error) => {
@@ -722,7 +1189,13 @@ const waitForDriverReady = (server, processState) => new Promise((resolveReady,
       const line = input.slice(0, newlineIndex);
       input = input.slice(newlineIndex + 1);
       try {
-        if (parseReadyMessage(line) !== void 0) {
+        const message = JSON.parse(line);
+        if (isDriverEventMessage(message)) {
+          const event = message;
+          if (event.channel === "system.output") {
+            routeWireSystemOutput(processState.systemOutputSink, event.value);
+          }
+        } else if (isRecord(message) && message.type === "ready" && parseReadyMessage(line) !== void 0) {
           if (settled) {
             return;
           }
@@ -800,6 +1273,7 @@ const decodeCapture = (capture) => ({
   visibleBounds: capture.visibleBounds
 });
 const createDriverSession = (socket, bufferedInput, processState, tempDirectory, poolOptions) => {
+  const eventHandlers = /* @__PURE__ */ new Map();
   const pending = /* @__PURE__ */ new Map();
   let input = bufferedInput;
   let nextRequestId = 1;
@@ -819,8 +1293,34 @@ const createDriverSession = (socket, bufferedInput, processState, tempDirectory,
     closed = true;
     rejectPending(createGtkAppExitedError("Launcher driver has exited."));
   };
+  const handleEvent = (event) => {
+    if (event.channel === "system.output") {
+      routeWireSystemOutput(processState.systemOutputSink, event.value);
+      return;
+    }
+    const handlers = eventHandlers.get(
+      createDriverEventKey(event.channel, event.scopeId)
+    );
+    if (handlers === void 0) {
+      return;
+    }
+    for (const handler of handlers) {
+      try {
+        handler(event.value);
+      } catch (error) {
+        queueMicrotask(() => {
+          throw error;
+        });
+      }
+    }
+  };
   const handleResponse = (line) => {
-    const response = JSON.parse(line);
+    const message = JSON.parse(line);
+    if (isDriverEventMessage(message)) {
+      handleEvent(message);
+      return;
+    }
+    const response = message;
     const entry = pending.get(response.id);
     if (entry === void 0) {
       return;
@@ -895,6 +1395,28 @@ const createDriverSession = (socket, bufferedInput, processState, tempDirectory,
       });
     });
   };
+  const subscribe = (channel, scopeId, handler) => {
+    const key = createDriverEventKey(channel, scopeId);
+    const handlers = eventHandlers.get(key) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    eventHandlers.set(key, handlers);
+    let disposed = false;
+    return {
+      dispose: () => {
+        if (disposed) {
+          return;
+        }
+        disposed = true;
+        handlers.delete(handler);
+        if (handlers.size === 0) {
+          eventHandlers.delete(key);
+        }
+      }
+    };
+  };
+  const setSystemOutputSink = (sink) => {
+    processState.systemOutputSink = sink;
+  };
   const waitForExit = async () => {
     const startedAt = Date.now();
     while (processState.child.exitCode === null && processState.child.signalCode === null) {
@@ -979,10 +1501,10 @@ const createDriverSession = (socket, bufferedInput, processState, tempDirectory,
       poolOptions.limits
     );
   };
-  session = { release, request, terminate };
+  session = { release, request, setSystemOutputSink, subscribe, terminate };
   return session;
 };
-const startFreshDriverSession = async (effective, xvfb, poolOptions) => {
+const startFreshDriverSession = async (effective, xvfb, poolOptions, systemOutputSink) => {
   const driverPath = resolveDriverPath();
   const tempDirectory = mkdtempSync(
     join(tmpdir(), `gestament-launcher-${process.pid}-${socketCounter}-`)
@@ -994,7 +1516,13 @@ const startFreshDriverSession = async (effective, xvfb, poolOptions) => {
   try {
     await listenOnSocket(server, socketPath);
     server.unref();
-    processState = spawnDriverProcess(driverPath, socketPath, effective, xvfb);
+    processState = spawnDriverProcess(
+      driverPath,
+      socketPath,
+      effective,
+      xvfb,
+      systemOutputSink
+    );
     const connection = await waitForDriverReady(server, processState);
     server.close();
     const resolvedPoolOptions = poolOptions.mode === "all" && xvfb !== void 0 ? {
@@ -1020,7 +1548,7 @@ const startFreshDriverSession = async (effective, xvfb, poolOptions) => {
     throw error;
   }
 };
-const startDriverSession = async (options) => {
+const startDriverSession = async (options, systemOutputSink) => {
   const display = resolveDisplay(options.display);
   const xvfbOptions = resolveXvfbOptions(options);
   const effective = resolveEffectiveDisplay(display, xvfbOptions);
@@ -1028,7 +1556,8 @@ const startDriverSession = async (options) => {
     return startFreshDriverSession(
       effective,
       void 0,
-      emptyDriverSessionPoolOptions()
+      emptyDriverSessionPoolOptions(),
+      systemOutputSink
     );
   }
   const pool = effective.xvfb.pool;
@@ -1036,18 +1565,24 @@ const startDriverSession = async (options) => {
     return startFreshDriverSession(
       effective,
       void 0,
-      emptyDriverSessionPoolOptions()
+      emptyDriverSessionPoolOptions(),
+      systemOutputSink
     );
   }
   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 xvfb2 = await leaseXvfb(effective.xvfb.screen, systemOutputSink);
+    return startFreshDriverSession(
+      effective,
+      xvfb2,
+      {
+        allKey: void 0,
+        allowedMappedWindowCount: 0,
+        limits: poolLimits(pool),
+        mode: "xvfb",
+        xvfb: xvfb2
+      },
+      systemOutputSink
+    );
   }
   const key = allPoolKey(effective.xvfb);
   for (; ; ) {
@@ -1058,20 +1593,27 @@ const startDriverSession = async (options) => {
     if (idle.xvfb.child.exitCode === null && idle.xvfb.child.signalCode === null) {
       idle.lastUsedAt = Date.now();
       idle.xvfb.lastUsedAt = idle.lastUsedAt;
+      idle.xvfb.systemOutputSink = systemOutputSink;
+      idle.session.setSystemOutputSink(systemOutputSink);
       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 xvfb = await leaseXvfb(effective.xvfb.screen, systemOutputSink);
+  return startFreshDriverSession(
+    effective,
+    xvfb,
+    {
+      allKey: key,
+      allowedMappedWindowCount: 0,
+      limits: poolLimits(pool),
+      mode: "all",
+      xvfb
+    },
+    systemOutputSink
+  );
 };
-const createLaunchPayload = (options, args) => {
+const createLaunchPayload = (options, args, launchOptions, outputScopeId) => {
   const display = resolveDisplay(options.display);
   const xvfb = resolveXvfbOptions(options);
   const effective = resolveEffectiveDisplay(display, xvfb);
@@ -1079,12 +1621,25 @@ const createLaunchPayload = (options, args) => {
     appPath: options.appPath,
     args: [...options.args ?? [], ...args],
     env: resolveLauncherEnvironment(options, effective),
+    outputBufferBytes: resolveOutputBufferBytes(
+      options.outputBufferBytes,
+      launchOptions?.outputBufferBytes
+    ),
+    outputScopeId,
     timeoutMs: options.timeoutMs ?? null
   };
 };
+const createEnvironmentPayload = (options) => {
+  const display = resolveDisplay(options.display);
+  const xvfb = resolveXvfbOptions(options);
+  const effective = resolveEffectiveDisplay(display, xvfb);
+  return {
+    env: resolveLauncherEnvironment(options, effective)
+  };
+};
 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) => {
+const createProxyGtkApp = (session, ref, outputSubscription) => {
   let released = false;
   const assertNotReleased = () => {
     if (released) {
@@ -1103,10 +1658,15 @@ const createProxyGtkApp = (session, ref) => {
       return;
     }
     released = true;
+    outputSubscription?.dispose();
     await session.request("app.release", { appId: ref.appId });
   };
   const app = {
     capture: async () => decodeCapture(await appRequest("app.capture")),
+    environment: async () => wireEnvironmentToGtkAppEnvironment(
+      await appRequest("app.environment")
+    ),
+    output: () => appRequest("app.output"),
     findById: async (id) => elementRefToProxy(
       session,
       await appRequest("app.findById", { id })
@@ -1219,6 +1779,13 @@ const createProxyGtkElement = (session, ref) => {
   };
   switch (ref.kind) {
     case "window":
+      target.bounds = () => session.request("element.bounds", { elementId });
+      target.resizeHints = () => session.request("window.resizeHints", {
+        elementId
+      });
+      target.x11Info = () => session.request("window.x11Info", { elementId });
+      addChildContainerProxyOperations(session, elementId, target);
+      break;
     case "container":
     case "menu":
       addChildContainerProxyOperations(session, elementId, target);
@@ -1327,19 +1894,84 @@ const createProxyGtkTrayItem = (session, ref) => {
   };
 };
 const createDriverBackedGtkAppLauncher = (options) => {
+  const outputSubscriptions = /* @__PURE__ */ new Set();
+  let systemOutputRecorder = createGtkSystemOutputRecorder(
+    normalizeOutputBufferBytes(
+      options.systemOutputBufferBytes,
+      "systemOutputBufferBytes"
+    )
+  );
   let sessionPromise;
   const ensureSession = () => {
-    sessionPromise ??= startDriverSession(options);
+    if (sessionPromise === void 0) {
+      systemOutputRecorder = createGtkSystemOutputRecorder(
+        normalizeOutputBufferBytes(
+          options.systemOutputBufferBytes,
+          "systemOutputBufferBytes"
+        )
+      );
+      sessionPromise = startDriverSession(
+        options,
+        createSystemOutputSink(systemOutputRecorder, options.onSystemOutput)
+      );
+    }
     return sessionPromise;
   };
-  const launch = async (args) => {
+  const trackOutputSubscription = (subscription) => {
+    let tracked;
+    tracked = {
+      dispose: () => {
+        if (!outputSubscriptions.delete(tracked)) {
+          return;
+        }
+        subscription.dispose();
+      }
+    };
+    outputSubscriptions.add(tracked);
+    return tracked;
+  };
+  const disposeOutputSubscriptions = () => {
+    for (const subscription of [...outputSubscriptions]) {
+      subscription.dispose();
+    }
+  };
+  const launch = async (args, launchOptions) => {
     const session = await ensureSession();
-    const appRef = await session.request(
-      "launcher.launch",
-      createLaunchPayload(options, args ?? [])
+    const onOutput = launchOptions?.onOutput;
+    const outputScopeId = onOutput === void 0 ? null : createOutputScopeId();
+    const outputSubscription = outputScopeId === null ? void 0 : trackOutputSubscription(
+      session.subscribe("app.output", outputScopeId, (value) => {
+        onOutput?.(value);
+      })
+    );
+    const payload = createLaunchPayload(
+      options,
+      args ?? [],
+      launchOptions,
+      outputScopeId
     );
-    return createProxyGtkApp(session, appRef);
+    try {
+      const appRef = await session.request(
+        "launcher.launch",
+        payload
+      );
+      return createProxyGtkApp(session, appRef, outputSubscription);
+    } catch (error) {
+      outputSubscription?.dispose();
+      throw error;
+    }
   };
+  const environment = async () => {
+    const payload = createEnvironmentPayload(options);
+    const session = await ensureSession();
+    return wireEnvironmentToGtkAppEnvironment(
+      await session.request(
+        "launcher.environment",
+        payload
+      )
+    );
+  };
+  const systemOutput = () => Promise.resolve(systemOutputRecorder.snapshot());
   const release = async () => {
     const releasingSession = sessionPromise;
     sessionPromise = void 0;
@@ -1347,11 +1979,17 @@ const createDriverBackedGtkAppLauncher = (options) => {
       return;
     }
     const session = await releasingSession;
-    await session.release();
+    try {
+      await session.release();
+    } finally {
+      disposeOutputSubscriptions();
+    }
   };
   return {
+    environment,
     launch,
     release,
+    systemOutput,
     [Symbol.asyncDispose]: release
   };
 };
@@ -1758,6 +2396,9 @@ const createImageInfoOperation = (handle) => async () => {
     capture: async () => nativeCaptureBounds(info.bounds)
   };
 };
+const createBoundsOperation = (handle) => async () => nativeBounds(handle);
+const createResizeHintsOperation = (handle) => async () => nativeResizeHints(handle);
+const createX11InfoOperation = (handle) => async () => nativeX11Info(handle);
 const createValueOperation = (handle) => async () => nativeValueInfo(handle).value;
 const createSetValueOperation = (handle) => async (value) => {
   assertFiniteNumber("value", value);
@@ -1929,7 +2570,10 @@ const createGtkElement = (handle) => {
       return {
         ...common,
         kind: "window",
-        ...createChildContainerOperations(handle, void 0)
+        bounds: createBoundsOperation(handle),
+        ...createChildContainerOperations(handle, void 0),
+        resizeHints: createResizeHintsOperation(handle),
+        x11Info: createX11InfoOperation(handle)
       };
     case "button":
       return { ...common, kind: "button", click: createClickOperation(handle) };
@@ -2257,30 +2901,70 @@ const createGtkAppEnvironment = (baseEnv, overrides) => {
 const launchGtkApp = (appPath, args, options) => {
   const _args = args ?? [];
   const _timeoutMs = options?.timeoutMs ?? 1e4;
+  const outputBufferBytes = normalizeOutputBufferBytes(
+    options?.outputBufferBytes
+  );
+  const outputRecorder = createGtkAppOutputRecorder(outputBufferBytes);
+  const appEnvironment = createGtkAppEnvironment(process.env, options?.env);
   const child = spawn(appPath, [..._args], {
-    env: createGtkAppEnvironment(process.env, options?.env),
+    env: appEnvironment,
     stdio: "pipe"
   });
+  let resolveClosed;
+  const closedPromise = new Promise((resolve2) => {
+    resolveClosed = resolve2;
+  });
   const state = {
     atspiReadiness: "missing-bus-name",
     atspiReady: false,
+    closed: false,
+    closedPromise,
     exitCode: null,
     exitSignal: null,
     process: child,
+    released: false,
     stderr: [],
     stdout: []
   };
+  const notifyOutput = (stream, chunk) => {
+    notifyGtkAppOutput(options?.onOutput, outputRecorder.append(stream, chunk));
+  };
+  const flushOutput = (stream) => {
+    notifyGtkAppOutput(options?.onOutput, outputRecorder.flush(stream));
+  };
   child.stdout.on("data", (chunk) => {
     appendOutput(state.stdout, chunk);
+    notifyOutput("stdout", chunk);
   });
   child.stderr.on("data", (chunk) => {
     appendOutput(state.stderr, chunk);
+    notifyOutput("stderr", chunk);
+  });
+  child.stdout.on("end", () => {
+    flushOutput("stdout");
+  });
+  child.stderr.on("end", () => {
+    flushOutput("stderr");
   });
   child.on("exit", (code, signal) => {
     state.exitCode = code;
     state.exitSignal = signal;
   });
+  child.on("close", (code, signal) => {
+    if (state.exitCode === null && state.exitSignal === null) {
+      state.exitCode = code;
+      state.exitSignal = signal;
+    }
+    flushOutput("stdout");
+    flushOutput("stderr");
+    state.closed = true;
+    resolveClosed?.();
+  });
   const release = async () => {
+    if (state.released) {
+      return;
+    }
+    state.released = true;
     if (state.exitCode !== null || state.exitSignal !== null) {
       return;
     }
@@ -2294,6 +2978,11 @@ const launchGtkApp = (appPath, args, options) => {
       await delay$1(25);
     }
   };
+  const assertNotReleased = () => {
+    if (state.released) {
+      throw createGtkAppExitedError("GTK application has been released.");
+    }
+  };
   const findById = async (id) => {
     const startedAt = Date.now();
     const timeoutMs = effectiveWaitTimeoutMs(_timeoutMs);
@@ -2401,6 +3090,7 @@ const launchGtkApp = (appPath, args, options) => {
   };
   const app = {
     capture: async () => {
+      assertNotReleased();
       assertProcessRunning(state, appPath);
       try {
         return nativeCaptureScreen();
@@ -2408,6 +3098,21 @@ const launchGtkApp = (appPath, args, options) => {
         throw normalizeNativeError(error);
       }
     },
+    environment: async () => {
+      assertNotReleased();
+      assertProcessRunning(state, appPath);
+      return { ...appEnvironment };
+    },
+    output: async () => {
+      assertNotReleased();
+      if ((state.exitCode !== null || state.exitSignal !== null) && !state.closed) {
+        await state.closedPromise;
+      }
+      return outputRecorder.snapshot(
+        state.exitCode,
+        state.exitSignal === null ? null : state.exitSignal
+      );
+    },
     findById,
     findByPath,
     getById,
@@ -2476,4 +3181,4 @@ export {
   createGtkAppEnvironment as c,
   launchGtkApp as l
 };
-//# sourceMappingURL=launchGtkApp-qi1qm5G4.js.map
+//# sourceMappingURL=launchGtkApp-EI6OIpPI.js.map