@mediar-ai/terminator 0.23.0 → 0.23.2

package/package.json

@@ -40,11 +40,11 @@
     }
   },
   "optionalDependencies": {
-    "@mediar-ai/terminator-darwin-arm64": "0.23.0",
-    "@mediar-ai/terminator-darwin-x64": "0.23.0",
-    "@mediar-ai/terminator-linux-x64-gnu": "0.23.0",
-    "@mediar-ai/terminator-win32-arm64-msvc": "0.23.0",
-    "@mediar-ai/terminator-win32-x64-msvc": "0.23.0"
+    "@mediar-ai/terminator-darwin-arm64": "0.23.2",
+    "@mediar-ai/terminator-darwin-x64": "0.23.2",
+    "@mediar-ai/terminator-linux-x64-gnu": "0.23.2",
+    "@mediar-ai/terminator-win32-arm64-msvc": "0.23.2",
+    "@mediar-ai/terminator-win32-x64-msvc": "0.23.2"
   },
   "repository": {
     "type": "git",
@@ -62,5 +62,5 @@
     "test-hook": "powershell.exe -ExecutionPolicy Bypass -File \"../../.git/hooks/pre-push.ps1\""
   },
   "types": "wrapper.d.ts",
-  "version": "0.23.0"
+  "version": "0.23.2"
 }

package/tests/execute-browser-script-wrapper.test.js

@@ -1,12 +1,12 @@
-const assert = require('assert');
-const path = require('path');
-const fs = require('fs');
+const assert = require("assert");
+const path = require("path");
+const fs = require("fs");
 
