surf-cli 2.7.2 → 2.9.0

package/native/request-pending.cjs

@@ -0,0 +1,148 @@
+const { abortError } = require("./abort.cjs");
+
+class RequestPendingMap extends Map {
+  constructor({ getRequest = () => undefined } = {}) {
+    super();
+    this.getRequest = getRequest;
+    this.drainWaiters = new Map();
+  }
+
+  set(id, data) {
+    const request = data.request || this.getRequest();
+    const cleanup = Boolean(data.cleanup || data.tool === "close_tab");
+    const entry = { ...data, id, request, cleanup, aborted: false, settled: false };
+    if (request) {
+      if (!request.pendingEntries) request.pendingEntries = new Set();
+      request.pendingEntries.add(entry);
+      if (cleanup) entry.abortCleanup = null;
+      else {
+        const onAbort = () => {
+          if (entry.abortNotified || entry.settled) return;
+          entry.abortNotified = true;
+          entry.aborted = true;
+          const error = abortError(request.signal);
+          if (entry.reject) entry.reject(error);
+          else entry.onAbort?.(error);
+          if (!entry.reject && !entry.onAbort) entry.onComplete?.({ error: error.message, cancelled: true });
+        };
+        entry.abortCleanup = () => request.signal.removeEventListener("abort", onAbort);
+        request.signal.addEventListener("abort", onAbort, { once: true });
+        if (request.signal.aborted) onAbort();
+      }
+    }
+    super.set(id, entry);
+    return this;
+  }
+
+  get(id) {
+    return super.get(id);
+  }
+
+  delete(id) {
+    const entry = super.get(id);
+    if (!entry) return false;
+    this.#removeEntry(entry);
+    return true;
+  }
+
+  #removeEntry(entry, notify = true) {
+    super.delete(entry.id);
+    entry.abortCleanup?.();
+    if (entry.tombstoneTimer) clearTimeout(entry.tombstoneTimer);
+    entry.request?.pendingEntries?.delete(entry);
+    if (notify) this.#notifyDrain(entry.request);
+  }
+
+  #notifyDrain(request) {
+    if (!request || request.pendingEntries?.size) return;
+    const waiters = this.drainWaiters.get(request);
+    if (!waiters) return;
+    this.drainWaiters.delete(request);
+    for (const waiter of waiters) waiter();
+  }
+
+  onDrain(request, callback) {
+    if (!request?.pendingEntries?.size) {
+      callback();
+      return;
+    }
+    const waiters = this.drainWaiters.get(request) || [];
+    waiters.push(callback);
+    this.drainWaiters.set(request, waiters);
+  }
+
+  resolve(id, value) {
+    const entry = this.get(id);
+    if (!entry) return false;
+    this.#removeEntry(entry, false);
+    try {
+      if (!entry.aborted && !entry.hardBoundary && !entry.settled) {
+        entry.settled = true;
+        if (entry.resolve) entry.resolve(value);
+        else if (entry.onComplete) entry.onComplete(value);
+      }
+    } finally {
+      this.#notifyDrain(entry.request);
+    }
+    return true;
+  }
+
+  expire(id, error) {
+    const entry = this.get(id);
+    if (!entry) return false;
+    if (!entry.settled) {
+      entry.settled = true;
+      entry.aborted = true;
+      entry.reject?.(error);
+      const request = entry.request;
+      const remaining = request ? Math.max(0, request.startedAt + request.deadlineMs - Date.now()) : 0;
+      entry.tombstoneTimer = setTimeout(() => this.delete(entry.id), remaining);
+    }
+    return true;
+  }
+
+  reject(id, error) {
+    const entry = this.get(id);
+    if (!entry) return false;
+    this.#removeEntry(entry, false);
+    try {
+      if (!entry.settled) {
+        entry.settled = true;
+        entry.reject?.(error);
+      }
+    } finally {
+      this.#notifyDrain(entry.request);
+    }
+    return true;
+  }
+
+  tombstoneAfterAbort(request) {
+    if (!request?.pendingEntries) return;
+    for (const entry of request.pendingEntries) {
+      if (entry.cleanup || entry.tombstoneTimer) continue;
+      const remaining = Math.max(0, request.startedAt + request.deadlineMs - Date.now());
+      entry.tombstoneTimer = setTimeout(() => this.delete(entry.id), remaining);
+    }
+  }
+
+  hardDeadline(request) {
+    if (!request) return;
+    request.hardBoundary = true;
+    for (const entry of [...(request.pendingEntries || [])]) {
+      entry.hardBoundary = true;
+      this.#removeEntry(entry);
+      if (!entry.settled) {
+        entry.settled = true;
+        entry.reject?.(abortError(request.signal, "Request timed out"));
+      }
+    }
+  }
+
+  clear() {
+    for (const entry of this.values()) this.#removeEntry(entry);
+    this.drainWaiters.clear();
+    super.clear();
+  }
+}
+
+module.exports = { RequestPendingMap };

