@gtkx/vitest 1.6.0 → 2.0.0-beta.10

package/README.md

@@ -5,15 +5,15 @@
 <h1 align="center">GTKX</h1>
 
 <p align="center">
-  The React framework for Linux, built on GTK.<br />
-  Write native GTK4 desktop applications with React and TypeScript.
-  Real GTK widgets, the GNOME stack, and standard web tooling.
+  The React framework for Linux.<br />
+  Write native GNOME applications with React and TypeScript.
+  Real Adwaita and GTK4 widgets with standard web tooling.
 </p>
 
 <p align="center">
   <a href="https://www.npmjs.com/package/create-gtkx"><img src="https://img.shields.io/npm/v/create-gtkx?color=cb3837&logo=npm&label=create-gtkx" alt="npm version" /></a>
   <a href="https://www.npmjs.com/package/create-gtkx"><img src="https://img.shields.io/npm/dm/create-gtkx?color=cb3837&logo=npm&label=downloads" alt="npm downloads" /></a>
-  <img src="https://img.shields.io/badge/node-%E2%89%A524-339933?logo=node.js&logoColor=white" alt="Node >= 24" />
+  <img src="https://img.shields.io/badge/node-%E2%89%A526.7-339933?logo=node.js&logoColor=white" alt="Node >= 26.7" />
   <a href="https://github.com/gtkx-org/gtkx/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MPL--2.0-blue.svg" alt="License: MPL-2.0" /></a>
   <a href="https://github.com/gtkx-org/gtkx/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/gtkx-org/gtkx/ci.yml?branch=main&logo=github&label=CI" alt="CI status" /></a>
   <img src="https://img.shields.io/badge/TypeScript-strict-3178c6?logo=typescript&logoColor=white" alt="TypeScript" />
@@ -38,11 +38,12 @@
 
 ## Demo
 
