@nyssance/tauri-hasgard 0.6.0-alpha.1 → 0.6.0-alpha.4

package/dist/index.js

@@ -1,29 +1,27 @@
-import {
-  stopProcessGroup
-} from "./chunk-N7YDYAKI.js";
-
 // src/endpoint.ts
-import { tmpdir } from "os";
-import { join } from "path";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 function endpointPathForPlatform(name, platform, temporaryDirectory) {
-  if (platform === "win32") return `\\\\.\\pipe\\${name}`;
+  if (platform === "win32")
+    return `\\\\.\\pipe\\${name}`;
   return join(temporaryDirectory, `${name}.sock`);
 }
 function hasgardEndpointPath(name) {
   return endpointPathForPlatform(name, process.platform, tmpdir());
 }
-
 // src/expect.ts
 async function poll(read, matches, timeoutMs) {
   if (!Number.isFinite(timeoutMs) || timeoutMs < 0)
     throw new RangeError("Assertion timeout must be a finite non-negative number");
   const deadline = Date.now() + timeoutMs;
-  for (; ; ) {
+  for (;; ) {
     try {
       const value = await read();
-      if (matches(value) || Date.now() >= deadline) return value;
+      if (matches(value) || Date.now() >= deadline)
+        return value;
     } catch (error) {
-      if (Date.now() >= deadline) throw error;
+      if (Date.now() >= deadline)
+        throw error;
     }
     await new Promise((resolve) => setTimeout(resolve, Math.min(50, Math.max(0, deadline - Date.now()))));
   }
@@ -31,29 +29,22 @@ async function poll(read, matches, timeoutMs) {
 function createHasgardExpect(playwrightExpect) {
   return playwrightExpect.extend({
     async toBeVisible(locator, options = {}) {
-      const timeout = options.timeout === void 0 ? 5e3 : options.timeout;
-      const result = await poll(
-        () => locator.isVisible(),
-        (visible) => this.isNot ? !visible : visible,
-        timeout
-      );
+      const { timeout = 5000 } = options;
+      const result = await poll(() => locator.isVisible(), (visible) => this.isNot ? !visible : visible, timeout);
       return {
-        pass: result === true,
+        pass: result,
         message: () => this.isNot ? "expected Hasgard locator not to be visible" : `expected Hasgard locator to be visible within ${timeout}ms`
       };
     },
     async toHaveText(locator, expected, options = {}) {
-      const timeout = options.timeout === void 0 ? 5e3 : options.timeout;
+      const { timeout = 5000 } = options;
       const matches = (text) => {
-        if (typeof expected === "string") return text === expected;
+        if (typeof expected === "string")
+          return text === expected;
         expected.lastIndex = 0;
         return expected.test(text);
       };
-      const result = await poll(
-        () => locator.textContent(),
-        (text) => this.isNot ? !matches(text) : matches(text),
-        timeout
-      );
+      const result = await poll(() => locator.textContent(), (text) => this.isNot ? !matches(text) : matches(text), timeout);
       return {
         pass: matches(result),
         message: () => this.isNot ? `expected Hasgard locator text not to match ${String(expected)}, received ${String(result)}` : `expected Hasgard locator text to match ${String(expected)}, received ${String(result)}`
@@ -61,13 +52,46 @@ function createHasgardExpect(playwrightExpect) {
     }
   });
 }
+// src/process-manager.ts
+import { fork, spawn } from "node:child_process";
+import { lstat } from "node:fs/promises";
+import { createConnection } from "node:net";
+import { setTimeout as delay2 } from "node:timers/promises";
+
+// src/process-group.js
+import { setTimeout as delay } from "node:timers/promises";
+function signalGroup(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+    return true;
+  } catch (error) {
+    if (error.code === "ESRCH")
+      return false;
+    if (signal === 0 && error.code === "EPERM")
+      return true;
+    throw error;
+  }
+}
+async function waitForExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (signalGroup(pid, 0)) {
+    if (Date.now() >= deadline)
+      return false;
+    await delay(25);
+  }
+  return true;
+}
+async function stopProcessGroup(pid) {
+  signalGroup(pid, "SIGTERM");
+  if (!await waitForExit(pid, 5000)) {
+    signalGroup(pid, "SIGKILL");
+    if (!await waitForExit(pid, 5000))
+      throw new Error(`Hasgard process group ${pid} survived SIGKILL`);
+  }
+}
 
 // src/process-manager.ts
-import { fork, spawn } from "child_process";
-import { lstat } from "fs/promises";
-import { createConnection } from "net";
-import { setTimeout as delay } from "timers/promises";
-var HasgardProcess = class {
+class HasgardProcess {
   child;
   stdout = "";
   stderr = "";
@@ -75,28 +99,29 @@ var HasgardProcess = class {
   stopping;
   applicationPid;
   applicationExit;
-  /** Bounded log tails and the supervisor's actual child-close result. */
   async diagnostics(waitForExitMs = 0) {
-    if (!Number.isFinite(waitForExitMs) || waitForExitMs < 0) throw new RangeError("Invalid diagnostics wait");
+    if (!Number.isFinite(waitForExitMs) || waitForExitMs < 0)
+      throw new RangeError("Invalid diagnostics wait");
     const deadline = Date.now() + waitForExitMs;
     while (this.child && !this.applicationExit && Date.now() < deadline)
-      await delay(Math.min(25, deadline - Date.now()));
+      await delay2(Math.min(25, deadline - Date.now()));
     return { pid: this.applicationPid, exit: this.applicationExit, stdout: this.stdout, stderr: this.stderr };
   }
   async start(config, socketPath) {
-    if (this.child || this.stopping || this.starting) throw new Error("Hasgard app process is already running");
+    if (this.child || this.stopping || this.starting)
+      throw new Error("Hasgard app process is already running");
     this.starting = this.launch(config, socketPath);
     try {
       await this.starting;
     } finally {
-      this.starting = void 0;
+      this.starting = undefined;
     }
   }
   async launch(config, socketPath) {
     this.stdout = "";
     this.stderr = "";
-    this.applicationPid = void 0;
-    this.applicationExit = void 0;
+    this.applicationPid = undefined;
+    this.applicationExit = undefined;
     if (process.platform !== "win32" && await endpointAcceptsConnections(socketPath)) {
       throw new Error(`Hasgard endpoint is already in use: ${socketPath}`);
     }
@@ -151,26 +176,28 @@ var HasgardProcess = class {
         };
         child.once("error", failed);
         child.once("exit", () => failed(new Error("Hasgard process supervisor exited")));
-        child.on(
-          "message",
-          (message) => {
-            if (message.type === "stdout") this.stdout = appendOutput(this.stdout, message.data);
-            else if (message.type === "stderr") this.stderr = appendOutput(this.stderr, message.data);
-            else if (message.type === "exit") this.applicationExit = { code: message.code, signal: message.signal };
-            else if (message.type === "error") failed(Object.assign(new Error(message.message), { code: message.code }));
-            else if (message.type === "started") {
-              if (!Number.isSafeInteger(message.pid) || message.pid <= 1) {
-                failed(new Error("Invalid supervised application PID"));
-                return;
-              }
-              this.applicationPid = message.pid;
-              clearTimeout(timer);
-              resolve();
+        child.on("message", (message) => {
+          if (message.type === "stdout")
+            this.stdout = appendOutput(this.stdout, message.data);
+          else if (message.type === "stderr")
+            this.stderr = appendOutput(this.stderr, message.data);
+          else if (message.type === "exit")
+            this.applicationExit = { code: message.code, signal: message.signal };
+          else if (message.type === "error")
+            failed(Object.assign(new Error(message.message), { code: message.code }));
+          else if (message.type === "started") {
+            if (!Number.isSafeInteger(message.pid) || message.pid <= 1) {
+              failed(new Error("Invalid supervised application PID"));
+              return;
             }
+            this.applicationPid = message.pid;
+            clearTimeout(timer);
+            resolve();
           }
-        );
+        });
         child.send({ ...config, env: { ...process.env, ...config.env, TAURI_HASGARD_SOCKET: socketPath } }, (error) => {
-          if (error) failed(error);
+          if (error)
+            failed(error);
         });
       });
       await this.waitForSocket(socketPath, config.timeoutMs);
@@ -190,114 +217,120 @@ var HasgardProcess = class {
       const child = this.child;
       if (this.applicationExit) {
         const { code, signal } = this.applicationExit;
-        throw new Error(
-          `Tauri process exited with ${signal ? `signal ${signal}` : `code ${code}`}
+        throw new Error(`Tauri process exited with ${signal ? `signal ${signal}` : `code ${code}`}
 stdout:
 ${this.stdout}
 stderr:
-${this.stderr}`
-        );
+${this.stderr}`);
       }
       if (child && (child.exitCode !== null || child.signalCode !== null)) {
-        throw new Error(
-          `Tauri process exited with ${child.signalCode ? `signal ${child.signalCode}` : `code ${child.exitCode}`}
+        throw new Error(`Tauri process exited with ${child.signalCode ? `signal ${child.signalCode}` : `code ${child.exitCode}`}
 stdout:
 ${this.stdout}
 stderr:
-${this.stderr}`
-        );
+${this.stderr}`);
       }
-      if (await endpointAcceptsConnections(socketPath)) return;
-      await delay(50);
+      if (await endpointAcceptsConnections(socketPath))
+        return;
+      await delay2(50);
     }
     throw new Error(`Hasgard socket did not appear within ${timeoutMs}ms: ${socketPath}`);
   }
   async confirmEndpointOwnership(child, path, timeoutMs) {
     const stat = await lstat(path);
-    if (!stat.isSocket()) throw new Error(`Hasgard endpoint is not a socket: ${path}`);
+    if (!stat.isSocket())
+      throw new Error(`Hasgard endpoint is not a socket: ${path}`);
     await new Promise((resolve, reject) => {
       const done = (error) => {
         clearTimeout(timer);
         child.off("message", message);
         child.off("exit", exited);
-        if (error) reject(error);
-        else resolve();
+        if (error)
+          reject(error);
+        else
+          resolve();
       };
       const message = (value) => {
-        if (value.type === "endpoint-owned") done();
-        else if (value.type === "error") done(new Error(value.message));
+        if (value.type === "endpoint-owned")
+          done();
+        else if (value.type === "error")
+          done(new Error(value.message));
       };
       const exited = () => done(new Error("Hasgard supervisor exited before acknowledging endpoint ownership"));
-      const timer = setTimeout(
-        () => done(new Error("Hasgard supervisor did not acknowledge endpoint ownership")),
-        timeoutMs
-      );
+      const timer = setTimeout(() => done(new Error("Hasgard supervisor did not acknowledge endpoint ownership")), timeoutMs);
       child.on("message", message);
       child.once("exit", exited);
       child.send({ type: "endpoint", identity: { dev: stat.dev, ino: stat.ino } }, (error) => {
-        if (error) done(error);
+        if (error)
+          done(error);
       });
     });
   }
   async stop() {
-    if (this.starting) await this.starting;
-    if (this.stopping) return this.stopping;
+    if (this.starting)
+      await this.starting;
+    if (this.stopping)
+      return this.stopping;
     this.stopping = this.stopChild();
     try {
       await this.stopping;
     } finally {
-      this.stopping = void 0;
+      this.stopping = undefined;
     }
   }
   async stopChild() {
     const child = this.child;
-    if (!child) return;
+    if (!child)
+      return;
     if (process.platform !== "win32") {
-      if (this.applicationPid !== void 0) {
+      if (this.applicationPid !== undefined) {
         await stopProcessGroup(this.applicationPid);
       }
-      const exited2 = child.exitCode !== null || child.signalCode !== null ? Promise.resolve() : new Promise((resolve) => child.once("exit", () => resolve()));
-      if (child.connected) child.disconnect();
-      const abort2 = new AbortController();
+      const exited = child.exitCode !== null || child.signalCode !== null ? Promise.resolve() : new Promise((resolve) => child.once("exit", () => resolve()));
+      if (child.connected)
+        child.disconnect();
+      const abort = new AbortController;
       try {
-        if (await Promise.race([exited2, delay(11e3, "timeout", { signal: abort2.signal })]) === "timeout") {
+        if (await Promise.race([exited, delay2(11000, "timeout", { signal: abort.signal })]) === "timeout") {
           throw new Error(`Hasgard process supervisor ${child.pid} did not finish cleanup`);
         }
       } finally {
-        abort2.abort();
+        abort.abort();
       }
-      this.child = void 0;
-      this.applicationPid = void 0;
+      this.child = undefined;
+      this.applicationPid = undefined;
       if (child.exitCode !== 0 || child.signalCode !== null) {
         throw new Error(`Hasgard supervisor cleanup failed (${child.signalCode ?? child.exitCode}):
 ${this.stderr}`);
       }
       return;
     }
-    if (child.pid === void 0 || child.exitCode !== null || child.signalCode !== null) {
-      this.child = void 0;
+    if (child.pid === undefined || child.exitCode !== null || child.signalCode !== null) {
+      this.child = undefined;
       return;
     }
     const exited = new Promise((resolve) => child.once("exit", () => resolve()));
-    if (process.platform === "win32" && child.pid !== void 0) {
+    if (process.platform === "win32" && child.pid !== undefined) {
       await terminateWindowsProcessTree(child.pid);
-    } else if (child.pid !== void 0) {
+    } else if (child.pid !== undefined) {
       process.kill(-child.pid, "SIGTERM");
     }
-    const abort = new AbortController();
-    const timeout = delay(5e3, "timeout", { signal: abort.signal });
+    const abort = new AbortController;
+    const timeout = delay2(5000, "timeout", { signal: abort.signal });
     try {
       if (await Promise.race([exited, timeout]) === "timeout") {
-        if (process.platform === "win32" && child.pid !== void 0) await terminateWindowsProcessTree(child.pid);
-        else if (child.pid !== void 0) process.kill(-child.pid, "SIGKILL");
+        if (process.platform === "win32" && child.pid !== undefined)
+          await terminateWindowsProcessTree(child.pid);
+        else if (child.pid !== undefined)
+          process.kill(-child.pid, "SIGKILL");
         await exited;
       }
     } finally {
       abort.abort();
     }
-    this.child = void 0;
+    this.child = undefined;
   }
-};
+}
 function appendOutput(previous, chunk) {
   const output = previous + chunk;
   return output.length > 65536 ? `[earlier output truncated]
@@ -306,9 +339,11 @@ ${output.slice(-65536)}` : output;
 async function endpointAcceptsConnections(path) {
   if (process.platform !== "win32") {
     try {
-      if (!(await lstat(path)).isSocket()) throw new Error(`Hasgard endpoint exists but is not a socket: ${path}`);
+      if (!(await lstat(path)).isSocket())
+        throw new Error(`Hasgard endpoint exists but is not a socket: ${path}`);
     } catch (error) {
-      if (error.code === "ENOENT") return false;
+      if (error.code === "ENOENT")
+        return false;
       throw error;
     }
   }
@@ -337,8 +372,11 @@ async function terminateWindowsProcessTree(pid) {
 }
 
 // src/rpc-client.ts
-import { createConnection as createConnection2 } from "net";
-import { createInterface } from "readline";
+import { createConnection as createConnection2 } from "node:net";
+import { createInterface } from "node:readline";
+
+// src/protocol-limits.ts
+var MAX_REQUEST_BYTES = 1048576;
 
 // src/protocol.ts
 function isObject(value) {
@@ -347,12 +385,16 @@ function isObject(value) {
 function parseRpcResponse(line) {
   const value = JSON.parse(line);
   const invalid = () => new Error(`Invalid Hasgard JSON-RPC envelope: ${line}`);
-  if (!isObject(value) || value.jsonrpc !== "2.0" || !Object.hasOwn(value, "id")) throw invalid();
-  if (value.id !== null && (!Number.isSafeInteger(value.id) || value.id < 0)) throw invalid();
+  if (!isObject(value) || value.jsonrpc !== "2.0" || !Object.hasOwn(value, "id"))
+    throw invalid();
+  if (value.id !== null && (!Number.isSafeInteger(value.id) || value.id < 0))
+    throw invalid();
   const hasResult = Object.hasOwn(value, "result");
   const hasError = Object.hasOwn(value, "error");
-  if (hasResult === hasError) throw invalid();
-  if (hasResult && value.id === null) throw invalid();
+  if (hasResult === hasError)
+    throw invalid();
+  if (hasResult && value.id === null)
+    throw invalid();
   if (hasError) {
     const error = value.error;
     if (!isObject(error) || !Number.isInteger(error.code) || error.code < -2147483648 || error.code > 2147483647 || typeof error.message !== "string")
@@ -361,11 +403,8 @@ function parseRpcResponse(line) {
   return value;
 }
 
-// src/protocol-limits.ts
-var MAX_REQUEST_BYTES = 1048576;
-
 // src/rpc-client.ts
-var HasgardRpcError = class extends Error {
+class HasgardRpcError extends Error {
   code;
   data;
   constructor(code, message, data) {
@@ -374,18 +413,20 @@ var HasgardRpcError = class extends Error {
     this.code = code;
     this.data = data;
   }
-};
-var HasgardRpcClient = class {
+}
+
+class HasgardRpcClient {
   socketPath;
   socket;
   lines;
   nextId = 1;
-  pending = /* @__PURE__ */ new Map();
+  pending = new Map;
   constructor(socketPath) {
     this.socketPath = socketPath;
   }
   async connect(timeoutMs) {
-    if (this.socket) throw new Error("Hasgard RPC client is already connected");
+    if (this.socket)
+      throw new Error("Hasgard RPC client is already connected");
     const socket = createConnection2({ path: this.socketPath });
     this.socket = socket;
     try {
@@ -414,24 +455,28 @@ var HasgardRpcClient = class {
         socket.once("close", closed);
       });
     } catch (error) {
-      if (this.socket === socket) this.socket = void 0;
+      if (this.socket === socket)
+        this.socket = undefined;
       socket.destroy();
       throw error;
     }
     this.lines = createInterface({ input: socket });
     this.lines.on("line", (line) => this.handleLine(line));
     socket.on("close", () => {
-      if (this.socket !== socket) return;
+      if (this.socket !== socket)
+        return;
       this.rejectPending(new Error("Hasgard socket closed"));
       this.disconnect();
     });
     socket.on("error", (error) => {
-      if (this.socket === socket) this.rejectPending(error);
+      if (this.socket === socket)
+        this.rejectPending(error);
     });
   }
   async call(method, params) {
     const socket = this.socket;
-    if (!socket || socket.destroyed || !socket.writable) throw new Error("Hasgard RPC client is not connected");
+    if (!socket || socket.destroyed || !socket.writable)
+      throw new Error("Hasgard RPC client is not connected");
     const id = this.nextId;
     this.nextId += 1;
     const request = params ? { jsonrpc: "2.0", id, method, params } : { jsonrpc: "2.0", id, method };
@@ -448,9 +493,11 @@ var HasgardRpcClient = class {
       });
     });
     socket.write(line, (error) => {
-      if (!error) return;
+      if (!error)
+        return;
       const pending = this.pending.get(id);
-      if (!pending) return;
+      if (!pending)
+        return;
       this.pending.delete(id);
       pending.reject(error);
     });
@@ -458,9 +505,9 @@ var HasgardRpcClient = class {
   }
   disconnect() {
     this.lines?.close();
-    this.lines = void 0;
+    this.lines = undefined;
     this.socket?.destroy();
-    this.socket = void 0;
+    this.socket = undefined;
     this.rejectPending(new Error("Hasgard RPC client disconnected"));
   }
   handleLine(line) {
@@ -475,7 +522,7 @@ var HasgardRpcClient = class {
       this.rejectPending(new HasgardRpcError(response.error.code, response.error.message, response.error.data));
       return;
     }
-    const pending = response.id === null ? void 0 : this.pending.get(response.id);
+    const pending = response.id === null ? undefined : this.pending.get(response.id);
     if (!pending) {
       this.rejectPending(new Error(`Unexpected Hasgard JSON-RPC response id: ${response.id}`));
       return;
@@ -488,19 +535,20 @@ var HasgardRpcClient = class {
     pending.resolve(response.result);
   }
   rejectPending(error) {
-    for (const pending of this.pending.values()) pending.reject(error);
+    for (const pending of this.pending.values())
+      pending.reject(error);
     this.pending.clear();
   }
-};
+}
 
 // src/window.ts
-import { readFile } from "fs/promises";
-import { basename } from "path";
-var locks = /* @__PURE__ */ new WeakMap();
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+var locks = new WeakMap;
 function lockFor(rpc, label) {
   let clientLocks = locks.get(rpc);
   if (!clientLocks) {
-    clientLocks = /* @__PURE__ */ new Map();
+    clientLocks = new Map;
     locks.set(rpc, clientLocks);
   }
   let lock = clientLocks.get(label);
@@ -518,36 +566,44 @@ function withWindow(window, params) {
 }
 async function readFileInputs(files) {
   const list = Array.isArray(files) ? files : [files];
-  return Promise.all(
-    list.map(async (entry) => {
-      if (typeof entry !== "string") return entry;
-      const contents = await readFile(entry);
-      return { name: basename(entry), data: contents.toString("base64") };
-    })
-  );
+  return Promise.all(list.map(async (entry) => {
+    if (typeof entry !== "string")
+      return entry;
+    const contents = await readFile(entry);
+    return { name: basename(entry), data: contents.toString("base64") };
+  }));
 }
 function targetParams(target) {
-  if ("ref" in target) return { ref: target.ref };
+  if ("ref" in target)
+    return { ref: target.ref };
   if ("selector" in target) {
-    return target.index === void 0 ? { selector: target.selector } : { selector: target.selector, index: target.index };
+    return target.index === undefined ? { selector: target.selector } : { selector: target.selector, index: target.index };
   }
   return { x: target.x, y: target.y };
 }
 function clickParams(options) {
   const params = {};
-  if (options.modifiers !== void 0) params.modifiers = options.modifiers;
-  if (options.button !== void 0) params.button = options.button;
-  if (options.clickCount !== void 0) params.clickCount = options.clickCount;
-  if (options.position !== void 0) params.position = { ...options.position };
+  if (options.modifiers !== undefined)
+    params.modifiers = options.modifiers;
+  if (options.button !== undefined)
+    params.button = options.button;
+  if (options.clickCount !== undefined)
+    params.clickCount = options.clickCount;
+  if (options.position !== undefined)
+    params.position = { ...options.position };
   return params;
 }
 function routeParams(options) {
   const params = { pattern: options.pattern };
-  if (options.method !== void 0) params.method = options.method;
-  if (options.times !== void 0) params.times = options.times;
-  if ("status" in options && options.status !== void 0) params.status = options.status;
-  if ("body" in options && options.body !== void 0) params.body = options.body;
-  if ("contentType" in options && options.contentType !== void 0) {
+  if (options.method !== undefined)
+    params.method = options.method;
+  if (options.times !== undefined)
+    params.times = options.times;
+  if ("status" in options && options.status !== undefined)
+    params.status = options.status;
+  if ("body" in options && options.body !== undefined)
+    params.body = options.body;
+  if ("contentType" in options && options.contentType !== undefined) {
     params.contentType = options.contentType;
   }
   return params;
@@ -595,27 +651,32 @@ function expectRecord(value, context) {
   return value;
 }
 function expectString(value, context) {
-  if (typeof value !== "string") throw new Error(`${context} must be a string`);
+  if (typeof value !== "string")
+    throw new Error(`${context} must be a string`);
   return value;
 }
 function expectBoolean(value, context) {
-  if (typeof value !== "boolean") throw new Error(`${context} must be a boolean`);
+  if (typeof value !== "boolean")
+    throw new Error(`${context} must be a boolean`);
   return value;
 }
 function expectNumber(value, context) {
-  if (typeof value !== "number") throw new Error(`${context} must be a number`);
+  if (typeof value !== "number")
+    throw new Error(`${context} must be a number`);
   return value;
 }
 function expectArray(value, context) {
-  if (!Array.isArray(value)) throw new Error(`${context} must be an array`);
+  if (!Array.isArray(value))
+    throw new Error(`${context} must be an array`);
   return value;
 }
 function expectNullableString(value, context) {
-  if (value === null) return null;
+  if (value === null)
+    return null;
   return expectString(value, context);
 }
 function optionalString(value, context) {
-  return value === void 0 ? void 0 : expectString(value, context);
+  return value === undefined ? undefined : expectString(value, context);
 }
 function parseConsoleLogEntry(value, index) {
   const entry = expectRecord(value, `console.getLogs[${index}]`);
@@ -650,7 +711,8 @@ function parseFormField(value, context) {
     name: expectString(field.name, `${context}.name`),
     value: Array.isArray(raw) ? raw.map((option, index) => expectString(option, `${context}.value[${index}]`)) : expectString(raw, `${context}.value`)
   };
-  if (field.checked !== void 0) parsed.checked = expectBoolean(field.checked, `${context}.checked`);
+  if (field.checked !== undefined)
+    parsed.checked = expectBoolean(field.checked, `${context}.checked`);
   return parsed;
 }
 function parseFormEntry(value, index) {
@@ -661,11 +723,9 @@ function parseFormEntry(value, index) {
     name: expectString(form.name, `${context}.name`),
     action: expectString(form.action, `${context}.action`),
     method: expectString(form.method, `${context}.method`),
-    fields: expectArray(form.fields, `${context}.fields`).map(
-      (field, fieldIndex) => parseFormField(field, `${context}.fields[${fieldIndex}]`)
-    )
+    fields: expectArray(form.fields, `${context}.fields`).map((field, fieldIndex) => parseFormField(field, `${context}.fields[${fieldIndex}]`))
   };
-  if (form.fieldsTruncated !== void 0) {
+  if (form.fieldsTruncated !== undefined) {
     parsed.fieldsTruncated = expectBoolean(form.fieldsTruncated, `${context}.fieldsTruncated`);
   }
   return parsed;
@@ -674,15 +734,20 @@ function parseWatchNode(value, context) {
   const node = expectRecord(value, context);
   const parsed = { tag: expectString(node.tag, `${context}.tag`) };
   const id = optionalString(node.id, `${context}.id`);
-  if (id !== void 0) parsed.id = id;
+  if (id !== undefined)
+    parsed.id = id;
   const className = optionalString(node.class, `${context}.class`);
-  if (className !== void 0) parsed.class = className;
+  if (className !== undefined)
+    parsed.class = className;
   const text = optionalString(node.text, `${context}.text`);
-  if (text !== void 0) parsed.text = text;
+  if (text !== undefined)
+    parsed.text = text;
   const attr = optionalString(node.attr, `${context}.attr`);
-  if (attr !== void 0) parsed.attr = attr;
+  if (attr !== undefined)
+    parsed.attr = attr;
   const attrValue = optionalString(node.value, `${context}.value`);
-  if (attrValue !== void 0) parsed.value = attrValue;
+  if (attrValue !== undefined)
+    parsed.value = attrValue;
   return parsed;
 }
 function parseWatchNodes(value, context) {
@@ -693,9 +758,7 @@ function parseDiffChange(value, index) {
   return {
     old: parseSnapshotElement(change.old, index),
     new: parseSnapshotElement(change.new, index),
-    changes: expectArray(change.changes, `diff.changed[${index}].changes`).map(
-      (entry, entryIndex) => expectString(entry, `diff.changed[${index}].changes[${entryIndex}]`)
-    )
+    changes: expectArray(change.changes, `diff.changed[${index}].changes`).map((entry, entryIndex) => expectString(entry, `diff.changed[${index}].changes[${entryIndex}]`))
   };
 }
 function parseRecorderEntry(value, index) {
@@ -706,7 +769,8 @@ function parseRecorderEntry(value, index) {
     timestamp: expectNumber(entry.timestamp, `record.stop.entries[${index}].timestamp`)
   };
 }
-var HasgardApplication = class {
+
+class HasgardApplication {
   rpc;
   constructor(rpc) {
     this.rpc = rpc;
@@ -720,7 +784,8 @@ var HasgardApplication = class {
   }
   async windows() {
     const value = expectRecord(await this.rpc.call("windows.list"), "windows.list result");
-    if (!Array.isArray(value.windows)) throw new Error("windows.list.windows must be an array");
+    if (!Array.isArray(value.windows))
+      throw new Error("windows.list.windows must be an array");
     return value.windows.map((entry, index) => {
       const window = expectRecord(entry, `windows[${index}]`);
       const info = {
@@ -728,7 +793,7 @@ var HasgardApplication = class {
         url: expectString(window.url, `windows[${index}].url`),
         title: expectString(window.title, `windows[${index}].title`)
       };
-      if (window.native_id !== void 0) {
+      if (window.native_id !== undefined) {
         info.nativeId = expectNumber(window.native_id, `windows[${index}].native_id`);
       }
       return info;
@@ -741,9 +806,11 @@ var HasgardApplication = class {
         const window = this.window(label);
         try {
           const state = await window.state();
-          if (state.url !== "about:blank" && state.readyState !== "loading") return window;
+          if (state.url !== "about:blank" && state.readyState !== "loading")
+            return window;
         } catch (error) {
-          if (!(error instanceof HasgardRpcError) || error.code !== -32002) throw error;
+          if (!(error instanceof HasgardRpcError) || error.code !== -32002)
+            throw error;
         }
       }
       await new Promise((resolve) => setTimeout(resolve, 50));
@@ -754,7 +821,8 @@ var HasgardApplication = class {
     const window = await this.waitForWindow(label, timeoutMs);
     const deadline = Date.now() + timeoutMs;
     while (Date.now() <= deadline) {
-      if (await window.locator(readySelector).count() === 1) return window;
+      if (await window.locator(readySelector).count() === 1)
+        return window;
       await new Promise((resolve) => setTimeout(resolve, 50));
     }
     throw new Error(`Window '${label}' did not match ready selector '${readySelector}' within ${timeoutMs}ms`);
@@ -762,10 +830,6 @@ var HasgardApplication = class {
   window(label) {
     return new HasgardWindow(this.rpc, label);
   }
-  /**
-   * Action recorder. Captures the RPC calls this connection makes into a
-   * replayable scenario — this is not video capture.
-   */
   recorder = {
     start: async () => {
       await this.rpc.call("record.start");
@@ -789,8 +853,9 @@ var HasgardApplication = class {
       await this.rpc.call("record.add", entry);
     }
   };
-};
-var HasgardWindow = class {
+}
+
+class HasgardWindow {
   label;
   rpc;
   constructor(rpc, label) {
@@ -803,12 +868,6 @@ var HasgardWindow = class {
   getByRole(role, query = {}) {
     return new HasgardLocator(this, { kind: "role", role, query });
   }
-  /**
-   * Locate by visible text. Matching runs in the page against the live DOM, not
-   * against a snapshot's `name`: that field collapses aria-label, alt, `<label>`,
-   * placeholder, and text into one 50-character string, so a button with an
-   * aria-label would never be findable by the text it actually shows.
-   */
   getByText(text, query = {}) {
     return new HasgardLocator(this, { kind: "query", by: "text", value: text, query });
   }
@@ -824,27 +883,16 @@ var HasgardWindow = class {
   getByTitle(text, query = {}) {
     return new HasgardLocator(this, { kind: "query", by: "title", value: text, query });
   }
-  /** Test ids always match exactly, so `save` cannot select `save-draft`. */
   getByTestId(testId) {
     return new HasgardLocator(this, { kind: "query", by: "testid", value: testId, query: {} });
   }
-  /**
-   * Scope locators to a same-origin `<iframe>`.
-   *
-   * Cross-origin frames are out of reach: the same-origin policy binds injected
-   * script exactly as it binds the page's own, so no bridge can see into a
-   * third-party payment or OAuth frame. Those raise an error naming the origin
-   * problem rather than reporting a missing element.
-   */
   frameLocator(selector) {
     return new HasgardFrameLocator(this, [selector]);
   }
   async snapshot(options = {}) {
-    const raw = expectRecord(
-      await this.rpc.call("snapshot", withWindow(this.label, options)),
-      "snapshot result"
-    );
-    if (!Array.isArray(raw.elements)) throw new Error("snapshot.elements must be an array");
+    const raw = expectRecord(await this.rpc.call("snapshot", withWindow(this.label, options)), "snapshot result");
+    if (!Array.isArray(raw.elements))
+      throw new Error("snapshot.elements must be an array");
     return {
       elements: raw.elements.map((entry, index) => parseSnapshotElement(entry, index))
     };
@@ -874,31 +922,29 @@ var HasgardWindow = class {
   async title() {
     return expectString(await this.rpc.call("title", withWindow(this.label)), "title result");
   }
-  /**
-   * Navigate this webview by assigning `location.href`. Unlike Playwright's
-   * `goto`, this does not wait for the load to finish and returns no response —
-   * follow it with `waitFor` or `waitForWindowReady`.
-   */
   async navigate(url) {
     await this.rpc.call("navigate", withWindow(this.label, { url }));
   }
-  /** Scroll the document by a relative amount, or to `top`/`bottom`. */
   async scrollBy(options) {
     await this.rpc.call("scroll", withWindow(this.label, options));
   }
   async press(key, options) {
     const params = { key };
     if (options) {
-      if (options.completion !== void 0) params.completion = options.completion;
-      if (options.waitFor !== void 0) params.waitFor = options.waitFor;
-      if (options.timeoutMs !== void 0) params.timeout = options.timeoutMs;
+      if (options.completion !== undefined)
+        params.completion = options.completion;
+      if (options.waitFor !== undefined)
+        params.waitFor = options.waitFor;
+      if (options.timeoutMs !== undefined)
+        params.timeout = options.timeoutMs;
     }
     await this.rpc.call("press", withWindow(this.label, params));
   }
   async diff(options = {}) {
     const { reference, ...snapshotOptions } = options;
     const params = { ...snapshotOptions };
-    if (reference) params.reference = reference;
+    if (reference)
+      params.reference = reference;
     const value = expectRecord(await this.rpc.call("diff", withWindow(this.label, params)), "diff result");
     return {
       added: expectArray(value.added, "diff.added").map(parseSnapshotElement),
@@ -906,26 +952,25 @@ var HasgardWindow = class {
       changed: expectArray(value.changed, "diff.changed").map(parseDiffChange)
     };
   }
-  /**
-   * Poll a JavaScript expression in the webview until it returns a truthy
-   * value, and return that value. The expression is polled rather than driven
-   * by DOM mutations, so predicates that flip on a timer or a resolved fetch
-   * are caught too. A predicate that throws rejects instead of being retried.
-   */
   async waitForFunction(expression, options = {}) {
     const params = { expression };
-    if (options.timeoutMs !== void 0) params.timeout = options.timeoutMs;
-    if (options.pollMs !== void 0) params.poll = options.pollMs;
+    if (options.timeoutMs !== undefined)
+      params.timeout = options.timeoutMs;
+    if (options.pollMs !== undefined)
+      params.poll = options.pollMs;
     const value = expectRecord(await this.rpc.call("wait", withWindow(this.label, params)), "wait result");
     return value.value;
   }
-  /** Observe DOM mutations until they settle, or reject when nothing changes. */
   async watch(options = {}) {
     const params = {};
-    if (options.selector !== void 0) params.selector = options.selector;
-    if (options.timeoutMs !== void 0) params.timeout = options.timeoutMs;
-    if (options.stableMs !== void 0) params.stable = options.stableMs;
-    if (options.requireMutation !== void 0) params.requireMutation = options.requireMutation;
+    if (options.selector !== undefined)
+      params.selector = options.selector;
+    if (options.timeoutMs !== undefined)
+      params.timeout = options.timeoutMs;
+    if (options.stableMs !== undefined)
+      params.stable = options.stableMs;
+    if (options.requireMutation !== undefined)
+      params.requireMutation = options.requireMutation;
     const value = expectRecord(await this.rpc.call("watch", withWindow(this.label, params)), "watch result");
     return {
       added: parseWatchNodes(value.added, "watch.added"),
@@ -935,43 +980,31 @@ var HasgardWindow = class {
     };
   }
   async consoleLogs(options = {}) {
-    const value = await this.rpc.call(
-      "console.getLogs",
-      withWindow(this.label, options)
-    );
+    const value = await this.rpc.call("console.getLogs", withWindow(this.label, options));
     return expectArray(value, "console.getLogs result").map(parseConsoleLogEntry);
   }
   async clearConsole() {
     await this.rpc.call("console.clear", withWindow(this.label));
   }
   async networkRequests(options = {}) {
-    const value = await this.rpc.call(
-      "network.getRequests",
-      withWindow(this.label, options)
-    );
+    const value = await this.rpc.call("network.getRequests", withWindow(this.label, options));
     return expectArray(value, "network.getRequests result").map(parseNetworkRequestEntry);
   }
   async clearNetwork() {
     await this.rpc.call("network.clear", withWindow(this.label));
   }
-  /** `localStorage` by default; pass `{ session: true }` for `sessionStorage`. */
   storage = {
     get: async (key, options = {}) => {
-      const value = expectRecord(
-        await this.rpc.call("storage.get", withWindow(this.label, { key, ...options })),
-        "storage.get result"
-      );
-      if (!expectBoolean(value.found, "storage.get.found")) return null;
+      const value = expectRecord(await this.rpc.call("storage.get", withWindow(this.label, { key, ...options })), "storage.get result");
+      if (!expectBoolean(value.found, "storage.get.found"))
+        return null;
       return expectString(value.value, "storage.get.value");
     },
     set: async (key, value, options = {}) => {
       await this.rpc.call("storage.set", withWindow(this.label, { key, value, ...options }));
     },
     list: async (options = {}) => {
-      const value = expectRecord(
-        await this.rpc.call("storage.list", withWindow(this.label, { ...options })),
-        "storage.list result"
-      );
+      const value = expectRecord(await this.rpc.call("storage.list", withWindow(this.label, { ...options })), "storage.list result");
       return {
         entries: expectArray(value.entries, "storage.list.entries").map((entry, index) => {
           const parsed = expectRecord(entry, `storage.list.entries[${index}]`);
@@ -988,7 +1021,7 @@ var HasgardWindow = class {
     }
   };
   async forms(selector) {
-    const params = selector ? { selector } : void 0;
+    const params = selector ? { selector } : undefined;
     const value = expectRecord(await this.rpc.call("forms.dump", withWindow(this.label, params)), "forms.dump result");
     return {
       forms: expectArray(value.forms, "forms.dump.forms").map(parseFormEntry),
@@ -1002,22 +1035,21 @@ var HasgardWindow = class {
     return this.rpc.call("ipc", withWindow(this.label, { command, args }));
   }
   async screenshot(selector) {
-    const params = selector ? { selector } : void 0;
+    const params = selector ? { selector } : undefined;
     const dataUrl = await this.rpc.call("screenshot", withWindow(this.label, params));
     const prefix = "data:image/png;base64,";
-    if (!dataUrl.startsWith(prefix)) throw new Error("screenshot result is not a PNG data URL");
+    if (!dataUrl.startsWith(prefix))
+      throw new Error("screenshot result is not a PNG data URL");
     return Buffer.from(dataUrl.slice(prefix.length), "base64");
   }
-  /** Start a bounded recording of this native window. macOS only; requires ffmpeg. */
   async startVideo(options) {
     await this.rpc.call("video.start", {
       window: this.label,
       output_path: options.outputPath,
-      ...options.fps === void 0 ? {} : { fps: options.fps },
-      ...options.maxDurationMs === void 0 ? {} : { max_duration_ms: options.maxDurationMs }
+      ...options.fps === undefined ? {} : { fps: options.fps },
+      ...options.maxDurationMs === undefined ? {} : { max_duration_ms: options.maxDurationMs }
     });
   }
-  /** Stop recording; capture and encoder failures reject rather than returning an empty artifact. */
   async stopVideo() {
     const value = expectRecord(await this.rpc.call("video.stop", { window: this.label }), "video.stop result");
     return {
@@ -1034,26 +1066,12 @@ var HasgardWindow = class {
       pendingResult: expectBoolean(value.pending_result, "video.pending_result")
     };
   }
-  /**
-   * Capture this window through the native compositor, writing a PNG to
-   * `outputPath`. macOS only.
-   *
-   * Unlike `screenshot`, which renders the DOM inside the page, this records
-   * what the window server actually shows — so it sees native chrome, layered
-   * content, and anything the DOM renderer cannot reproduce.
-   *
-   * The operating-system window id is resolved from this window's label, so
-   * callers do not have to discover it themselves.
-   */
   async screenshotNative(options) {
     const windowId = options.windowId ?? await this.nativeId();
-    const value = expectRecord(
-      await this.rpc.call("screenshot_native", {
-        window_id: windowId,
-        output_path: options.outputPath
-      }),
-      "screenshot_native result"
-    );
+    const value = expectRecord(await this.rpc.call("screenshot_native", {
+      window_id: windowId,
+      output_path: options.outputPath
+    }), "screenshot_native result");
     return {
       output_path: expectString(value.output_path, "screenshot_native.output_path"),
       window_id: expectNumber(value.window_id, "screenshot_native.window_id"),
@@ -1065,102 +1083,58 @@ var HasgardWindow = class {
       tcc_denied: expectBoolean(value.tcc_denied, "screenshot_native.tcc_denied")
     };
   }
-  /**
-   * Scroll the page by wheel.
-   *
-   * The document sees a real `wheel` event first and may cancel it; the scroll
-   * only follows if it does not. Resolves to whether the page cancelled — which
-   * is how you tell "the app intercepted my wheel" from "nothing was
-   * listening". Use the locator method to scroll a nested scrollport.
-   */
   async wheel(deltaX, deltaY) {
     const value = expectRecord(await this.call("wheel", { deltaX, deltaY }), "wheel result");
     return expectBoolean(value.defaultPrevented, "wheel.defaultPrevented");
   }
-  /**
-   * The page's modal dialogs (`alert`, `confirm`, `prompt`).
-   *
-   * These block the webview until answered, so the bridge always answers them —
-   * dismissing by default, as Playwright does. A test that never touches this
-   * namespace still cannot hang on a `confirm()`, and can read back what the
-   * app tried to ask.
-   */
   dialogs = {
-    /** Answer every subsequent dialog with OK. `promptText` fills a `prompt`. */
     accept: async (promptText) => {
       const params = { action: "accept" };
-      if (promptText !== void 0) params.promptText = promptText;
+      if (promptText !== undefined)
+        params.promptText = promptText;
       return parseDialogPolicy(await this.call("dialog.handle", params));
     },
-    /** Answer every subsequent dialog with Cancel. This is the default. */
     dismiss: async () => parseDialogPolicy(await this.call("dialog.handle", { action: "dismiss" })),
-    /** Every dialog the page has opened so far, oldest first. */
     list: async () => {
       const value = expectRecord(await this.call("dialog.list"), "dialog.list result");
-      if (!Array.isArray(value.dialogs)) throw new Error("dialog.list.dialogs must be an array");
+      if (!Array.isArray(value.dialogs))
+        throw new Error("dialog.list.dialogs must be an array");
       return {
         dialogs: value.dialogs.map((entry, index) => parseDialogRecord(entry, index)),
         policy: parseDialogPolicy(value.policy)
       };
     },
-    /** Forget the recorded dialogs. Leaves the accept/dismiss policy alone. */
     clear: async () => {
       await this.call("dialog.clear");
     }
   };
-  /**
-   * Shape what the page's own requests receive, without a real backend.
-   *
-   * Rules are declarative rather than Playwright's per-request callback: the
-   * bridge only ever answers requests, so it cannot call back into this process
-   * and await a handler while the page sits inside `fetch`. The same constraint
-   * shaped `dialogs`.
-   *
-   * Rules are checked in registration order and the first match wins, so
-   * register the narrow ones before a catch-all. Both `fetch` and
-   * `XMLHttpRequest` are covered; resources the webview loads itself -- the
-   * document, `<img src>`, stylesheets -- are not, since no page script sees
-   * them.
-   */
   routes = {
-    /** Answer matching requests with this response instead of the network. */
     fulfill: async (options) => {
-      const value = expectRecord(
-        await this.call("route.add", { ...routeParams(options), action: "fulfill" }),
-        "route.add result"
-      );
+      const value = expectRecord(await this.call("route.add", { ...routeParams(options), action: "fulfill" }), "route.add result");
       return { id: expectNumber(value.id, "route.add.id") };
     },
-    /** Fail matching requests the way a dropped connection does. */
     abort: async (options) => {
-      const value = expectRecord(
-        await this.call("route.add", { ...routeParams(options), action: "abort" }),
-        "route.add result"
-      );
+      const value = expectRecord(await this.call("route.add", { ...routeParams(options), action: "abort" }), "route.add result");
       return { id: expectNumber(value.id, "route.add.id") };
     },
-    /** The active rules, their use counts, and every request they answered. */
     list: async () => {
       const value = expectRecord(await this.call("route.list"), "route.list result");
       return {
         routes: expectArray(value.routes, "route.list.routes").map((entry, index) => parseRouteRule(entry, index)),
-        intercepted: expectArray(value.intercepted, "route.list.intercepted").map(
-          (entry, index) => parseInterceptedRequest(entry, index)
-        )
+        intercepted: expectArray(value.intercepted, "route.list.intercepted").map((entry, index) => parseInterceptedRequest(entry, index))
       };
     },
-    /** Remove every rule and its interception log. */
     clear: async () => {
       const value = expectRecord(await this.call("route.clear"), "route.clear result");
       return { removed: expectNumber(value.removed, "route.clear.removed") };
     }
   };
-  /** This window's operating-system window id, where the platform exposes one. */
   async nativeId() {
     const listing = await new HasgardApplication(this.rpc).windows();
     const self = listing.find((entry) => entry.label === this.label);
-    if (!self) throw new Error(`Window '${this.label}' is no longer open`);
-    if (self.nativeId === void 0) {
+    if (!self)
+      throw new Error(`Window '${this.label}' is no longer open`);
+    if (self.nativeId === undefined) {
       throw new Error(`Window '${this.label}' has no native window id on this platform`);
     }
     return self.nativeId;
@@ -1183,17 +1157,17 @@ var HasgardWindow = class {
       release();
     }
   }
-};
-var HasgardFrameLocator = class _HasgardFrameLocator {
+}
+
+class HasgardFrameLocator {
   windowRef;
   frame;
   constructor(window, frame) {
     this.windowRef = window;
     this.frame = frame;
   }
-  /** Descend into a frame nested inside this one. */
   frameLocator(selector) {
-    return new _HasgardFrameLocator(this.windowRef, [...this.frame, selector]);
+    return new HasgardFrameLocator(this.windowRef, [...this.frame, selector]);
   }
   locator(selector) {
     return new HasgardLocator(this.windowRef, { kind: "selector", selector, frame: [...this.frame] });
@@ -1219,29 +1193,21 @@ var HasgardFrameLocator = class _HasgardFrameLocator {
   getByTestId(testId) {
     return this.byDimension("testid", testId, {});
   }
-  /** Snapshot the frame's own document rather than the top one. */
   async snapshot(options = {}) {
     return this.windowRef.snapshot({ ...options, frame: [...this.frame] });
   }
   byDimension(by, value, query) {
     return new HasgardLocator(this.windowRef, { kind: "query", by, value, query, frame: [...this.frame] });
   }
-};
-var HasgardLocator = class _HasgardLocator {
+}
+
+class HasgardLocator {
   window;
   query;
   constructor(window, query) {
     this.window = window;
     this.query = query;
   }
-  /**
-   * Click this element.
-   *
-   * A right or middle click raises `contextmenu`/`auxclick` and no `click`, and
-   * `clickCount: 2` escalates `detail` across the presses before a single
-   * `dblclick` -- both matching what the platform does, so a listener bound to
-   * the wrong event fails here rather than in front of a user.
-   */
   async click(options = {}) {
     await this.withTarget((target) => this.window.call("click", { ...this.scoped(target), ...clickParams(options) }));
   }
@@ -1251,61 +1217,37 @@ var HasgardLocator = class _HasgardLocator {
   async type(text) {
     await this.withTarget((target) => this.window.call("type", { ...this.scoped(target), text }));
   }
-  /** Empty the control, firing `input` and `change` as `fill` does. */
   async clear() {
     await this.fill("");
   }
-  /**
-   * Select files on an `<input type="file">` without a native file chooser,
-   * which an embedded webview gives no way to drive.
-   *
-   * Strings are read from the test machine's disk; `DropFile` payloads let you
-   * supply content that never existed as a file. An empty array deselects.
-   */
   async setInputFiles(files) {
     const payloads = await readFileInputs(files);
-    await this.withTarget(
-      (target) => this.window.call("setInputFiles", {
-        ...this.scoped(target),
-        files: payloads
-      })
-    );
-  }
-  /**
-   * Scroll this element by wheel.
-   *
-   * The page sees a real `wheel` event first and may cancel it; the scroll only
-   * follows if it does not — the same two steps a physical wheel produces.
-   * Resolves to whether the page cancelled.
-   */
+    await this.withTarget((target) => this.window.call("setInputFiles", {
+      ...this.scoped(target),
+      files: payloads
+    }));
+  }
   async wheel(deltaX, deltaY) {
     return this.withTarget(async (target) => {
-      const value = expectRecord(
-        await this.window.call("wheel", { ...this.scoped(target), deltaX, deltaY }),
-        "wheel result"
-      );
+      const value = expectRecord(await this.window.call("wheel", { ...this.scoped(target), deltaX, deltaY }), "wheel result");
       return expectBoolean(value.defaultPrevented, "wheel.defaultPrevented");
     });
   }
   async selectOption(value) {
     await this.withTarget((target) => this.window.call("select", { ...this.scoped(target), value }));
   }
-  /** Drive the checkbox to checked. A no-op when it is already checked. */
   async check() {
     await this.withTarget((target) => this.window.call("check", { ...this.scoped(target), checked: true }));
   }
-  /** Drive the checkbox to unchecked. A no-op when it is already unchecked. */
   async uncheck() {
     await this.withTarget((target) => this.window.call("check", { ...this.scoped(target), checked: false }));
   }
-  /** Flip the checkbox, whatever its current state. */
   async toggle() {
     await this.withTarget((target) => this.window.call("check", this.scoped(target)));
   }
   async hover() {
     await this.withTarget((target) => this.window.call("hover", this.scoped(target)));
   }
-  /** Shorthand for `click({ clickCount: 2 })`; other options still apply. */
   async dblclick(options = {}) {
     await this.click({ ...options, clickCount: 2 });
   }
@@ -1315,11 +1257,8 @@ var HasgardLocator = class _HasgardLocator {
   async blur() {
     await this.withTarget((target) => this.window.call("blur", this.scoped(target)));
   }
-  /** Scroll this element's own scrollport. */
   async scrollBy(options) {
-    await this.withTarget(
-      (target) => this.window.call("scroll", { ...this.scoped(target), ...options })
-    );
+    await this.withTarget((target) => this.window.call("scroll", { ...this.scoped(target), ...options }));
   }
   async boundingBox() {
     return this.withTarget(async (target) => {
@@ -1342,25 +1281,18 @@ var HasgardLocator = class _HasgardLocator {
     return !await this.isDisabled();
   }
   async textContent() {
-    return this.withTarget(
-      async (target) => expectString(await this.window.call("text", this.scoped(target)), "text result")
-    );
+    return this.withTarget(async (target) => expectString(await this.window.call("text", this.scoped(target)), "text result"));
   }
   async inputValue() {
-    return this.withTarget(
-      async (target) => expectString(await this.window.call("value", this.scoped(target)), "value result")
-    );
+    return this.withTarget(async (target) => expectString(await this.window.call("value", this.scoped(target)), "value result"));
   }
   async innerHTML() {
-    return this.withTarget(
-      async (target) => expectString(await this.window.call("html", this.scoped(target)), "html result")
-    );
+    return this.withTarget(async (target) => expectString(await this.window.call("html", this.scoped(target)), "html result"));
   }
   async getAttribute(name) {
     const attributes = await this.attributes();
-    return Object.prototype.hasOwnProperty.call(attributes, name) ? attributes[name] : null;
+    return Object.hasOwn(attributes, name) ? attributes[name] : null;
   }
-  /** Drag this element onto another one in the same window. */
   async dragTo(target) {
     if (target.window !== this.window) {
       throw new Error("dragTo requires both locators to belong to the same window");
@@ -1374,33 +1306,26 @@ var HasgardLocator = class _HasgardLocator {
       });
     });
   }
-  /** Drag this element by a pixel offset from its centre. */
   async dragBy(offset) {
-    await this.withTarget(
-      (target) => this.window.call("drag", { source: this.scoped(target), offset: { x: offset.x, y: offset.y } })
-    );
+    await this.withTarget((target) => this.window.call("drag", { source: this.scoped(target), offset: { x: offset.x, y: offset.y } }));
   }
-  /** Dispatch a file drop onto this element. `data` is base64-encoded. */
   async dropFiles(files) {
-    await this.withTarget(
-      (target) => this.window.call("drop", {
-        ...this.scoped(target),
-        files
-      })
-    );
+    await this.withTarget((target) => this.window.call("drop", {
+      ...this.scoped(target),
+      files
+    }));
   }
   async attributes() {
     return this.withTarget(async (target) => {
       const value = expectRecord(await this.window.call("attrs", this.scoped(target)), "attrs result");
-      return Object.fromEntries(
-        Object.entries(value).map(([name, attr]) => [name, expectString(attr, `attribute ${name}`)])
-      );
+      return Object.fromEntries(Object.entries(value).map(([name, attr]) => [name, expectString(attr, `attribute ${name}`)]));
     });
   }
   async isVisible() {
     return this.window.runExclusive(async () => {
       const target = await this.resolveUnique(true);
-      if (target === null) return false;
+      if (target === null)
+        return false;
       const value = expectRecord(await this.window.call("visible", this.scoped(target)), "visible result");
       return expectBoolean(value.visible, "visible.visible");
     });
@@ -1412,19 +1337,14 @@ var HasgardLocator = class _HasgardLocator {
     });
   }
   async count() {
-    const total = this.query.kind === "selector" && !this.query.filters?.length ? expectNumber(
-      expectRecord(
-        await this.window.call("count", { selector: this.query.selector, ...this.frameParams() }),
-        "count result"
-      ).count,
-      "count.count"
-    ) : (await this.resolveAll()).length;
-    if (this.query.index === void 0) return total;
+    const total = this.query.kind === "selector" && !this.query.filters?.length ? expectNumber(expectRecord(await this.window.call("count", { selector: this.query.selector, ...this.frameParams() }), "count result").count, "count.count") : (await this.resolveAll()).length;
+    if (this.query.index === undefined)
+      return total;
     const position = absoluteIndex(this.query.index, total);
     return position >= 0 && position < total ? 1 : 0;
   }
   async waitFor(options) {
-    if (this.query.kind === "selector" && this.query.index === void 0 && !this.query.filters?.length) {
+    if (this.query.kind === "selector" && this.query.index === undefined && !this.query.filters?.length) {
       await this.window.call("wait", {
         selector: this.query.selector,
         gone: options.state === "detached",
@@ -1436,32 +1356,22 @@ var HasgardLocator = class _HasgardLocator {
     const deadline = Date.now() + options.timeoutMs;
     while (Date.now() <= deadline) {
       const found = await this.count() > 0;
-      if (found === (options.state === "attached")) return;
+      if (found === (options.state === "attached"))
+        return;
       await new Promise((resolve) => setTimeout(resolve, 50));
     }
     throw new Error(`Locator did not become ${options.state} within ${options.timeoutMs}ms`);
   }
-  /**
-   * Narrow this locator to a single match by position. A negative index counts
-   * back from the end, so `last()` stays one round trip.
-   */
   nth(index) {
-    if (!Number.isInteger(index)) throw new Error("nth requires an integer index");
-    return new _HasgardLocator(this.window, { ...this.query, index });
-  }
-  /**
-   * Narrow this locator to the elements whose text matches.
-   *
-   * Filters accumulate, so `filter({hasText}).filter({hasNotText})` applies
-   * both. Ordering matters against `nth`: filtering happens first, so
-   * `filter({hasText: "x"}).first()` is the first *matching* element, which is
-   * the reading that makes `first()` mean what it says.
-   */
+    if (!Number.isInteger(index))
+      throw new Error("nth requires an integer index");
+    return new HasgardLocator(this.window, { ...this.query, index });
+  }
   filter(options) {
-    if (options.hasText === void 0 && options.hasNotText === void 0) {
+    if (options.hasText === undefined && options.hasNotText === undefined) {
       throw new Error("filter requires hasText or hasNotText");
     }
-    return new _HasgardLocator(this.window, {
+    return new HasgardLocator(this.window, {
       ...this.query,
       filters: [...this.query.filters ?? [], options]
     });
@@ -1474,30 +1384,25 @@ var HasgardLocator = class _HasgardLocator {
   }
   async resolveUnique(allowMissing = false) {
     if (this.query.kind === "selector" && !this.query.filters?.length) {
-      return this.query.index === void 0 ? bySelector(this.query.selector) : { selector: this.query.selector, index: this.query.index };
+      return this.query.index === undefined ? bySelector(this.query.selector) : { selector: this.query.selector, index: this.query.index };
     }
     const elements = await this.resolveAll();
-    if (this.query.index !== void 0) {
+    if (this.query.index !== undefined) {
       const element = elements[absoluteIndex(this.query.index, elements.length)];
       if (!element) {
-        if (allowMissing) return null;
+        if (allowMissing)
+          return null;
         throw new Error(`Locator has no element at index ${this.query.index} (${elements.length} matched)`);
       }
       return byRef(element.ref);
     }
-    if (elements.length === 0 && allowMissing) return null;
+    if (elements.length === 0 && allowMissing)
+      return null;
     if (elements.length !== 1) {
       throw new Error(`Locator resolved to ${elements.length} elements; expected exactly one`);
     }
     return byRef(elements[0].ref);
   }
-  /**
-   * Serialize a target together with the frame chain this locator lives in.
-   *
-   * A ref carries its own document, so the bridge ignores `frame` for one; the
-   * chain still travels so that a selector or coordinate target -- which the
-   * bridge must resolve itself -- lands in the right document.
-   */
   scoped(target) {
     return { ...targetParams(target), ...this.frameParams() };
   }
@@ -1516,36 +1421,38 @@ var HasgardLocator = class _HasgardLocator {
     }
     if (this.query.kind === "query") {
       const params = { by: this.query.by, value: this.query.value };
-      if (this.query.query.exact !== void 0) params.exact = this.query.query.exact;
+      if (this.query.query.exact !== undefined)
+        params.exact = this.query.query.exact;
       return this.runQuery(params);
     }
     const query = this.query;
     const snapshot = await this.window.snapshot(query.frame ? { frame: [...query.frame] } : {});
     return snapshot.elements.filter((element) => {
-      if (element.role !== query.role) return false;
+      if (element.role !== query.role)
+        return false;
       const expected = query.query.name;
-      if (expected === void 0) return true;
-      if (element.name === void 0) return false;
-      if (expected instanceof RegExp) return expected.test(element.name);
+      if (expected === undefined)
+        return true;
+      if (element.name === undefined)
+        return false;
+      if (expected instanceof RegExp)
+        return expected.test(element.name);
       return query.query.exact ? element.name === expected : element.name.includes(expected);
     });
   }
-  /**
-   * Apply each accumulated filter, one round trip per filter.
-   *
-   * Filters run server-side rather than against a snapshot because the text a
-   * filter matches on is not carried in snapshot entries — deliberately, so
-   * that every unrelated `snapshot` call stays small.
-   */
   async applyFilters(elements) {
     const filters = this.query.filters ?? [];
     let current = elements;
     for (const filter of filters) {
-      if (current.length === 0) return current;
+      if (current.length === 0)
+        return current;
       const params = { refs: current.map((element) => element.ref) };
-      if (filter.hasText !== void 0) params.hasText = filter.hasText;
-      if (filter.hasNotText !== void 0) params.hasNotText = filter.hasNotText;
-      if (filter.exact !== void 0) params.exact = filter.exact;
+      if (filter.hasText !== undefined)
+        params.hasText = filter.hasText;
+      if (filter.hasNotText !== undefined)
+        params.hasNotText = filter.hasNotText;
+      if (filter.exact !== undefined)
+        params.exact = filter.exact;
       current = this.parseElements(await this.window.call("filter", params), "filter");
     }
     return current;
@@ -1555,10 +1462,11 @@ var HasgardLocator = class _HasgardLocator {
   }
   parseElements(raw, source) {
     const value = expectRecord(raw, `${source} result`);
-    if (!Array.isArray(value.elements)) throw new Error(`${source}.elements must be an array`);
+    if (!Array.isArray(value.elements))
+      throw new Error(`${source}.elements must be an array`);
     return value.elements.map((entry, index) => parseSnapshotElement(entry, index));
   }
-};
+}
 function parseDialogPolicy(value) {
   const record = expectRecord(value, "dialog policy");
   const action = expectString(record.action, "dialog policy.action");
@@ -1583,10 +1491,11 @@ function parseDialogRecord(value, index) {
     message: expectString(entry.message, `dialogs[${index}].message`),
     accepted: expectBoolean(entry.accepted, `dialogs[${index}].accepted`)
   };
-  if (entry.defaultValue !== void 0) {
+  if (entry.defaultValue !== undefined) {
     record.defaultValue = expectString(entry.defaultValue, `dialogs[${index}].defaultValue`);
   }
-  if (entry.returned !== void 0) record.returned = expectString(entry.returned, `dialogs[${index}].returned`);
+  if (entry.returned !== undefined)
+    record.returned = expectString(entry.returned, `dialogs[${index}].returned`);
   return record;
 }
 function parseSnapshotElement(value, index) {
@@ -1596,10 +1505,13 @@ function parseSnapshotElement(value, index) {
     role: expectString(entry.role, `snapshot.elements[${index}].role`),
     depth: expectNumber(entry.depth, `snapshot.elements[${index}].depth`)
   };
-  if (entry.name !== void 0) element.name = expectString(entry.name, `snapshot.elements[${index}].name`);
-  if (entry.value !== void 0) element.value = expectString(entry.value, `snapshot.elements[${index}].value`);
-  if (entry.checked !== void 0) element.checked = expectBoolean(entry.checked, `snapshot.elements[${index}].checked`);
-  if (entry.disabled !== void 0)
+  if (entry.name !== undefined)
+    element.name = expectString(entry.name, `snapshot.elements[${index}].name`);
+  if (entry.value !== undefined)
+    element.value = expectString(entry.value, `snapshot.elements[${index}].value`);
+  if (entry.checked !== undefined)
+    element.checked = expectBoolean(entry.checked, `snapshot.elements[${index}].checked`);
+  if (entry.disabled !== undefined)
     element.disabled = expectBoolean(entry.disabled, `snapshot.elements[${index}].disabled`);
   return element;
 }
@@ -1608,23 +1520,26 @@ function parseSnapshotElement(value, index) {
 function createHasgardTest(config) {
   const base = config.test;
   const expect = createHasgardExpect(config.expect);
-  const readinessTimeoutMs = config.launch ? config.launch.timeoutMs : 3e4;
-  const fixtureTimeoutMs = config.launch ? config.launch.timeoutMs + 3e4 : 3e4;
-  const processes = /* @__PURE__ */ new WeakMap();
+  const readinessTimeoutMs = config.launch ? config.launch.timeoutMs : 30000;
+  const fixtureTimeoutMs = config.launch ? config.launch.timeoutMs + 30000 : 30000;
+  const processes = new WeakMap;
   const test = base.extend({
     hasgard: [
       async ({}, use, workerInfo) => {
         const socketPath = typeof config.socketPath === "function" ? config.socketPath(workerInfo.workerIndex) : config.socketPath;
-        const process2 = new HasgardProcess();
+        const process2 = new HasgardProcess;
         const rpc = new HasgardRpcClient(socketPath);
         try {
-          if (config.launch) await process2.start(config.launch, socketPath);
-          else await process2.waitForSocket(socketPath, workerInfo.project.timeout);
+          if (config.launch)
+            await process2.start(config.launch, socketPath);
+          else
+            await process2.waitForSocket(socketPath, workerInfo.project.timeout);
           await rpc.connect(workerInfo.project.timeout);
           const hasgard = new HasgardApplication(rpc);
           processes.set(hasgard, process2);
           const ping = await hasgard.ping();
-          if (ping.status !== "ok") throw new Error(`Unexpected Hasgard ping status: ${ping.status}`);
+          if (ping.status !== "ok")
+            throw new Error(`Unexpected Hasgard ping status: ${ping.status}`);
           await hasgard.waitForWindowReady(config.windowLabel, config.readySelector, readinessTimeoutMs);
           await use(hasgard);
         } catch (error) {
@@ -1653,7 +1568,8 @@ function createHasgardTest(config) {
             body: JSON.stringify(diagnostics, null, 2),
             contentType: "application/json"
           });
-          if (diagnostics.exit) console.error(`Hasgard application exited: ${JSON.stringify(diagnostics)}`);
+          if (diagnostics.exit)
+            console.error(`Hasgard application exited: ${JSON.stringify(diagnostics)}`);
         }
         try {
           const screenshot = await hasgard.window(config.windowLabel).screenshot();