package/native/socket-path.cjs

@@ -0,0 +1,46 @@
+const path = require("path");
+const os = require("os");
+
+const IS_WIN = process.platform === "win32";
+const DEFAULT_SOCKET_PATH = IS_WIN ? "//./pipe/surf" : "/tmp/surf.sock";
+const SOCKET_PATH = process.env.SURF_SOCKET || DEFAULT_SOCKET_PATH;
+const SURF_TMP = process.env.SURF_TMP || (IS_WIN ? path.join(os.tmpdir(), "surf") : "/tmp");
+
+function getSocketTroubleshootingHint() {
+  const lines = [
+    `Attempted socket: ${SOCKET_PATH}`,
+    "Make sure the browser is running with the Surf extension enabled, then restart the browser after native host install changes.",
+    "Run `surf doctor --browser all` for detailed native host diagnostics.",
+  ];
+
+  if (process.env.SURF_SOCKET) {
+    lines.push("SURF_SOCKET is set; make sure the native host and CLI use the same value.");
+  }
+
+  if (process.platform === "linux") {
+    lines.push("On WSL2 with Windows Chrome, run `surf install <extension-id>` from WSL and restart Windows Chrome.");
+  }
+
+  return lines.join("\n");
+}
+
+function formatSocketError(error, context = "connect") {
+  let message;
+  if (error && error.code === "ENOENT") {
+    message = "Socket not found.";
+  } else if (error && error.code === "ECONNREFUSED") {
+    message = "Connection refused. Native host is not accepting connections.";
+  } else {
+    message = error && error.message ? error.message : String(error);
+  }
+
+  return `Socket ${context} failed: ${message}\n${getSocketTroubleshootingHint()}`;
+}
+
+module.exports = {
+  DEFAULT_SOCKET_PATH,
+  SOCKET_PATH,
+  SURF_TMP,
+  formatSocketError,
+  getSocketTroubleshootingHint,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "surf-cli",
-  "version": "2.7.2",
+  "version": "2.9.0",
   "description": "CLI for AI agents to control Chrome. Zero config, agent-agnostic, battle-tested.",
   "keywords": [
     "chrome",
@@ -43,6 +43,7 @@
     "lint:test": "biome check test/",
     "format": "biome format --write .",
     "test": "vitest run",
+    "test:e2e:chrome": "node test/e2e/real-chrome.mjs",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "test:ui": "vitest --ui",
@@ -56,16 +57,17 @@
     "crypto-browserify": "^3.12.1",
     "events": "^3.3.0",
     "stream-browserify": "^3.0.0",
-    "vite-plugin-node-polyfills": "^0.25.0",
+    "vite-plugin-node-polyfills": "^0.28.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.4",
-    "@types/chrome": "^0.1.37",
-    "@vitest/coverage-v8": "^4.0.18",
-    "@vitest/ui": "^4.0.18",
-    "typescript": "^5.7.2",
-    "vite": "^7.3.1",
-    "vitest": "^4.0.18"
+    "@biomejs/biome": "^2.5.4",
+    "@types/chrome": "^0.2.2",
+    "@vitest/coverage-v8": "^4.1.9",
+    "@vitest/ui": "^4.1.9",
+    "puppeteer": "25.3.0",
+    "typescript": "^7.0.2",
+    "vite": "^8.1.4",
+    "vitest": "^4.1.9"
   }
 }

