@appium/base-driver 10.2.0 → 10.2.1

package/lib/helpers/capabilities.ts

@@ -0,0 +1,83 @@
+import type {Constraints, W3CCapabilities, Capabilities, AppiumLogger} from '@appium/types';
+import _ from 'lodash';
+
+/**
+ * Determine whether the given argument is valid
+ * W3C capabilities instance.
+ */
+export function isW3cCaps(caps: unknown): caps is W3CCapabilities<Constraints> {
+  if (!_.isPlainObject(caps)) {
+    return false;
+  }
+
+  const c = caps as Record<string, unknown>;
+  const isFirstMatchValid = () =>
+    _.isArray(c.firstMatch) &&
+    !_.isEmpty(c.firstMatch) &&
+    _.every(c.firstMatch, _.isPlainObject);
+  const isAlwaysMatchValid = () => _.isPlainObject(c.alwaysMatch);
+  if (_.has(c, 'firstMatch') && _.has(c, 'alwaysMatch')) {
+    return isFirstMatchValid() && isAlwaysMatchValid();
+  }
+  if (_.has(c, 'firstMatch')) {
+    return isFirstMatchValid();
+  }
+  if (_.has(c, 'alwaysMatch')) {
+    return isAlwaysMatchValid();
+  }
+  return false;
+}
+
+/**
+ * Normalize capability values according to constraints (e.g. string 'true' → boolean).
+ */
+export function fixCaps<C extends Constraints>(
+  oldCaps: Record<string, unknown>,
+  desiredCapConstraints: C,
+  log: AppiumLogger
+): Capabilities<C> {
+  const caps = _.clone(oldCaps) as Record<string, unknown>;
+
+  const logCastWarning = (prefix: string) => log.warn(`${prefix}. This may cause unexpected behavior`);
+
+  // boolean capabilities can be passed in as strings 'false' and 'true'
+  // which we want to translate into boolean values
+  const booleanCaps = _.keys(_.pickBy(desiredCapConstraints, (k) => k.isBoolean === true));
+  for (const cap of booleanCaps) {
+    const value = oldCaps[cap];
+    if (!_.isString(value)) {
+      continue;
+    }
+
+    if (!['true', 'false'].includes(value.toLowerCase())) {
+      logCastWarning(`String capability '${cap}' ('${value}') cannot be converted to a boolean`);
+      continue;
+    }
+
+    logCastWarning(`Capability '${cap}' changed from string '${value}' to boolean`);
+    caps[cap] = value.toLowerCase() === 'true';
+  }
+
+  // int capabilities are often sent in as strings by frameworks
+  const intCaps = _.keys(_.pickBy(desiredCapConstraints, (k) => k.isNumber === true));
+  for (const cap of intCaps) {
+    const value = oldCaps[cap];
+    if (!_.isString(value)) {
+      continue;
+    }
+
+    const intValue = parseInt(value as string, 10);
+    const floatValue = parseFloat(value as string);
+    const newValue = floatValue !== intValue ? floatValue : intValue;
+
+    if (Number.isNaN(newValue)) {
+      logCastWarning(`String capability '${cap}' ('${value}') cannot be converted to a number`);
+      continue;
+    }
+
+    logCastWarning(`Capability '${cap}' changed from string '${value}' to number ${newValue}`);
+    caps[cap] = newValue;
+  }
+
+  return caps as Capabilities<C>;
+}

package/lib/jsonwp-status/{status.js → status.ts}

