gestament 0.3.0 → 0.5.0

package/dist/{launchGtkApp-BIO_5Xjn.cjs → launchGtkApp-CzYcrc9f.cjs}

@@ -8,8 +8,233 @@ 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");
+const native = require("./native-Kfm95Uxw.cjs");
 var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
+const normalizeOutputBufferBytes = (value, optionName = "outputBufferBytes") => {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw errors.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";
@@ -22,8 +247,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();
@@ -40,6 +280,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") {
@@ -58,6 +304,41 @@ ${stdoutText}
 stderr:
 ${stderrText}`;
 };
+const createXvfbProbeError = (message, retryable) => {
+  const error = errors.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
@@ -83,6 +364,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 errors.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;
@@ -230,6 +568,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);
@@ -240,6 +579,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);
@@ -313,15 +654,37 @@ 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 errors.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 = 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)),
+    node_path.dirname(node_url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("launchGtkApp-CzYcrc9f.cjs", document.baseURI).href)),
     "..",
     "dist",
     "gestament-launcher-driver.cjs"
@@ -335,7 +698,7 @@ const resolveDriverPath = () => {
 };
 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)),
+    node_path.dirname(node_url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("launchGtkApp-CzYcrc9f.cjs", document.baseURI).href)),
     "..",
     "dist",
     "gestament-xvfb-pool-probe.cjs"
@@ -352,11 +715,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;
@@ -424,7 +793,7 @@ const installPoolCleanup = () => {
     }
   });
 };
-const spawnDirectXvfb = async (screen) => {
+const spawnDirectXvfb = async (screen, systemOutputSink) => {
   installPoolCleanup();
   for (let displayNumber = firstPooledDisplayNumber; displayNumber <= lastPooledDisplayNumber; displayNumber += 1) {
     if (!isDisplayNumberAvailable(displayNumber)) {
@@ -441,11 +810,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);
@@ -468,22 +856,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")) {
@@ -511,39 +887,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 = node_child_process.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(
-      errors.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);
   });
@@ -551,42 +957,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(
-        errors.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(
-        errors.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(
-        errors.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 errors.createGtkOperationFailedError("Timed out probing Xvfb pool.");
+};
 const cleanCheckXvfb = async (xvfb, allowedMappedWindowCount) => {
   try {
     const probe = await runXvfbProbe(xvfb);
@@ -605,7 +1040,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,
@@ -638,14 +1073,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) => {
@@ -724,7 +1191,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;
           }
@@ -802,6 +1275,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;
@@ -821,8 +1295,34 @@ const createDriverSession = (socket, bufferedInput, processState, tempDirectory,
     closed = true;
     rejectPending(errors.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;
@@ -897,6 +1397,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) {
@@ -981,10 +1503,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 = node_fs.mkdtempSync(
     node_path.join(node_os.tmpdir(), `gestament-launcher-${process.pid}-${socketCounter}-`)
@@ -996,7 +1518,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 ? {
@@ -1022,7 +1550,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);
@@ -1030,7 +1558,8 @@ const startDriverSession = async (options) => {
     return startFreshDriverSession(
       effective,
       void 0,
-      emptyDriverSessionPoolOptions()
+      emptyDriverSessionPoolOptions(),
+      systemOutputSink
     );
   }
   const pool = effective.xvfb.pool;
@@ -1038,18 +1567,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 (; ; ) {
@@ -1060,20 +1595,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);
@@ -1081,12 +1623,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) {
@@ -1105,10 +1660,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 })
@@ -1221,6 +1781,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);
@@ -1329,19 +1896,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;
@@ -1349,11 +1981,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
   };
 };
@@ -1760,6 +2398,9 @@ const createImageInfoOperation = (handle) => async () => {
     capture: async () => native.nativeCaptureBounds(info.bounds)
   };
 };
+const createBoundsOperation = (handle) => async () => native.nativeBounds(handle);
+const createResizeHintsOperation = (handle) => async () => native.nativeResizeHints(handle);
+const createX11InfoOperation = (handle) => async () => native.nativeX11Info(handle);
 const createValueOperation = (handle) => async () => native.nativeValueInfo(handle).value;
 const createSetValueOperation = (handle) => async (value) => {
   assertFiniteNumber("value", value);
@@ -1931,7 +2572,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) };
@@ -2259,30 +2903,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 = node_child_process.spawn(appPath, [..._args], {
-    env: createGtkAppEnvironment(process.env, options?.env),
+    env: appEnvironment,
     stdio: "pipe"
   });
+  let resolveClosed;
+  const closedPromise = new Promise((resolve) => {
+    resolveClosed = resolve;
+  });
   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;
     }
@@ -2296,6 +2980,11 @@ const launchGtkApp = (appPath, args, options) => {
       await wait.delay(25);
     }
   };
+  const assertNotReleased = () => {
+    if (state.released) {
+      throw errors.createGtkAppExitedError("GTK application has been released.");
+    }
+  };
   const findById = async (id) => {
     const startedAt = Date.now();
     const timeoutMs = wait.effectiveWaitTimeoutMs(_timeoutMs);
@@ -2403,6 +3092,7 @@ const launchGtkApp = (appPath, args, options) => {
   };
   const app = {
     capture: async () => {
+      assertNotReleased();
       assertProcessRunning(state, appPath);
       try {
         return native.nativeCaptureScreen();
@@ -2410,6 +3100,21 @@ const launchGtkApp = (appPath, args, options) => {
         throw errors.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 @@ const createGtkAppLauncher = (options) => createDriverBackedGtkAppLauncher(optio
 exports.createGtkAppEnvironment = createGtkAppEnvironment;
 exports.createGtkAppLauncher = createGtkAppLauncher;
 exports.launchGtkApp = launchGtkApp;
-//# sourceMappingURL=launchGtkApp-BIO_5Xjn.cjs.map
+//# sourceMappingURL=launchGtkApp-CzYcrc9f.cjs.map