package/scripts/install-native-host.cjs

@@ -2,7 +2,9 @@
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
-const { execSync, spawnSync } = require("child_process");
+const { execFileSync, execSync } = require("child_process");
+const { parseListenEndpoint } = require("../native/listener.cjs");
+const { getStateDir, loadHostIdentity, loadRegistry } = require("../native/remote-auth.cjs");
 
 const HOST_NAME = "surf.browser.host";
 
@@ -12,12 +14,14 @@ const BROWSERS = {
     darwin: "Library/Application Support/Google/Chrome/NativeMessagingHosts",
     linux: ".config/google-chrome/NativeMessagingHosts",
     win32: "Google\\Chrome",
+    wsl: "Google/Chrome/User Data/NativeMessagingHosts",
   },
   chromium: {
     name: "Chromium",
     darwin: "Library/Application Support/Chromium/NativeMessagingHosts",
     linux: ".config/chromium/NativeMessagingHosts",
     win32: "Chromium",
+    wsl: "Chromium/User Data/NativeMessagingHosts",
   },
   brave: {
     name: "Brave",
@@ -25,12 +29,14 @@ const BROWSERS = {
       "Library/Application Support/BraveSoftware/Brave-Browser/NativeMessagingHosts",
     linux: ".config/BraveSoftware/Brave-Browser/NativeMessagingHosts",
     win32: "BraveSoftware\\Brave-Browser",
+    wsl: "BraveSoftware/Brave-Browser/User Data/NativeMessagingHosts",
   },
   edge: {
     name: "Microsoft Edge",
     darwin: "Library/Application Support/Microsoft Edge/NativeMessagingHosts",
     linux: ".config/microsoft-edge/NativeMessagingHosts",
     win32: "Microsoft\\Edge",
+    wsl: "Microsoft/Edge/User Data/NativeMessagingHosts",
   },
   arc: {
     name: "Arc",
@@ -38,12 +44,14 @@ const BROWSERS = {
       "Library/Application Support/Arc/User Data/NativeMessagingHosts",
     linux: null,
     win32: null,
+    wsl: null,
   },
   helium: {
     name: "Helium",
     darwin: "Library/Application Support/net.imput.helium/NativeMessagingHosts",
     linux: null,
     win32: null,
+    wsl: null,
   },
 };
 
@@ -63,6 +71,16 @@ const NODE_PATHS = {
   ],
 };
 