-const { Desktop } = require('../wrapper.js');
+const { Desktop } = require("../wrapper.js");
 
 async function testFunctionInput() {
   let capturedScript = null;
-  const expected = { greeting: 'hello', answer: 42 };
+  const expected = { greeting: "hello", answer: 42 };
   const fake = {
     _originalExecuteBrowserScript: async (script) => {
       capturedScript = script;
@@ -17,68 +17,119 @@ async function testFunctionInput() {
   const result = await Desktop.prototype.executeBrowserScript.call(
     fake,
     ({ greeting, answer }) => ({ greeting, answer }),
-    { greeting: 'hello', answer: 42 }
+    { greeting: "hello", answer: 42 },
   );
 
   assert.deepStrictEqual(result, expected);
   assert.ok(
     capturedScript.includes('"greeting":"hello"') &&
       capturedScript.includes('"answer":42'),
-    'env payload should be embedded in generated script'
+    "env payload should be embedded in generated script",
   );
   assert.ok(
-    capturedScript.trim().startsWith('(async function()'),
-    'generated script should be wrapped in async IIFE'
+    capturedScript.trim().startsWith("(async function()"),
+    "generated script should be wrapped in async IIFE",
   );
 }
 
 async function testStringInput() {
   const fake = {
-    _originalExecuteBrowserScript: async () => 'raw-result',
+    _originalExecuteBrowserScript: async () => "raw-result",
   };
   const script = '(() => "ignored")()';
-  const result = await Desktop.prototype.executeBrowserScript.call(fake, script);
-  assert.strictEqual(result, 'raw-result');
+  const result = await Desktop.prototype.executeBrowserScript.call(
+    fake,
+    script,
+  );
+  assert.strictEqual(result, "raw-result");
 }
 
 async function testFileInput() {
-  const fixturePath = path.join(__dirname, 'fixtures', 'sample-browser-script.js');
-  const expectedScript = fs.readFileSync(fixturePath, 'utf8');
+  const fixturePath = path.join(
+    __dirname,
+    "fixtures",
+    "sample-browser-script.js",
+  );
+  const expectedScript = fs.readFileSync(fixturePath, "utf8");
   let receivedScript = null;
   const fake = {
     _originalExecuteBrowserScript: async (script) => {
       receivedScript = script;
-      return 'file-result';
+      return "file-result";
     },
   };
 
+  // Test without env - should not inject
   const result = await Desktop.prototype.executeBrowserScript.call(fake, {
     file: fixturePath,
-    env: { unused: true },
   });
 
-  assert.strictEqual(result, 'file-result');
+  assert.strictEqual(result, "file-result");
   assert.strictEqual(receivedScript, expectedScript);
 }
 
+async function testFileInputWithEnvInjection() {
+  const fixturePath = path.join(__dirname, "fixtures", "script-with-env.js");
+  const columnPositions = [10, 20, 30];
+  let receivedScript = null;
+  const fake = {
+    _originalExecuteBrowserScript: async (script) => {
+      receivedScript = script;
+      // Simulate executing the script with injected env
+      const column_positions = columnPositions;
+      const result = eval(script);
+      return JSON.stringify(result);
+    },
+  };
+
+  const result = await Desktop.prototype.executeBrowserScript.call(fake, {
+    file: fixturePath,
+    env: { column_positions: columnPositions },
+  });
+
+  // Result comes back as JSON string for file-based scripts
+  const parsed = JSON.parse(result);
+  assert.deepStrictEqual(parsed, {
+    positions: columnPositions,
+    count: 3,
+  });
+
+  // Verify the env was injected into the script as an env object
+  assert.ok(
+    receivedScript.includes("const env = "),
+    "env object should be injected into script",
+  );
+  assert.ok(
+    receivedScript.includes('"column_positions"'),
+    "column_positions key should be in env object",
+  );
+  assert.ok(
+    receivedScript.includes(JSON.stringify(columnPositions)),
+    "column_positions value should be embedded",
+  );
+}
+
 async function run() {
   try {
     await testFunctionInput();
-    console.log('✅ executeBrowserScript handles function input');
+    console.log("✅ executeBrowserScript handles function input");
 
     await testStringInput();
-    console.log('✅ executeBrowserScript preserves string behavior');
+    console.log("✅ executeBrowserScript preserves string behavior");
 
     await testFileInput();
-    console.log('✅ executeBrowserScript loads scripts from files');
+    console.log("✅ executeBrowserScript loads scripts from files");
 
-    console.log('🎉 All executeBrowserScript wrapper tests passed');
+    await testFileInputWithEnvInjection();
+    console.log(
+      "✅ executeBrowserScript injects env variables into file scripts",
+    );
+
+    console.log("🎉 All executeBrowserScript wrapper tests passed");
   } catch (err) {
-    console.error('❌ executeBrowserScript wrapper test failed:', err);
+    console.error("❌ executeBrowserScript wrapper test failed:", err);
     process.exitCode = 1;
   }
 }
 
 run();
-
-

package/tests/fixtures/script-with-env.js

@@ -0,0 +1,16 @@
+// Browser script that uses injected env object
+(() => {
+  // env object should be auto-injected by wrapper
+  if (typeof env === "undefined") {
+    throw new Error("env not injected");
+  }
+
+  if (!env.column_positions) {
+    throw new Error("column_positions not in env");
+  }
+
+  return {
+    positions: env.column_positions,
+    count: env.column_positions.length,
+  };
+})();

package/wrapper.js

@@ -152,25 +152,35 @@ function mapNativeError(error) {
   if (!error.message) return error;
   const message = error.message;
   if (message.startsWith("ELEMENT_NOT_FOUND:")) {
-    return new ElementNotFoundError(message.replace("ELEMENT_NOT_FOUND:", "").trim());
+    return new ElementNotFoundError(
+      message.replace("ELEMENT_NOT_FOUND:", "").trim()
+    );
   }
   if (message.startsWith("OPERATION_TIMED_OUT:")) {
     return new TimeoutError(message.replace("OPERATION_TIMED_OUT:", "").trim());
   }
   if (message.startsWith("PERMISSION_DENIED:")) {
-    return new PermissionDeniedError(message.replace("PERMISSION_DENIED:", "").trim());
+    return new PermissionDeniedError(
+      message.replace("PERMISSION_DENIED:", "").trim()
+    );
   }
   if (message.startsWith("PLATFORM_ERROR:")) {
     return new PlatformError(message.replace("PLATFORM_ERROR:", "").trim());
   }
   if (message.startsWith("UNSUPPORTED_OPERATION:")) {
-    return new UnsupportedOperationError(message.replace("UNSUPPORTED_OPERATION:", "").trim());
+    return new UnsupportedOperationError(
+      message.replace("UNSUPPORTED_OPERATION:", "").trim()
+    );
   }
   if (message.startsWith("UNSUPPORTED_PLATFORM:")) {
-    return new UnsupportedPlatformError(message.replace("UNSUPPORTED_PLATFORM:", "").trim());
+    return new UnsupportedPlatformError(
+      message.replace("UNSUPPORTED_PLATFORM:", "").trim()
+    );
   }
   if (message.startsWith("INVALID_ARGUMENT:")) {
-    return new InvalidArgumentError(message.replace("INVALID_ARGUMENT:", "").trim());
+    return new InvalidArgumentError(
+      message.replace("INVALID_ARGUMENT:", "").trim()
+    );
   }
   if (message.startsWith("INTERNAL_ERROR:")) {
     return new InternalError(message.replace("INTERNAL_ERROR:", "").trim());
@@ -180,6 +190,7 @@ function mapNativeError(error) {
 async function enhancedExecuteBrowserScript(scriptOrFunction, envOrOptions) {
   let script;
   let env = {};
+  let shouldInjectEnv = false;
   if (typeof scriptOrFunction === "string") {
     if (scriptOrFunction.endsWith(".ts") || scriptOrFunction.endsWith(".js")) {
       const filePath = path.resolve(scriptOrFunction);
@@ -197,11 +208,15 @@ async function enhancedExecuteBrowserScript(scriptOrFunction, envOrOptions) {
           });
           fileContent = result.code;
         } catch (e) {
-          console.warn("esbuild not found - using TypeScript file as-is:", e.message);
+          console.warn(
+            "esbuild not found - using TypeScript file as-is:",
+            e.message
+          );
         }
       }
       script = fileContent;
       env = envOrOptions || {};
+      shouldInjectEnv = true;
     } else {
       script = scriptOrFunction;
     }
@@ -240,13 +255,24 @@ async function enhancedExecuteBrowserScript(scriptOrFunction, envOrOptions) {
         });
         fileContent = result.code;
       } catch (e) {
-        console.warn("esbuild not found - using TypeScript file as-is:", e.message);
+        console.warn(
+          "esbuild not found - using TypeScript file as-is:",
+          e.message
+        );
       }
     }
     script = fileContent;
     env = options.env || {};
+    shouldInjectEnv = true;
   } else {
-    throw new Error("Invalid argument to executeBrowserScript: expected string, function, or {file, env} object");
+    throw new Error(
+      "Invalid argument to executeBrowserScript: expected string, function, or {file, env} object"
+    );
+  }
+  if (shouldInjectEnv && env && Object.keys(env).length > 0) {
+    const envObject = `const env = ${JSON.stringify(env)};`;
+    script = `${envObject}
+${script}`;
   }
   const resultStr = await this._originalExecuteBrowserScript(script);
   if (typeof scriptOrFunction === "function") {

package/wrapper.ts

@@ -1,27 +1,35 @@
-import * as native from './index.js';
-import * as util from 'util';
-import * as fs from 'fs';
-import * as path from 'path';
+import * as native from "./index.js";
+import * as util from "util";
+import * as fs from "fs";
+import * as path from "path";
 
 // Type definitions for native classes
-type NativeClass = typeof native.Desktop | typeof native.Element | typeof native.Locator | typeof native.Selector;
-
-function patchInspector(Klass: any, methodName = 'toString', forcePlainObject = false): void {
-  if (!Klass || typeof Klass !== 'function') {
-    console.log('inspect not a function')
+type NativeClass =
+  | typeof native.Desktop
+  | typeof native.Element
+  | typeof native.Locator
+  | typeof native.Selector;
+
+function patchInspector(
+  Klass: any,
+  methodName = "toString",
+  forcePlainObject = false,
+): void {
+  if (!Klass || typeof Klass !== "function") {
+    console.log("inspect not a function");
     return;
   }
   const proto = Klass.prototype;
   const original = proto[util.inspect.custom];
-  proto[util.inspect.custom] = function(...args: any[]) {
-    if (typeof this[methodName] === 'function') {
+  proto[util.inspect.custom] = function (...args: any[]) {
+    if (typeof this[methodName] === "function") {
       const result = this[methodName](...args);
-      if (forcePlainObject && result && typeof result === 'object') {
+      if (forcePlainObject && result && typeof result === "object") {
         return { ...result };
       }
       return result;
     }
-    if (typeof original === 'function') {
+    if (typeof original === "function") {
       return original.apply(this, args);
     }
     return { ...this };
@@ -29,12 +37,12 @@ function patchInspector(Klass: any, methodName = 'toString', forcePlainObject =
 }
 
 function wrapNativeFunction<T extends Function>(fn: T): T {
-  if (typeof fn !== 'function') return fn;
-  return function(this: any, ...args: any[]) {
+  if (typeof fn !== "function") return fn;
+  return function (this: any, ...args: any[]) {
     try {
       const result = fn.apply(this, args);
       if (result instanceof Promise) {
-        return result.catch(error => {
+        return result.catch((error) => {
           throw mapNativeError(error);
         });
       }
@@ -48,15 +56,18 @@ function wrapNativeFunction<T extends Function>(fn: T): T {
 function wrapClassMethods<T extends NativeClass>(Class: T): T {
   const prototype = Class.prototype;
   const methods = Object.getOwnPropertyNames(prototype);
-  methods.forEach(method => {
-    if (method !== 'constructor' && typeof prototype[method] === 'function') {
+  methods.forEach((method) => {
+    if (method !== "constructor" && typeof prototype[method] === "function") {
       prototype[method] = wrapNativeFunction(prototype[method]);
     }
   });
   return Class;
 }
 
-function wrapClass<T extends NativeClass>(Class: T, ...inspectOptions: any[]): T {
+function wrapClass<T extends NativeClass>(
+  Class: T,
+  ...inspectOptions: any[]
+): T {
   const Wrapped = wrapClassMethods(Class);
   patchInspector(Wrapped, ...(inspectOptions || []));
   return Wrapped;
@@ -64,91 +75,101 @@ function wrapClass<T extends NativeClass>(Class: T, ...inspectOptions: any[]): T
 
 // Custom error classes
 export class ElementNotFoundError extends Error {
-    constructor(message: string) {
-        super(message);
-        this.name = 'ElementNotFoundError';
-    }
+  constructor(message: string) {
+    super(message);
+    this.name = "ElementNotFoundError";
+  }
 }
 
 export class TimeoutError extends Error {
-    constructor(message: string) {
-        super(message);
-        this.name = 'TimeoutError';
-    }
+  constructor(message: string) {
+    super(message);
+    this.name = "TimeoutError";
+  }
 }
 
 export class PermissionDeniedError extends Error {
-    constructor(message: string) {
-        super(message);
-        this.name = 'PermissionDeniedError';
-    }
+  constructor(message: string) {
+    super(message);
+    this.name = "PermissionDeniedError";
+  }
 }
 
 export class PlatformError extends Error {
-    constructor(message: string) {
-        super(message);
-        this.name = 'PlatformError';
-    }
+  constructor(message: string) {
+    super(message);
+    this.name = "PlatformError";
+  }
 }
 
 export class UnsupportedOperationError extends Error {
-    constructor(message: string) {
-        super(message);
-        this.name = 'UnsupportedOperationError';
-    }
+  constructor(message: string) {
+    super(message);
+    this.name = "UnsupportedOperationError";
+  }
 }
 
 export class UnsupportedPlatformError extends Error {
-    constructor(message: string) {
-        super(message);
-        this.name = 'UnsupportedPlatformError';
-    }
+  constructor(message: string) {
+    super(message);
+    this.name = "UnsupportedPlatformError";
+  }
 }
 
 export class InvalidArgumentError extends Error {
-    constructor(message: string) {
-        super(message);
-        this.name = 'InvalidArgumentError';
-    }
+  constructor(message: string) {
+    super(message);
+    this.name = "InvalidArgumentError";
+  }
 }
 
 export class InternalError extends Error {
-    constructor(message: string) {
-        super(message);
-        this.name = 'InternalError';
-    }
+  constructor(message: string) {
+    super(message);
+    this.name = "InternalError";
+  }
 }
 
 // Error mapping function
 function mapNativeError(error: any): Error {
-    if (!error.message) return error;
+  if (!error.message) return error;
 
-    const message = error.message;
-    if (message.startsWith('ELEMENT_NOT_FOUND:')) {
-        return new ElementNotFoundError(message.replace('ELEMENT_NOT_FOUND:', '').trim());
-    }
-    if (message.startsWith('OPERATION_TIMED_OUT:')) {
-        return new TimeoutError(message.replace('OPERATION_TIMED_OUT:', '').trim());
-    }
-    if (message.startsWith('PERMISSION_DENIED:')) {
-        return new PermissionDeniedError(message.replace('PERMISSION_DENIED:', '').trim());
-    }
-    if (message.startsWith('PLATFORM_ERROR:')) {
-        return new PlatformError(message.replace('PLATFORM_ERROR:', '').trim());
-    }
-    if (message.startsWith('UNSUPPORTED_OPERATION:')) {
-        return new UnsupportedOperationError(message.replace('UNSUPPORTED_OPERATION:', '').trim());
-    }
-    if (message.startsWith('UNSUPPORTED_PLATFORM:')) {
-        return new UnsupportedPlatformError(message.replace('UNSUPPORTED_PLATFORM:', '').trim());
-    }
-    if (message.startsWith('INVALID_ARGUMENT:')) {
-        return new InvalidArgumentError(message.replace('INVALID_ARGUMENT:', '').trim());
-    }
-    if (message.startsWith('INTERNAL_ERROR:')) {
-        return new InternalError(message.replace('INTERNAL_ERROR:', '').trim());
-    }
-    return error;
+  const message = error.message;
+  if (message.startsWith("ELEMENT_NOT_FOUND:")) {
+    return new ElementNotFoundError(
+      message.replace("ELEMENT_NOT_FOUND:", "").trim(),
+    );
+  }
+  if (message.startsWith("OPERATION_TIMED_OUT:")) {
+    return new TimeoutError(message.replace("OPERATION_TIMED_OUT:", "").trim());
+  }
+  if (message.startsWith("PERMISSION_DENIED:")) {
+    return new PermissionDeniedError(
+      message.replace("PERMISSION_DENIED:", "").trim(),
+    );
+  }
+  if (message.startsWith("PLATFORM_ERROR:")) {
+    return new PlatformError(message.replace("PLATFORM_ERROR:", "").trim());
+  }
+  if (message.startsWith("UNSUPPORTED_OPERATION:")) {
+    return new UnsupportedOperationError(
+      message.replace("UNSUPPORTED_OPERATION:", "").trim(),
+    );
+  }
+  if (message.startsWith("UNSUPPORTED_PLATFORM:")) {
+    return new UnsupportedPlatformError(
+      message.replace("UNSUPPORTED_PLATFORM:", "").trim(),
+    );
+  }
+  if (message.startsWith("INVALID_ARGUMENT:")) {
+    return new InvalidArgumentError(
+      message.replace("INVALID_ARGUMENT:", "").trim(),
+    );
+  }
+  if (message.startsWith("INTERNAL_ERROR:")) {
+    return new InternalError(message.replace("INTERNAL_ERROR:", "").trim());
+  }
+  return error;
 }
 
 // Types for executeBrowserScript arguments
@@ -164,46 +185,51 @@ type BrowserScriptInput = string | BrowserScriptFunction | BrowserScriptOptions;
 async function enhancedExecuteBrowserScript(
   this: any,
   scriptOrFunction: BrowserScriptInput,
-  envOrOptions?: any
+  envOrOptions?: any,
 ): Promise<any> {
   let script: string;
   let env: any = {};
+  let shouldInjectEnv = false; // Only inject env for file-based and string scripts, not functions
 
   // Handle different input types
-  if (typeof scriptOrFunction === 'string') {
+  if (typeof scriptOrFunction === "string") {
     // Check if it's a file path
-    if (scriptOrFunction.endsWith('.ts') || scriptOrFunction.endsWith('.js')) {
+    if (scriptOrFunction.endsWith(".ts") || scriptOrFunction.endsWith(".js")) {
       // File path - read and compile
       const filePath = path.resolve(scriptOrFunction);
       if (!fs.existsSync(filePath)) {
         throw new Error(`Browser script file not found: ${filePath}`);
       }
 
-      let fileContent = fs.readFileSync(filePath, 'utf-8');
+      let fileContent = fs.readFileSync(filePath, "utf-8");
 
       // If TypeScript, compile it
-      if (filePath.endsWith('.ts')) {
+      if (filePath.endsWith(".ts")) {
         try {
-          const esbuild = require('esbuild');
+          const esbuild = require("esbuild");
           const result = await esbuild.transform(fileContent, {
-            loader: 'ts',
-            target: 'es2020',
-            format: 'iife'
+            loader: "ts",
+            target: "es2020",
+            format: "iife",
           });
           fileContent = result.code;
         } catch (e: any) {
           // If esbuild not available, try to use as-is (may work for simple TS)
-          console.warn('esbuild not found - using TypeScript file as-is:', e.message);
+          console.warn(
+            "esbuild not found - using TypeScript file as-is:",
+            e.message,
+          );
         }
       }
 
       script = fileContent;
       env = envOrOptions || {};
+      shouldInjectEnv = true; // Inject env for file paths passed as strings
     } else {
       // Plain string script - use as-is (backward compatible)
       script = scriptOrFunction;
     }
-  } else if (typeof scriptOrFunction === 'function') {
+  } else if (typeof scriptOrFunction === "function") {
     // Function - convert to IIFE with proper wrapping
     const funcString = scriptOrFunction.toString();
     env = envOrOptions || {};
@@ -224,7 +250,10 @@ async function enhancedExecuteBrowserScript(
         return null;
       })()
     `;
-  } else if (typeof scriptOrFunction === 'object' && (scriptOrFunction as BrowserScriptOptions).file) {
+  } else if (
+    typeof scriptOrFunction === "object" &&
+    (scriptOrFunction as BrowserScriptOptions).file
+  ) {
     // Object with file property
     const options = scriptOrFunction as BrowserScriptOptions;
     const filePath = path.resolve(options.file);
@@ -232,34 +261,47 @@ async function enhancedExecuteBrowserScript(
       throw new Error(`Browser script file not found: ${filePath}`);
     }
 
-    let fileContent = fs.readFileSync(filePath, 'utf-8');
+    let fileContent = fs.readFileSync(filePath, "utf-8");
 
     // If TypeScript, compile it
-    if (filePath.endsWith('.ts')) {
+    if (filePath.endsWith(".ts")) {
       try {
-        const esbuild = require('esbuild');
+        const esbuild = require("esbuild");
         const result = await esbuild.transform(fileContent, {
-          loader: 'ts',
-          target: 'es2020',
-          format: 'iife'
+          loader: "ts",
+          target: "es2020",
+          format: "iife",
         });
         fileContent = result.code;
       } catch (e: any) {
-        console.warn('esbuild not found - using TypeScript file as-is:', e.message);
+        console.warn(
+          "esbuild not found - using TypeScript file as-is:",
+          e.message,
+        );
       }
     }
 
     script = fileContent;
     env = options.env || {};
+    shouldInjectEnv = true; // Inject env for file option objects
   } else {
-    throw new Error('Invalid argument to executeBrowserScript: expected string, function, or {file, env} object');
+    throw new Error(
+      "Invalid argument to executeBrowserScript: expected string, function, or {file, env} object",
+    );
+  }
+
+  // If env variables are provided and we should inject them (file-based scripts only)
+  if (shouldInjectEnv && env && Object.keys(env).length > 0) {
+    // Inject as an env object that scripts can access
+    const envObject = `const env = ${JSON.stringify(env)};`;
+    script = `${envObject}\n${script}`;
   }
 
   // Call the original native method
   const resultStr = await this._originalExecuteBrowserScript(script);
 
   // If function was passed, try to parse JSON result
-  if (typeof scriptOrFunction === 'function') {
+  if (typeof scriptOrFunction === "function") {
     try {
       return JSON.parse(resultStr);
     } catch (e) {
@@ -280,15 +322,28 @@ export const Selector = wrapClass(native.Selector);
 
 // Patch executeBrowserScript on Desktop and Element
 if (Desktop.prototype.executeBrowserScript) {
-  (Desktop.prototype as any)._originalExecuteBrowserScript = Desktop.prototype.executeBrowserScript;
+  (Desktop.prototype as any)._originalExecuteBrowserScript =
+    Desktop.prototype.executeBrowserScript;
   Desktop.prototype.executeBrowserScript = enhancedExecuteBrowserScript;
 }
 
 if (Element.prototype.executeBrowserScript) {
-  (Element.prototype as any)._originalExecuteBrowserScript = Element.prototype.executeBrowserScript;
+  (Element.prototype as any)._originalExecuteBrowserScript =
+    Element.prototype.executeBrowserScript;
   Element.prototype.executeBrowserScript = enhancedExecuteBrowserScript;
 }
 
 // Re-export native types
-export type { ValidationResult, Bounds, Coordinates, ClickResult, CommandOutput, Monitor, MonitorScreenshotPair, ScreenshotResult, UIElementAttributes, UINode } from './index.js';
-export { PropertyLoadingMode, TextPosition } from './index.js';
+export type {
+  ValidationResult,
+  Bounds,
+  Coordinates,
+  ClickResult,
+  CommandOutput,
+  Monitor,
+  MonitorScreenshotPair,
+  ScreenshotResult,
+  UIElementAttributes,
+  UINode,
+} from "./index.js";
+export { PropertyLoadingMode, TextPosition } from "./index.js";