-The intrinsic elements in this snippet render GTK4 widgets, and ordinary React hooks and events drive them:
+This app starts with an Adwaita application shell, renders native GTK4 widgets inside it, and uses ordinary React hooks and events:
 
 ```tsx
 import * as Gtk from "@gtkx/gi/gtk";
-import { GtkApplication, GtkApplicationWindow, GtkBox, GtkButton, GtkLabel } from "@gtkx/jsx/gtk";
+import { AdwApplication, AdwApplicationWindow, AdwHeaderBar, AdwToolbarView } from "@gtkx/jsx/adw";
+import { GtkBox, GtkButton, GtkLabel } from "@gtkx/jsx/gtk";
 import { createRoot, quit } from "@gtkx/react";
 import { useState } from "react";
 
@@ -50,38 +51,40 @@ const Counter = () => {
   const [count, setCount] = useState(0);
 
   return (
-    <GtkApplicationWindow
+    <AdwApplicationWindow
       title="Hello GTKX"
       defaultWidth={400}
       defaultHeight={300}
       onCloseRequest={quit}
     >
-      <GtkBox
-        orientation={Gtk.Orientation.VERTICAL}
-        spacing={20}
-        marginTop={40}
-        marginBottom={40}
-        marginStart={40}
-        marginEnd={40}
-        valign={Gtk.Align.CENTER}
-        halign={Gtk.Align.CENTER}
-      >
-        <GtkLabel cssClasses={["title-1"]}>Welcome to GTKX!</GtkLabel>
-        <GtkLabel cssClasses={["title-2"]}>{`Count: ${count}`}</GtkLabel>
-        <GtkButton
-          label="Increment"
-          onClicked={() => setCount((c) => c + 1)}
-          cssClasses={["suggested-action", "pill"]}
-        />
-      </GtkBox>
-    </GtkApplicationWindow>
+      <AdwToolbarView topBar={<AdwHeaderBar />}>
+        <GtkBox
+          orientation={Gtk.Orientation.VERTICAL}
+          spacing={20}
+          marginTop={40}
+          marginBottom={40}
+          marginStart={40}
+          marginEnd={40}
+          valign={Gtk.Align.CENTER}
+          halign={Gtk.Align.CENTER}
+        >
+          <GtkLabel cssClasses={["title-1"]}>Welcome to GTKX!</GtkLabel>
+          <GtkLabel cssClasses={["title-2"]}>{`Count: ${String(count)}`}</GtkLabel>
+          <GtkButton
+            label="Increment"
+            onClicked={() => setCount((c) => c + 1)}
+            cssClasses={["suggested-action", "pill"]}
+          />
+        </GtkBox>
+      </AdwToolbarView>
+    </AdwApplicationWindow>
   );
 };
 
 const App = () => (
-  <GtkApplication>
+  <AdwApplication>
     <Counter />
-  </GtkApplication>
+  </AdwApplication>
 );
 
 createRoot().render(<App />);
@@ -91,9 +94,9 @@ This is the [`hello-world`](https://github.com/gtkx-org/gtkx/tree/main/examples/
 
 ## Why GTKX
 
-### A declarative layer for the GNOME stack
+### Adwaita-first application development
 
-GTK4 is mature, and GtkBuilder XML can lay out a static interface, but nothing re-renders that interface when your application state changes, and nothing hot-reloads it as you work. GTKX adds that missing layer, and the tooling around it, on top of the stack you already know:
+GTKX uses Adwaita as the foundation for applications, windows, navigation, dialogs, and adaptive layouts, with the complete GTK4 toolkit underneath. It adds a declarative React layer and an integrated TypeScript toolchain to the GNOME platform:
 
 - a React reconciler that exposes every GObject as a JSX element,
 - a CLI for scaffolding, development, and production builds,
@@ -102,29 +105,29 @@ GTK4 is mature, and GtkBuilder XML can lay out a static interface, but nothing r
 - a Testing Library-style API for querying and driving your widgets in tests,
 - and a Model Context Protocol (MCP) server that exposes your live app to AI agents.
 
-### The full GNOME API surface
+### Native GNOME widgets, without a compatibility layer
 
-React Native and similar frameworks hide the native toolkit so one API can run everywhere. GTKX exposes it: GTK4, Adwaita, and any other GObject-Introspection library on your system. Linux-only by design.
+React Native and similar frameworks hide the native toolkit so one API can run everywhere. GTKX renders real Adwaita and GTK4 widgets and exposes any other GObject-Introspection library on your system. It is GNOME-native and Linux-only by design.
 
 ### Why Node.js, and why generated bindings
 
 GTKX runs on Node.js, which puts native modules, the npm ecosystem, and the tooling built for Node.js APIs within reach. GJS is GNOME's own runtime, built on SpiderMonkey rather than V8; node-gtk runs on Node.js but is lightly maintained, on the older nan/V8 ABI rather than N-API, and still centered on GTK3. The [Why GTKX guide](https://gtkx.dev/guide/why-gtkx) covers what running on Node.js means day to day.
 
-GTKX generates the TypeScript types and the native FFI calls from the same GObject-Introspection data, so the types cannot drift from the calls they back. Codegen covers the whole GTK4 and Adwaita surface.
+GTKX generates the TypeScript types and native FFI calls from the same GObject-Introspection data, so the types cannot drift from the calls they back. `Adw-1` is the sole default GIR root; its GIR include pulls in `Gtk-4.0`, so codegen covers both complete API surfaces. Neither belongs in a GTKX 2 `libraries` list.
 
-At runtime, the native Rust core calls straight into the system GTK4, Adwaita, and GLib libraries through libffi, without loading libgirepository at all.
+At runtime, the native Rust core calls straight into the system Adwaita, GTK4, and GLib libraries through libffi, without loading libgirepository at all.
 
 ## Quick start
 
-GTKX is Linux-only and needs Node.js 24 or later. See [Requirements](#requirements).
+GTKX is Linux-only and needs Node.js 26.7 or later. See [Requirements](#requirements).
 
 Scaffold a new app with the `create-gtkx` initializer:
 
 ```sh