+function isWsl() {
+  if (process.platform !== "linux") return false;
+  if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP) return true;
+  try {
+    return /microsoft|wsl/i.test(fs.readFileSync("/proc/version", "utf8"));
+  } catch {
+    return false;
+  }
+}
+
 function findNode() {
   if (process.env.SURF_NODE_PATH && fs.existsSync(process.env.SURF_NODE_PATH)) {
     return process.env.SURF_NODE_PATH;
@@ -88,10 +106,14 @@ function findNpmGlobalRoot() {
   }
 }
 
-function getWrapperDir() {
-  const platform = process.platform;
+function getWrapperDir(target = process.platform) {
   const home = os.homedir();
-  switch (platform) {
+  if (target === "wsl-windows") {
+    const localAppData = getWindowsEnv("LOCALAPPDATA");
+    if (!localAppData) return null;
+    return path.join(windowsPathToWslPath(localAppData), "surf-cli");
+  }
+  switch (process.platform) {
     case "darwin":
       return path.join(home, "Library/Application Support/surf-cli");
     case "linux":
@@ -117,72 +139,129 @@ function getHostPath() {
   return null;
 }
 
-function createWrapper(wrapperDir, nodePath, hostPath) {
-  const platform = process.platform;
+function getWindowsEnv(name) {
+  try {
+    return execFileSync("cmd.exe", ["/c", "echo", `%${name}%`], { encoding: "utf8" })
+      .trim()
+      .replace(/\r/g, "");
+  } catch {
+    return null;
+  }
+}
+
+function windowsPathToWslPath(winPath) {
+  const normalized = winPath.replace(/\\/g, "/");
+  const match = normalized.match(/^([A-Za-z]):\/(.*)$/);
+  if (!match) return normalized;
+  return `/mnt/${match[1].toLowerCase()}/${match[2]}`;
+}
+
+function wslPathToWindowsPath(wslPath) {
+  try {
+    return execFileSync("wslpath", ["-w", wslPath], { encoding: "utf8" }).trim().replace(/\r/g, "");
+  } catch {
+    const match = wslPath.match(/^\/mnt\/([a-zA-Z])\/(.*)$/);
+    if (match) return `${match[1].toUpperCase()}:\\${match[2].replace(/\//g, "\\")}`;
+    return wslPath;
+  }
+}
+
+function createWrapper(wrapperDir, nodePath, hostPath, target = process.platform, listen) {
   fs.mkdirSync(wrapperDir, { recursive: true });
 
-  if (platform === "win32") {
+  if (target === "wsl-windows") {
+    const cmdPath = path.join(wrapperDir, "host-wrapper-wsl.cmd");
+    const distroArg = process.env.WSL_DISTRO_NAME ? ` -d "${process.env.WSL_DISTRO_NAME}"` : "";
+    const content = `@echo off\r\nwsl.exe${distroArg} --cd "${path.dirname(hostPath)}" --exec "${nodePath}" "${hostPath}" %*\r\n`;
+    fs.writeFileSync(cmdPath, content);
+    return wslPathToWindowsPath(cmdPath);
+  }
+
+  if (process.platform === "win32") {
     const batPath = path.join(wrapperDir, "host-wrapper.bat");
-    const content = `@echo off\r\n"${nodePath}" "${hostPath}"\r\n`;
+    const content = `@echo off\r\n"${nodePath}" "${hostPath}" %*\r\n`;
     fs.writeFileSync(batPath, content);
     return batPath;
-  } else {
-    const shPath = path.join(wrapperDir, "host-wrapper.sh");
-    const hostDir = path.dirname(hostPath);
-    const content = `#!/bin/bash
+  }
+
+  const shPath = path.join(wrapperDir, "host-wrapper.sh");
+  const hostDir = path.dirname(hostPath);
+  const content = `#!/usr/bin/env bash
 cd "${hostDir}"
-exec "${nodePath}" "${hostPath}"
+${listen ? `: "\${SURF_LISTEN:=${listen}}"\nexport SURF_LISTEN\n` : ""}exec "${nodePath}" "${hostPath}" "$@"
 `;
-    fs.writeFileSync(shPath, content);
-    fs.chmodSync(shPath, "755");
-    return shPath;
-  }
+  fs.writeFileSync(shPath, content);
+  fs.chmodSync(shPath, "755");
+  return shPath;
 }
 
-function installManifest(browser, extensionId, wrapperPath) {
-  const platform = process.platform;
-  const browserConfig = BROWSERS[browser];
-
-  if (!browserConfig || !browserConfig[platform]) {
-    return null;
+function assertListenTargetSupported(listen, target) {
+  if (listen && (target === "win32" || target === "wsl-windows")) {
+    throw new Error("--listen is not supported for Windows native-host wrappers");
   }
+}
 
-  if (platform === "win32") {
-    return installWindowsRegistry(browser, extensionId, wrapperPath);
-  }
+function readExistingManifest(manifestPath) {
+  if (!fs.existsSync(manifestPath)) return {};
+  return JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+}
 
-  const manifestDir = path.join(os.homedir(), browserConfig[platform]);
-  fs.mkdirSync(manifestDir, { recursive: true });
+function writeManifest(manifestPath, extensionId, wrapperPath) {
+  const origin = `chrome-extension://${extensionId}/`;
+  const existing = readExistingManifest(manifestPath);
+  const allowedOrigins = Array.isArray(existing.allowed_origins) ? existing.allowed_origins : [];
 
   const manifest = {
+    ...existing,
     name: HOST_NAME,
-    description: "Surf CLI Native Host",
+    description: existing.description || "Surf CLI Native Host",
     path: wrapperPath,
     type: "stdio",
-    allowed_origins: [`chrome-extension://${extensionId}/`],
+    allowed_origins: Array.from(new Set([...allowedOrigins, origin])),
   };
 
-  const manifestPath = path.join(manifestDir, `${HOST_NAME}.json`);
+  fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
   fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
   return manifestPath;
 }
 
+function getWslWindowsManifestDir(browserConfig) {
+  const localAppData = getWindowsEnv("LOCALAPPDATA");
+  if (!localAppData || !browserConfig.wsl) return null;
+  return path.join(windowsPathToWslPath(localAppData), browserConfig.wsl);
+}
+
+function installManifest(browser, extensionId, wrapperPath, target) {
+  const browserConfig = BROWSERS[browser];
+
+  if (!browserConfig) return null;
+
+  if (target === "wsl-windows") {
+    const manifestDir = getWslWindowsManifestDir(browserConfig);
+    if (!manifestDir) return null;
+    const manifestPath = path.join(manifestDir, `${HOST_NAME}.json`);
+    return writeManifest(manifestPath, extensionId, wrapperPath);
+  }
+
+  const platform = process.platform;
+  if (!browserConfig[platform]) return null;
+
+  if (platform === "win32") {
+    return installWindowsRegistry(browser, extensionId, wrapperPath);
+  }
+
+  const manifestDir = path.join(os.homedir(), browserConfig[platform]);
+  const manifestPath = path.join(manifestDir, `${HOST_NAME}.json`);
+  return writeManifest(manifestPath, extensionId, wrapperPath);
+}
+
 function installWindowsRegistry(browser, extensionId, wrapperPath) {
   const browserConfig = BROWSERS[browser];
   const regPath = `HKCU\\Software\\${browserConfig.win32}\\NativeMessagingHosts\\${HOST_NAME}`;
 
   const manifestDir = getWrapperDir();
   const manifestPath = path.join(manifestDir, `${HOST_NAME}.json`);
-
-  const manifest = {
-    name: HOST_NAME,
-    description: "Surf CLI Native Host",
-    path: wrapperPath,
-    type: "stdio",
-    allowed_origins: [`chrome-extension://${extensionId}/`],
-  };
-
-  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+  writeManifest(manifestPath, extensionId, wrapperPath);
 
   try {
     execSync(`reg add "${regPath}" /ve /t REG_SZ /d "${manifestPath}" /f`, {
@@ -197,7 +276,7 @@ function installWindowsRegistry(browser, extensionId, wrapperPath) {
 
 function parseArgs() {
   const args = process.argv.slice(2);
-  const result = { extensionId: null, browsers: ["chrome"] };
+  const result = { extensionId: null, browsers: ["chrome"], target: "auto", listen: undefined };
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -208,6 +287,11 @@ function parseArgs() {
       } else {
         result.browsers = browserArg.split(",").map((b) => b.trim().toLowerCase());
       }
+    } else if (arg === "--target") {
+      result.target = args[++i];
+    } else if (arg === "--listen") {
+      result.listen = args[++i];
+      if (!result.listen || result.listen.startsWith("--")) throw new Error("--listen requires a Tailnet IP and port");
     } else if (arg === "--help" || arg === "-h") {
       printHelp();
       process.exit(0);
@@ -232,20 +316,30 @@ Options:
   -b, --browser   Browser(s) to install for (default: chrome)
                   Values: chrome, chromium, brave, edge, arc, helium, all
                   Multiple: --browser chrome,brave
+  --target        Install target: auto, linux, windows
+                  On WSL2, auto installs for Windows Chrome. Use linux for WSLg/Linux browsers.
+  --listen <tailscale-ip>:<port>
+                  Persist an authenticated Tailnet-only listener endpoint.
+                  Requires at least one surf remote authorize client first.
+                  Supports Tailscale IPv4 or IPv6 addresses; POSIX wrappers only.
 
 Examples:
   node install-native-host.cjs abcdefghijklmnopabcdefghijklmnop
   node install-native-host.cjs abcdefghijklmnop --browser brave
   node install-native-host.cjs abcdefghijklmnop --browser all
+  node install-native-host.cjs abcdefghijklmnop --target linux
+  node install-native-host.cjs abcdefghijklmnop --listen 100.64.1.2:4321
 `);
 }
 
 function main() {
-  const { extensionId, browsers } = parseArgs();
+  let parsed;
+  try { parsed = parseArgs(); } catch (error) { console.error(`Error: ${error.message}`); process.exit(1); }
+  const { extensionId, browsers, target, listen } = parsed;
 
   if (!extensionId) {
     console.error("Error: Extension ID required");
-    console.error("Usage: install-native-host.cjs <extension-id> [--browser chrome|chromium|brave|edge|arc|helium|all]");
+    console.error("Usage: install-native-host.cjs <extension-id> [--browser chrome|chromium|brave|edge|arc|helium|all] [--target auto|linux|windows]");
     console.error("\nFind your extension ID at chrome://extensions (enable Developer Mode)");
     process.exit(1);
   }
@@ -255,6 +349,36 @@ function main() {
     console.error("Expected 32 lowercase letters (a-p)");
     process.exit(1);
   }
+  let listener;
+  try {
+    listener = listen ? parseListenEndpoint(listen).display : undefined;
+    if (listener) {
+      const stateDir = getStateDir();
+      loadHostIdentity(stateDir);
+      if (loadRegistry(stateDir).clients.length === 0) {
+        throw new Error("--listen requires at least one authorized remote client; run `surf remote authorize <label> --output <path>` first");
+      }
+    }
+  } catch (error) { console.error(`Error: ${error.message}`); process.exit(1); }
+
+  if (!["auto", "linux", "windows"].includes(target)) {
+    console.error("Error: Invalid --target value. Expected auto, linux, or windows");
+    process.exit(1);
+  }
+
+  const runningInWsl = isWsl();
+  if (target === "windows" && !runningInWsl && process.platform !== "win32") {
+    console.error("Error: --target windows is only supported on Windows or WSL2");
+    process.exit(1);
+  }
+
+  if (target === "linux" && process.platform !== "linux") {
+    console.error("Error: --target linux is only supported on Linux or WSL2");
+    process.exit(1);
+  }
+
+  const effectiveTarget = runningInWsl && target !== "linux" ? "wsl-windows" : process.platform;
+  try { assertListenTargetSupported(listen, effectiveTarget); } catch (error) { console.error(`Error: ${error.message}`); process.exit(1); }
 
   const nodePath = findNode();
   if (!nodePath) {
@@ -270,19 +394,20 @@ function main() {
     process.exit(1);
   }
 
-  const wrapperDir = getWrapperDir();
+  const wrapperDir = getWrapperDir(effectiveTarget);
   if (!wrapperDir) {
-    console.error("Error: Unsupported platform");
+    console.error("Error: Unsupported platform or Windows interop unavailable");
     process.exit(1);
   }
 
-  console.log(`Platform: ${process.platform}`);
+  console.log(`Platform: ${process.platform}${runningInWsl ? " (WSL2 detected)" : ""}`);
+  console.log(`Target: ${effectiveTarget === "wsl-windows" ? "Windows browser from WSL2" : effectiveTarget}`);
   console.log(`Node: ${nodePath}`);
   console.log(`Host: ${hostPath}`);
   console.log(`Wrapper dir: ${wrapperDir}`);
   console.log("");
 
-  const wrapperPath = createWrapper(wrapperDir, nodePath, hostPath);
+  const wrapperPath = createWrapper(wrapperDir, nodePath, hostPath, effectiveTarget, listener);
   console.log(`Created wrapper: ${wrapperPath}`);
   console.log("");
 
@@ -295,7 +420,7 @@ function main() {
       continue;
     }
 
-    const result = installManifest(browser, extensionId, wrapperPath);
+    const result = installManifest(browser, extensionId, wrapperPath, effectiveTarget);
     if (result) {
       installed.push({ browser: BROWSERS[browser].name, path: result });
     } else {
@@ -311,10 +436,18 @@ function main() {
   }
 
   if (skipped.length > 0) {
-    console.log(`\nSkipped (not supported on ${process.platform}): ${skipped.join(", ")}`);
+    console.log(`\nSkipped (not supported for ${effectiveTarget}): ${skipped.join(", ")}`);
   }
 
   console.log("\nDone! Restart your browser for changes to take effect.");
 }
 
-main();
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  createWrapper,
+  writeManifest,
+  assertListenTargetSupported,
+};