@@ -1,6 +1,4 @@
-import _ from 'lodash';
-
-const codes = {
+export const codes = {
   Success: {
     code: 0,
     summary: 'The command executed successfully.',
@@ -112,17 +110,16 @@ const codes = {
     code: 35,
     summary: 'No such context found.',
   },
-};
+} as const;
 
-function getSummaryByCode(code) {
-  code = parseInt(code, 10);
-  for (let obj of _.values(codes)) {
-    if (!_.isUndefined(obj.code) && obj.code === code) {
-      return obj.summary;
-    }
-  }
-  return 'An error occurred';
+/**
+ * Returns the summary message for a JSONWP status code.
+ *
+ * @param code - Numeric status code (e.g. 0, 7) or string representation
+ * @returns Human-readable summary for the code, or 'An error occurred' if unknown
+ */
+export function getSummaryByCode(code: number | string): string {
+  const parsed = parseInt(String(code), 10);
+  const match = Object.values(codes).find((obj) => obj.code === parsed);
+  return match?.summary ?? 'An error occurred';
 }
-
-export default codes;
-export {codes, getSummaryByCode};

package/lib/protocol/{bidi-commands.js → bidi-commands.ts}

@@ -1,9 +1,11 @@
-const SUBSCRIPTION_REQUEST_PARAMS = /** @type {const} */ ({
+import type {BidiModuleMap} from '@appium/types';
+
+const SUBSCRIPTION_REQUEST_PARAMS = {
   required: ['events'],
   optional: ['contexts'],
-});
+} as const;
 
-export const BIDI_COMMANDS = /** @type {const} */ ({
+export const BIDI_COMMANDS = {
   session: {
     subscribe: {
       command: 'bidiSubscribe',
@@ -16,7 +18,7 @@ export const BIDI_COMMANDS = /** @type {const} */ ({
     status: {
       command: 'bidiStatus',
       params: {},
-    }
+    },
   },
   browsingContext: {
     navigate: {
@@ -27,7 +29,7 @@ export const BIDI_COMMANDS = /** @type {const} */ ({
       },
     },
   },
-});
+} as const satisfies BidiModuleMap;
 
 // TODO add definitions for all bidi commands.
 // spec link: https://w3c.github.io/webdriver-bidi/

package/lib/protocol/errors.ts

@@ -1,7 +1,7 @@
 import _ from 'lodash';
 import {util, logger} from '@appium/support';
 import {StatusCodes as HTTPStatusCodes} from 'http-status-codes';
-import type { ErrorBiDiCommandResponse, Class } from '@appium/types';
+import type {ErrorBiDiCommandResponse, Class} from '@appium/types';
 
 const mjsonwpLog = logger.getLogger('MJSONWP');
 const w3cLog = logger.getLogger('W3C');

package/lib/protocol/{helpers.js → helpers.ts}

@@ -5,13 +5,12 @@ import {MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY} from '../constants';
 /**
  * Preprocesses the resulting value for API responses,
  * so they have keys for both W3C and JSONWP protocols.
- * The argument value is NOT mutated
+ * The argument value is NOT mutated.
  *
- * @param {Object | undefined} resValue The actual response value
- * @returns {Object | null} Either modified value or the same one if
- * nothing has been modified
+ * @param resValue - The actual response value
+ * @returns Either modified value or the same one if nothing has been modified
  */
-export function formatResponseValue(resValue) {
+export function formatResponseValue(resValue: object | undefined): object | null {
   if (_.isUndefined(resValue)) {
     // convert undefined to null
     return null;
@@ -27,13 +26,11 @@ export function formatResponseValue(resValue) {
  * Properly formats the status for API responses,
  * so they are correct for the W3C protocol.
  *
- * @param {Object} responseBody
- * @returns {Object} The fixed response body
+ * @param responseBody - The response body
+ * @returns The fixed response body
  */
-export function ensureW3cResponse(responseBody) {
+export function ensureW3cResponse(responseBody: Record<string, unknown>): Record<string, unknown> {
   return _.isPlainObject(responseBody)
-    ? _.omit(responseBody, ['status', 'sessionId'])
+    ? (_.omit(responseBody, ['status', 'sessionId']) as Record<string, unknown>)
     : responseBody;
 }
-
-export {MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY};

package/lib/protocol/protocol.ts

@@ -14,13 +14,13 @@ import B from 'bluebird';
 import {formatResponseValue, ensureW3cResponse} from './helpers';
 import {MAX_LOG_BODY_LENGTH, PROTOCOLS, DEFAULT_BASE_PATH} from '../constants';
 import {isW3cCaps} from '../helpers/capabilities';
-import log from '../basedriver/logger';
-import { generateDriverLogPrefix } from '../basedriver/helpers';
-import type { Core, AppiumLogger, PayloadParams, MethodMap, Driver, DriverMethodDef } from '@appium/types';
-import type { BaseDriver } from '../basedriver/driver';
-import type { Request, Response, Application } from 'express';
-import type { MultidimensionalReadonlyArray } from 'type-fest';
-import type { RouteConfiguringFunction } from '../express/server';
+import {log} from '../basedriver/logger';
+import {generateDriverLogPrefix} from '../basedriver/helpers';
+import type {Core, AppiumLogger, PayloadParams, MethodMap, Driver, DriverMethodDef} from '@appium/types';
+import type {BaseDriver} from '../basedriver/driver';
+import type {Request, Response, Application} from 'express';
+import type {MultidimensionalReadonlyArray} from 'type-fest';
+import type {RouteConfiguringFunction} from '../express/server';
 
 export const CREATE_SESSION_COMMAND = 'createSession';
 export const DELETE_SESSION_COMMAND = 'deleteSession';
@@ -34,6 +34,34 @@ export function determineProtocol(createSessionArgs: any[]): keyof typeof PROTOC
   return _.some(createSessionArgs, isW3cCaps) ? PROTOCOLS.W3C : PROTOCOLS.MJSONWP;
 }
 
+/**
+ * Extract and validate the sessionId from the Express route parameter.
+ * Express may return route params as string | string[] | undefined.
+ * Appium uses standard routes (e.g., /session/:sessionId) which should always be strings.
+ * Only `*` such as `/session/*sessionId` can return `string[]`.
+ * Then, this method will return the first element as the session id.
+ * It may break existing appium routing handling also, thus this method will log
+ * received parameters as well to help debugging.
+ * @param driver Running driver
+ * @param req The request in Express
+ * @returns The normalized sessionId (string or undefined)
+ */
+export function getSessionId(driver: Core<any>, req: Request): string | undefined {
+  if (Array.isArray(req.params.sessionId)) {
+    const sessionId = req.params.sessionId[0];
+    getLogger(driver, sessionId).warn(
+      `Received malformed sessionId as array from the route: ${req.originalUrl}. ` +
+      `This indicates the route definition issue. The route should start with '/session/:sessionId' (named parameter) ` +
+      `instead of '/session/*sessionId' (wildcard). ` +
+      `Using the first element as session id: ${sessionId}. ` +
+      `Please fix the route definition to prevent this error.`
+    );
+    // This is to not log the message multiple times.
+    req.params.sessionId = sessionId;
+    return sessionId;
+  }
+  return req.params.sessionId;
+}
 
 function extractProtocol(driver: Core<any>, sessionId: string | null = null): keyof typeof PROTOCOLS {
   const dstDriver = _.isFunction(driver.driverForSession) && sessionId
@@ -310,13 +338,14 @@ function buildHandler(
     let httpResBody = {} as any;
     let httpStatus = 200;
     let newSessionId: string | undefined;
-    let currentProtocol = extractProtocol(driver, req.params.sessionId);
+    const sessionId = getSessionId(driver, req);
+    let currentProtocol = extractProtocol(driver, sessionId);
 
     try {
       // if the route accessed is deprecated, log a warning
       if (spec.deprecated && spec.command && !deprecatedCommandsLogged.has(spec.command)) {
         deprecatedCommandsLogged.add(spec.command);
-        getLogger(driver, req.params.sessionId).warn(
+        getLogger(driver, sessionId).warn(
           `The ${method} ${path} endpoint has been deprecated and will be removed in a future ` +
             `version of Appium or your driver/plugin. Please use a different endpoint or contact the ` +
             `driver/plugin author to add explicit support for the endpoint before it is removed`
@@ -325,7 +354,7 @@ function buildHandler(
 
       // if this is a session command but we don't have a session,
       // error out early (especially before proxying)
-      if (isSessCmd && !driver.sessionExists(req.params.sessionId)) {
+      if (isSessCmd && !driver.sessionExists(sessionId)) {
         throw new errors.NoSuchDriverError();
       }
 
@@ -341,12 +370,12 @@ function buildHandler(
       if (isSessCmd && !spec.neverProxy && spec.command && driverShouldDoJwpProxy(driver, req, spec.command)) {
         if (
           !('pluginsToHandleCmd' in driver) || !_.isFunction(driver.pluginsToHandleCmd) ||
-          driver.pluginsToHandleCmd(spec.command, req.params.sessionId).length === 0
+          driver.pluginsToHandleCmd(spec.command, sessionId).length === 0
         ) {
           await doJwpProxy(driver as BaseDriver<any>, req, res);
           return;
         }
-        getLogger(driver, req.params.sessionId).debug(
+        getLogger(driver, sessionId).debug(
           `Would have proxied ` +
             `command directly, but a plugin exists which might require its value, so will let ` +
             `its value be collected internally and made part of plugin chain`
@@ -393,7 +422,7 @@ function buildHandler(
       }
 
       // run the driver command wrapped inside the argument validators
-      getLogger(driver, req.params.sessionId).debug(
+      getLogger(driver, sessionId).debug(
         `Calling %s.%s() with args: %s`,
         driver.constructor.name, spec.command,
         logger.markSensitive(_.truncate(JSON.stringify(args), {length: MAX_LOG_BODY_LENGTH}))
@@ -409,7 +438,7 @@ function buildHandler(
       driverRes = await (driver as BaseDriver<any>).executeCommand(spec.command, ...args);
 
       // Get the protocol after executeCommand
-      currentProtocol = extractProtocol(driver, req.params.sessionId) || currentProtocol;
+      currentProtocol = extractProtocol(driver, sessionId) || currentProtocol;
 
       // If `executeCommand` was overridden and the method returns an object
       // with a protocol and value/error property, re-assign the protocol
@@ -440,12 +469,12 @@ function buildHandler(
 
       // delete should not return anything even if successful
       if (spec.command === DELETE_SESSION_COMMAND) {
-        getLogger(driver, req.params.sessionId).debug(
+        getLogger(driver, sessionId).debug(
           `Received response: ${_.truncate(JSON.stringify(driverRes), {
             length: MAX_LOG_BODY_LENGTH,
           })}`
         );
-        getLogger(driver, req.params.sessionId).debug('But deleting session, so not returning');
+        getLogger(driver, sessionId).debug('But deleting session, so not returning');
         driverRes = null;
       }
 
@@ -467,7 +496,7 @@ function buildHandler(
       }
 
       httpResBody.value = driverRes;
-      getLogger(driver, req.params.sessionId || newSessionId).debug(
+      getLogger(driver, sessionId || newSessionId).debug(
         `Responding ` +
           `to client with driver.${spec.command}() result: ${_.truncate(JSON.stringify(driverRes), {
             length: MAX_LOG_BODY_LENGTH,
@@ -480,7 +509,7 @@ function buildHandler(
       if (err instanceof Error || (_.has(err, 'stack') && _.has(err, 'message'))) {
         actualErr = err;
       } else {
-        getLogger(driver, req.params.sessionId || newSessionId).warn(
+        getLogger(driver, sessionId || newSessionId).warn(
           'The thrown error object does not seem to be a valid instance of the Error class. This ' +
             'might be a genuine bug of a driver or a plugin.'
         );
@@ -488,7 +517,7 @@ function buildHandler(
       }
 
       currentProtocol =
-        currentProtocol || extractProtocol(driver, req.params.sessionId || newSessionId);
+        currentProtocol || extractProtocol(driver, sessionId || newSessionId);
 
       let errMsg = err.stacktrace || err.stack;
       if (!_.includes(errMsg, err.message)) {
@@ -499,7 +528,7 @@ function buildHandler(
       if (isErrorType(err, errors.ProxyRequestError)) {
         actualErr = err.getActualError();
       } else {
-        getLogger(driver, req.params.sessionId || newSessionId).debug(
+        getLogger(driver, sessionId || newSessionId).debug(
           `Encountered internal error running command: ${errMsg}`
         );
       }
@@ -525,9 +554,10 @@ function buildHandler(
   });
 }
 
-export function driverShouldDoJwpProxy(driver: Core<any>, req: import('express').Request, command: string): boolean {
+export function driverShouldDoJwpProxy(driver: Core<any>, req: Request, command: string): boolean {
+  const sessionId = getSessionId(driver, req);
   // drivers need to explicitly say when the proxy is active
-  if (!driver.proxyActive(req.params.sessionId)) {
+  if (!driver.proxyActive(sessionId)) {
     return false;
   }
 
@@ -539,7 +569,7 @@ export function driverShouldDoJwpProxy(driver: Core<any>, req: import('express')
 
   // validate avoidance schema, and say we shouldn't proxy if anything in the
   // avoid list matches our req
-  if (driver.proxyRouteIsAvoided(req.params.sessionId, req.method, req.originalUrl, req.body)) {
+  if (driver.proxyRouteIsAvoided(sessionId as string, req.method, req.originalUrl, req.body)) {
     return false;
   }
 
@@ -547,16 +577,17 @@ export function driverShouldDoJwpProxy(driver: Core<any>, req: import('express')
 }
 
 async function doJwpProxy(driver: BaseDriver<any>, req: Request, res: Response): Promise<void> {
-  getLogger(driver, req.params.sessionId).info(
+  const sessionId = getSessionId(driver, req) as string;
+  getLogger(driver, sessionId).info(
     'Driver proxy active, passing request on via HTTP proxy'
   );
 
   // check that the inner driver has a proxy function
-  if (!driver.canProxy(req.params.sessionId)) {
+  if (!driver.canProxy(sessionId)) {
     throw new Error('Trying to proxy to a server but the driver is unable to proxy');
   }
   try {
-    await driver.executeCommand('proxyReqRes', req, res, req.params.sessionId);
+    await driver.executeCommand('proxyReqRes', req, res, sessionId);
   } catch (err) {
     if (isErrorType(err, errors.ProxyRequestError)) {
       throw err;

package/lib/protocol/{routes.js → routes.ts}

@@ -1,20 +1,19 @@
+import type {Driver, DriverMethodDef, HTTPMethod, MethodMap} from '@appium/types';
 import _ from 'lodash';
 import {DEFAULT_BASE_PATH} from '../constants';
 import {match} from 'path-to-regexp';
 import {LRUCache} from 'lru-cache';
 
-/** @type {LRUCache<string, string>} */
-const COMMAND_NAMES_CACHE = new LRUCache({
+const COMMAND_NAMES_CACHE = new LRUCache<string, string>({
   max: 1024,
 });
 
 /**
- * define the routes, mapping of HTTP methods to particular driver commands, and
- * any parameters that are expected in a request parameters can be `required` or
- * `optional`
- * @satisfies {import('@appium/types').MethodMap<import('../basedriver/driver').BaseDriver>}
+ * Define the routes: mapping of HTTP methods to particular driver commands, and
+ * any parameters that are expected in a request. Parameters can be `required` or
+ * `optional`.
  */
-export const METHOD_MAP = /** @type {const} */ ({
+export const METHOD_MAP = {
 
   // #region W3C WebDriver
   // https://www.w3.org/TR/webdriver2/
@@ -566,42 +565,40 @@ export const METHOD_MAP = /** @type {const} */ ({
     DELETE: {command: 'deleteVirtualPressureSource'},
   },
   // #endregion
-});
+} as const satisfies MethodMap<Driver>;
 
 // driver command names
 export const ALL_COMMANDS = _.flatMap(_.values(METHOD_MAP).map(_.values))
   .filter((m) => Boolean(m.command))
   .map((m) => m.command);
 
-/**
- *
- * @param {string} endpoint
- * @param {import('@appium/types').HTTPMethod} [method]
- * @param {string} [basePath=DEFAULT_BASE_PATH]
- * @returns {string|undefined}
- */
-export function routeToCommandName(endpoint, method, basePath = DEFAULT_BASE_PATH) {
-  let normalizedEndpoint = basePath
-    ? endpoint.replace(new RegExp(`^${_.escapeRegExp(basePath)}`), '')
+export function routeToCommandName(
+  endpoint: string,
+  method?: HTTPMethod,
+  basePath?: string
+): string | undefined {
+  const resolvedBasePath = basePath ?? DEFAULT_BASE_PATH;
+  let normalizedEndpoint = resolvedBasePath
+    ? endpoint.replace(new RegExp(`^${_.escapeRegExp(resolvedBasePath)}`), '')
     : endpoint;
   normalizedEndpoint = `${_.startsWith(normalizedEndpoint, '/') ? '' : '/'}${normalizedEndpoint}`;
-  /** @type {string} */
-  let normalizedPathname;
+  let normalizedPathname: string;
   try {
     // we could use any prefix there as we anyway need to only extract the pathname
     normalizedPathname = new URL(`https://appium.io${normalizedEndpoint}`).pathname;
-  } catch (err) {
-    throw new Error(`'${endpoint}' cannot be translated to a command name: ${err.message}`);
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`'${endpoint}' cannot be translated to a command name: ${msg}`);
   }
 
-  const normalizedMethod = _.toUpper(method);
+  const normalizedMethod = _.toUpper(method ?? '');
   const cacheKey = toCommandNameCacheKey(normalizedPathname, normalizedMethod);
-  if (COMMAND_NAMES_CACHE.has(cacheKey)) {
-    return COMMAND_NAMES_CACHE.get(cacheKey) || undefined;
+  const cached = COMMAND_NAMES_CACHE.get(cacheKey);
+  if (cached !== undefined) {
+    return cached || undefined;
   }
 
-  /** @type {string[]} */
-  const possiblePathnames = [];
+  const possiblePathnames: string[] = [];
   if (!normalizedPathname.startsWith('/session/')) {
     possiblePathnames.push(`/session/any-session-id${normalizedPathname}`);
   }
@@ -609,12 +606,10 @@ export function routeToCommandName(endpoint, method, basePath = DEFAULT_BASE_PAT
   for (const [routePath, routeSpec] of _.toPairs(METHOD_MAP)) {
     const routeMatcher = match(routePath);
     if (possiblePathnames.some((pp) => routeMatcher(pp))) {
-      const commandForAnyMethod = () => _.first(
-        (_.keys(routeSpec) ?? []).map((key) => routeSpec[key]?.command)
-      );
-      const commandName = normalizedMethod
-        ? routeSpec?.[normalizedMethod]?.command
-        : commandForAnyMethod();
+      const spec = routeSpec as Record<string, DriverMethodDef<Driver>>;
+      const commandForAnyMethod = () =>
+        _.first(_.keys(spec).map((key) => spec[key]?.command));
+      const commandName = normalizedMethod ? spec[normalizedMethod]?.command : commandForAnyMethod();
       if (commandName) {
         COMMAND_NAMES_CACHE.set(cacheKey, commandName);
         return commandName;
@@ -626,13 +621,7 @@ export function routeToCommandName(endpoint, method, basePath = DEFAULT_BASE_PAT
   COMMAND_NAMES_CACHE.set(cacheKey, '');
 }
 
-/**
- *
- * @param {string} endpoint
- * @param {string} [method]
- * @returns {string}
- */
-function toCommandNameCacheKey(endpoint, method) {
+function toCommandNameCacheKey(endpoint: string, method?: string): string {
   return `${endpoint}:${method ?? ''}`;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appium/base-driver",
-  "version": "10.2.0",
+  "version": "10.2.1",
   "description": "Base driver class for Appium drivers",
   "keywords": [
     "automation",
@@ -39,30 +39,30 @@
   ],
   "scripts": {
     "test": "run-p test:unit test:types",
-    "test:e2e": "mocha --exit --timeout 20s --slow 10s \"./test/e2e/**/*.spec.js\"",
+    "test:e2e": "mocha --exit --timeout 20s --slow 10s \"./test/e2e/**/*.spec.ts\"",
     "test:smoke": "node ./index.js",
-    "test:unit": "mocha \"./test/unit/**/*.spec.js\"",
-    "test:types": "tsd"
+    "test:unit": "mocha \"./test/unit/**/*.spec.ts\"",
+    "test:types": "tsd && tsc -p tsconfig.test.json"
   },
   "dependencies": {
-    "@appium/support": "^7.0.5",
-    "@appium/types": "^1.2.0",
+    "@appium/support": "^7.0.6",
+    "@appium/types": "^1.2.1",
     "@colors/colors": "1.6.0",
     "async-lock": "1.4.1",
-    "asyncbox": "6.0.1",
-    "axios": "1.13.3",
+    "asyncbox": "6.1.0",
+    "axios": "1.13.6",
     "bluebird": "3.7.2",
     "body-parser": "2.2.2",
     "express": "5.2.1",
     "fastest-levenshtein": "1.0.16",
     "http-status-codes": "2.3.0",
     "lodash": "4.17.23",
-    "lru-cache": "11.2.5",
+    "lru-cache": "11.2.6",
     "method-override": "3.0.0",
     "morgan": "1.10.1",
     "path-to-regexp": "8.3.0",
     "serve-favicon": "2.5.1",
-    "type-fest": "5.4.1"
+    "type-fest": "5.4.4"
   },
   "optionalDependencies": {
     "spdy": "4.0.2"
@@ -74,7 +74,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f7b20335eab4022e5cbbb627ec86866a994444f8",
+  "gitHead": "980a121804ae006db879fb6860f627ac36174c15",
   "tsd": {
     "directory": "test/types"
   }

package/tsconfig.json

@@ -7,8 +7,10 @@
       "@appium/types": ["../types"],
       "@appium/driver-test-support": ["../driver-test-support"]
     },
-    "checkJs": true
+    "checkJs": true,
+    "types": ["node", "mocha"]
   },
   "include": ["lib"],
+  "exclude": ["build"],
   "references": [{"path": "../support"}, {"path": "../types"}]
 }

package/lib/basedriver/logger.js

@@ -1,4 +0,0 @@
-import {logger} from '@appium/support';
-
-const log = logger.getLogger('BaseDriver');
-export default log;

package/lib/express/crash.js

@@ -1,11 +0,0 @@
-import {errors} from '../protocol';
-
-function produceError() {
-  throw new errors.UnknownCommandError('Produced generic error for testing');
-}
-
-function produceCrash() {
-  throw new Error('We just tried to crash Appium!');
-}
-
-export {produceError, produceCrash};