-npm create gtkx
+npm create gtkx@beta
 ```
 
-The same command works with other package managers: `pnpm create gtkx` or `yarn create gtkx`.
+The same command works with other package managers: `pnpm create gtkx@beta` or `yarn create gtkx@beta`.
 
 Then run your new app:
 
@@ -145,8 +148,8 @@ The documentation at **[gtkx.dev](https://gtkx.dev)** includes a step-by-step tu
 
 GTKX is Linux-only. You need:
 
-- Linux with the GTK4 (4.20 or later) and GLib development libraries, plus Adwaita (1.8 or later) once your project binds `Adw-1`
-- Node.js 24 or later
+- Linux with the Adwaita (1.8 or later), GTK4 (4.20 or later), and GLib development libraries
+- Node.js 26.7 or later
 
 The `@gtkx/native` addon ships prebuilt for x64 and arm64 glibc Linux; other targets need to build it from the GTKX repository, which requires a Rust toolchain.
 
@@ -154,10 +157,10 @@ The `@gtkx/native` addon ships prebuilt for x64 and arm64 glibc Linux; other tar
 
 Explore the [example apps](https://github.com/gtkx-org/gtkx/tree/main/examples):
 
-- [`hello-world`](https://github.com/gtkx-org/gtkx/tree/main/examples/hello-world): the counter above.
-- [`gtk-demo`](https://github.com/gtkx-org/gtkx/tree/main/examples/gtk-demo): a React port of the official GTK4 widget showcase, covering lists, dialogs, gestures, CSS, and OpenGL.
-- [`browser`](https://github.com/gtkx-org/gtkx/tree/main/examples/browser): a WebKitWebView-based web browser.
-- [`animations`](https://github.com/gtkx-org/gtkx/tree/main/examples/animations): a tour of `@gtkx/animated`, React Spring animations driven by the GTK frame clock.
+- [`hello-world`](https://github.com/gtkx-org/gtkx/tree/main/examples/hello-world): the Adwaita counter above.
+- [`gtk-demo`](https://github.com/gtkx-org/gtkx/tree/main/examples/gtk-demo): the official GTK4 widget showcase in an Adwaita application shell, covering lists, dialogs, gestures, CSS, and OpenGL.
+- [`browser`](https://github.com/gtkx-org/gtkx/tree/main/examples/browser): an Adwaita browser built around `WebKitWebView`.
+- [`animations`](https://github.com/gtkx-org/gtkx/tree/main/examples/animations): an Adwaita showcase for `@gtkx/animated`, with React Spring animations driven by the GTK frame clock.
 - [`navigation`](https://github.com/gtkx-org/gtkx/tree/main/examples/navigation): a tour of `@gtkx/navigation`, React Navigation's stack, tab, and drawer navigators rendered with libadwaita.
 - [`tutorial`](https://github.com/gtkx-org/gtkx/tree/main/examples/tutorial): the Tasks app the documentation builds.
 
@@ -167,7 +170,7 @@ GTKX is stable and ready for production use.
 
 ## Contributing
 
-Contributions are welcome. See [CONTRIBUTING.md](https://github.com/gtkx-org/gtkx/blob/main/CONTRIBUTING.md), the [Code of Conduct](https://github.com/gtkx-org/gtkx/blob/main/CODE_OF_CONDUCT.md), and the [security policy](https://github.com/gtkx-org/gtkx/blob/main/SECURITY.md). Building the repo needs Node.js 24 or later, pnpm, and a Rust toolchain.
+Contributions are welcome. See [CONTRIBUTING.md](https://github.com/gtkx-org/gtkx/blob/main/CONTRIBUTING.md), the [Code of Conduct](https://github.com/gtkx-org/gtkx/blob/main/CODE_OF_CONDUCT.md), and the [security policy](https://github.com/gtkx-org/gtkx/blob/main/SECURITY.md). Building the repo needs Node.js 26.7 or later, pnpm, and a Rust toolchain.
 
 ## License
 

package/dist/headless-config.d.ts

@@ -0,0 +1,7 @@
+declare const HEADLESS_RUNTIME_MARKER = ".gtkx-headless-runtime";
+declare const createSwayConfig: (width: string, height: string) => string;
+declare const createBusConfig: (busSocketPath: string) => string;
+declare const createHeadlessRuntimeMarker: (runtimeDir: string) => string;
+declare const isSwayConfig: (value: string) => boolean;
+export { createBusConfig, createHeadlessRuntimeMarker, createSwayConfig, HEADLESS_RUNTIME_MARKER, isSwayConfig, };
+//# sourceMappingURL=headless-config.d.ts.map

package/dist/headless-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headless-config.d.ts","sourceRoot":"","sources":["../src/headless-config.ts"],"names":[],"mappings":"AAIA,QAAA,MAAM,uBAAuB,2BAA2B,CAAC;AAazD,QAAA,MAAM,gBAAgB,GAAI,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAG,MAU1C,CAAC;AAEjB,QAAA,MAAM,eAAe,GAAI,eAAe,MAAM,KAAG,MAajC,CAAC;AAEjB,QAAA,MAAM,2BAA2B,GAAI,YAAY,MAAM,KAAG,MACc,CAAC;AAEzE,QAAA,MAAM,YAAY,GAAI,OAAO,MAAM,KAAG,OAKrC,CAAC;AAEF,OAAO,EACH,eAAe,EACf,2BAA2B,EAC3B,gBAAgB,EAChB,uBAAuB,EACvB,YAAY,GACf,CAAC"}

package/dist/headless-config.js

@@ -0,0 +1,44 @@
+const BUS_CONFIG_DOCTYPE = '<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN" ' +
+    '"https://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">';
+const HEADLESS_RUNTIME_MARKER = ".gtkx-headless-runtime";
+const SWAY_CONFIG_LINES = [
+    /^xwayland disable$/,
+    /^default_border none$/,
+    /^default_floating_border none$/,
+    /^output HEADLESS-1 resolution [1-9]\d*x[1-9]\d*$/,
+    /^output HEADLESS-1 bg #000000 solid_color$/,
+    /^for_window \[app_id="\.\*"\] floating enable, border none$/,
+    /^for_window \[title="\.\*"\] floating enable, border none$/,
+    /^$/,
+];
+const createSwayConfig = (width, height) => [
+    "xwayland disable",
+    "default_border none",
+    "default_floating_border none",
+    `output HEADLESS-1 resolution ${width}x${height}`,
+    "output HEADLESS-1 bg #000000 solid_color",
+    'for_window [app_id=".*"] floating enable, border none',
+    'for_window [title=".*"] floating enable, border none',
+    "",
+].join("\n");
+const createBusConfig = (busSocketPath) => [
+    BUS_CONFIG_DOCTYPE,
+    "<busconfig>",
+    "  <type>session</type>",
+    `  <listen>unix:path=${busSocketPath}</listen>`,
+    "  <auth>EXTERNAL</auth>",
+    '  <policy context="default">',
+    '    <allow send_destination="*" eavesdrop="true"/>',
+    '    <allow eavesdrop="true"/>',
+    '    <allow own="*"/>',
+    "  </policy>",
+    "</busconfig>",
+].join("\n");
+const createHeadlessRuntimeMarker = (runtimeDir) => ["gtkx-headless-runtime-v1", `runtime=${runtimeDir}`, ""].join("\n");
+const isSwayConfig = (value) => {
+    const lines = value.split("\n");
+    return lines.length === SWAY_CONFIG_LINES.length &&
+        SWAY_CONFIG_LINES.every((pattern, index) => pattern.test(lines[index] ?? "invalid"));
+};
+export { createBusConfig, createHeadlessRuntimeMarker, createSwayConfig, HEADLESS_RUNTIME_MARKER, isSwayConfig, };
+//# sourceMappingURL=headless-config.js.map

package/dist/headless-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"headless-config.js","sourceRoot":"","sources":["../src/headless-config.ts"],"names":[],"mappings":"AAAA,MAAM,kBAAkB,GACpB,mFAAmF;IACnF,iEAAiE,CAAC;AAEtE,MAAM,uBAAuB,GAAG,wBAAwB,CAAC;AAEzD,MAAM,iBAAiB,GAAG;IACtB,oBAAoB;IACpB,uBAAuB;IACvB,gCAAgC;IAChC,kDAAkD;IAClD,4CAA4C;IAC5C,6DAA6D;IAC7D,4DAA4D;IAC5D,IAAI;CACP,CAAC;AAEF,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAAE,MAAc,EAAU,EAAE,CAC/D;IACI,kBAAkB;IAClB,qBAAqB;IACrB,8BAA8B;IAC9B,gCAAgC,KAAK,IAAI,MAAM,EAAE;IACjD,0CAA0C;IAC1C,uDAAuD;IACvD,sDAAsD;IACtD,EAAE;CACL,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEjB,MAAM,eAAe,GAAG,CAAC,aAAqB,EAAU,EAAE,CACtD;IACI,kBAAkB;IAClB,aAAa;IACb,wBAAwB;IACxB,uBAAuB,aAAa,WAAW;IAC/C,yBAAyB;IACzB,8BAA8B;IAC9B,oDAAoD;IACpD,+BAA+B;IAC/B,sBAAsB;IACtB,aAAa;IACb,cAAc;CACjB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEjB,MAAM,2BAA2B,GAAG,CAAC,UAAkB,EAAU,EAAE,CAC/D,CAAC,0BAA0B,EAAE,WAAW,UAAU,EAAE,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEzE,MAAM,YAAY,GAAG,CAAC,KAAa,EAAW,EAAE;IAC5C,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAEhC,OAAO,KAAK,CAAC,MAAM,KAAK,iBAAiB,CAAC,MAAM;QAC5C,iBAAiB,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC;AAC7F,CAAC,CAAC;AAEF,OAAO,EACH,eAAe,EACf,2BAA2B,EAC3B,gBAAgB,EAChB,uBAAuB,EACvB,YAAY,GACf,CAAC","sourcesContent":["const BUS_CONFIG_DOCTYPE =\n    '<!DOCTYPE busconfig PUBLIC \"-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN\" ' +\n    '\"https://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd\">';\n\nconst HEADLESS_RUNTIME_MARKER = \".gtkx-headless-runtime\";\n\nconst SWAY_CONFIG_LINES = [\n    /^xwayland disable$/,\n    /^default_border none$/,\n    /^default_floating_border none$/,\n    /^output HEADLESS-1 resolution [1-9]\\d*x[1-9]\\d*$/,\n    /^output HEADLESS-1 bg #000000 solid_color$/,\n    /^for_window \\[app_id=\"\\.\\*\"\\] floating enable, border none$/,\n    /^for_window \\[title=\"\\.\\*\"\\] floating enable, border none$/,\n    /^$/,\n];\n\nconst createSwayConfig = (width: string, height: string): string =>\n    [\n        \"xwayland disable\",\n        \"default_border none\",\n        \"default_floating_border none\",\n        `output HEADLESS-1 resolution ${width}x${height}`,\n        \"output HEADLESS-1 bg #000000 solid_color\",\n        'for_window [app_id=\".*\"] floating enable, border none',\n        'for_window [title=\".*\"] floating enable, border none',\n        \"\",\n    ].join(\"\\n\");\n\nconst createBusConfig = (busSocketPath: string): string =>\n    [\n        BUS_CONFIG_DOCTYPE,\n        \"<busconfig>\",\n        \"  <type>session</type>\",\n        `  <listen>unix:path=${busSocketPath}</listen>`,\n        \"  <auth>EXTERNAL</auth>\",\n        '  <policy context=\"default\">',\n        '    <allow send_destination=\"*\" eavesdrop=\"true\"/>',\n        '    <allow eavesdrop=\"true\"/>',\n        '    <allow own=\"*\"/>',\n        \"  </policy>\",\n        \"</busconfig>\",\n    ].join(\"\\n\");\n\nconst createHeadlessRuntimeMarker = (runtimeDir: string): string =>\n    [\"gtkx-headless-runtime-v1\", `runtime=${runtimeDir}`, \"\"].join(\"\\n\");\n\nconst isSwayConfig = (value: string): boolean => {\n    const lines = value.split(\"\\n\");\n\n    return lines.length === SWAY_CONFIG_LINES.length &&\n        SWAY_CONFIG_LINES.every((pattern, index) => pattern.test(lines[index] ?? \"invalid\"));\n};\n\nexport {\n    createBusConfig,\n    createHeadlessRuntimeMarker,\n    createSwayConfig,\n    HEADLESS_RUNTIME_MARKER,\n    isSwayConfig,\n};\n"]}

package/dist/headless-display.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"headless-display.d.ts","sourceRoot":"","sources":["../src/headless-display.ts"],"names":[],"mappings":"AASA;;GAEG;AACH,KAAK,YAAY,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEtC;;GAEG;AACH,KAAK,eAAe,GAAG;IACnB,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;IACb,4DAA4D;IAC5D,UAAU,EAAE,YAAY,CAAC;CAC5B,CAAC;AAuGF,QAAA,MAAM,mBAAmB;;;;;;;;;;;CAWxB,CAAC;AAEF,QAAA,MAAM,sBAAsB,GAAI,UAAU,OAAO,CAAC,eAAe,CAAC,KAAG,eAGnE,CAAC;AAqCH,QAAA,MAAM,mBAAmB,GAAI,QAAQ,eAAe,KAAG,OAAO,CAAC,eAAe,CAe7E,CAAC;AAsOF,QAAA,MAAM,oBAAoB,GAAU,SAAS,eAAe,KAAG,OAAO,CAAC,MAAM,IAAI,CAmDhF,CAAC;AAEF,OAAO,EACH,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,eAAe,GACvB,CAAC"}
+{"version":3,"file":"headless-display.d.ts","sourceRoot":"","sources":["../src/headless-display.ts"],"names":[],"mappings":"AAoBA;;GAEG;AACH,KAAK,YAAY,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEtC;;GAEG;AACH,KAAK,eAAe,GAAG;IACnB,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;IACb,4DAA4D;IAC5D,UAAU,EAAE,YAAY,CAAC;CAC5B,CAAC;AAoGF,QAAA,MAAM,mBAAmB;;;;;;;;;;;CAWxB,CAAC;AAEF,QAAA,MAAM,sBAAsB,GAAI,UAAU,OAAO,CAAC,eAAe,CAAC,KAAG,eAWpE,CAAC;AAqCF,QAAA,MAAM,mBAAmB,GAAI,QAAQ,eAAe,KAAG,OAAO,CAAC,eAAe,CAe7E,CAAC;AA6TF,QAAA,MAAM,oBAAoB,GAAU,SAAS,eAAe,KAAG,OAAO,CAAC,MAAM,IAAI,CAqDhF,CAAC;AAEF,OAAO,EACH,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,eAAe,GACvB,CAAC"}

package/dist/headless-display.js

@@ -1,15 +1,15 @@
-import { resolveExecutable, spawnWithParentDeathSignal } from "@gtkx/utils";
+import { isProcessAlive, resolveExecutable, spawnWithParentDeathSignal, spawnWithParentDeathSupervisor, } from "@gtkx/utils";
 import { spawnSync } from "node:child_process";
-import { chmodSync, createWriteStream, existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { Socket } from "node:net";
+import { chmodSync, closeSync, existsSync, mkdtempSync, openSync, rmSync, writeFileSync, writeSync } from "node:fs";
+import { connect, Socket } from "node:net";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { createBusConfig, createHeadlessRuntimeMarker, createSwayConfig, HEADLESS_RUNTIME_MARKER, } from "./headless-config.js";
 import { startNotificationService } from "./notification-service.js";
 import { startVirtualSeat } from "./virtual-seat.js";
 const DEFAULT_HEADLESS_SIZE = "1024x768";
 const DEFAULT_HEADLESS_COMPOSITOR = "sway";
-const BUS_CONFIG_DOCTYPE = '<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN" ' +
-    '"https://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">';
+const HEADLESS_SIZE_PATTERN = /^[1-9]\d*x[1-9]\d*$/;
 const hasWestonFakeSeat = createWestonFakeSeatProbe();
 const compositorRegistry = {
     sway: {
@@ -24,17 +24,11 @@ const compositorRegistry = {
         },
         start: (runtimeDir, width, height) => {
             const configPath = join(runtimeDir, "sway.conf");
-            writeFileSync(configPath, [
-                "xwayland disable",
-                "default_border none",
-                "default_floating_border none",
-                `output HEADLESS-1 resolution ${width}x${height}`,
-                "output HEADLESS-1 bg #000000 solid_color",
-                'for_window [app_id=".*"] floating enable, border none',
-                'for_window [title=".*"] floating enable, border none',
-                "",
-            ].join("\n"));
-            return spawnWithParentDeathSignal("sway", ["-c", configPath], { stdio: ["ignore", "ignore", "pipe"] });
+            writeFileSync(configPath, createSwayConfig(width, height));
+            return spawnWithParentDeathSupervisor("sway", ["-c", configPath], {
+                stdio: ["ignore", "ignore", "pipe"],
+                cleanupDirectory: runtimeDir,
+            });
         },
     },
     weston: {
@@ -48,7 +42,7 @@ const compositorRegistry = {
             `--width=${width}`,
             `--height=${height}`,
             "--socket=wayland-0",
-        ], { stdio: ["ignore", "ignore", "pipe"] }),
+        ], { stdio: ["ignore", "ignore", "pipe"], cleanupDirectories: [_runtimeDir] }),
     },
 };
 const STATIC_HEADLESS_ENV = {
@@ -63,10 +57,16 @@ const STATIC_HEADLESS_ENV = {
     ALSOFT_DRIVERS: "null",
     ALSOFT_LOGLEVEL: "0",
 };
-const resolveHeadlessOptions = (provided) => ({
-    size: provided.size ?? DEFAULT_HEADLESS_SIZE,
-    compositor: provided.compositor ?? DEFAULT_HEADLESS_COMPOSITOR,
-});
+const resolveHeadlessOptions = (provided) => {
+    const size = provided.size ?? DEFAULT_HEADLESS_SIZE;
+    if (!HEADLESS_SIZE_PATTERN.test(size)) {
+        throw new Error(`Invalid headless display size: ${size}`);
+    }
+    return {
+        size,
+        compositor: provided.compositor ?? DEFAULT_HEADLESS_COMPOSITOR,
+    };
+};
 const applyEnv = (snapshot, values) => {
     for (const [name, value] of Object.entries(values)) {
         if (!Object.hasOwn(snapshot, name)) {
@@ -119,21 +119,8 @@ const startCompositor = (runtimeDir, options, env) => {
     };
 };
 const noVirtualSeat = () => undefined;
-const attachVirtualSeat = (compositor, socketPath) => compositor.requiresVirtualSeat ? startVirtualSeat(socketPath) : Promise.resolve(noVirtualSeat);
 const writeBusConfig = (busConfigPath, busSocketPath) => {
-    writeFileSync(busConfigPath, [
-        BUS_CONFIG_DOCTYPE,
-        "<busconfig>",
-        "  <type>session</type>",
-        `  <listen>unix:path=${busSocketPath}</listen>`,
-        "  <auth>EXTERNAL</auth>",
-        '  <policy context="default">',
-        '    <allow send_destination="*" eavesdrop="true"/>',
-        '    <allow eavesdrop="true"/>',
-        '    <allow own="*"/>',
-        "  </policy>",
-        "</busconfig>",
-    ].join("\n"));
+    writeFileSync(busConfigPath, createBusConfig(busSocketPath));
 };
 const exitedMessage = (label, path, code, signal) => `${label} exited (code ${String(code)}, signal ${signal ?? "null"}) before ${path} appeared`;
 const monitorChild = (child, label, path) => {
@@ -163,6 +150,7 @@ const monitorChild = (child, label, path) => {
         path,
         read: () => log,
         failure: () => failure,
+        isRunning: () => child.exitCode === null && child.signalCode === null && isProcessAlive(child.pid),
         subscribe: (notify) => {
             subscribers.add(notify);
             return () => {
@@ -184,11 +172,9 @@ const runCleanups = (cleanups) => {
     }
     cleanups.length = 0;
 };
-const pollForPath = (path, onFound) => setInterval(() => {
-    if (existsSync(path)) {
-        onFound();
-    }
-}, 50);
+const isMonitorReady = (monitor) => monitor.isRunning() && existsSync(monitor.path);
+const pendingMonitors = (monitors) => monitors.filter((monitor) => !isMonitorReady(monitor));
+const isEveryMonitorReady = (monitors) => monitors.every((monitor) => isMonitorReady(monitor));
 const firstFailure = (monitors) => {
     for (const monitor of monitors) {
         const failure = monitor.failure();
@@ -198,66 +184,125 @@ const firstFailure = (monitors) => {
     }
     return undefined;
 };
-const watchForSocket = ({ options, resolve, reject }) => {
-    const { monitor, guards = [], timeout = 15_000 } = options;
-    const watched = [monitor, ...guards];
-    const cleanups = [monitor.stop];
+const SOCKET_TIMEOUT_MS = 15_000;
+const missingMessage = (pending, timeout) => `${pending.map((monitor) => monitor.label).join(", ")} did not become available within ${String(timeout)}ms\n` +
+    pending.map((monitor) => monitor.read()).join("");
+const watchForSockets = ({ options, resolve, reject }) => {
+    const { monitors, timeout = SOCKET_TIMEOUT_MS } = options;
+    const cleanups = monitors.map((monitor) => monitor.stop);
     const stop = () => {
         runCleanups(cleanups);
     };
     const fail = (message) => {
         stop();
-        for (const guard of guards) {
-            guard.stop();
-        }
         reject(new Error(message));
     };
-    const alreadyFailed = firstFailure(watched);
+    const alreadyFailed = firstFailure(monitors);
     if (alreadyFailed !== undefined) {
         fail(alreadyFailed);
         return;
     }
-    const poll = pollForPath(monitor.path, () => {
+    const settle = () => {
         stop();
         resolve();
-    });
+    };
+    if (isEveryMonitorReady(monitors)) {
+        settle();
+        return;
+    }
+    const poll = setInterval(() => {
+        if (isEveryMonitorReady(monitors)) {
+            settle();
+        }
+    }, 10);
     const timer = setTimeout(() => {
-        fail(`${monitor.label} did not become available within ${String(timeout)}ms\n${monitor.read()}`);
+        fail(missingMessage(pendingMonitors(monitors), timeout));
     }, timeout);
     cleanups.push(() => {
         clearInterval(poll);
         clearTimeout(timer);
-    }, ...watched.map((entry) => entry.subscribe(fail)));
+    }, ...monitors.map((monitor) => monitor.subscribe(fail)));
 };
-const waitForSocket = (options) => new Promise((resolve, reject) => {
-    watchForSocket({ options, resolve, reject });
+const waitForSockets = (options) => new Promise((resolve, reject) => {
+    watchForSockets({ options, resolve, reject });
 });
 const captureCompositorStderr = (child, logPath) => {
     const captured = [];
     const stderr = child.stderr;
-    if (stderr !== null) {
-        stderr.setEncoding("utf8");
-        const logStream = createWriteStream(logPath);
-        logStream.on("error", () => undefined);
-        stderr.on("data", (chunk) => {
-            captured.push(chunk);
-            logStream.write(chunk);
-        });
+    if (stderr === null) {
+        return { chunks: captured, logPath, stop: noVirtualSeat };
     }
-    return captured;
+    stderr.setEncoding("utf8");
+    const descriptor = openSync(logPath, "a");
+    let isOpen = true;
+    const onData = (chunk) => {
+        captured.push(chunk);
+        try {
+            writeSync(descriptor, chunk);
+        }
+        catch {
+            return;
+        }
+    };
+    stderr.on("data", onData);
+    return {
+        chunks: captured,
+        logPath,
+        stop: () => {
+            stderr.removeListener("data", onData);
+            if (isOpen) {
+                isOpen = false;
+                closeSync(descriptor);
+            }
+        },
+    };
 };
-const compositorExitMessage = (code, signal, capturedStderr) => `[gtkx] the headless compositor exited (code ${String(code)}, signal ${signal ?? "null"}); ` +
-    `every Wayland client in this worker has been severed.\n${capturedStderr.join("")}`;
-const watchCompositorExit = (child, capturedStderr) => {
+const compositorExitMessage = (code, signal, captured) => `[gtkx] the headless compositor exited (code ${String(code)}, signal ${signal ?? "null"}); ` +
+    "every Wayland client in this worker has been severed. " +
+    `Its stderr log is kept at ${captured.logPath} until this worker exits.\n${captured.chunks.join("")}`;
+const watchCompositorExit = (child, captured) => {
     const report = (code, signal) => {
-        process.stderr.write(compositorExitMessage(code, signal, capturedStderr));
+        process.stderr.write(compositorExitMessage(code, signal, captured));
     };
     child.on("exit", report);
     return () => child.removeListener("exit", report);
 };
-const waitForDisplaySockets = async ({ compositorMonitor, busMonitor }) => {
-    await waitForSocket({ monitor: busMonitor, guards: [compositorMonitor] });
-    await waitForSocket({ monitor: compositorMonitor });
+const waitForDisplaySockets = ({ compositorMonitor, busMonitor }) => waitForSockets({ monitors: [busMonitor, compositorMonitor] });
+const CONNECT_RETRY_MS = 10;
+const pause = (duration) => new Promise((resolve) => {
+    setTimeout(resolve, duration);
+});
+const connectFailure = (path) => new Promise((resolve) => {
+    const socket = connect(path);
+    socket.once("connect", () => {
+        socket.destroy();
+        resolve(undefined);
+    });
+    socket.once("error", (cause) => {
+        socket.destroy();
+        resolve(cause);
+    });
+});
+const unreachableMessage = (monitor, cause) => `${monitor.label} did not accept a connection on ${monitor.path}: ${cause.message}\n${monitor.read()}`;
+const waitUntilConnectable = async (monitor) => {
+    const deadline = Date.now() + SOCKET_TIMEOUT_MS;
+    for (;;) {
+        const failure = await connectFailure(monitor.path);
+        if (failure === undefined) {
+            return;
+        }
+        if (!monitor.isRunning() || Date.now() >= deadline) {
+            throw new Error(unreachableMessage(monitor, failure));
+        }
+        await pause(CONNECT_RETRY_MS);
+    }
+};
+const attachCompositorClient = async (compositor, monitor) => {
+    if (compositor.requiresVirtualSeat) {
+        return startVirtualSeat(monitor.path);
+    }
+    await waitUntilConnectable(monitor);
+    return noVirtualSeat;
 };
 const killSpawned = (children) => {
     for (const child of children) {
@@ -274,22 +319,37 @@ const makeTeardown = (stops) => {
         runCleanups(stops);
     };
 };
+const createHeadlessRuntimeDirectory = () => {
+    const runtimeDir = mkdtempSync(join(tmpdir(), "gtkx-xdg-"));
+    try {
+        chmodSync(runtimeDir, 0o700);
+        const markerPath = join(runtimeDir, HEADLESS_RUNTIME_MARKER);
+        writeFileSync(markerPath, createHeadlessRuntimeMarker(runtimeDir), { flag: "wx", mode: 0o600 });
+        chmodSync(markerPath, 0o600);
+        return runtimeDir;
+    }
+    catch (error) {
+        rmSync(runtimeDir, { recursive: true, force: true });
+        throw error;
+    }
+};
 const startHeadlessDisplay = async (options) => {
     const env = {};
-    const runtimeDir = mkdtempSync(join(tmpdir(), "gtkx-xdg-"));
-    chmodSync(runtimeDir, 0o700);
+    const runtimeDir = createHeadlessRuntimeDirectory();
     const spawned = [];
     const removeRuntime = () => {
         restoreEnv(env);
         rmSync(runtimeDir, { recursive: true, force: true });
     };
     try {
+        applyEnv(env, STATIC_HEADLESS_ENV);
         applyEnv(env, { XDG_RUNTIME_DIR: runtimeDir });
         const busConfigPath = join(runtimeDir, "session.conf");
         const busSocketPath = join(runtimeDir, "bus");
         writeBusConfig(busConfigPath, busSocketPath);
         const busChild = spawnWithParentDeathSignal("dbus-daemon", [`--config-file=${busConfigPath}`], {
             stdio: ["ignore", "ignore", "pipe"],
+            cleanupDirectories: [runtimeDir],
         });
         busChild.unref();
         spawned.push(busChild);
@@ -302,12 +362,13 @@ const startHeadlessDisplay = async (options) => {
         const compositorMonitor = monitorChild(compositor.child, "Compositor", compositorSocketPath);
         applyEnv(env, { WAYLAND_DISPLAY: compositor.socket });
         await waitForDisplaySockets({ compositorMonitor, busMonitor });
-        const stopVirtualSeat = await attachVirtualSeat(compositor, compositorSocketPath);
+        const stopVirtualSeat = await attachCompositorClient(compositor, compositorMonitor);
         const stopNotifications = await startNotificationService(`unix:path=${busSocketPath}`);
         const capturedStderr = captureCompositorStderr(compositor.child, join(runtimeDir, "compositor.stderr.log"));
         const stopExitWatch = watchCompositorExit(compositor.child, capturedStderr);
         return makeTeardown([
             stopExitWatch,
+            capturedStderr.stop,
             () => {
                 killSpawned(spawned);
             },