playwright 1.55.0 → 1.56.0-alpha-2025-08-21

package/lib/index.js

@@ -42,6 +42,9 @@ var playwrightLibrary = __toESM(require("playwright-core"));
 var import_utils = require("playwright-core/lib/utils");
 var import_globals = require("./common/globals");
 var import_testType = require("./common/testType");
+var import_backend = require("./mcp/browser/backend");
+var import_babelBundle = require("./transform/babelBundle");
+var import_util = require("./util");
 var import_expect = require("./matchers/expect");
 var import_configLoader = require("./common/configLoader");
 var import_testType2 = require("./common/testType");
@@ -219,7 +222,7 @@ const playwrightFixtures = {
     if ((0, import_utils.debugMode)() === "inspector")
       testInfo._setDebugMode();
     playwright._defaultContextOptions = _combinedContextOptions;
-    playwright._defaultContextTimeout = actionTimeout || 0;
+    playwright._defaultContextTimeout = process.env.PLAYWRIGHT_TEST_DEBUGGER_MCP ? 5e3 : actionTimeout || 0;
     playwright._defaultContextNavigationTimeout = navigationTimeout || 0;
     await use();
     playwright._defaultContextOptions = void 0;
@@ -258,10 +261,18 @@ const playwrightFixtures = {
         if (data.apiName === "tracing.group")
           tracingGroupSteps.push(step);
       },
-      onApiCallRecovery: (data, error, recoveryHandlers) => {
+      onApiCallRecovery: (data, error, channelOwner, recoveryHandlers) => {
         const step = data.userData;
-        if (step)
-          recoveryHandlers.push(() => step.recoverFromStepError(error));
+        if (!step)
+          return;
+        const page = channelToPage(channelOwner);
+        if (!page)
+          return;
+        recoveryHandlers.push(async () => {
+          await (0, import_backend.runBrowserBackendOnError)(page, () => {
+            return (0, import_util.stripAnsiEscapes)(createErrorCodeframe(error.message, step.location));
+          });
+        });
       },
       onApiCallEnd: (data) => {
         if (data.apiName === "tracing.group")
@@ -672,6 +683,36 @@ function tracing() {
   return test.info()._tracing;
 }
 const test = _baseTest.extend(playwrightFixtures);
+function channelToPage(channelOwner) {
+  if (channelOwner._type === "Page")
+    return channelOwner;
+  if (channelOwner._type === "Frame")
+    return channelOwner.page();
+  return void 0;
+}
+function createErrorCodeframe(message, location) {
+  let source;
+  try {
+    source = import_fs.default.readFileSync(location.file, "utf-8") + "\n//";
+  } catch (e) {
+    return "";
+  }
+  return (0, import_babelBundle.codeFrameColumns)(
+    source,
+    {
+      start: {
+        line: location.line,
+        column: location.column
+      }
+    },
+    {
+      highlightCode: true,
+      linesAbove: 5,
+      linesBelow: 5,
+      message: message.split("\n")[0] || void 0
+    }
+  );
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   _baseTest,

package/lib/isomorphic/testServerConnection.js

@@ -63,7 +63,6 @@ class TestServerConnection {
     this._onStdioEmitter = new events.EventEmitter();
     this._onTestFilesChangedEmitter = new events.EventEmitter();
     this._onLoadTraceRequestedEmitter = new events.EventEmitter();
-    this._onRecoverFromStepErrorEmitter = new events.EventEmitter();
     this._lastId = 0;
     this._callbacks = /* @__PURE__ */ new Map();
     this._isClosed = false;
@@ -72,7 +71,6 @@ class TestServerConnection {
     this.onStdio = this._onStdioEmitter.event;
     this.onTestFilesChanged = this._onTestFilesChangedEmitter.event;
     this.onLoadTraceRequested = this._onLoadTraceRequestedEmitter.event;
-    this.onRecoverFromStepError = this._onRecoverFromStepErrorEmitter.event;
     this._transport = transport;
     this._transport.onmessage((data) => {
       const message = JSON.parse(data);
@@ -129,8 +127,6 @@ class TestServerConnection {
       this._onTestFilesChangedEmitter.fire(params);
     else if (method === "loadTraceRequested")
       this._onLoadTraceRequestedEmitter.fire(params);
-    else if (method === "recoverFromStepError")
-      this._onRecoverFromStepErrorEmitter.fire(params);
   }
   async initialize(params) {
     await this._sendMessage("initialize", params);
@@ -201,9 +197,6 @@ class TestServerConnection {
   async closeGracefully(params) {
     await this._sendMessage("closeGracefully", params);
   }
-  async resumeAfterStepError(params) {
-    await this._sendMessage("resumeAfterStepError", params);
-  }
   close() {
     try {
       this._transport.close();

package/lib/matchers/expect.js

@@ -234,7 +234,7 @@ class ExpectMetaInfoProxyHandler {
         infectParentStepsWithError: this._info.isSoft
       };
       const step = testInfo._addStep(stepInfo);
-      const reportStepError = (isAsync, e) => {
+      const reportStepError = (e) => {
         const jestError = (0, import_matcherHint.isJestError)(e) ? e : null;
         const expectError = jestError ? new import_matcherHint.ExpectError(jestError, customMessage, stackFrames) : void 0;
         if (jestError?.matcherResult.suggestedRebaseline) {
@@ -243,22 +243,10 @@ class ExpectMetaInfoProxyHandler {
         }
         const error = expectError ?? e;
         step.complete({ error });
-        if (!isAsync || !expectError) {
-          if (this._info.isSoft)
-            testInfo._failWithError(error);
-          else
-            throw error;
-          return;
-        }
-        return (async () => {
-          const recoveryResult = await step.recoverFromStepError(expectError);
-          if (recoveryResult.status === "recovered")
-            return recoveryResult.value;
-          if (this._info.isSoft)
-            testInfo._failWithError(expectError);
-          else
-            throw expectError;
-        })();
+        if (this._info.isSoft)
+          testInfo._failWithError(error);
+        else
+          throw error;
       };
       const finalizer = () => {
         step.complete({});
@@ -268,11 +256,11 @@ class ExpectMetaInfoProxyHandler {
         const callback = () => matcher.call(target, ...args);
         const result = (0, import_utils.currentZone)().with("stepZone", step).run(callback);
         if (result instanceof Promise)
-          return result.then(finalizer).catch(reportStepError.bind(null, true));
+          return result.then(finalizer).catch(reportStepError);
         finalizer();
         return result;
       } catch (e) {
-        void reportStepError(false, e);
+        void reportStepError(e);
       }
     };
   }

package/lib/matchers/toBeTruthy.js

@@ -23,6 +23,7 @@ __export(toBeTruthy_exports, {
 module.exports = __toCommonJS(toBeTruthy_exports);
 var import_util = require("../util");
 var import_matcherHint = require("./matcherHint");
+var import_backend = require("../mcp/browser/backend");
 async function toBeTruthy(matcherName, receiver, receiverType, expected, arg, query, options = {}) {
   (0, import_util.expectTypes)(receiver, [receiverType], matcherName);
   const matcherOptions = {
@@ -55,6 +56,7 @@ ${printedReceived}`);
     const logText = (0, import_util.callLogText)(log);
     return `${header}${logText}`;
   };
+  await (0, import_backend.runBrowserBackendOnError)(receiver.page(), message);
   return {
     message,
     pass,

package/lib/matchers/toEqual.js

@@ -24,6 +24,7 @@ module.exports = __toCommonJS(toEqual_exports);
 var import_utils = require("playwright-core/lib/utils");
 var import_util = require("../util");
 var import_matcherHint = require("./matcherHint");
+var import_backend = require("../mcp/browser/backend");
 const EXPECTED_LABEL = "Expected";
 const RECEIVED_LABEL = "Received";
 async function toEqual(matcherName, receiver, receiverType, query, expected, options = {}, messagePreventExtraStatIndent) {
@@ -78,6 +79,7 @@ ${printedReceived}`;
     const header = (0, import_matcherHint.matcherHint)(this, receiver, matcherName, "locator", void 0, matcherOptions, timedOut ? timeout : void 0, details, messagePreventExtraStatIndent);
     return `${header}${(0, import_util.callLogText)(log)}`;
   };
+  await (0, import_backend.runBrowserBackendOnError)(receiver.page(), message);
   return {
     actual: received,
     expected,

package/lib/matchers/toMatchText.js

@@ -26,6 +26,7 @@ var import_util = require("../util");
 var import_expect = require("./expect");
 var import_matcherHint = require("./matcherHint");
 var import_expectBundle = require("../common/expectBundle");
+var import_backend = require("../mcp/browser/backend");
 async function toMatchText(matcherName, receiver, receiverType, query, expected, options = {}) {
   (0, import_util.expectTypes)(receiver, [receiverType], matcherName);
   const matcherOptions = {
@@ -89,6 +90,8 @@ async function toMatchText(matcherName, receiver, receiverType, query, expected,
     const hints = (0, import_matcherHint.matcherHint)(this, receiverType === "Locator" ? receiver : void 0, matcherName, options.receiverLabel ?? "locator", void 0, matcherOptions, timedOut ? timeout : void 0, resultDetails, true);
     return hints + (0, import_util.callLogText)(log);
   };
+  if (receiverType === "Locator")
+    await (0, import_backend.runBrowserBackendOnError)(receiver.page(), message);
   return {
     name: matcherName,
     expected,

package/lib/mcp/browser/backend.js

@@ -0,0 +1,88 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var backend_exports = {};
+__export(backend_exports, {
+  BrowserBackend: () => BrowserBackend,
+  runBrowserBackendOnError: () => runBrowserBackendOnError
+});
+module.exports = __toCommonJS(backend_exports);
+var mcp = __toESM(require("../sdk/exports"));
+var mcpBundle = __toESM(require("../sdk/bundle"));
+var import_tools = require("./tools");
+var import_exports = require("../sdk/exports");
+var import_mdb = require("../sdk/mdb");
+var import_util = require("../../util");
+class BrowserBackend {
+  constructor(page) {
+    this.name = "Playwright";
+    this.version = "0.0.1";
+    this._tools = [import_tools.snapshot, import_tools.pickLocator, import_tools.evaluate];
+    this._page = page;
+  }
+  async initialize() {
+  }
+  async listTools() {
+    return [...this._tools.map((tool) => mcp.toMcpTool(tool.schema)), mcp.toMcpTool(doneToolSchema)];
+  }
+  async callTool(name, args) {
+    if (name === "done") {
+      this.requestSelfDestruct?.();
+      return {
+        content: [{ type: "text", text: "Done" }]
+      };
+    }
+    const tool = this._tools.find((tool2) => tool2.schema.name === name);
+    if (!tool)
+      throw new Error(`Tool not found: ${name}. Available tools: ${this._tools.map((tool2) => tool2.schema.name).join(", ")}`);
+    const parsedArguments = tool.schema.inputSchema.parse(args || {});
+    return await tool.handle(this._page, parsedArguments);
+  }
+}
+const doneToolSchema = (0, import_exports.defineToolSchema)({
+  name: "done",
+  title: "Done",
+  description: "Done",
+  inputSchema: mcpBundle.z.object({}),
+  type: "destructive"
+});
+async function runBrowserBackendOnError(page, message) {
+  if (!process.env.PLAYWRIGHT_TEST_DEBUGGER_MCP)
+    return;
+  const introMessage = `Paused on error:
+
+${(0, import_util.stripAnsiEscapes)(message())}
+
+Try recovering from the error prior to continuing.`;
+  await (0, import_mdb.runOnPauseBackendLoop)(process.env.PLAYWRIGHT_TEST_DEBUGGER_MCP, new BrowserBackend(page), introMessage);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserBackend,
+  runBrowserBackendOnError
+});

package/lib/mcp/browser/tool.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tool_exports = {};
+__export(tool_exports, {
+  defineTool: () => defineTool
+});
+module.exports = __toCommonJS(tool_exports);
+function defineTool(tool) {
+  return tool;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineTool
+});

package/lib/mcp/browser/tools.js

@@ -0,0 +1,132 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tools_exports = {};
+__export(tools_exports, {
+  elementSchema: () => elementSchema,
+  evaluate: () => evaluate,
+  pickLocator: () => pickLocator,
+  snapshot: () => snapshot
+});
+module.exports = __toCommonJS(tools_exports);
+var import_utils = require("playwright-core/lib/utils");
+var import_tool = require("./tool.js");
+var mcp = __toESM(require("../sdk/bundle"));
+const snapshot = (0, import_tool.defineTool)({
+  schema: {
+    name: "browser_snapshot",
+    title: "Page snapshot",
+    description: "Capture accessibility snapshot of the current page, this is better than screenshot",
+    inputSchema: mcp.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (page, params) => {
+    const snapshot2 = await page._snapshotForAI();
+    return {
+      content: [
+        {
+          type: "text",
+          text: snapshot2
+        }
+      ]
+    };
+  }
+});
+const elementSchema = mcp.z.object({
+  element: mcp.z.string().describe("Human-readable element description used to obtain permission to interact with the element"),
+  ref: mcp.z.string().describe("Exact target element reference from the page snapshot")
+});
+const pickLocator = (0, import_tool.defineTool)({
+  schema: {
+    name: "browser_pick_locator",
+    title: "Pick locator",
+    description: "Pick a locator for the given element",
+    inputSchema: elementSchema,
+    type: "readOnly"
+  },
+  handle: async (page, params) => {
+    const locator = await refLocator(page, params);
+    const locatorString = await generateLocator(locator);
+    return {
+      content: [
+        {
+          type: "text",
+          text: locatorString
+        }
+      ]
+    };
+  }
+});
+const evaluateSchema = mcp.z.object({
+  function: mcp.z.string().describe("() => { /* code */ } or (element) => { /* code */ } when element is provided"),
+  element: mcp.z.string().optional().describe("Human-readable element description used to obtain permission to interact with the element"),
+  ref: mcp.z.string().optional().describe("Exact target element reference from the page snapshot")
+});
+const evaluate = (0, import_tool.defineTool)({
+  schema: {
+    name: "browser_evaluate",
+    title: "Evaluate JavaScript",
+    description: "Evaluate JavaScript expression on page or element",
+    inputSchema: evaluateSchema,
+    type: "destructive"
+  },
+  handle: async (page, params) => {
+    if (params.ref && params.element) {
+      const locator = await refLocator(page, { ref: params.ref, element: params.element });
+      const result2 = await locator.evaluate(params.function);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result2, null, 2) || "undefined" }]
+      };
+    }
+    const result = await page.evaluate(params.function);
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) || "undefined" }]
+    };
+  }
+});
+async function refLocator(page, elementRef) {
+  const snapshot2 = await page._snapshotForAI();
+  if (!snapshot2.includes(`[ref=${elementRef.ref}]`))
+    throw new Error(`Ref ${elementRef.ref} not found in the current page snapshot. Try capturing new snapshot.`);
+  return page.locator(`aria-ref=${elementRef.ref}`).describe(elementRef.element);
+}
+async function generateLocator(locator) {
+  try {
+    const { resolvedSelector } = await locator._resolveSelector();
+    return (0, import_utils.asLocator)("javascript", resolvedSelector);
+  } catch (e) {
+    throw new Error("Ref not found, likely because element was removed. Use browser_snapshot to see what elements are currently on the page.");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  elementSchema,
+  evaluate,
+  pickLocator,
+  snapshot
+});

package/lib/mcp/{bundle.js → sdk/bundle.js}

@@ -26,18 +26,20 @@ __export(bundle_exports, {
   SSEServerTransport: () => SSEServerTransport,
   Server: () => Server,
   StdioServerTransport: () => StdioServerTransport,
+  StreamableHTTPClientTransport: () => StreamableHTTPClientTransport,
   StreamableHTTPServerTransport: () => StreamableHTTPServerTransport,
   z: () => z,
   zodToJsonSchema: () => zodToJsonSchema
 });
 module.exports = __toCommonJS(bundle_exports);
-const bundle = require("./mcpBundleImpl");
-const zodToJsonSchema = require("./mcpBundleImpl").zodToJsonSchema;
+const bundle = require("../../mcpBundleImpl");
+const zodToJsonSchema = bundle.zodToJsonSchema;
 const Client = bundle.Client;
 const Server = bundle.Server;
 const SSEServerTransport = bundle.SSEServerTransport;
 const StdioServerTransport = bundle.StdioServerTransport;
 const StreamableHTTPServerTransport = bundle.StreamableHTTPServerTransport;
+const StreamableHTTPClientTransport = bundle.StreamableHTTPClientTransport;
 const CallToolRequestSchema = bundle.CallToolRequestSchema;
 const ListRootsRequestSchema = bundle.ListRootsRequestSchema;
 const ListToolsRequestSchema = bundle.ListToolsRequestSchema;
@@ -53,6 +55,7 @@ const z = bundle.z;
   SSEServerTransport,
   Server,
   StdioServerTransport,
+  StreamableHTTPClientTransport,
   StreamableHTTPServerTransport,
   z,
   zodToJsonSchema

package/lib/mcp/sdk/call.js

@@ -0,0 +1,49 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var call_exports = {};
+__export(call_exports, {
+  callTool: () => callTool
+});
+module.exports = __toCommonJS(call_exports);
+var mcpBundle = __toESM(require("./bundle.js"));
+async function callTool(mcpUrl, name, params) {
+  const transport = new mcpBundle.StreamableHTTPClientTransport(new URL(mcpUrl));
+  const client = new mcpBundle.Client({ name: "Internal", version: "0.0.0" });
+  await client.connect(transport);
+  try {
+    return await client.callTool({ name, arguments: params });
+  } finally {
+    await transport.terminateSession();
+    await client.close();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  callTool
+});

package/lib/mcp/{exports.js → sdk/exports.js}

@@ -15,16 +15,18 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var exports_exports = {};
 module.exports = __toCommonJS(exports_exports);
-__reExport(exports_exports, require("./inProcessTransport.js"), module.exports);
-__reExport(exports_exports, require("./proxyBackend.js"), module.exports);
-__reExport(exports_exports, require("./server.js"), module.exports);
-__reExport(exports_exports, require("./tool.js"), module.exports);
-__reExport(exports_exports, require("./transport.js"), module.exports);
+__reExport(exports_exports, require("./inProcessTransport"), module.exports);
+__reExport(exports_exports, require("./proxyBackend"), module.exports);
+__reExport(exports_exports, require("./server"), module.exports);
+__reExport(exports_exports, require("./tool"), module.exports);
+__reExport(exports_exports, require("./http"), module.exports);
+__reExport(exports_exports, require("./call"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./inProcessTransport.js"),
-  ...require("./proxyBackend.js"),
-  ...require("./server.js"),
-  ...require("./tool.js"),
-  ...require("./transport.js")
+  ...require("./inProcessTransport"),
+  ...require("./proxyBackend"),
+  ...require("./server"),
+  ...require("./tool"),
+  ...require("./http"),
+  ...require("./call")
 });